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