yml2: comparison backend.py

equal deleted inserted replaced

-:a1ecf17c60eb
+:d3dddb80d1f5
-# 2.5.10 backend
+# 2.6.0 backend
 # written by VB.
 import re, codecs
 import fileinput
-import sys, traceback, exceptions, os
+import sys, traceback, os
 from xml.sax.saxutils import escape, quoteattr
 from copy import copy, deepcopy
 from glob import glob
 from pyPEG import code, parse, parseLine, u, Symbol
 from yml2 import ymlCStyle, comment, _inner
 ymlFunc, pointers, pythonFunc = {}, {}, {}
-in_ns = u""
+in_ns = ""
 operator = []
-included = u""
+included = ""
 includePath = []
 emitlinenumbers = False
 encoding = "utf-8"
 first = True
 ymlFunc["operator"] = "#error"
 def clearAll():
 global ymlFunc, pointers, pythonFunc, in_ns, operator, included
 ymlFunc, pointers, pythonFunc = {}, {}, {}
-in_ns = u""
+in_ns = ""
 operator = []
-included = u""
+included = ""
 lq = re.compile(r"\|(\>*)(.*)")
 sq = re.compile(r"(\d*)\>(.*)")
 ts = re.compile(r'(\|\|(?P<inds>\>*)\s*\n(?P<text1>.*?)\n(?P<base>\s*)\|\|)|("""(?P<text2>.*?)""")|(\>\>(?P<text3>.*?)\>\>)', re.S)
 tq = re.compile(r"(\]|\<)\s*(.*)")
 def pointer(name):
 try:
 return u(pointers[name[1:]])
 except:
 if name == "*_trace_info":
-return u'""'
+return '""'
 if included:
-raise LookupError(u"in " + included + u":" + u(line) + u": pointer " + name)
+raise LookupError("in " + included + ":" + u(line) + ": pointer " + name)
 else:
-raise LookupError(u"in " + u(line) + u": pointer " + name)
+raise LookupError("in " + u(line) + ": pointer " + name)
 def evalPython(expr):
 try:
 result = eval(u(expr), pythonFunc)
-if type(result) is str:
+if type(result) is bytes:
 return codecs.decode(result, encoding)
 else:
 return result
 except:
 name, parm, tb = sys.exc_info()
-msg = u"in python expression: " + u(parm)
+msg = "in python expression: " + u(parm)
-if name is exceptions.SyntaxError:
+if name is SyntaxError:
 tbl = traceback.format_exception(name, parm, tb)
-msg += u"\n" + tbl[-3] + tbl[-2]
+msg += "\n" + tbl[-3] + tbl[-2]
 else:
-msg += u": " + expr + u"\n"
+msg += ": " + expr + "\n"
 if included:
-raise name(u"in " + included + u":" + u(line) + u": " + msg)
+raise name("in " + included + ":" + u(line) + ": " + msg)
 else:
-raise name(u"in " + u(line) + u": " + msg)
+raise name("in " + u(line) + ": " + msg)
 def execPython(script):
 try:
-if type(script) is unicode:
+if type(script) is str:
-exec script in pythonFunc
+exec(script, pythonFunc)
 else:
-exec codecs.decode(script, encoding) in pythonFunc
+exec(codecs.decode(script, encoding), pythonFunc)
 except:
 name, parm, tb = sys.exc_info()
-msg = u"in python script: " + u(parm)
+msg = "in python script: " + u(parm)
-if name is exceptions.SyntaxError:
+if name is SyntaxError:
 tbl = traceback.format_exception(name, parm, tb)
-msg += u"\n" + tbl[-3] + tbl[-2]
+msg += "\n" + tbl[-3] + tbl[-2]
 else:
-msg += u": " + expr + u"\n"
+msg += ": " + expr + "\n"
 if included:
-raise name(u"in " + included + u":" + u(line) + u": " + msg)
+raise name("in " + included + ":" + u(line) + ": " + msg)
 else:
-raise name(u"in " + u(line) + u": " + msg)
+raise name("in " + u(line) + ": " + msg)
 def textOut(text):
 if not text:
-return u""
+return ""
-if type(text) is not unicode:
+if type(text) is not str:
 text = codecs.decode(text, encoding)
 text = text.replace(r'\"', r'\\"')
