home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 August / PCWorld_2001-08_cd.bin / Komunikace / phptriad / phptriadsetup2-11.exe / php / pear / HTML / IT.php < prev    next >
PHP Script  |  2001-02-08  |  27KB  |  829 lines
  1. <?php
  2. //
  3. // +----------------------------------------------------------------------+
  4. // | PHP version 4.0                                                      |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997-2001 The PHP Group                                |
  7. // +----------------------------------------------------------------------+
  8. // | This source file is subject to version 2.02 of the PHP license,      |
  9. // | that is bundled with this package in the file LICENSE, and is        |
  10. // | available at through the world-wide-web at                           |
  11. // | http://www.php.net/license/2_02.txt.                                 |
  12. // | If you did not receive a copy of the PHP license and are unable to   |
  13. // | obtain it through the world-wide-web, please send a note to          |
  14. // | license@php.net so we can mail you a copy immediately.               |
  15. // +----------------------------------------------------------------------+
  16. // | Authors: Ulf Wendel <ulf.wendel@phpdoc.de>                           |
  17. // +----------------------------------------------------------------------+
  18. //
  19. // $Id: IT.php,v 1.4 2001/02/08 22:19:59 chagenbu Exp $
  20. //
  21. /**
  22. * Integrated Template - IT
  23. * 
  24. * Well there's not much to say about it. I needed a template class that
  25. * supports a single template file with multiple (nested) blocks inside and 
  26. * a simple block API.
  27. * 
  28. * The Isotemplate API is somewhat tricky for a beginner although it is the best
  29. * one you can build. template::parse() [phplib template = Isotemplate] requests
  30. * you to name a source and a target where the current block gets parsed into.
  31. * Source and target can be block names or even handler names. This API gives you
  32. * a maximum of fexibility but you always have to know what you do which is 
  33. * quite unusual for php skripter like me.
  34. * 
  35. * I noticed that I do not any control on which block gets parsed into which one. 
  36. * If all blocks are within one file, the script knows how they are nested and in 
  37. * which way you have to parse them. IT knows that inner1 is a child of block2, there's
  38. * no need to tell him about this.
  39. * 
  40. * <table border>
  41. *   <tr>
  42. *     <td colspan=2>
  43. *       __global__
  44. *       <p>
  45. *       (hidden and automatically added)
  46. *     </td>
  47. *   </tr>
  48. *   <tr>
  49. *     <td>block1</td>
  50. *     <td>
  51. *       <table border>
  52. *         <tr>
  53. *           <td colspan=2>block2</td>
  54. *         </tr>
  55. *         <tr>
  56. *           <td>inner1</td>
  57. *           <td>inner2</td>
  58. *         </tr>
  59. *       </table>
  60. *     </td>
  61. *   </tr>
  62. * </table>
  63. * 
  64. * To add content to block1 you simply type:
  65. * <code>$tpl->setCurrentBlock("block1");</code>
  66. * and repeat this as often as needed:
  67. * <code>
  68. *   $tpl->setVariable(...);
  69. *   $tpl->parseCurrentBlock();
  70. * </code>
  71. * 
  72. * To add content to block2 you would type something like:
  73. * <code>
  74. * $tpl->setCurrentBlock("inner1");
  75. * $tpl->setVariable(...);
  76. * $tpl->parseCurrentBlock();
  77. * 
  78. * $tpl->setVariable(...);
  79. * $tpl->parseCurrentBlock();
  80. *
  81. * $tpl->parse("block1");
  82. * </code>
  83. * 
  84. * This will result in one repition of block1 which contains two repitions
  85. * of inner1. inner2 will be removed if $removeEmptyBlock is set to true which is the default.
  86. * 
  87. * Usage:
  88. * <code>
  89. * $tpl = new IntegratedTemplate( [string filerootdir] );
  90. * 
  91. * // load a template or set it with setTemplate()
  92. * $tpl->loadTemplatefile( string filename [, boolean removeUnknownVariables, boolean removeEmptyBlocks] )
  93. *
  94. * // set "global" Variables meaning variables not beeing within a (inner) block
  95. * $tpl->setVariable( string variablename, mixed value );
  96. * 
  97. * // like with the Isotemplates there's a second way to use setVariable()
  98. * $tpl->setVariable( array ( string varname => mixed value ) );
  99. * 
  100. * // Let's use any block, even a deeply nested one
  101. * $tpl->setCurrentBlock( string blockname );
  102. *
  103. * // repeat this as often as you need it. 
  104. * $tpl->setVariable( array ( string varname => mixed value ) );
  105. * $tpl->parseCurrentBlock();
  106. *
  107. * // get the parsed template or print it: $tpl->show()
  108. * $tpl->get();
  109. * </code>
  110. * 
  111. * @author      Ulf Wendel <uw@netuse.de>
  112. * @version  $Id: IT.php,v 1.4 2001/02/08 22:19:59 chagenbu Exp $
  113. * @access        public
  114. */
  115. class IntegratedTemplate {
  116.  
  117.     /**
  118.     * Contains the error objects
  119.     * @var        array
  120.     * @access    public
  121.     * @see        halt(), $printError, $haltOnError
  122.     */
  123.     var $err = array();
  124.     
  125.     /**
  126.     * Print error messages?
  127.     * @var        boolean
  128.     * @access    public
  129.     * @see        halt(), $haltOnError, $err
  130.     */
  131.     var $printError = false;
  132.     
  133.     /**
  134.     * Call die() on error?
  135.     * @var        boolean
  136.     * @access    public
  137.     * @see        halt(), $printError, $err
  138.     */
  139.     var $haltOnError = false;
  140.     
  141.     /**
  142.     * Clear cache on get()? 
  143.     * @var    boolean
  144.     */ 
  145.     var $clearCache = false;
  146.         
  147.     /**
  148.     * First character of a variable placeholder ( _{_VARIABLE} ).
  149.     * @var        string
  150.     * @access    public
  151.     * @see        $closingDelimiter, $blocknameRegExp, $variablenameRegExp
  152.     */
  153.     var $openingDelimiter = "{";
  154.     
  155.     /**
  156.     * Last character of a variable placeholder ( {VARIABLE_}_ ).
  157.     * @var        string
  158.     * @access    public
  159.     * @see        $openingDelimiter, $blocknameRegExp, $variablenameRegExp
  160.     */
  161.     var $closingDelimiter     = "}";
  162.     
  163.     /**
  164.     * RegExp matching a block in the template. 
  165.     * Per default "sm" is used as the regexp modifier, "i" is missing.
  166.     * That means a case sensitive search is done.
  167.     * @var        string
  168.     * @access    public
  169.     * @see        $variablenameRegExp, $openingDelimiter, $closingDelimiter
  170.     */
  171.     var $blocknameRegExp    = "[0-9A-Za-z_-]+";
  172.     
  173.     /**
  174.     * RegExp matching a variable placeholder in the template.
  175.     * Per default "sm" is used as the regexp modifier, "i" is missing.
  176.     * That means a case sensitive search is done.
  177.     * @var        string    
  178.     * @access    public
  179.     * @see        $blocknameRegExp, $openingDelimiter, $closingDelimiter
  180.     */
  181.     var $variablenameRegExp    = "[0-9A-Za-z_-]+";
  182.     
  183.     /**
  184.     * RegExp used to find variable placeholder, filled by the constructor.
  185.     * @var      string    Looks somewhat like @(delimiter varname delimiter)@
  186.   * @access public
  187.     * @see    IntegratedTemplate()
  188.     */
  189.     var $variablesRegExp = "";
  190.     
  191.     /**
  192.     * RegExp used to strip unused variable placeholder.
  193.     * @brother    $variablesRegExp
  194.     */
  195.     var $removeVariablesRegExp = "";
  196.     
  197.     /**
  198.     * Controls the handling of unknown variables, default is remove.
  199.     * @var    boolean
  200.     * @access public
  201.     */
  202.     var $removeUnknownVariables = true;
  203.     
  204.     /**
  205.     * Controls the handling of empty blocks, default is remove.
  206.     * @var    boolean
  207.     * @access public
  208.     */
  209.     var $removeEmptyBlocks = true;
  210.     
  211.     /**
  212.     * RegExp used to find blocks an their content, filled by the constructor.
  213.     * @var    string
  214.     * @see    IntegratedTemplate()
  215.     */
  216.     var $blockRegExp = "";
  217.     
  218.     /**
  219.     * Name of the current block.
  220.     * @var        string
  221.     */
  222.     var $currentBlock = "__global__";
  223.  
  224.     /**
  225.     * Content of the template.
  226.     * @var        string
  227.     */    
  228.     var $template = "";
  229.     
  230.     /**
  231.     * Array of all blocks and their content.
  232.     * 
  233.     * @var    array
  234.     * @see    findBlocks()
  235.     */    
  236.     var $blocklist = array();
  237.   
  238.     /**
  239.     * Array with the parsed content of a block.
  240.     *
  241.     * @var  array
  242.     */
  243.     var $blockdata = array();
  244.     
  245.     /**
  246.     * Array of variables in a block.
  247.     * @var    array
  248.     */
  249.     var $blockvariables = array();
  250.  
  251.     /**
  252.     * Array of inner blocks of a block.
  253.     * @var    array
  254.     */    
  255.     var $blockinner         = array();
  256.     
  257.     /**
  258.     * List of blocks to preverse even if they are "empty".
  259.     *
  260.     * This is something special. Sometimes you have blocks that 
  261.     * should be preserved although they are empty (no placeholder replaced). 
  262.     * Think of a shopping basket. If it's empty you have to drop a message to 
  263.     * the user. If it's filled you have to show the contents of the shopping baseket.
  264.     * Now where do you place the message that the basket is empty? It's no good
  265.     * idea to place it in you applications as customers tend to like unecessary minor
  266.     * text changes. Having another template file for an empty basket means that it's
  267.     * very likely that one fine day the filled and empty basket templates have different
  268.     * layout. I decided to introduce blocks that to not contain any placeholder but only
  269.     * text such as the message "Your shopping basked is empty".
  270.     *
  271.     * Now if there is no replacement done in such a block the block will be recognized 
  272.     * as "empty" and by default ($removeEmptyBlocks = true) be stripped off. To avoid this
  273.     * you can now call touchBlock() to avoid this.
  274.     *
  275.     * The array $touchedBlocks stores a list of touched block which must not be removed even
  276.     * if they are empty.
  277.     *
  278.     * @var  array    $touchedBlocks
  279.     * @see    touchBlock(), $removeEmptyBlocks
  280.     */
  281.     var $touchedBlocks = array();
  282.   
  283.     /**
  284.     * Variable cache.
  285.     *
  286.     * Variables get cached before any replacement is done.
  287.     * Advantage: empty blocks can be removed automatically.
  288.     * Disadvantage: might take some more memory
  289.     * 
  290.     * @var    array
  291.     * @see    setVariable(), $clearCacheOnParse
  292.     */
  293.     var $variableCache = array();
  294.     
  295.     /**
  296.     * Clear the variable cache on parse? 
  297.     * 
  298.     * If you're not an expert just leave the default false.
  299.     * True reduces memory consumption somewhat if you tend to
  300.     * add lots of values for unknown placeholder.
  301.     *
  302.     * @var    boolean
  303.     */
  304.     var $clearCacheOnParse = false;
  305.     
  306.     /**
  307.     * Root directory for all file operations. 
  308.     * The string gets prefixed to all filenames given.
  309.     * @var    string
  310.     * @see    IntegratedTemplate(), setRoot()
  311.     */
  312.     var $fileRoot = "";
  313.     
  314.     /**
  315.     * Internal flag indicating that a blockname was used multiple times.
  316.     * @var    boolean
  317.     */
  318.     var $flagBlocktrouble = false;
  319.     
  320.     /**
  321.     * Flag indicating that the global block was parsed.
  322.     * @var    boolean
  323.     */
  324.     var $flagGlobalParsed = false;
  325.     
  326.     /**
  327.     * EXPERIMENTAL! FIXME!
  328.     * Flag indication that a template gets cached.
  329.     * 
  330.     * Complex templates require some times to be preparsed
  331.     * before the replacement can take place. Often I use
  332.     * one template file over and over again but I don't know
  333.     * before that I will use the same template file again. 
  334.     * Now IT could notice this and skip the preparse.
  335.     * 
  336.     * @var    boolean
  337.     */
  338.     var $flagCacheTemplatefile = true;
  339.     
  340.     /**
  341.     * EXPERIMENTAL! FIXME!
  342.     */
  343.     var $lastTemplatefile = "";
  344.     
  345.     /**
  346.     * Builds some complex regular expressions and optinally sets the file root directory.
  347.     *
  348.     * Make sure that you call this constructor if you derive your template 
  349.     * class from this one. 
  350.     *
  351.     * @param    string    File root directory, prefix for all filenames given to the object.
  352.     * @see    setRoot()
  353.     */
  354.     function IntegratedTemplate($root = "") {
  355.     
  356.         $this->variablesRegExp = "@" . $this->openingDelimiter . "(" . $this->variablenameRegExp . ")" . $this->closingDelimiter . "@sm";
  357.         $this->removeVariablesRegExp = "@" . $this->openingDelimiter . "\s*(" . $this->variablenameRegExp . ")\s*" . $this->closingDelimiter . "@sm";
  358.         
  359.         $this->blockRegExp = '@<!--\s+BEGIN\s+(' . $this->blocknameRegExp . ')\s+-->(.*)<!--\s+END\s+\1\s+-->@sm';
  360.  
  361.         $this->setRoot($root);        
  362.     } // end constructor
  363.     
  364.     /**
  365.     * Print a certain block with all replacements done.
  366.     * @brother get()
  367.     */
  368.     function show($block = "__global__") {
  369.         print $this->get($block);
  370.     } // end func show
  371.     
  372.     /**
  373.     * Returns a block with all replacements done.
  374.     * 
  375.     * @param    string     name of the block
  376.     * @return   string      
  377.     * @access   public
  378.     * @see      show()
  379.     */
  380.     function get($block = "__global__") {
  381.  
  382.         if ("__global__" == $block && !$this->flagGlobalParsed)
  383.             $this->parse("__global__");
  384.  
  385.         if (!isset($this->blocklist[$block])) {
  386.             $this->halt("The block '$block' was not found in the template.", __FILE__, __LINE__);
  387.             return true;
  388.         }
  389.  
  390.         if ($this->clearCache) {
  391.  
  392.             $data = (isset($this->blockdata[$block])) ? $this->blockdata[$block] : "";
  393.             unset($this->blockdata[$block]);
  394.             return $data;
  395.  
  396.         } else {
  397.  
  398.             return (isset($this->blockdata[$block])) ? $this->blockdata[$block] : "";
  399.  
  400.         }
  401.  
  402.     } // end func get()
  403.         
  404.     /**
  405.     * Parses the given block.
  406.     *    
  407.     * @param    string    name of the block to be parsed
  408.     * @access   public
  409.     * @see      parseCurrentBlock()
  410.     */
  411.     function parse($block = "__global__", $flag_recursion = false) {
  412.  
  413.         if (!isset($this->blocklist[$block])) {
  414.             $this->halt("The block '$block' was not found in the template.", __FILE__, __LINE__);
  415.             return false;
  416.         }
  417.  
  418.         if ("__global__" == $block)
  419.             $this->flagGlobalParsed = true;
  420.             
  421.         $regs = array();
  422.         $values = array();
  423.  
  424.         if ($this->clearCacheOnParse) {
  425.             
  426.             foreach ($this->variableCache as $name => $value) {
  427.                 $regs[] = "@" . $this->openingDelimiter . $name . $this->closingDelimiter . "@";
  428.                 $values[] = $value;
  429.             }
  430.             $this->variableCache = array();
  431.         
  432.         } else {
  433.  
  434.             foreach ($this->blockvariables[$block] as $allowedvar => $v) {
  435.         
  436.                 if (isset($this->variableCache[$allowedvar])) {
  437.                    $regs[]   = "@".$this->openingDelimiter . $allowedvar . $this->closingDelimiter . "@";
  438.                    $values[] = $this->variableCache[$allowedvar];
  439.                     unset($this->variableCache[$allowedvar]);
  440.                 }
  441.  
  442.             }        
  443.             
  444.         }
  445.  
  446.         $outer = (0 == count($regs)) ? $this->blocklist[$block] : preg_replace($regs, $values, $this->blocklist[$block]);
  447.         $empty = (0 == count($values)) ? true : false;
  448.  
  449.         if (isset($this->blockinner[$block])) {
  450.         
  451.           foreach ($this->blockinner[$block] as $k => $innerblock) {
  452.  
  453.             $this->parse($innerblock, true);
  454.                 if ("" != $this->blockdata[$innerblock])
  455.                     $empty = false;
  456.  
  457.                 $placeholder = $this->openingDelimiter . "__" . $innerblock . "__" . $this->closingDelimiter;                
  458.                 $outer = str_replace($placeholder, $this->blockdata[$innerblock], $outer);
  459.                 $this->blockdata[$innerblock] = "";                
  460.       }
  461.             
  462.     }
  463.  
  464.     if ($this->removeUnknownVariables)
  465.             $outer = preg_replace($this->removeVariablesRegExp, "", $outer);
  466.  
  467.         if ($empty) {
  468.  
  469.             if (!$this->removeEmptyBlocks) {
  470.             
  471.                 $this->blockdata[$block ].= $outer;
  472.                 
  473.             } else {
  474.  
  475.                 if (isset($this->touchedBlocks[$block]))
  476.                     $this->blockdata[$block] .= $outer;
  477.                 
  478.             }
  479.                 
  480.         } else {
  481.         
  482.             $this->blockdata[$block] .= $outer;
  483.         
  484.         }
  485.  
  486.         return $empty;
  487.     } // end func parse
  488.  
  489.     /**
  490.     * Parses the current block
  491.     * @see      parse(), setCurrentBlock(), $currentBlock
  492.     * @access   public
  493.     */
  494.     function parseCurrentBlock() {
  495.         return $this->parse($this->currentBlock);
  496.     } // end func parseCurrentBlock
  497.  
  498.     /**
  499.     * Sets a variable value.
  500.     * 
  501.     * The function can be used eighter like setVariable( "varname", "value")
  502.     * or with one array $variables["varname"] = "value" given setVariable($variables)
  503.     * quite like phplib templates set_var().
  504.     * 
  505.     * @param    mixed        string with the variable name or an array %variables["varname"] = "value"
  506.     * @param    string    value of the variable or empty if $variable is an array.
  507.     * @param    string    prefix for variable names
  508.     * @access   public
  509.     */    
  510.     function setVariable($variable, $value = "") {
  511.         
  512.         if (is_array($variable)) {
  513.         
  514.             $this->variableCache = array_merge($this->variableCache, $variable);
  515.                 
  516.         } else {
  517.             
  518.             $this->variableCache[$variable] = $value;
  519.             
  520.         }
  521.     
  522.     } // end func setVariable
  523.     
  524.     /**
  525.     * Sets the name of the current block that is the block where variables are added.
  526.     *
  527.     * @param    string    name of the block 
  528.     * @return    boolean    false on failure, otherwise true
  529.     *    @access    public
  530.     */
  531.     function setCurrentBlock($block = "__global__") {
  532.     
  533.         if (!isset($this->blocklist[$block])) {
  534.             $this->halt("Can't find the block '$block' in the template.", __FILE__, __LINE__);
  535.             return false;
  536.         }
  537.             
  538.         $this->currentBlock = $block;
  539.         
  540.         return true;
  541.     } // end func setCurrentBlock
  542.     
  543.     /**
  544.     * Preserves an empty block even if removeEmptyBlocks is true.
  545.     *
  546.     * @param    string    name of the block
  547.     * @return    boolean    false on false, otherwise true
  548.     * @access    public
  549.     * @see    $removeEmptyBlocks
  550.     */
  551.     function touchBlock($block) {
  552.         
  553.         if (!isset($this->blocklist[$block])) {
  554.             $this->halt("Can't find the block '$block' in the template.", __FILE__, __LINE__);
  555.             return false;
  556.         }
  557.         
  558.         $this->touchedBlocks[$block] = true;
  559.         
  560.         return true;
  561.     } // end func touchBlock
  562.     
  563.     /**
  564.     * Clears all datafields of the object and rebuild the internal blocklist
  565.     * 
  566.     * LoadTemplatefile() and setTemplate() automatically call this function 
  567.     * when a new template is given. Don't use this function 
  568.     * unless you know what you're doing.
  569.     *
  570.     * @access    public
  571.     * @see    free()
  572.     */
  573.     function init() {
  574.     
  575.         $this->free();
  576.         $this->findBlocks($this->template);
  577.         $this->buildBlockvariablelist();
  578.         
  579.     } // end func init
  580.     
  581.     /**
  582.     * Clears all datafields of the object.
  583.     * 
  584.     * Don't use this function unless you know what you're doing.
  585.     *
  586.     * @access    public
  587.     * @see    init()
  588.     */
  589.     function free() {
  590.     
  591.         $this->err = array();
  592.         
  593.         $this->currentBlock = "__global__";
  594.         
  595.         $this->variableCache    = array();        
  596.         $this->blocklookup      = array();
  597.         $this->touchedBlocks    = array();
  598.         
  599.         $this->flagBlocktrouble = false;
  600.         $this->flagGlobalParsed = false;
  601.         
  602.     } // end func free
  603.     
  604.     /**
  605.     * Sets the template.
  606.     *  
  607.     * You can eighter load a template file from disk with LoadTemplatefile() or set the
  608.     * template manually using this function.
  609.     * 
  610.     * @param        string    template content
  611.     * @param        boolean    Unbekannte, nicht ersetzte Platzhalter entfernen?
  612.     * @param        boolean    remove unknown/unused variables?
  613.     * @param        boolean    remove empty blocks?
  614.     * @see            LoadTemplatefile(), $template
  615.     * @access        public
  616.     */
  617.     function setTemplate($template, $removeUnknownVariables = true, $removeEmptyBlocks = true) {
  618.                 
  619.         $this->removeUnknownVariables = $removeUnknownVariables;
  620.         $this->removeEmptyBlocks = $removeEmptyBlocks;
  621.         
  622.         if ("" == $template && $this->flagCacheTemplatefile) {
  623.         
  624.             $this->variableCache = array();
  625.             $this->blockdata = array();
  626.             $this->touchedBlocks = array();
  627.             $this->currentBlock = "__global__";
  628.             
  629.         } else {
  630.         
  631.             $this->template = '<!-- BEGIN __global__ -->' . $template . '<!-- END __global__ -->';
  632.             $this->init();
  633.             
  634.         }
  635.         
  636.         if ($this->flagBlocktrouble)
  637.             return false;
  638.         
  639.         return true;
  640.     } // end func setTemplate
  641.     
  642.     /**
  643.     * Reads a template file from the disk.
  644.     *
  645.     * @param    string    name of the template file
  646.     * @param    bool        How to handle unknown variables.
  647.     * @param    bool      How to handle empty blocks. 
  648.     * @access   public
  649.     * @return   boolean    false on failure, otherwise true
  650.     * @see      $template, setTemplate(), $removeUnknownVariables, $removeEmptyBlocks
  651.     */
  652.     function loadTemplatefile($filename, $removeUnknownVariables = true, $removeEmptyBlocks = true) {
  653.  
  654.         $template = "";        
  655.         if (!$this->flagCacheTemplatefile || $this->lastTemplatefile != $filename)
  656.             $template = $this->getfile($filename);
  657.             
  658.         $this->lastTemplatefile = $filename;
  659.         
  660.         return $this->setTemplate($template, $removeUnknownVariables, $removeEmptyBlocks, true);
  661.     } // end func LoadTemplatefile
  662.     
  663.     /**
  664.     * Sets the file root. The file root gets prefixed to all filenames passed to the object.
  665.     * 
  666.     * Make sure that you override this function when using the class
  667.     * on windows.
  668.     * 
  669.     * @param    string
  670.     * @see      IntegratedTemplate()
  671.     * @access   public
  672.     */
  673.     function setRoot($root) {
  674.         
  675.         if ("" != $root && "/" != substr($root, -1))
  676.             $root .= "/";
  677.         
  678.         $this->fileRoot = $root;
  679.         
  680.     } // end func setRoot
  681.  
  682.     /**
  683.     * Build a list of all variables within of a block
  684.     */    
  685.     function buildBlockvariablelist() {
  686.  
  687.         foreach ($this->blocklist as $name => $content) {
  688.             preg_match_all( $this->variablesRegExp, $content, $regs );
  689.  
  690.             if (0 != count($regs[1])) {
  691.  
  692.                 foreach ($regs[1] as $k => $var)             
  693.                     $this->blockvariables[$name][$var] = true;
  694.                     
  695.             } else {
  696.             
  697.                 $this->blockvariables[$name] = array();
  698.                 
  699.             }
  700.                 
  701.         }    
  702.         
  703.     } // end func buildBlockvariablelist
  704.     
  705.     /**
  706.     * Returns a list of all 
  707.     */
  708.     function getGlobalvariables() {
  709.  
  710.         $regs   = array();
  711.         $values = array();
  712.  
  713.         foreach ($this->blockvariables["__global__"] as $allowedvar => $v) {
  714.             
  715.             if (isset($this->variableCache[$allowedvar])) {
  716.                 $regs[]   = "@" . $this->openingDelimiter . $allowedvar . $this->closingDelimiter."@";
  717.                 $values[] = $this->variableCache[$allowedvar];
  718.                 unset($this->variableCache[$allowedvar]);
  719.             }
  720.             
  721.         }
  722.         
  723.         return array($regs, $values);
  724.     } // end func getGlobalvariables
  725.  
  726.     /**
  727.     * Recusively builds a list of all blocks within the template.
  728.     *
  729.     * @param    string    string that gets scanned
  730.     * @access    private
  731.     * @see    $blocklist
  732.     */    
  733.     function findBlocks($string) {
  734.  
  735.         $blocklist = array();
  736.  
  737.         if (preg_match_all($this->blockRegExp, $string, $regs, PREG_SET_ORDER)) {
  738.             
  739.             foreach ($regs as $k => $match) {
  740.             
  741.                 $blockname         = $match[1];
  742.                 $blockcontent = $match[2];
  743.             
  744.                 if (isset($this->blocklist[$blockname])) {
  745.                     $this->halt("The name of a block must be unique within a template. Found '$blockname' twice. Unpredictable results may appear.", __FILE__, __LINE__);
  746.                     $this->flagBlocktrouble = true;
  747.                 }                
  748.  
  749.                 $this->blocklist[$blockname] = $blockcontent;
  750.                 $this->blockdata[$blockname] = "";
  751.  
  752.                 $blocklist[] = $blockname;
  753.                 
  754.                 $inner = $this->findBlocks($blockcontent);
  755.                 foreach ($inner as $k => $name) {
  756.  
  757.                     $pattern = sprintf('@<!--\s+BEGIN\s+%s\s+-->(.*)<!--\s+END\s+%s\s+-->@sm', 
  758.                                                     $name,
  759.                                                     $name
  760.                                                 );
  761.  
  762.                     $this->blocklist[$blockname] = preg_replace(    $pattern, 
  763.                                                                     $this->openingDelimiter . "__" . $name . "__" . $this->closingDelimiter, 
  764.                                                                     $this->blocklist[$blockname]
  765.                                                                );
  766.                     $this->blockinner[$blockname][] = $name;
  767.                     $this->blockparents[$name] = $blockname;
  768.                     
  769.                 }
  770.                 
  771.             }
  772.             
  773.         }
  774.  
  775.         return $blocklist;
  776.     } // end func findBlocks
  777.  
  778.     /**
  779.     * Reads a file from disk and returns its content.
  780.     * @param    string    Filename
  781.     * @return    string    Filecontent
  782.     */    
  783.     function getFile($filename) {
  784.         
  785.         if ("/" == $filename{0} && "/" == substr($this->fileRoot, -1)) 
  786.             $filename = substr($filename, 1);
  787.             
  788.         $filename = $this->fileRoot . $filename;
  789.         
  790.         if (!($fh = @fopen($filename, "r"))) {
  791.             $this->halt("Can't read '$filename'.", __FILE__, __LINE__);
  792.             return "";
  793.         }
  794.     
  795.         $content = fread($fh, filesize($filename));
  796.         fclose($fh);
  797.         
  798.         return $content; 
  799.     } // end func getFile
  800.     
  801.     /**
  802.     * Error Handling function.
  803.     * @param    string    error message
  804.     * @param    mixed        File where the error occured
  805.     * @param    int            Line where the error occured
  806.     * @see        $err
  807.     */
  808.     function halt($message, $file = "", $line = 0) {
  809.         
  810.         
  811.         $message = sprintf("IntegratedTemplate Error: %s [File: %s, Line: %d]",
  812.                                                             $message,
  813.                                                             $file,
  814.                                                             $line
  815.                                                     );
  816.  
  817.         $this->err[] = $message;
  818.  
  819.         if ($this->printError)
  820.             print $message;
  821.             
  822.         if ($this->haltOnError)
  823.             die($message);
  824.  
  825.     } // end func halt
  826.     
  827. } // end class IntegratedTemplate
  828. ?>
  829.