Templification.class.php

Go to the documentation of this file.

<?php

class Templification
{
    var $_input;

    var $_position;

    var $_output;

    var $_errors;

    var $_CallConvertPhpTags;

    var $_CallRemoveNewlines;

    var $_CallRemoveTabs;

    var $_CallCompressWhite;

    var $_CallOutputExpr;

    var $_CallIncludeExpr;

    var $_CallForeachExpr;

    var $_CallIfBlockExpr;

    function & Templification()
    {
        // Initialize required variables
        $this->_input    = ""      ;
        $this->_output   = ""      ;
        $this->_position = 0       ;
        $this->_errors   = array() ;

        // Initialize engine choice
        $this->_CallConvertPhpTags = TRUE  ;
        $this->_CallRemoveNewlines = FALSE ;
        $this->_CallRemoveTabs     = TRUE  ;
        $this->_CallCompressWhite  = TRUE  ;
        $this->_CallOutputExpr     = TRUE  ;
        $this->_CallIncludeExpr    = TRUE  ;
        $this->_CallForeachExpr    = TRUE  ;
        $this->_CallIfBlockExpr    = TRUE  ;

        // Return self
        return($this);
    }

    function ChangeMode($NewModes=array())
    {
        $name_conversion = array(
                "php"  => "_CallConvertPhpTags" ,
                "rmnl" => "_CallRemoveNewlines" ,
                "rmtb" => "_CallRemoveTabs"     ,
                "rmws" => "_CallCompressWhite"  ,
                "out"  => "_CallOutputExpr"     ,
                "inc"  => "_CallIncludeExpr"    ,
                "for"  => "_CallForeachExpr"    ,
                "if"   => "_CallIfBlockExpr"    ,
                );

        if(!is_array($NewModes))
        {
            return(FALSE);
        }

        foreach($NewModes as $Name => $Value)
        {
            if(!isset($name_conversion[$Name]))
            {
                return(FALSE);
            }

            if(!is_bool($Value))
            {
                return(FALSE);
            }

            $Name = $name_conversion[$Name];
            $this->$Name = $Value;
        }

        return(TRUE);
    }

    function GetModes()
    {
        return(array(
            array(
                "Name"        => "php",
                "Default"     => TRUE,
                "Description" =>
                    "Allow raw PHP in the templates"
                ),
            array(
                "Name"        => "rmnl",
                "Default"     => FALSE,
                "Description" =>
                    "Remove all newlines"
                ),
            array(
                "Name"        => "rmtb",
                "Default"     => TRUE,
                "Description" =>
                    "Remove all tabs"
                ),
            array(
                "Name"        => "rmws",
                "Default"     => TRUE,
                "Description" =>
                    "Remove extra whitespace"
                ),
            array(
                "Name"        => "out",
                "Default"     => TRUE,
                "Description" =>
                    "Process {||} tags"
                ),
            array(
                "Name"        => "inc",
                "Default"     => TRUE,
                "Description" =>
                    "Process {++} tags"
                ),
            array(
                "Name"        => "for",
                "Default"     => TRUE,
                "Description" =>
                    "Process {@@} tags"
                ),
            array(
                "Name"        => "if",
                "Default"     => TRUE,
                "Description" =>
                    "Process {??} tags"
                ),
            ));
    }

    function GetErrors()
    {
        // Sanity checks
        if(!is_array($this->_errors))
        {
            return(array("Error getting errors... WTF"));
        }
        foreach($this->_errors as $err)
        {
            if(!is_string($err))
            {
                return(array("Error getting errors... WTF"));
            }
        }

        // Simple accessor return
        return($this->_errors);
    }