-text = u'u"""' + text.replace('"', r'\"') + u'"""'
+text = '"""' + text.replace('"', r'\"') + '"""'
 try:
 textFunc = ymlFunc["text"]
 parms = ['text', ('parm', [text])]
 c, result = textFunc(parms)
 if c:
-if type(textFunc.alias) is unicode:
+if type(textFunc.alias) is str:
-result += u"</" + textFunc.alias + u">"
+result += "</" + textFunc.alias + ">"
 else:
-result += u"</" + codecs.decode(textFunc.alias, encoding) + u">"
+result += "</" + codecs.decode(textFunc.alias, encoding) + ">"
 return result
 except:
 return escape(eval(text))
 def strRepl(text):
 if not text:
-return u""
+return ""
-if type(text) is not unicode:
+if type(text) is not str:
 text = codecs.decode(text, encoding)
 text = text.replace(r'\"', r'\\"')
-text = u'u"""' + text.replace('"', r'\"') + u'"""'
+text = '"""' + text.replace('"', r'\"') + '"""'
-if type(text) is unicode:
+if type(text) is str:
 return escape(eval(text))
 def applyMacros(macros, text):
 result = text
-for key, value in macros.iteritems():
+for key, value in macros.items():
 result = result.replace(key, value)
 return result
 class YF:
 def __init__(self, name):
 self.values = {}
 self.content = None
 self.pointers = {}
 self.macros = {}
 if in_ns:
-self.alias = in_ns + u":" + name.replace("_", "-")
+self.alias = in_ns + ":" + name.replace("_", "-")
 else:
 self.alias = name.replace("_", "-")
 pythonFunc["yml_" + name] = self
 if emitlinenumbers:
 self.values["yml:declared"] = u(line)
 vals[parm] = u(val)
 elif data[0] == "content":
 hasContent = True
 if enable_tracing:
-text = u(parms) + u", " + u(vals)
+text = u(parms) + ", " + u(vals)
-pointers["_trace_info"] = u'"' + u(line) + u": " + u(self.name) + u" " + text.replace(u'"', u'#') + u'"'
+pointers["_trace_info"] = '"' + u(line) + ": " + u(self.name) + " " + text.replace('"', '#') + '"'
 if emitlinenumbers:
 global first
 if first:
-vals["xmlns:yml"] = u"http://fdik.org/yml"
+vals["xmlns:yml"] = "http://fdik.org/yml"
 first = False
 vals["yml:called"] = u(line)
 return self.xml(parms, vals, hasContent, avoidTag)
 def addParm(self, parm):
 self.descends.append(desc[1:])
 else:
 self.descends.append(desc)
 def addValue(self, parm, value):
-if type(value) is str or type(value) is unicode:
+if type(value) is str or type(value) is str:
 if value[0] != "'" and value[0] != '"':
 self.values[parm] = u(value)
 else:
 self.values[parm] = u(evalPython(value))
 else:
 self.values[parm] = u(evalPython(u(value)))
 def xml(self, callParms, callValues, hasContent, avoidTag = False):
 global pointers
-extraContent = u""
+extraContent = ""
 if self.content:
 hasContent = True
 resultParms = self.values.copy()
 macros = self.macros.copy()
 toDelete = resultParms.keys()
 for key in toDelete:
 if key[0] == "*":
 del resultParms[key]
-for key, value in callValues.iteritems():
+for key, value in callValues.items():
 if key[0] == "%":
 macros[key] = value
 else:
 resultParms[key] = value
 i = 0
 for cp in callParms:
 if i < len(self.parms):
 if self.parms[i][0] == "*":
 cp = u(cp)
 if "'" in cp:
-pointers[self.parms[i][1:]] = u'"' + cp + u'"'
+pointers[self.parms[i][1:]] = '"' + cp + '"'
 else:
-pointers[self.parms[i][1:]] = u"'" + cp + u"'"
+pointers[self.parms[i][1:]] = "'" + cp + "'"
 elif self.parms[i][0] == "%":
 macros[self.parms[i]] = u(cp)
 else:
 resultParms[self.parms[i]] = cp
 else:
 extraContent += u(cp)
 hasContent = True
 i += 1
