--- /dev/null
+\r
+#\r
+# Template (Version 2.5)\r
+#\r
+# Klasse zum Parsen von Templates\r
+#\r
+# Autor: Patrick Canterino <patrick@patshaping.de>\r
+# Letzte Aenderung: 25.11.2011\r
+#\r
+# Copyright (C) 2002-2011 Patrick Canterino\r
+#\r
+# Diese Datei kann unter den Bedingungen der "Artistic License 2.0"\r
+# weitergegeben und / oder veraendert werden.\r
+# Siehe:\r
+# http://www.opensource.org/licenses/artistic-license-2.0\r
+#\r
+\r
+import os.path\r
+import sys\r
+\r
+class Template:\r
+\r
+ # __init__()\r
+ #\r
+ # Konstruktor\r
+ #\r
+ # Parameter: -keine-\r
+ #\r
+ # Rueckgabe: -nichts-\r
+\r
+ def __init__(self):\r
+ self.file = ''\r
+ self.template = ''\r
+ self.original = ''\r
+ self.old_parsing = 0\r
+ self.vars = {}\r
+ self.defined_vars = []\r
+ self.loop_vars = {}\r
+\r
+ # get_template()\r
+ #\r
+ # Kompletten Vorlagentext zurueckgeben\r
+ #\r
+ # Parameter: -keine-\r
+ #\r
+ # Rueckgabe: Kompletter Vorlagentext (String)\r
+\r
+ def get_template(self):\r
+ return str(self.template)\r
+\r
+ # set_template()\r
+ #\r
+ # Kompletten Vorlagentext aendern\r
+ #\r
+ # Parameter: Vorlagentext\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def set_template(self,template):\r
+ self.template = str(template)\r
+\r
+ # add_text()\r
+ #\r
+ # Vorlagentext ans Template-Objekt anhaengen\r
+ #\r
+ # Parameter: Vorlagentext\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def add_text(self,text):\r
+ self.set_template(self.get_template()+str(text))\r
+\r
+ # read_file()\r
+ #\r
+ # Einlesen einer Vorlagendatei und {INCLUDE}-Anweisungen ggf. verarbeiten\r
+ # (Text wird an bereits vorhandenen Text angehaengt)\r
+ #\r
+ # Parameter: 1. Datei zum Einlesen\r
+ # 2. Status-Code (Boolean):\r
+ # true => {INCLUDE}-Anweisungen nicht verarbeiten\r
+ # false => {INCLUDE}-Anweisungen verarbeiten (Standard)\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def read_file(self,file,not_include=0):\r
+ self.file = file\r
+\r
+ fp = open(file,'r')\r
+ content = fp.read()\r
+ fp.close()\r
+\r
+ self.add_text(content)\r
+ self.save_state()\r
+\r
+ if not not_include: self.parse_includes()\r
+\r
+ # set_var()\r
+ #\r
+ # Wert einer Variable setzen\r
+ #\r
+ # Parameter: 1. Name der Variable\r
+ # 2. Wert, den die Variable erhalten soll\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def set_var(self,var,content):\r
+ self.vars[var] = content\r
+\r
+ # get_var()\r
+ #\r
+ # Wert einer Variable zurueckgeben\r
+ #\r
+ # Parameter: (optional) Variablenname\r
+ #\r
+ # Rueckgabe: Wert der Variable;\r
+ # wenn die Variable nicht existiert, false;\r
+ # wenn kein Variablenname angegeben wurde, wird ein\r
+ # Array mit den Variablennamen zurueckgegeben\r
+\r
+ def get_var(self,var=None):\r
+ if var is not None:\r
+ if self.vars.has_key(var):\r
+ return self.vars[var]\r
+ else:\r
+ return None\r
+ else:\r
+ return self.vars.keys()\r
+\r
+ # set_vars()\r
+ #\r
+ # Komplettes Variablen-Array mit einem anderen Array ueberschreiben\r
+ #\r
+ # Parameter: Array\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def set_vars(self,vars):\r
+ self.vars = vars\r
+\r
+ # add_vars()\r
+ #\r
+ # Zum bestehenden Variablen-Array weitere Variablen in Form eines Arrays\r
+ # hinzufuegen\r
+ #\r
+ # Parameter: Array\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def add_vars(self,vars):\r
+ self.vars.update(vars)\r
+\r
+ # set_loop_data()\r
+ #\r
+ # Daten fuer eine Schleife setzen\r
+ #\r
+ # Parameter: 1. Name der Schleife\r
+ # 2. Array mit den Dictionaries mit den Variablen fuer\r
+ # die Schleifendurchgaenge\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def set_loop_data(self,loop,data):\r
+ self.loop_vars[loop] = data\r
+\r
+ # add_loop_data()\r
+ #\r
+ # Daten fuer einen Schleifendurchgang hinzufuegen\r
+ #\r
+ # Parameter: 1. Name der Schleife\r
+ # 2. Dictionary mit den Variablen fuer den\r
+ # Schleifendurchgang\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def add_loop_data(self,loop,data):\r
+ if self.loop_vars.has_key(loop) and type(self.loop_vars[loop]) is list:\r
+ self.loop_vars[loop].append(data)\r
+ else:\r
+ self.loop_vars[loop] = [data]\r
+\r
+ # parse()\r
+ #\r
+ # In der Template definierte Variablen auslesen, Variablen\r
+ # ersetzen, {IF}- und {TRIM}-Bloecke parsen\r
+ #\r
+ # Parameter: -nichts-\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def parse(self):\r
+ if self.old_parsing: return self.parse_old()\r
+\r
+ # Zuerst die Schleifen parsen\r
+\r
+ if self.loop_vars and self.loop_vars.keys():\r
+ loops = self.loop_vars.keys()\r
+\r
+ for loop in loops:\r
+ self.parse_loop(loop)\r
+\r
+ # In Template-Datei definierte Variablen auslesen\r
+\r
+ self.get_defined_vars()\r
+\r
+ # Variablen ersetzen\r
+\r
+ vars = self.get_var()\r
+\r
+ if vars is not None and type(vars) is list:\r
+ self.parse_if_blocks()\r
+ self.replace_vars()\r
+\r
+ # {TRIM}-Bloecke entfernen\r
+\r
+ self.parse_trim_blocks()\r
+\r
+ # parse_old()\r
+ #\r
+ # In der Template definierte Variablen auslesen, Variablen\r
+ # ersetzen, {IF}- und {TRIM}-Bloecke parsen\r
+ # (alte Methode)\r
+ #\r
+ # Parameter: -nichts-\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def parse_old(self):\r
+ # Zuerst die Schleifen parsen\r
+\r
+ if self.loop_vars and self.loop_vars.keys():\r
+ loops = self.loop_vars.keys()\r
+\r
+ for loop in loops:\r
+ self.parse_loop(loop)\r
+\r
+ # Normale Variablen durchgehen\r
+\r
+ if self.get_var():\r
+ vars = self.get_var()\r
+\r
+ for var in vars:\r
+ val = self.get_var(var)\r
+\r
+ self.parse_if_block(var,val)\r
+\r
+ if type(val) is list:\r
+ self.fillin_array(var,val)\r
+ else:\r
+ self.fillin(var,val)\r
+\r
+ # Jetzt dasselbe mit denen, die direkt in der Template-Datei definiert\r
+ # sind, machen. Ich weiss, dass das eine ziemlich unsaubere Loesung ist,\r
+ # aber es funktioniert\r
+\r
+ self.get_defined_vars()\r
+\r
+ for var in self.defined_vars:\r
+ val = self.get_var(var)\r
+\r
+ self.parse_if_block(var,val)\r
+ self.fillin(var,val)\r
+\r
+ # {TRIM}-Bloecke entfernen\r
+\r
+ self.parse_trim_blocks()\r
+\r
+ # fillin()\r
+ #\r
+ # Variablen durch Text ersetzen\r
+ #\r
+ # Parameter: 1. Variable zum Ersetzen\r
+ # 2. Text, durch den die Variable ersetzt werden soll\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def fillin(self,var,text):\r
+ if text is None: text = ''\r
+\r
+ template = self.get_template();\r
+ template = template.replace('{'+str(var)+'}',str(text));\r
+\r
+ self.set_template(template);\r
+\r
+ # fillin_array()\r
+ #\r
+ # Variable durch Array ersetzen\r
+ #\r
+ # Parameter: 1. Variable zum Ersetzen\r
+ # 2. Array, durch das die Variable ersetzt werden soll\r
+ # 3. Zeichenkette, mit der das Array verbunden werden soll\r
+ # (Standard: '')\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def fillin_array(self,var,array,glue=''):\r
+ self.fillin(var,str(glue).join(array))\r
+\r
+ # replace_vars()\r
+ #\r
+ # Variablen eine nach der anderen ersetzen. Sollte in einer Variable eine\r
+ # andere Variable auftauchen, so wird diese nicht ersetzt.\r
+ #\r
+ # Parameter: Array mit zu parsenden Variablen (optional)\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def replace_vars(self,valid=None):\r
+ template = self.get_template()\r
+\r
+ if valid is None:\r
+ valid_vars = self.get_var()\r
+ else:\r
+ valid_vars = valid\r
+\r
+ x = 0\r
+\r
+ while x < len(template):\r
+ if template[x] == '{':\r
+ for var in valid_vars:\r
+ # Pruefen, ob hier eine gueltige Variable beginnt\r
+\r
+ if template[x+1:x+len(var)+2] == var + '}':\r
+ if type(self.get_var(var)) is list:\r
+ content = ''.join(self.get_var(var))\r
+ else:\r
+ # Muss es nochmal zum String machen\r
+ # Hilft gegen den "ordinal not in range(128)"-Fehler\r
+ # Habe aber keine Ahnung, welche neuen Probleme das verursachen koennte\r
+ # Bin gespannt...\r
+ content = str(self.get_var(var))\r
+\r
+ if content is None: content = ''\r
+\r
+ # Daten vor und nach der Variable\r
+\r
+ pre = template[0:x]\r
+ post = template[len(pre)+2+len(var):]\r
+\r
+ # Alles neu zusammensetzen\r
+\r
+ template = pre + content + post\r
+\r
+ # Zaehler aendern\r
+\r
+ x = len(pre + content) - 1\r
+\r
+ x += 1\r
+\r
+ self.set_template(template)\r
+\r
+ # to_file()\r
+ #\r
+ # Template in Datei schreiben\r
+ #\r
+ # Parameter: Datei-Handle\r
+ #\r
+ # Rueckgabe: Status-Code (Boolean)\r
+\r
+ def to_file(self,handle):\r
+ return handle.write(self.get_template())\r
+\r
+ # reset()\r
+ #\r
+ # Den gesicherten Stand des Template-Textes wiederherstellen\r
+ #\r
+ # Parameter: -nichts-\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def reset(self):\r
+ self.template = self.original\r
+\r
+ # save_state()\r
+ #\r
+ # Aktuellen Stand des Template-Textes sichern\r
+ # (alte Sicherung wird ueberschrieben)\r
+ #\r
+ # Parameter: -nichts-\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def save_state(self):\r
+ self.original = self.template\r
+\r
+ # parse_loop()\r
+ #\r
+ # Eine Schleife parsen\r
+ #\r
+ # Parameter: Name der Schleife\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def parse_loop(self,name):\r
+ template = self.get_template()\r
+ if template.find('{LOOP '+name+'}') == -1: return\r
+\r
+ offset = 0\r
+ name_len = len(name)\r
+\r
+ while template.find('{LOOP '+name+'}',offset) != -1:\r
+ begin = template.find('{LOOP '+name+'}',offset)\r
+\r
+ if template.find('{ENDLOOP}',begin+6+name_len) != -1:\r
+ end = template.find('{ENDLOOP}',begin+6+name_len)\r
+\r
+ block = template[begin:end+9]\r
+ content = block[name_len+7:-9]\r
+\r
+ parsed_block = ''\r
+\r
+ x = 0\r
+\r
+ while x < len(self.loop_vars[name]):\r
+ loop_data = self.loop_vars[name][x]\r
+ loop_vars = loop_data.keys()\r
+\r
+ ctpl = Template()\r
+ ctpl.set_template(content)\r
+\r
+ for loop_var in loop_vars:\r
+ ctpl.set_var(name+'.'+loop_var,loop_data[loop_var])\r
+\r
+ if self.old_parsing:\r
+ ctpl.parse_old()\r
+ else:\r
+ ctpl.parse()\r
+\r
+ parsed_block += ctpl.get_template()\r
+\r
+ del(ctpl)\r
+ x += 1\r
+\r
+ template = template.replace(block,parsed_block)\r
+ offset = begin+len(parsed_block)\r
+\r
+ else:\r
+ break\r
+\r
+ self.set_template(template)\r
+\r
+ # get_defined_vars()\r
+ #\r
+ # In der Template-Datei definierte Variablen auslesen\r
+ #\r
+ # Parameter: -nichts-\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def get_defined_vars(self):\r
+ template = self.get_template()\r
+ if template.find('{DEFINE ') == -1: return\r
+\r
+ offset = 0\r
+\r
+ while template.find('{DEFINE ',offset) != -1:\r
+ begin = template.find('{DEFINE ',offset)+8\r
+ offset = begin\r
+\r
+ name = ''\r
+ content = ''\r
+\r
+ var_open = 0\r
+ name_found = 0\r
+ define_block = 0\r
+\r
+ x = begin\r
+\r
+ while x < len(template):\r
+ if template[x] == '\012' or template[x] == '\015':\r
+ # Wenn in einem {DEFINE}-Block ein Zeilenumbruch gefunden wird,\r
+ # brechen wir mit dem Parsen des Blockes ab\r
+\r
+ break\r
+\r
+ if var_open == 1:\r
+ if template[x] == '"':\r
+ # Der Inhalt der Variable ist hier zu Ende\r
+\r
+ var_open = 0\r
+\r
+ if template[x+1] == '}':\r
+ # Hier ist der Block zu Ende\r
+\r
+ if self.get_var(name) is None:\r
+ # Die Variable wird nur gesetzt, wenn sie nicht bereits gesetzt ist\r
+\r
+ self.set_var(name,content)\r
+ self.defined_vars.append(name)\r
+\r
+ # {DEFINE}-Block entfernen\r
+\r
+ pre = template[0:begin-8]\r
+ post = template[x+2:]\r
+\r
+ template = pre+post\r
+\r
+ # Fertig!\r
+\r
+ offset = len(pre)\r
+ break\r
+\r
+ elif template[x] == '\\':\r
+ # Ein Backslash wurde gefunden, er dient zum Escapen von Zeichen\r
+\r
+ if template[x+1] == 'n':\r
+ # "\n" in Zeilenumbrueche umwandeln\r
+\r
+ content += "\n"\r
+ else:\r
+ content += template[x+1]\r
+\r
+ x += 1\r
+\r
+ else:\r
+ content += template[x]\r
+\r
+ else:\r
+ if name_found == 1:\r
+ if var_open == 0:\r
+ if template[x] == '"':\r
+ var_open = 1\r
+ else:\r
+ break\r
+\r
+ else:\r
+ # Variablennamen auslesen\r
+\r
+ if template[x] == '}' and name != '':\r
+ # Wir haben einen {DEFINE}-Block\r
+\r
+ name_found = 1\r
+ define_found = 1\r
+\r
+ # Alles ab hier sollte mit dem Teil verbunden werden, der das\r
+ # {DEFINE} in einer Zeile verarbeitet\r
+\r
+ # Der Parser fuer {DEFINE}-Bloecke ist nicht rekursiv, was auch\r
+ # nicht noetig sein sollte\r
+\r
+ if template.find('{ENDDEFINE}',x) != -1:\r
+ end = template.find('{ENDDEFINE}',x)\r
+ x += 1\r
+\r
+ content = template[x:end]\r
+\r
+ if self.get_var(name) is None:\r
+ # Die Variable wird nur gesetzt, wenn sie nicht bereits gesetzt ist\r
+\r
+ self.set_var(name,content)\r
+ self.defined_vars.append(name)\r
+\r
+ pre = template[0:begin-8]\r
+ post = template[end+11:]\r
+\r
+ template = pre + post\r
+\r
+ # Fertig!\r
+\r
+ offset = len(pre)\r
+ break\r
+\r
+ else:\r
+ break\r
+\r
+ elif template[x] != ' ':\r
+ name += template[x]\r
+\r
+ elif template[x] != '':\r
+ name_found = 1\r
+\r
+ else:\r
+ break\r
+\r
+ x += 1\r
+\r
+ self.set_template(template)\r
+\r
+ # parse_if_block()\r
+ #\r
+ # IF-Bloecke verarbeiten\r
+ #\r
+ # Parameter: 1. Name des IF-Blocks (das, was nach dem IF steht)\r
+ # 2. Status-Code (true => Inhalt anzeigen\r
+ # false => Inhalt nicht anzeigen\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def parse_if_block(self,name,state,no_negate=0):\r
+ name = str(name)\r
+ template = self.get_template()\r
+\r
+ count = 0;\r
+\r
+ while template.find('{IF '+name+'}') >= 0:\r
+ count += 1\r
+\r
+ start = template.find('{IF '+name+'}')\r
+ tpl_tmp = template[start:]\r
+ splitted = tpl_tmp.split('{ENDIF}')\r
+\r
+ block = '' # Kompletter bedingter Block\r
+ ifs = 0 # IF-Zaehler (wird fuer jedes IF erhoeht und fuer jedes ENDIF erniedrigt)\r
+\r
+ # {IF}\r
+\r
+ x = 0\r
+\r
+ while x < len(splitted):\r
+ # Verschachtelungsfehler abfangen\r
+ if x == len(splitted)-1: raise TplClassIFNestingError(self.file,name,count)\r
+\r
+ ifs += splitted[x].count('{IF ') # Zum Zaehler jedes Vorkommen von IF hinzuzaehlen\r
+ ifs -= 1 # Zaehler um 1 erniedrigen\r
+ block += splitted[x]+'{ENDIF}' # Daten zum Block hinzufuegen\r
+\r
+ x += 1\r
+\r
+ if ifs == 0:\r
+ # Zaehler wieder 0, also haben wir das Ende des IF-Blocks gefunden :-))\r
+ break\r
+\r
+ if_block = block[len(name)+5:-7] # Alles zwischen {IF} und {ENDIF}\r
+\r
+ # {ELSE}\r
+\r
+ else_block = '' # Alles ab {ELSE}\r
+ ifs = 0 # IF-Zaehler\r
+\r
+ splitted = if_block.split('{ELSE}');\r
+\r
+ x = 0\r
+\r
+ while x < len(splitted):\r
+ ifs += splitted[x].count('{IF ') # Zum Zaehler jedes Vorkommen von IF hinzuzaehlen\r
+ ifs -= splitted[x].count('{ENDIF}') # Vom Zaehler jedes Vorkommen von ENDIF abziehen\r
+\r
+ x += 1\r
+\r
+ if ifs == 0:\r
+ # Zaehler 0, also haben wir das Ende des IF-Abschnitts gefunden\r
+\r
+ # Aus dem Rest den ELSE-Block zusammenbauen\r
+\r
+ y = x\r
+\r
+ while y < len(splitted):\r
+ else_block += '{ELSE}'+splitted[y]\r
+ y += 1\r
+\r
+ if else_block:\r
+ if_block = if_block[0:len(if_block)-len(else_block)]\r
+ else_block = else_block[6:]\r
+\r
+ break\r
+\r
+ if state:\r
+ replacement = if_block\r
+ else:\r
+ replacement = else_block\r
+\r
+ template = template.replace(block,replacement)\r
+\r
+ self.set_template(template)\r
+\r
+ # Evtl. verneinte Form parsen\r
+\r
+ if not no_negate:\r
+ self.parse_if_block('!'+name,not state,1)\r
+\r
+ # parse_if_blocks()\r
+ #\r
+ # IF-Bloecke zu allen definierten Variablen verarbeiten\r
+ #\r
+ # Parameter: Array mit zu verarbeitenden IF-Bloecken (optional)\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def parse_if_blocks(self,valid=None):\r
+ if valid is None:\r
+ valid_vars = self.get_var()\r
+ else:\r
+ valid_vars = valid\r
+\r
+ for valid_var in valid_vars:\r
+ self.parse_if_block(valid_var,self.get_var(valid_var))\r
+\r
+ # parse_trim_blocks()\r
+ #\r
+ # {TRIM}-Bloecke parsen\r
+ #\r
+ # Dieser Parser ist nicht rekursiv, was auch nicht\r
+ # noetig sein sollte.\r
+ #\r
+ # Parameter: -nichts-\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def parse_trim_blocks(self):\r
+ template = self.get_template()\r
+ if template.find('{TRIM}') == -1: return\r
+\r
+ offset = 0\r
+\r
+ while template.find('{TRIM}',offset) >= 0:\r
+ begin = template.find('{TRIM}',offset)\r
+\r
+ if template.find('{ENDTRIM}',begin+6) >= 0:\r
+ end = template.find('{ENDTRIM}',begin+6)\r
+\r
+ block = template[begin:end+9]\r
+ content = block[6:-9]\r
+\r
+ trimmed = content.strip()\r
+\r
+ template = template.replace(block,trimmed)\r
+\r
+ offset = begin+len(trimmed)\r
+ else:\r
+ break\r
+\r
+ self.set_template(template)\r
+\r
+ # parse_condtag()\r
+ #\r
+ # Bedingungstags in einem Vorlagentext verarbeiten\r
+ #\r
+ # Parameter: 1. Tagname\r
+ # 2. Status-Code (true => Tag-Inhalt anzeigen\r
+ # false => Tag-Inhalt nicht anzeigen\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def parse_condtag(self,condtag,state):\r
+ condtag = str(condtag)\r
+ template = self.get_template()\r
+\r
+ while template.find('<'+condtag+'>') >= 0:\r
+ start = template.find('<'+condtag+'>') # Beginn des Blocks\r
+ end = template.find('</'+condtag+'>')+len(condtag)+3 # Ende des Blocks\r
+\r
+ extract = template[start:end] # Kompletten Bedingungsblock extrahieren...\r
+\r
+ if state:\r
+ replacement = extract[len(condtag)+2:0-len(condtag)-3]\r
+ else:\r
+ replacement = ''\r
+\r
+ template = template.replace(extract,replacement) # Block durch neue Daten ersetzen\r
+\r
+ self.set_template(template)\r
+\r
+ # parse_includes()\r
+ #\r
+ # {INCLUDE}-Anweisungen verarbeiten\r
+ #\r
+ # Parameter: -nichts-\r
+ #\r
+ # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)\r
+\r
+ def parse_includes(self):\r
+ template = self.get_template()\r
+ if template.find('{INCLUDE ') == -1: return\r
+\r
+ offset = 0\r
+\r
+ while template.find('{INCLUDE ',offset) >= 0:\r
+ begin = template.find('{INCLUDE ',offset)\r
+\r
+ start = begin+9\r
+ offset = start\r
+ long = 0\r
+\r
+ if template[start] == '"':\r
+ long = 1\r
+ start += 1\r
+\r
+ file = ''\r
+ skip = 0\r
+\r
+ x = start\r
+\r
+ while x < len(template):\r
+ if template[x] == '\012' or template[x] == '\015':\r
+ skip = 1\r
+ break\r
+ elif long == 0 and template[x] == ' ':\r
+ skip = 1\r
+ break\r
+ elif long == 1 and template[x] == '"':\r
+ if template[x+1] != '}': skip = 1\r
+ break\r
+ elif long == 0 and template[x] == '}':\r
+ break\r
+ else:\r
+ file += template[x]\r
+\r
+ x += 1\r
+\r
+ if skip == 1: continue\r
+\r
+ if file != '':\r
+ filepath = file\r
+\r
+ if not os.path.isabs(file):\r
+ dir = os.path.dirname(self.file)\r
+ if not dir: dir = '.'\r
+ filepath = os.path.normpath(dir+'/'+file)\r
+\r
+ if os.path.isfile(filepath):\r
+ inc = Template()\r
+ inc.read_file(file)\r
+\r
+ if long == 1: end = start + len(file) + 2\r
+ else: end = start + len(file) + 1\r
+\r
+ pre = template[0:begin]\r
+ post = template[end:]\r
+\r
+ template = pre+inc.get_template()+post\r
+ offset = len(pre)+len(inc.get_template())\r
+\r
+ del(inc)\r
+\r
+ self.set_template(template)\r
+\r
+# Klasse zum Erzeugen des Fehlers bei falsch verschachtelten\r
+# {IF}-Bloecken\r
+\r
+class TplClassIFNestingError:\r
+\r
+ def __init__(self,file,name,count):\r
+ self.file = file\r
+ self.name = name\r
+ self.count = count\r
+\r
+ def __str__(self):\r
+ return 'Nesting error found while parsing IF block "'+self.name+'" nr. '+str(self.count)+' in template file "'+self.file+'"'\r
+\r
+#\r
+### Ende ###
\ No newline at end of file
git.p6c8.net / template-class.git / commitdiff