    function Compile($Input)
    {
        // Locally reference variables
        $I =& $this->_input;
        $P =& $this->_position;
        $O =& $this->_output;
        $E =& $this->_errors;

        // Re-initialize with input
        $I = $Input;
        $P = 0;
        $O = "";
        $E = array();

        // Check sanity
        if(!is_string($Input))
        {
            $E[0] = "Template not a string";
            $I = "";
            $O = "";
            $P = 0;
        }

        // Run each engine
        while(  $this-> _ConvertPhpTags ()
             || $this-> _RemoveNewlines ()
             || $this-> _RemoveTabs     ()
             || $this-> _CompressWhite  ()
             || $this-> _OutputExpr     ()
             || $this-> _IncludeExpr    ()
             || $this-> _ForeachExpr    ()
             || $this-> _IfBlockExpr    ()
             || $this-> _SimpleCopyChar ()
             );

        // Sanity check
        if(strlen($I) > $P)
        {
            $E[0] = "Template not completely parsed!";
            $O = "";
        }

        // Return output
        return($O);
    }

    function _CheckPosition($SkipPositionCheck = FALSE)
    {
        // Locally reference variables
        $I =& $this->_input;
        $P =& $this->_position;
        $O =& $this->_output;
        $E =& $this->_errors;

        // Check variables
        if(   !is_string($I)
          ||  !is_string($O)
          ||  !is_array($E)
          ||  !is_int($P)
          ||  !is_bool($this->_CallConvertPhpTags)
          ||  !is_bool($this->_CallRemoveNewlines)
          ||  !is_bool($this->_CallRemoveTabs    )
          ||  !is_bool($this->_CallCompressWhite )
          ||  !is_bool($this->_CallOutputExpr    )
          ||  !is_bool($this->_CallIncludeExpr   )
          ||  !is_bool($this->_CallForeachExpr   )
          ||  !is_bool($this->_CallIfBlockExpr   )
          ||  strlen($I) == 0
          )
        {
            return(FALSE);
        }
        if(FALSE === $SkipPositionCheck && strlen($I) <= $P)
        {
            return(FALSE);
        }

        // No problems found so far
        return(TRUE);
    }

    function _MatchStart($Needle)
    {
        // Check sanity
        if(!$this->_CheckPosition(TRUE))
        {
            return(FALSE);
        }

        // Locally reference variables
        $I =& $this->_input;
        $P =& $this->_position;
        $O =& $this->_output;
        $E =& $this->_errors;

        // First check raw size problems
        if((strlen($I) - $P) < strlen($Needle))
        {
            return(FALSE);
        }

        // Step across needle
        for($x = 0; $x < strlen($Needle); $x++)
        {
            if($I[$P+$x] != $Needle[$x])
            {
                return(FALSE);
            }
        }

        // Didn't fail, so beginning matches
        return(TRUE);
    }

    function _ConvertPhpTags()
    {
        // Check sanity
        if(!$this->_CheckPosition())
        {
            return(FALSE);
        }

        // Check if we should be running
        if(!$this->_CallConvertPhpTags)
        {
            return(FALSE);
        }

        // Locally reference variables
        $I =& $this->_input;
        $P =& $this->_position;
        $O =& $this->_output;
        $E =& $this->_errors;

        // Check php tags
        if($this->_MatchStart("<"."?"))
        {
            $E[$P] = "Found opening PHP tag";
            $O .= "&lt;?";
            $P += 2;
            return(TRUE);
        }
        if($this->_MatchStart("?".">"))
        {
            $E[$P] = "Found closing PHP tag";
            $O .= "?&gt;";
            $P += 2;
            return(TRUE);
        }

        // Check asp tags
        if($this->_MatchStart("<"."%"))
        {
            $E[$P] = "Found opening ASP tag";
            $O .= "&lt;%";
            $P += 2;
            return(TRUE);
        }
        if($this->_MatchStart("%".">"))
        {
            $E[$P] = "Found closing ASP tag";
            $O .= "%&gt;";
            $P += 2;
            return(TRUE);
        }

        // Not handled
        return(FALSE);
    }

    function _SimpleCopyChar()
    {
        // Check sanity
        if(!$this->_CheckPosition())
        {
            return(FALSE);
        }

        // Locally reference variables
        $I =& $this->_input;
        $P =& $this->_position;
        $O =& $this->_output;
        $E =& $this->_errors;

        // Copy character and increment position
        $O .= $I[$P];
        $P++;
        return(TRUE);
    }