-result = u""
+result = ""
-for p, v in resultParms.iteritems():
+for p, v in resultParms.items():
 if p[0] == "'" or p[0] == '"':
 p = eval(p)
-result += u" "+ p + u"=" + quoteattr(applyMacros(macros, u(v)))
+result += " "+ p + "=" + quoteattr(applyMacros(macros, u(v)))
 if hasContent:
 if avoidTag:
 return True, strRepl(extraContent)
 else:
-return True, u"<" + self.alias + result + u">" + strRepl(extraContent)
+return True, "<" + self.alias + result + ">" + strRepl(extraContent)
 else:
 if avoidTag:
-return False, u""
+return False, ""
 else:
-return False, u"<" + self.alias + result + u"/>"
+return False, "<" + self.alias + result + "/>"
 def replaceContent(tree, subtree):
 n = 0
 while n < len(tree):
 obj = tree[n]
 replaceContent(obj[1], subtree)
 n += 1
 return tree
 def executeCmd(text):
-if type(text) is not unicode:
+if type(text) is not str:
 text = codecs.decode(text, encoding)
 for (regex, pattern) in operator:
 match = re.search(regex, text)
 while match:
 cmd = pattern
 opt = match.groups()
 for i in range(len(opt)):
-cmd = cmd.replace(u"%" + u(i+1), opt[i])
+cmd = cmd.replace("%" + u(i+1), opt[i])
-text = text[:match.start()] + u"`" + cmd + u"`"+ text[match.end():]
+text = text[:match.start()] + "`" + cmd + "`"+ text[match.end():]
 match = re.search(regex, text)
-result = u""
+result = ""
 m = re.search(bq, text)
 while text and m:
 cmd  = m.group(1)
 head = textOut(text[:m.start()])
 text = text[m.end():]
 try:
 r, rest = parseLine(cmd, _inner, [], True, comment)
 if rest: raise SyntaxError(cmd)
 except SyntaxError:
 if included:
-raise SyntaxError(u"in " + included + u":" + u(line) + u": syntax error in executing command: " + cmd.strip())
+raise SyntaxError("in " + included + ":" + u(line) + ": syntax error in executing command: " + cmd.strip())
 else:
-raise SyntaxError(u"in " + u(line) + u": syntax error in executing command: " + cmd.strip())
+raise SyntaxError("in " + u(line) + ": syntax error in executing command: " + cmd.strip())
 inner = _finish(r)
 result += head + inner
 m = re.search(bq, text)
 result += textOut(text)
 try:
 if ctype.line: line = ctype.line
 except: pass
 if ctype == "empty":
-return code(u"")
+return code("")
 if ctype == "in_ns":
 in_ns = obj[1][0]
 subtree = obj[1]
 for sel in subtree:
 codegen(sel)
-in_ns = u""
+in_ns = ""
-return code(u"")
+return code("")
 elif ctype == "decl":
-name = u""
+name = ""
 for data in obj[1]:
-if type(data) is unicode or type(data) is str:
+if type(data) is str:
 name = data
 try:
 yf = ymlFunc[name]
 yf.alias
 except:
 ymlFunc[name] = YF(name)
 yf = ymlFunc[name]
 if in_ns:
-yf.alias = in_ns + u":" + name
+yf.alias = in_ns + ":" + name
 if not enable_tracing:
 if in_ns == "xsl" and (name == "debug" or name=="assert" or name[:7]=="_trace_"):
 yf.alias = "-"
 yf.addParm("skip1")
 yf.addParm("skip2")
 base = data[1][0]
 try:
 yf = ymlFunc[name] = ymlFunc[base].copy(name)
 except KeyError:
 if included:
-raise KeyError(u"in " + included + u":" + u(line) + u": " + base + u" as base for " + name)
+raise KeyError("in " + included + ":" + u(line) + ": " + base + " as base for " + name)
 else:
-raise KeyError(u"in " + u(line) + u": " + base + u" as base for " + name)
+raise KeyError("in " + u(line) + ": " + base + " as base for " + name)
 elif data[0] == "shape":
 shape = ymlFunc[data[1]]
 try:
 yf = ymlFunc[name]
 yf.patch(shape)
 except KeyError:
 if included:
-raise KeyError(u"in " + included + u":" + u(line) + u": " + base + u" as shape for " + name)
+raise KeyError("in " + included + ":" + u(line) + ": " + base + " as shape for " + name)
 else:
-raise KeyError(u"in " + u(line) + u": " + base + u" as shape for " + name)
+raise KeyError("in " + u(line) + ": " + base + " as shape for " + name)
 elif data[0] == "descend":
 yf.addDescend(data[1])
 elif data[0] == "declParm":
 l = data[1]
 parmName = l[0]
 yf.addValue(parmName, value)
 if parmName[0] == "*":
 yf.pointers[parmName[1:]] = value
 yf.addParm(parmName)
 elif parmName[0] == "%":
-if type(value) is unicode or type(value) is str:
+if type(value) is str:
 yf.macros[parmName] = u(evalPython(value))
 else:
 yf.macros[parmName] = u(evalPython(u(value)))
 yf.addParm(parmName)
 elif data[0] == "alias":
 if in_ns:
-yf.alias = in_ns + u":" + data[1][0]
+yf.alias = in_ns + ":" + data[1][0]
 else:
 yf.alias = data[1][0]
 elif data[0] == "content":
 yf.content = data[1]
-return code(u"")
+return code("")
 elif ctype == "funclist":
-result = u""
+result = ""
 for f in obj[1]:
 result += codegen(f)
 return code(result)
 elif ctype == "parentheses":
 if len(obj[1]):
 return codegen(('func', ['_parentheses', ('content', [obj[1][0]])]))
 else:
-return u""
+return ""
 elif ctype == "fparm":
 if len(obj[1]):
 return codegen(('func', ['_parm', ('content', [obj[1][0]])]))
 else:
-return u""
+return ""
 elif ctype == "generic":
 return codegen(('func', ['_generic', ('content', [obj[1][0]])]))
 elif ctype == "xbase":
 name = obj[1][0]
 if name == "decl":
 if ymlFunc[name] == "#error":
 if included:
-raise SyntaxError(u"in " + included + u":" + u(line) + u": syntax error in decl statement")
+raise SyntaxError("in " + included + ":" + u(line) + ": syntax error in decl statement")
 else:
-raise SyntaxError(u"in " + u(line) + u": syntax error in decl statement")
+raise SyntaxError("in " + u(line) + ": syntax error in decl statement")
 if name == "define" or name == "operator":
 if ymlFunc[name] == "#error":
 if included:
-raise SyntaxError(u"in " + included + u":" + u(line) + u": syntax error in define statement")
+raise SyntaxError("in " + included + ":" + u(line) + ": syntax error in define statement")
 else:
-raise SyntaxError(u"in " + u(line) + u": syntax error in define statement")
+raise SyntaxError("in " + u(line) + ": syntax error in define statement")
 if name[0] == "&":
 avoidTag = True
 name = name[1:]
 hasContent = False
 if len(name) > 2:
 if name[0:2] == "**":
-return code(eval('u'+pointer(name[1:])))
+return code(eval(''+pointer(name[1:])))
 if name[0] == "*":
 name = eval(pointer(name))
 if name[0] == "&":
 avoidTag = True
 try:
 ymlFunc[name]
 except KeyError:
 try:
-if ymlFunc["_"].alias != u"-":
+if ymlFunc["_"].alias != "-":
 return codegen(('func', ['_', ('content', [('funclist', [obj])])]))
 else:
 ymlFunc[name] = copy(ymlFunc["_"])
 ymlFunc[name].alias = name.replace("_", "-")
 return codegen(obj)
 to_add = []
 if len(ymlFunc[name].descends):
 if obj[1][-1][0] != 'content':
 if included:
-raise KeyError(u"in " + included + u":" + u(line) + u": " + name + u" has descending attributes, but no descendants are following")
+raise KeyError("in " + included + ":" + u(line) + ": " + name + " has descending attributes, but no descendants are following")
 else:
-raise KeyError(u"in " + u(line) + u": " + name + u" has descending attributes, but no descendants are following")
+raise KeyError("in " + u(line) + ": " + name + " has descending attributes, but no descendants are following")
 def first_func(obj):
 if type(obj) is tuple or type(obj) is Symbol:
 if obj[0] == 'func':
 return obj
 for dname in ymlFunc[name].descends:
 f, c = first_func(c), copy_without_first_func(c)
 if dname[0] == "*":
 pointers[dname[1:]] = "'" + f[1][0] + "'"
 else:
-add_params.append( ('parm', [dname, u"'" + f[1][0] + u"'"]) )
+add_params.append( ('parm', [dname, "'" + f[1][0] + "'"]) )
 try:
 add_params.extend( get_parms(f) )
 except: pass
 new_things = [ e[1][0] ]
 new_things.append( ('content', c) )
 to_add.append( ('func', new_things ) )
 except:
 if included:
-raise KeyError(u"in " + included + u":" + u(line) + u": " + name + u" has descending attributes, and too less descendants are following")
+raise KeyError("in " + included + ":" + u(line) + ": " + name + " has descending attributes, and too less descendants are following")
 else:
-raise KeyError(u"in " + u(line) + u": " + name + u" has descending attributes, and too less descendants are following")
+raise KeyError("in " + u(line) + ": " + name + " has descending attributes, and too less descendants are following")
 if not to_add:
 to_add = ( obj, )
-complete = u""
+complete = ""
 for obj in to_add:
 subtree = None
 try:
 if obj[1][-1][0] == "content":
 if subtree:
 for sel in subtree:
 result += codegen(sel)
 if hasContent and not(avoidTag):
-result += u"</" + ymlFunc[name].alias + u">"
+result += "</" + ymlFunc[name].alias + ">"
 complete += result
 return code(complete)
 elif ctype == "textsection":
-result = u''
+result = ''
 ll = obj[1].splitlines()
 space = len(ll[-1]) - 2
 for l in ll[1:-1]:
 m = re.match(bqq, l)
 if m:
 r, x = parseLine(cmd, _inner, [], True, comment)
 if x: raise SyntaxError(cmd)
 result += _finish(r)
 except SyntaxError:
 if included:
-raise SyntaxError(u"in " + included + u":" + u(line) + u": syntax error in executing command: " + cmd.strip())
+raise SyntaxError("in " + included + ":" + u(line) + ": syntax error in executing command: " + cmd.strip())
 else:
-raise SyntaxError(u"in " + u(line) + u": syntax error in executing command: " + cmd.strip())
+raise SyntaxError("in " + u(line) + ": syntax error in executing command: " + cmd.strip())
 else:
-result += codegen(Symbol(u'lineQuote', u'| ' + l[space:]))
+result += codegen(Symbol('lineQuote', '| ' + l[space:]))
 return code(result)
-elif ctype == "textsectionu":
+elif ctype == "textsection":
-result = u''
+result = ''
 ll = obj[1].splitlines()
 space = len(ll[-1]) - 2
 for l in ll[1:-1]:
 m = re.match(bqq, l)
 if m:
 r, x = parseLine(cmd, _inner, [], True, comment)
 if x: raise SyntaxError(cmd)
 result += _finish(r)
 except SyntaxError:
 if included:
-raise SyntaxError(u"in " + included + u":" + u(line) + u": syntax error in executing command: " + cmd.strip())
+raise SyntaxError("in " + included + ":" + u(line) + ": syntax error in executing command: " + cmd.strip())
 else:
-raise SyntaxError(u"in " + u(line) + u": syntax error in executing command: " + cmd.strip())
+raise SyntaxError("in " + u(line) + ": syntax error in executing command: " + cmd.strip())
 else:
-if result != u'': result += u' '
+if result != '': result += ' '
-result += codegen(Symbol(u'quote', [u'> ' + l[space:]]))
+result += codegen(Symbol('quote', ['> ' + l[space:]]))
 return code(result)
 elif ctype == "lineQuote" or ctype == "quote":
-m, text, base, inds = None, u"", 0, 0
+m, text, base, inds = None, "", 0, 0
 if ctype == "lineQuote":
 text = obj[1]
 m = lq.match(text)
 if m:
 if m:
 if m.group(1):
 inds = int(m.group(1))
 text = m.group(2)[1:]
 else:
-if type(text) is unicode or type(text) is str:
+if type(text) is str:
 text = u(evalPython(text))
