modules/exp/libraries/ExpParser.php

   1 <?php
   2
   3 /**
   4  * Exception from ExpParser
   5  */
   6 class ExpParserException extends Exception {}
   7
   8 /**
   9  * Base class to handle the logic and lexing in a descendent recursive parser
  10  */
  11 abstract class ExpParser {
  12         /**
  13          * The expression to parse
  14          */
  15         protected $expr; /* Protected, just so we can add custom acceptors... */
  16         /**
  17          * The current position during parsing, as an integer
  18          */
  19         protected $ptr;
  20
  21         /**
  22          * Start parsing of an expression
  23          */
  24         public function parse( $expr ) {
  25                 $this->expr = $expr;
  26                 $this->ptr  = 0;
  27
  28                 $result = $this->run();
  29
  30                 $curptr = $this->ptr; /* Keep $this->ptr for error message */
  31                 while( ctype_space( substr( $this->expr, $curptr, 1 ) ) ) $this->ptr++;
  32                 if( $curptr < strlen( $this->expr ) ) {
  33                         $this->error( 'Expected end' );
  34                 }
  35
  36                 return $result;
  37         }
  38
  39         /**
  40          * Entry point to start parsing. Runned when the state is set up correctly
  41          */
  42         abstract protected function run();
  43
  44         /**
  45          * Trim whitespaces at the current pointer
  46          */
  47         protected function trimLeft() {
  48                 while( ctype_space( substr( $this->expr, $this->ptr, 1 ) ) ) $this->ptr++;
  49         }
  50
  51         /**
  52          * Accept a symbol.
  53          *
  54          * Takes an array of possible symbols, must be ordered from the longest to the shortest.
  55          */
  56         protected function acceptSym( $tokenlist ) {
  57                 $this->trimLeft();
  58
  59                 /* Test tokens */
  60                 foreach( $tokenlist as $token ) {
  61                         if( substr( $this->expr, $this->ptr, strlen( $token ) ) == $token ) {
  62                                 $this->ptr += strlen( $token );
  63                                 return $token;
  64                         }
  65                 }
  66                 return false;
  67         }
  68
  69         /**
  70          * Excpect a symbol, but fail if not availible
  71          *
  72          * @see acceptSym
  73          */
  74         protected function expectSym( $tokenlist ) {
  75                 $sym = $this->acceptSym( $tokenlist );
  76                 if( $sym === false )
  77                         $this->error('Unexpected token, expected '.implode(',',$tokenlist));
  78                 return $sym;
  79         }
  80
  81         /**
  82          * Accept a keyword, finished by a whitespace.
  83          */
  84         protected function acceptKeyword( $keywordlist = false, $case_insensitive = false, $numeric = false ) {
  85                 $this->trimLeft();
  86
  87                 /* Peek at next keyword */
  88                 $curptr = $this->ptr;
  89                 $buffer = '';
  90                 $c = substr( $this->expr, $curptr, 1 );
  91                 while( ctype_alpha( $c ) || $c == '_' || ($buffer !== '' && ctype_digit($c)) ) {
  92                         $curptr++;
  93                         $buffer .= $c;
  94                         $c = substr( $this->expr, $curptr, 1 );
  95                 }
  96                 if( $case_insensitive )
  97                         $buffer = strtolower( $buffer );
  98                 if( $keywordlist === false || in_array( $buffer, $keywordlist ) ) {
  99                         $this->ptr = $curptr;
 100                         return $buffer;
 101                 }
 102                 return false;
 103         }
 104
 105         /**
 106          * Excpect a keyword
 107          *
 108          * @see acceptKeyword
 109          */
 110         protected function expectKeyword( $keywordlist = false, $case_insensitive = false, $numeric = false ) {
 111                 $sym = $this->acceptKeyword( $keywordlist, $case_insensitive, $numeric );
 112                 if( $sym === false )
 113                         $this->error('Unexpected token, expected '.(($keywordlist===false)?('keyword'):implode(',',$keywordlist)));
 114                 return $sym;
 115         }
 116
 117         /**
 118          * Accept a string
 119          *
 120          * Strings can be quoted by doublequotes, and may have backslash escape sequences
 121          */
 122         protected function acceptString( ) {
 123                 $this->trimLeft();
 124
 125                 /* Fetch first " */
 126                 if( substr( $this->expr, $this->ptr, 1 ) != '"' ) {
 127                         return false;
 128                 }
 129                 $this->ptr++;
 130
 131                 $buffer = '';
 132                 while( ($c = substr( $this->expr, $this->ptr++, 1 )) != '"' ) {
 133                         if( $c == '\\' ) {
 134                                 $c = substr( $this->expr, $this->ptr++, 1 );
 135                         }
 136                         $buffer .= $c;
 137                 }
 138                 return $buffer;
 139         }
 140
 141         /**
 142          * Expect a string
 143          *
 144          * @see acceptString
 145          */
 146         protected function expectString() {
 147                 $sym = $this->acceptString();
 148                 if( $sym === false )
 149                         $this->error('Unexpected token, expected string');
 150                 return $sym;
 151         }
 152
 153         /**
 154          * Accept a number, (only digits)
 155          */
 156         protected function acceptNum() {
 157                 $this->trimLeft();
 158
 159                 /* Peek at next integer */
 160                 $curptr = $this->ptr;
 161                 $buffer = '';
 162                 while( ctype_digit( $c = substr( $this->expr, $curptr, 1 ) ) ) {
 163                         $curptr++;
 164                         $buffer .= $c;
 165                 }
 166
 167                 if( strlen( $buffer ) > 0 ) {
 168                         $this->ptr = $curptr;
 169                         return intval($buffer);
 170                 }
 171                 return false;
 172         }
 173
 174         /**
 175          * Except a number
 176          *
 177          * @see acceptNumber
 178          */
 179         protected function expectNum() {
 180                 $sym = $this->acceptNum();
 181                 if( $sym === false )
 182                         $this->error('Unexpected token, expected number');
 183                 return $sym;
 184         }
 185
 186         /**
 187          * Trigger a parser error, format the current position and throw an exception.
 188          */
 189         protected function error( $msg ) {
 190                 throw new ExpParserException($msg . ' at ' . $this->ptr);
 191         }
 192 }