    function _RemoveNewlines()
    {
        // Check sanity
        if(!$this->_CheckPosition())
        {
            return(FALSE);
        }

        // Check if we should be running
        if(!$this->_CallRemoveNewlines)
        {
            return(FALSE);
        }

        // Locally reference variables
        $I =& $this->_input;
        $P =& $this->_position;
        $O =& $this->_output;
        $E =& $this->_errors;

        // Check if current character is newline
        if("\n" == $I[$P])
        {
            $P++;
            return(TRUE);
        }

        // Not handled
        return(FALSE);
    }

    function _RemoveTabs()
    {
        // Check sanity
        if(!$this->_CheckPosition())
        {
            return(FALSE);
        }

        // Check if we should be running
        if(!$this->_CallRemoveTabs)
        {
            return(FALSE);
        }

        // Locally reference variables
        $I =& $this->_input;
        $P =& $this->_position;
        $O =& $this->_output;
        $E =& $this->_errors;

        // Check if current character is newline
        if("\t" == $I[$P])
        {
            $P++;
            return(TRUE);
        }

        // Not handled
        return(FALSE);
    }

    function _CompressWhite()
    {
        // Check sanity
        if(!$this->_CheckPosition())
        {
            return(FALSE);
        }

        // Check if we should be running
        if(!$this->_CallCompressWhite)
        {
            return(FALSE);
        }

        // Locally reference variables
        $I =& $this->_input;
        $P =& $this->_position;
        $O =& $this->_output;
        $E =& $this->_errors;

        // Check for whitespace
        if($I[$P] == " " || $I[$P] == "\t")
        {
            while($P < strlen($I) && ($I[$P] == " " || $I[$P] == "\t"))
            {
                $P++;
            }
            $O .= " ";
            return(TRUE);
        }

        // Not handled
        return(FALSE);
    }

    function _OutputExpr()
    {
        // Check sanity
        if(!$this->_CheckPosition())
        {
            return(FALSE);
        }

        // Check if we should be running
        if(!$this->_CallOutputExpr)
        {
            return(FALSE);
        }

        // Locally reference variables
        $I =& $this->_input;
        $P =& $this->_position;
        $O =& $this->_output;
        $E =& $this->_errors;

        // Record the start position for if this is a tag
        $start_pos = $P;

        // Reference since we can't just smack these in place
        $o = '<'.'?php';
        $c = '?'.'>';

        // Check for orphans first
        if($this->_MatchStart("|}"))
        {
            $E[$P] = "Orphan |}";
            $O = "";
            $P = strlen($I);
            return(TRUE);
        }

        // Check for opening tag
        if($this->_MatchStart("{|"))
        {
            // Store output for success case only
            $temp_output = "";

            // We'll always skip the open tag itself
            $start = $P;
            $P += 2;

            // Scan to end tag or EOF using temporary position
            while($P < strlen($I) && !$this->_MatchStart("|}"))
            {
                $temp_output .= $I[$P++];
            }

            // If end tag found then close, else record error
            if($this->_MatchStart("|}"))
            {
                $O .= "$o print ( ";
                $O .= $temp_output;
                $O .= " ); $c";
                $P += 2;
            }
            else
            {
                $E[$start] = "{| Missing closing tag";
                $O = "";
                $P = strlen($I);
                return(TRUE);
            }

            // Either way we DID handle this
            return(TRUE);
        }

        // Didn't find a tag
        return(FALSE);
    }