-ind = u""
+ind = ""
 if inds > -1:
 try:
-cmd = evalPython(u"indent(" + u(inds) + u")")
+cmd = evalPython("indent(" + u(inds) + ")")
 result, rest = parseLine(u(cmd), _inner, [], True, comment)
 if rest:
 raise SyntaxError()
 ind = _finish(result)
 except: pass
-if ctype == "lineQuote": text += u"\n"
+if ctype == "lineQuote": text += "\n"
 hasTextFunc = False
 try:
 ymlFunc["text"]
 hasTextFunc = True
 return code(ind + text)
 elif ctype == "tagQuote":
 m = tq.match(obj[1])
 if m.group(1) == "<":
-return code(u"<" + m.group(2))
+return code("<" + m.group(2))
 else:
 return code(m.group(2))
 elif ctype == "operator":
 operator.append((re.compile(evalPython(obj[1][0])), obj[1][1]))
-return code(u"")
+return code("")
 elif ctype == "constant":
 name = obj[1][0]
 if name[0] == "*":
 name = name[1:]
 value = obj[1][1]
 pointers[name] = value
-return code(u"")
+return code("")
 elif ctype == "include":
 reverse = False
 ktext, kxml = False, False
 for arg in obj[1]:
 reverse = True
 elif arg[0] == "ktext":
 ktext = True
 elif arg[0] == "kxml":
 kxml = True
-elif type(arg) is unicode or type(arg) is str:
+elif type(arg) is str:
 filemask = arg
 if filemask[0] == '/' or filemask[0] == '.':
 files = sorted(glob(filemask))
 else:
 if files and reverse:
 files = files[-1::-1]
 if not(files):
 if included:
-raise IOError(u"in " + included + ":" + u(line) + u": include file(s) '" + filemask + u"' not found")
+raise IOError("in " + included + ":" + u(line) + ": include file(s) '" + filemask + "' not found")
 else:
-raise IOError(u"in " + u(line) + u": include file(s) '" + filemask + u"' not found")
+raise IOError("in " + u(line) + ": include file(s) '" + filemask + "' not found")
 includeFile = fileinput.input(files, mode="rU", openhook=fileinput.hook_encoded(encoding))
 _included = included
 if ktext or kxml:
-text = u""
+text = ""
 for line in includeFile:
 included = includeFile.filename()
 if kxml:
 if (not line[:6] == '<?xml ') and (not line[:6] == '<?XML '):
 text += line
 elif ctype == "pythonCall":
 parms = []
 data = obj[1]
 for p in data:
-if type(p) is unicode or type(p) is str:
+if type(p) is str:
 name = p
 elif type(p) is tuple or type(p) is Symbol:
 ptype = p[0]
 if ptype == "parm":
 if p[1][0][0] == "*":
 parms.append(pointer(p[1][0]))
 else:
 parms.append(p[1][0])
 if len(parms) == 0:
-exp = name + u"()"
+exp = name + "()"
 elif len(parms) == 1:
-exp = name + u"(" + u(parms[0]) + u")"
+exp = name + "(" + u(parms[0]) + ")"
 else:
 exp = name + u(tuple(parms))
 cmd = evalPython(exp)
 result, rest = parseLine(u(cmd), _inner, [], True, comment)
 if rest:
 raise SyntaxError()
 return code(_finish(result))
 else:
-return code(u"")
+return code("")
 def _finish(tree):
-result = u""
+result = ""
-python = u""
+python = ""
 for el in tree:
 if el[0] == "python":
 if el[1][0][:2] == "!!":
 python += el[1][0][2:-2]
 else:
-python += el[1][0][1:] + u"\n"
+python += el[1][0][1:] + "\n"
 continue
 else:
 if python:
 execPython(python)
-python = u""
+python = ""
 try:
 result += codegen(el)
 except RuntimeError:
 if included:
-raise RuntimeError(u"in " + included + u":" + u(line))
+raise RuntimeError("in " + included + ":" + u(line))
 else:
-raise RuntimeError(u"in " + u(line))
+raise RuntimeError("in " + u(line))
 if python:
 execPython(python)
 return result

changeset 31	d3dddb80d1f5
parent 29	6a8a7951d8e6
child 32	2b7b48758eaa