class.Template.php

   1 <?php
   2
   3 #
   4 # Template (Version 2.5)
   5 #
   6 # Klasse zum Parsen von Templates
   7 #
   8 # Autor:            Patrick Canterino <patrick@patshaping.de>
   9 # Letzte Aenderung: 25.11.2011
  10 #
  11 # Copyright (C) 2002-2011 Patrick Canterino
  12 #
  13 # Diese Datei kann unter den Bedingungen der "Artistic License 2.0"
  14 # weitergegeben und / oder veraendert werden.
  15 # Siehe:
  16 # http://www.opensource.org/licenses/artistic-license-2.0
  17 #
  18
  19 class Template {
  20     var $file;
  21     var $template;
  22     var $original;
  23     var $old_parsing = 0;
  24     var $vars = array();
  25     var $defined_vars = array();
  26     var $loop_vars = array();
  27
  28     # get_template()
  29     #
  30     # Kompletten Vorlagentext zurueckgeben
  31     #
  32     # Parameter: -keine-
  33     #
  34     # Rueckgabe: Kompletter Vorlagentext (String)
  35
  36     function get_template() {
  37         return $this->template;
  38     }
  39
  40     # set_template()
  41     #
  42     # Kompletten Vorlagentext aendern
  43     #
  44     # Parameter: Vorlagentext
  45     #
  46     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
  47
  48     function set_template($text) {
  49         $this->template = $text;
  50     }
  51
  52     # add_text()
  53     #
  54     # Vorlagentext ans Template-Objekt anhaengen
  55     #
  56     # Parameter: Vorlagentext
  57     #
  58     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
  59
  60     function add_text($text) {
  61         $this->set_template($this->get_template().$text);
  62     }
  63
  64     # read_file()
  65     #
  66     # Einlesen einer Vorlagendatei und {INCLUDE}-Anweisungen ggf. verarbeiten
  67     # (Text wird an bereits vorhandenen Text angehaengt)
  68     #
  69     # Parameter: 1. Datei zum Einlesen
  70     #            2. Status-Code (Boolean):
  71     #               true  => {INCLUDE}-Anweisungen nicht verarbeiten
  72     #               false => {INCLUDE}-Anweisungen verarbeiten (Standard)
  73     #
  74     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
  75
  76     function read_file($file,$not_include=0) {
  77         $this->file = $file;
  78
  79         if(filesize($file) > 0) {
  80             $fp = fopen($file,'r');
  81             if(!$fp) die;
  82             $content = fread($fp,filesize($file));
  83             fclose($fp);
  84         }
  85         else $content = '';
  86
  87         $this->add_text($content);
  88         $this->save_state();
  89
  90         if(!$not_include) $this->parse_includes();
  91     }
  92
  93     # set_var()
  94     #
  95     # Wert einer Variable setzen
  96     #
  97     # Parameter: 1. Name der Variable
  98     #            2. Wert, den die Variable erhalten soll
  99     #
 100     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 101
 102     function set_var($var,$content) {
 103         $this->vars[$var] = $content;
 104     }
 105
 106     # get_var()
 107     #
 108     # Wert einer Variable zurueckgeben
 109     #
 110     # Parameter: (optional) Variablenname
 111     #
 112     # Rueckgabe: Wert der Variable;
 113     #            wenn die Variable nicht existiert, false;
 114     #            wenn kein Variablenname angegeben wurde, wird ein
 115     #            Array mit den Variablennamen zurueckgegeben
 116
 117     function get_var($var=false) {
 118         if($var !== false) {
 119             if(isset($this->vars[$var])) {
 120                 return $this->vars[$var];
 121             }
 122             else {
 123                 return false;
 124             }
 125         }
 126         else {
 127             return array_keys($this->vars);
 128         }
 129     }
 130
 131     # set_vars()
 132     #
 133     # Komplettes Variablen-Array mit einem anderen Array ueberschreiben
 134     #
 135     # Parameter: Array
 136     #
 137     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 138
 139     function set_vars($vars) {
 140         $this->vars = $vars;
 141     }
 142
 143     # add_vars()
 144     #
 145     # Zum bestehenden Variablen-Array weitere Variablen in Form eines Arrays
 146     # hinzufuegen
 147     #
 148     # Parameter: Array
 149     #
 150     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 151
 152     function add_vars($vars) {
 153         $this->vars = array_merge($this->vars,$vars);
 154     }
 155
 156     # set_loop_data()
 157     #
 158     # Daten fuer eine Schleife setzen
 159     #
 160     # Parameter: 1. Name der Schleife
 161     #            2. Array mit den Arrays mit den Variablen fuer
 162     #               die Schleifendurchgaenge
 163     #
 164     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 165
 166     function set_loop_data($loop,$data) {
 167         $this->loop_vars[$loop] = $data;
 168     }
 169
 170     # add_loop_data()
 171     #
 172     # Daten fuer einen Schleifendurchgang hinzufuegen
 173     #
 174     # Parameter: 1. Name der Schleife
 175     #            2. Array mit den Variablen fuer den
 176     #               Schleifendurchgang
 177     #
 178     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 179
 180     function add_loop_data($loop,$data) {
 181         if(isset($this->loop_vars[$loop]) && is_array($this->loop_vars[$loop])) {
 182             array_push($this->loop_vars[$loop],$data);
 183         }
 184         else {
 185             $this->loop_vars[$loop] = array($data);
 186         }
 187     }
 188
 189     # parse()
 190     #
 191     # In der Template definierte Variablen auslesen, Variablen
 192     # ersetzen, {IF}- und {TRIM}-Bloecke parsen
 193     #
 194     # Parameter: -nichts-
 195     #
 196     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 197
 198     function parse() {
 199         if($this->old_parsing) return $this->parse_old();
 200
 201         # Zuerst die Schleifen parsen
 202
 203         if(is_array($this->loop_vars) && ($loops = array_keys($this->loop_vars))) {
 204             foreach($loops as $loop) {
 205                 $this->parse_loop($loop);
 206             }
 207         }
 208
 209         # In Template-Datei definierte Variablen auslesen
 210
 211         $this->get_defined_vars();
 212
 213         # Variablen ersetzen
 214
 215         if(($vars = $this->get_var()) !== false && is_array($vars)) {
 216             $this->parse_if_blocks();
 217             $this->replace_vars();
 218         }
 219
 220         # {TRIM}-Bloecke entfernen
 221
 222         $this->parse_trim_blocks();
 223     }
 224
 225     # parse_old()
 226     #
 227     # In der Template definierte Variablen auslesen, Variablen
 228     # ersetzen, {IF}- und {TRIM}-Bloecke parsen
 229     # (alte Methode)
 230     #
 231     # Parameter: -nichts-
 232     #
 233     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 234
 235     function parse_old() {
 236         # Zuerst die Schleifen parsen
 237
 238         if(is_array($this->loop_vars) && ($loops = array_keys($this->loop_vars))) {
 239             foreach($loops as $loop) {
 240                 $this->parse_loop($loop);
 241             }
 242         }
 243
 244         # Normale Variablen durchgehen
 245
 246         if(($vars = $this->get_var()) !== false && is_array($vars)) {
 247             foreach($vars as $var) {
 248                 $val = $this->get_var($var);
 249
 250                 $this->parse_if_block($var,$val);
 251
 252                 if(is_array($val)) {
 253                     $this->fillin_array($var,$val);
 254                 }
 255                 else {
 256                     $this->fillin($var,$val);
 257                 }
 258
 259                 unset($val);
 260             }
 261         }
 262
 263         # Jetzt dasselbe mit denen, die direkt in der Template-Datei definiert
 264         # sind, machen. Ich weiss, dass das eine ziemlich unsaubere Loesung ist,
 265         # aber es funktioniert
 266
 267         $this->get_defined_vars();
 268
 269         foreach($this->defined_vars as $var) {
 270             $val = $this->get_var($var);
 271
 272             $this->parse_if_block($var,$val);
 273             $this->fillin($var,$val);
 274
 275             unset($val);
 276         }
 277
 278         # {TRIM}-Bloecke entfernen
 279
 280         $this->parse_trim_blocks();
 281     }
 282
 283     # fillin()
 284     #
 285     # Variablen durch Text ersetzen
 286     #
 287     # Parameter: 1. Variable zum Ersetzen
 288     #            2. Text, durch den die Variable ersetzt werden soll
 289     #
 290     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 291
 292     function fillin($var,$text) {
 293         $template = $this->get_template();
 294         $template = str_replace('{'.$var.'}',$text,$template);
 295
 296         $this->set_template($template);
 297     }
 298
 299     # fillin_array()
 300     #
 301     # Variable durch Array ersetzen
 302     #
 303     # Parameter: 1. Variable zum Ersetzen
 304     #            2. Array, durch das die Variable ersetzt werden soll
 305     #            3. Zeichenkette, mit der das Array verbunden werden soll
 306     #               (Standard: '')
 307     #
 308     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 309
 310     function fillin_array($var,$array,$glue='') {
 311         $this->fillin($var,implode($glue,$array));
 312     }
 313
 314     # replace_vars()
 315     #
 316     # Variablen eine nach der anderen ersetzen. Sollte in einer Variable eine
 317     # andere Variable auftauchen, so wird diese nicht ersetzt.
 318     #
 319     # Parameter: Array mit zu parsenden Variablen (optional)
 320     #
 321     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 322
 323     function replace_vars($valid=array()) {
 324         $template = $this->get_template();
 325
 326         $valid_vars = (empty($valid)) ? $this->get_var() : $valid;
 327
 328         for($x=0;$x<strlen($template);$x++) {
 329             if($template[$x] == '{') {
 330                 foreach($valid_vars as $var) {
 331                     # Pruefen, ob hier eine gueltige Variable beginnt
 332
 333                     if(substr($template,$x+1,strlen($var)+1) == $var.'}') {
 334                         if(is_array($this->get_var($var))) {
 335                             $content = implode('',$this->get_var($var));
 336                         }
 337                         else {
 338                             $content = $this->get_var($var);
 339                         }
 340
 341                         # Daten vor und nach der Variable
 342
 343                         $pre  = substr($template,0,$x);
 344                         $post = substr($template,strlen($pre)+2+strlen($var));
 345
 346                         # Alles neu zusammensetzen
 347
 348                         $template = $pre.$content.$post;
 349
 350                         # Zaehler aendern
 351
 352                         $x = strlen($pre.$content)-1;
 353                     }
 354                 }
 355             }
 356         }
 357
 358         $this->set_template($template);
 359     }
 360
 361     # to_file()
 362     #
 363     # Template in Datei schreiben
 364     #
 365     # Parameter: Datei-Handle
 366     #
 367     # Rueckgabe: Status-Code (Boolean)
 368
 369     function to_file($handle) {
 370         return @fwrite($handle,$this->get_template());
 371     }
 372
 373     # reset()
 374     #
 375     # Den gesicherten Stand des Template-Textes wiederherstellen
 376     #
 377     # Parameter: -nichts-
 378     #
 379     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 380
 381     function reset() {
 382         $this->template = $this->original;
 383     }
 384
 385     # save_state()
 386     #
 387     # Aktuellen Stand des Template-Textes sichern
 388     # (alte Sicherung wird ueberschrieben)
 389     #
 390     # Parameter: -nichts-
 391     #
 392     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 393
 394     function save_state() {
 395         $this->original = $this->template;
 396     }
 397
 398     # parse_loop()
 399     #
 400     # Eine Schleife parsen
 401     #
 402     # Parameter: Name der Schleife
 403     #
 404     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 405
 406     function parse_loop($name) {
 407         $template = $this->get_template();
 408         if(strpos($template,'{LOOP '.$name.'}') === false) return;
 409
 410         $offset   = 0;
 411         $name_len = strlen($name);
 412
 413         while(($begin = strpos($template,'{LOOP '.$name.'}',$offset)) !== false) {
 414             if(($end = strpos($template,'{ENDLOOP}',$begin+6+$name_len)) !== false) {
 415                 $block   = substr($template,$begin,$end+9-$begin);
 416                 $content = substr($block,$name_len+7,-9);
 417
 418                 $parsed_block = '';
 419
 420                 for($x=0;$x<count($this->loop_vars[$name]);$x++) {
 421                     $loop_data = $this->loop_vars[$name][$x];
 422                     $loop_vars = array_keys($loop_data);
 423
 424                     $ctpl = new Template;
 425                     $ctpl->set_template($content);
 426
 427                     foreach($loop_vars as $loop_var) {
 428                         $ctpl->set_var($name.'.'.$loop_var,$loop_data[$loop_var]);
 429                     }
 430
 431                     if($this->old_parsing) {
 432                         $ctpl->parse_old();
 433                     }
 434                     else {
 435                         $ctpl->parse();
 436                     }
 437
 438                     $parsed_block .= $ctpl->get_template();
 439
 440                     unset($ctpl);
 441                 }
 442
 443                 $template = str_replace($block,$parsed_block,$template);
 444                 $offset   = $begin+strlen($parsed_block);
 445             }
 446             else break;
 447         }
 448
 449         $this->set_template($template);
 450         }
 451
 452         # get_defined_vars()
 453         #
 454         # In der Template-Datei definierte Variablen auslesen
 455         #
 456         # Parameter: -nichts-
 457         #
 458         # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 459
 460         function get_defined_vars() {
 461             $template = $this->get_template();
 462             if(strpos($template,'{DEFINE ') === false) return;
 463
 464             $offset = 0;
 465
 466             while(strpos($template,'{DEFINE ',$offset) !== false) {
 467                 $begin  = strpos($template,'{DEFINE ',$offset)+8;
 468                 $offset = $begin;
 469
 470                 $name    = '';
 471                 $content = '';
 472
 473                 $var_open     = 0;
 474                 $name_found   = 0;
 475                 $define_block = 0;
 476
 477                 for($x=$begin;$x<strlen($template);$x++) {
 478                     if($template[$x] == "\012" || $template[$x] == "\015") {
 479                         # Wenn in einem {DEFINE}-Block ein Zeilenumbruch gefunden wird,
 480                         # brechen wir mit dem Parsen des Blockes ab
 481
 482                         break;
 483                     }
 484
 485                     if($var_open == 1) {
 486                         if($template[$x] == '"') {
 487                             # Der Inhalt der Variable ist hier zu Ende
 488
 489                             $var_open = 0;
 490
 491                             if($template[$x+1] == '}') {
 492                                 # Hier ist der Block zu Ende
 493
 494                                 if($this->get_var($name) === false) {
 495                                     # Die Variable wird nur gesetzt, wenn sie nicht bereits gesetzt ist
 496
 497                                     $this->set_var($name,$content);
 498                                     array_push($this->defined_vars,$name);
 499                                 }
 500
 501                             # {DEFINE}-Block entfernen
 502
 503                             $pre  = substr($template,0,$begin-8);
 504                             $post = substr($template,$x+2);
 505
 506                             $template = $pre.$post;
 507
 508                             # Fertig!
 509
 510                             $offset = strlen($pre);
 511                             break;
 512                         }
 513                     }
 514                     elseif($template[$x] == '\\') {
 515                         # Ein Backslash wurde gefunden, er dient zum Escapen von Zeichen
 516
 517                         if($template[$x+1] == 'n') {
 518                             # "\n" in Zeilenumbrueche umwandeln
 519
 520                             $content .= "\n";
 521                         }
 522                         else $content .= $template[$x+1];
 523
 524                         $x++;
 525                     }
 526                     else $content .= $template[$x];
 527                 }
 528                 else {
 529                     if($name_found == 1) {
 530                         if($var_open == 0) {
 531                             if($template[$x] == '"') $var_open = 1;
 532                             else break;
 533                         }
 534                     }
 535                     else {
 536                         # Variablennamen auslesen
 537
 538                         if($template[$x] == '}' && $name != '') {
 539                             # Wir haben einen {DEFINE}-Block
 540
 541                             $name_found   = 1;
 542                             $define_block = 1;
 543
 544                             # Alles ab hier sollte mit dem Teil verbunden werden, der das
 545                             # {DEFINE} in einer Zeile verarbeitet
 546
 547                             # Der Parser fuer {DEFINE}-Bloecke ist nicht rekursiv, was auch
 548                             # nicht noetig sein sollte
 549
 550                             if(($end = strpos($template,'{ENDDEFINE}',$x)) !== false) {
 551                                 $x++;
 552
 553                                 $content = substr($template,$x,$end-$x);
 554
 555                                 if($this->get_var($name) === false) {
 556                                     # Die Variable wird nur gesetzt, wenn sie nicht bereits gesetzt ist
 557
 558                                     $this->set_var($name,$content);
 559                                     array_push($this->defined_vars,$name);
 560                                 }
 561
 562                                 $pre  = substr($template,0,$begin-8);
 563                                 $post = substr($template,$end+11);
 564
 565                                 $template = $pre.$post;
 566
 567                                 # Fertig!
 568
 569                                 $offset = strlen($pre);
 570                                 break;
 571                             }
 572                             else break;
 573                         }
 574                         elseif($template[$x] != ' ') {
 575                             $name .= $template[$x];
 576                         }
 577                         elseif($name != '') {
 578                             $name_found = 1;
 579                         }
 580                         else break;
 581                     }
 582                 }
 583             }
 584         }
 585
 586         $this->set_template($template);
 587     }
 588
 589     # parse_if_block()
 590     #
 591     # IF-Bloecke verarbeiten
 592     #
 593     # Parameter: 1. Name des IF-Blocks (das, was nach dem IF steht)
 594     #            2. Status-Code (true  => Inhalt anzeigen
 595     #                            false => Inhalt nicht anzeigen
 596     #            3. true  => Verneinten Block nicht parsen
 597     #               false => Verneinten Block parsen (Standard)
 598     #
 599     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 600
 601     function parse_if_block($name,$state,$no_negate=0) {
 602         $template = $this->get_template();
 603
 604         $count = 0;
 605
 606         while(strpos($template,'{IF '.$name.'}') !== false) {
 607             # Das alles hier ist nicht wirklich elegant geloest...
 608             # ... aber solange es funktioniert... ;-)
 609
 610             $count++;
 611
 612             $start    = strpos($template,'{IF '.$name.'}');
 613             $tpl_tmp  = substr($template,$start);
 614             $splitted = explode('{ENDIF}',$tpl_tmp);
 615
 616             $block = ''; # Kompletter bedingter Block
 617             $ifs   = 0;  # IF-Zaehler (wird fuer jedes IF erhoeht und fuer jedes ENDIF erniedrigt)
 618
 619             # {IF}
 620
 621             for($x=0;$x<count($splitted);$x++) {
 622                 if($x == count($splitted)-1) die('Nesting error found while parsing IF block "'.$name.'" nr. '.$count.' in template file "'.$this->file.'"');
 623
 624                 $ifs += substr_count($splitted[$x],'{IF '); # Zum Zaehler jedes Vorkommen von IF hinzuzaehlen
 625                 $ifs--;                                     # Zaehler um 1 erniedrigen
 626                 $block .= $splitted[$x].'{ENDIF}';          # Daten zum Block hinzufuegen
 627
 628                 if($ifs == 0) {
 629                     # Zaehler wieder 0, also haben wir das Ende des IF-Blocks gefunden :-))
 630
 631                     break;
 632                 }
 633             }
 634
 635             $if_block = substr($block,strlen($name)+5,-7); # Alles zwischen {IF} und {ENDIF}
 636
 637             # {ELSE}
 638
 639             $else_block = ''; # Alles ab {ELSE}
 640             $ifs        = 0;  # IF-Zaehler
 641
 642             $splitted = explode('{ELSE}',$if_block);
 643
 644             for($x=0;$x<count($splitted);$x++) {
 645                 $ifs += substr_count($splitted[$x],'{IF ');    # Zum Zaehler jedes Vorkommen von IF hinzuzaehlen
 646                 $ifs -= substr_count($splitted[$x],'{ENDIF}'); # Vom Zaehler jedes Vorkommen von ENDIF abziehen
 647
 648                 if($ifs == 0) {
 649                     # Zaehler 0, also haben wir das Ende des IF-Abschnitts gefunden
 650
 651                     # Aus dem Rest den ELSE-Block zusammenbauen
 652
 653                     for($y=$x+1;$y<count($splitted);$y++) {
 654                         $else_block .= '{ELSE}'.$splitted[$y];
 655                     }
 656
 657                     if($else_block) {
 658                         $if_block   = substr($if_block,0,strlen($if_block)-strlen($else_block));
 659                         $else_block = substr($else_block,6);
 660                     }
 661
 662                     break;
 663                 }
 664             }
 665
 666             # Block durch die jeweiligen Daten ersetzen
 667
 668             $replacement = ($state) ? $if_block : $else_block;
 669
 670             $template = str_replace($block,$replacement,$template);
 671         }
 672
 673         $this->set_template($template);
 674
 675         # Evtl. verneinte Form parsen
 676
 677         if(!$no_negate) {
 678             $this->parse_if_block('!'.$name,!$state,1);
 679         }
 680     }
 681
 682     # parse_if_blocks()
 683     #
 684     # IF-Bloecke zu allen definierten Variablen verarbeiten
 685     #
 686     # Parameter: Array mit zu verarbeitenden IF-Bloecken (optional)
 687     #
 688     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 689
 690     function parse_if_blocks($valid=array()) {
 691         $valid_vars = (empty($valid)) ? $this->get_var() : $valid;
 692
 693         foreach($valid_vars as $valid_var) {
 694             $this->parse_if_block($valid_var,$this->get_var($valid_var));
 695         }
 696     }
 697
 698     # parse_trim_blocks()
 699     #
 700     # {TRIM}-Bloecke parsen
 701     #
 702     # Dieser Parser ist nicht rekursiv, was auch nicht
 703     # noetig sein sollte.
 704     #
 705     # Parameter: -nichts-
 706     #
 707     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 708
 709     function parse_trim_blocks() {
 710         $template = $this->get_template();
 711         if(strpos($template,'{TRIM}') === false) return;
 712
 713         $offset = 0;
 714
 715         while(($begin = strpos($template,'{TRIM}',$offset)) !== false) {
 716             if(($end = strpos($template,'{ENDTRIM}',$begin+6)) !== false) {
 717                 $block    = substr($template,$begin,$end+9-$begin);
 718                 $content  = substr($block,6,-9);
 719
 720                 $trimmed  = trim($content);
 721
 722                 $template = str_replace($block,$trimmed,$template);
 723
 724                 $offset   = $begin+strlen($trimmed);
 725             }
 726             else break;
 727         }
 728
 729         $this->set_template($template);
 730     }
 731
 732     # parse_condtag()
 733     #
 734     # Bedingungstags in einem Vorlagentext verarbeiten
 735     #
 736     # Parameter: 1. Tagname
 737     #            2. Status-Code (true  => Tag-Inhalt anzeigen
 738     #                            false => Tag-Inhalt nicht anzeigen
 739     #
 740     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 741
 742     function parse_condtag($condtag,$state) {
 743         $template = $this->get_template();
 744
 745         while(strpos($template,'<'.$condtag.'>') !== false) {
 746             $start = strpos($template,'<'.$condtag.'>');                                        # Beginn des Blocks
 747             $end   = strpos($template,'</'.$condtag.'>')+strlen($condtag)+3;                    # Ende des Blocks
 748
 749             $extract = substr($template,$start,$end-$start);                                    # Kompletten Bedingungsblock extrahieren...
 750
 751             $replacement = ($state) ? substr($extract,strlen($condtag)+2,0-strlen($condtag)-3) : '';
 752
 753             $template = str_replace($extract,$replacement,$template);                           # Block durch neue Daten ersetzen
 754         }
 755
 756         $this->set_template($template);
 757     }
 758
 759     # parse_includes()
 760     #
 761     # {INCLUDE}-Anweisungen verarbeiten
 762     #
 763     # Parameter: -nichts-
 764     #
 765     # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
 766
 767     function parse_includes() {
 768         $template = $this->get_template();
 769         if(strpos($template,'{INCLUDE ') === false) return;
 770
 771         $offset = 0;
 772
 773         $y = 0;
 774
 775         while(($begin = strpos($template,'{INCLUDE ',$offset)) !== false) {
 776             $y++;
 777
 778             $start  = $begin+9;
 779             $offset = $start;
 780             $long   = 0;
 781
 782             if($template[$start] == '"') {
 783                 $long = 1;
 784                 $start++;
 785             }
 786
 787             $file = '';
 788             $skip = 0;
 789
 790             for($x=$start;$x<strlen($template);$x++) {
 791                 if($template[$x] == "\012" || $template[$x] == "\015") {
 792                     $skip = 1;
 793                     break;
 794                 }
 795                 elseif($long == 0 && $template[$x] == ' ') {
 796                     $skip = 1;
 797                     break;
 798                 }
 799                 elseif($long == 1 && $template[$x] == '"') {
 800                     if($template[$x+1] != '}') $skip = 1;
 801                     break;
 802                 }
 803                 elseif($long == 0 && $template[$x] == '}') {
 804                     break;
 805                 }
 806                 else {
 807                     $file .= $template[$x];
 808                 }
 809             }
 810
 811             if($skip == 1) continue;
 812
 813             if($file != '') {
 814                 $filepath = $file;
 815
 816                 $is_absolute = (strtoupper(substr(PHP_OS,0,3)) === 'WIN')
 817                              ? preg_match('!^([a-z]:)?/!i',$file)
 818                              : preg_match('!^/!',$file);
 819
 820                 if(!$is_absolute) {
 821                     if(!empty($this->file)) $dir = dirname($this->file);
 822                     else $dir = '.';
 823
 824                     $dir = str_replace('\\','/',$dir);
 825
 826                     if(!preg_match('!/+$!',$dir)) $dir .= '/';
 827
 828                     $filepath = $dir.$file;
 829                 }
 830
 831                 if(is_file($filepath)) {
 832                     $inc = new Template;
 833                     $inc->read_file($filepath);
 834
 835                     $end = ($long == 1)
 836                          ? $start + strlen($file) + 2
 837                          : $start + strlen($file) + 1;
 838
 839                     $pre  = substr($template,0,$begin);
 840                     $post = substr($template,$end);
 841
 842                     $template = $pre.$inc->get_template().$post;
 843                     $offset   = strlen($pre)+strlen($inc->get_template());
 844
 845                     unset($inc);
 846                 }
 847             }
 848         }
 849
 850         $this->set_template($template);
 851     }
 852 }
 853
 854 #
 855 ### Ende ###
 856
 857 ?>