    function _IncludeExpr()
    {
        // Check sanity
        if(!$this->_CheckPosition())
        {
            return(FALSE);
        }

        // Check if we should be running
        if(!$this->_CallIncludeExpr)
        {
            return(FALSE);
        }

        // Locally reference variables
        $I =& $this->_input;
        $P =& $this->_position;
        $O =& $this->_output;
        $E =& $this->_errors;

        // Record the start position for if this is a tag
        $start_pos = $P;

        // Reference since we can't just smack these in place
        $o = '<'.'?php';
        $c = '?'.'>';

        // Check for orphans first
        if($this->_MatchStart("+}"))
        {
            $E[$P] = "Orphan +}";
            $O = "";
            $P = strlen($I);
            return(TRUE);
        }

        // Check for opening tag
        if($this->_MatchStart("{+"))
        {
            // Store output for success case only
            $temp_output = "";

            // We'll always skip the open tag itself
            $start = $P;
            $P += 2;

            // Scan to end tag or EOF using temporary position
            while($P < strlen($I) && !$this->_MatchStart("+}"))
            {
                $temp_output .= $I[$P++];
            }

            // If end tag found then close, else record error
            if($this->_MatchStart("+}"))
            {
                $O .= "$o include ( ";
                $O .= $temp_output;
                $O .= " ); $c";
                $P += 2;
            }
            else
            {
                $E[$start] = "{+ Missing its closing tag";
                $O = "";
                $P = strlen($I);
                return(TRUE);
            }

            // Either way we DID handle this
            return(TRUE);
        }

        // Didn't find a tag
        return(FALSE);
    }

    function _ForeachExpr()
    {
        // Statically store start locations
        static $start_pos = array();

        // Check sanity
        if(!$this->_CheckPosition(TRUE))
        {
            return(FALSE);
        }

        // Check if we should be running
        if(!$this->_CallForeachExpr)
        {
            return(FALSE);
        }

        // Locally reference variables
        $I =& $this->_input;
        $P =& $this->_position;
        $O =& $this->_output;
        $E =& $this->_errors;

        // Reference since we can't just smack these in place
        $o = '<'.'?php';
        $c = '?'.'>';

        // If EOF with nest level > 0: Report open-ended loops
        if(strlen($I) <= $P && 0 < count($start_pos))
        {
            foreach($start_pos as $p)
            {
                $E[$p] = "Foreach expression missing close";
            }
            $O = "";
            $start_pos = array();
            return(FALSE);
        }

        // We skipped this in the sanity check so we could report
        // open-ended loops, so now we need to perform the check.
        if(!$this->_CheckPosition())
        {
            return(FALSE);
        }

        // If we find a closing tag and we're in a nested level, close
        // that level, otherwise we found an orphan
        if($this->_MatchStart("{@}"))
        {
            if(0 <  count($start_pos))
            {
                array_pop($start_pos);
                $O .= "$o } $c";
                $P += 3;
                return(TRUE);
            }
            else
            {
                $E[$P] = "Found orphan loop-close";
                $O = "";
                $P = strlen($I);
                return(TRUE);
            }
        }

        // If we found an orphan expression-close
        if($this->_MatchStart("@}"))
        {
            $E[$P] = "Found orphan loop-expression-close";
            $O = "";
            $P = strlen($I);
            return(TRUE);
        }

        // If we found a loop-expression-start
        if($this->_MatchStart("{@"))
        {
            // Always skip the tag, even if we end up reporting it
            // is an orphan
            $start = $P;
            $P += 2;
            $temp_output = "";

            // Scan to end tag or EOF using temporary position
            while($P < strlen($I) && !$this->_MatchStart("@}"))
            {
                $temp_output .= $I[$P++];
            }

            // If we hit a close-tag instead of close-expression, skip
            // the ENTIRE thing
            $P--;
            if($this->_MatchStart("{@}"))
            {
                $E[$start] = "Open-ended loop-expression (close)";
                $O = "";
                $P = strlen($I);
                return(TRUE);
            }

            // If we hit EOF, it's an orphan open tag
            $P++;
            if(!$this->_MatchStart("@}"))
            {
                $E[$start] = "Open-ended loop-expression (EOF)";
                $O = "";
                $P = strlen($I);
                return(TRUE);
            }

            // We did find the close tag successfully
            $O .= "$o foreach ( ";
            $O .= $temp_output;
            $O .= " ) { $c";
            $P += 2;
            array_push($start_pos, $start);
            return(TRUE);
        }
    }

    function _IfBlockExpr()
    {
        // Reference
        $o = '<'.'?php';
        $c = '?'.'>';
        $tagorder = array("{?}" , "{?" , "?}" , "{!}" , "{!" , "!}");
        $nestinc = array(
            "{?}" => -1,
            "{?"  =>  1,
            "?}"  =>  0,
            "{!}" =>  0,
            "{!"  =>  0,
            "!}"  =>  0,
            );
        $allow = array(
            "{?}" => array( 2 , 4 , 5 ,   ),
            "{?"  => array( 0 , 2 , 4 , 5 ),
            "?}"  => array( 1             ),
            "{!}" => array( 2 , 4         ),
            "{!"  => array( 2 , 4         ),
            "!}"  => array( 3             ),
            );
        $newstate = array(
            "{?}" => 0,
            "{?"  => 1,
            "?}"  => 2,
            "{!}" => 5,
            "{!"  => 3,
            "!}"  => 4,
            );
        $replace = array(
            "{?}" => "$o } $c"        , # Close if block
            "{?"  => "$o if( "        , # Open if expression
            "?}"  => " ) { $c"        , # Enter if block
            "{!}" => "$o } else { $c" , # Enter else block
            "{!"  => "$o } elseif( "  , # Open elseif expression
            "!}"  => " ) { $c"        , # Enter elseif block
            );

        // Statically store nesting info
        static $nest = array();

        // Check sanity
        if(!$this->_CheckPosition(TRUE))
        {
            return(FALSE);
        }

        // Check if we should be running
        if(!$this->_CallIfBlockExpr)
        {
            return(FALSE);
        }

        // Locally reference variables
        $I =& $this->_input;
        $P =& $this->_position;
        $O =& $this->_output;
        $E =& $this->_errors;

        // Find most recent addition to nest
        if($level =  count($nest))
        {
            $start =& $nest[$level]["start"];
            $state =& $nest[$level]["state"];
        }
        else
        {
            $start = 0;
            $state = 0;
        }

        // Special case: EOF
        if(strlen($I) <= $P && $level)
        {
            foreach($nest as $level)
            {
                $name = "";
                switch($level["state"])
                {
                    case 1: $name = "If expression"     ; break;
                    case 2: $name = "If block"          ; break;
                    case 3: $name = "ElseIf expression" ; break;
                    case 4: $name = "ElseIf block"      ; break;
                    case 5: $name = "Else block"        ; break;
                }

                $E[$level["start"]] = "$name missing close";
            }
            $O = "";
            $P = strlen($I);
            $nest = array();
            return(TRUE);
        }

        // We skipped this in the sanity check so we could report
        // open-ended loops, so now we need to perform the check.
        if(!$this->_CheckPosition())
        {
            return(FALSE);
        }

        // For each tag, check current character
        foreach($tagorder as $tag)
        {
            // If we have a match
            if($this->_MatchStart($tag))
            {
                // If we're allowed at this point to use this tag
                if(in_array($state, $allow[$tag]))
                {
                    // Bump nesting level up
                    if(1 == $nestinc[$tag])
                    {
                        $level =  count($nest)+1;
                        $start =& $nest[$level]["start"];
                        $state =& $nest[$level]["state"];
                    }

                    // Record tag location
                    $start = $P;
                    $state = $newstate[$tag];

                    // Record in output
                    $O .= $replace[$tag];
                    $P += strlen($tag);

                    // Drop nesting level down
                    if(-1 == $nestinc[$tag])
                    {
                        array_pop($nest);
                    }

                    return(TRUE);
                }
                else
                {
                    $E[$P] = "Invalid use of $tag";
                    $O = "";
                    $P = strlen($I);
                    return(TRUE);
                }
            }
        }

        return(FALSE);
    }
}

return("Templification");

?>

---