phpDocumentor PHP_ParserGenerator
[ class tree: PHP_ParserGenerator ] [ index: PHP_ParserGenerator ] [ all elements ]

Source for file Action.php

Documentation is available at Action.php

  1. <?php
  2. /**
  3.  * PHP_ParserGenerator, a php 5 parser generator.
  4.  * 
  5.  * This is a direct port of the Lemon parser generator, found at
  6.  * {@link http://www.hwaci.com/sw/lemon/}
  7.  *
  8.  * PHP version 5
  9.  *
  10.  * LICENSE:
  11.  * 
  12.  * Copyright (c) 2006, Gregory Beaver <cellog@php.net>
  13.  * All rights reserved.
  14.  *
  15.  * Redistribution and use in source and binary forms, with or without
  16.  * modification, are permitted provided that the following conditions
  17.  * are met:
  18.  *
  19.  *     * Redistributions of source code must retain the above copyright
  20.  *       notice, this list of conditions and the following disclaimer.
  21.  *     * Redistributions in binary form must reproduce the above copyright
  22.  *       notice, this list of conditions and the following disclaimer in
  23.  *       the documentation and/or other materials provided with the distribution.
  24.  *     * Neither the name of the PHP_ParserGenerator nor the names of its
  25.  *       contributors may be used to endorse or promote products derived
  26.  *       from this software without specific prior written permission.
  27.  *
  28.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  29.  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  30.  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  31.  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  32.  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  33.  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  34.  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  35.  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  36.  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  37.  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  38.  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  39.  *
  40.  * @category   php
  41.  * @package    PHP_ParserGenerator
  42.  * @author     Gregory Beaver <cellog@php.net>
  43.  * @copyright  2006 Gregory Beaver
  44.  * @license    http://www.opensource.org/licenses/bsd-license.php New BSD License
  45.  * @version    CVS: $Id$
  46.  * @since      File available since Release 0.1.0
  47.  */
  48. /**
  49.  * Every shift or reduce operation is stored as one of the following objects.
  50.  * 
  51.  * @package    PHP_ParserGenerator
  52.  * @author     Gregory Beaver <cellog@php.net>
  53.  * @copyright  2006 Gregory Beaver
  54.  * @license    http://www.opensource.org/licenses/bsd-license.php New BSD License
  55.  * @version    @package_version@
  56.  * @since      Class available since Release 0.1.0
  57.  */
  58.     const SHIFT 1,
  59.     ACCEPT 2,
  60.     REDUCE 3,
  61.     ERROR 4,
  62.     /**
  63.            * Was a reduce, but part of a conflict
  64.            */
  65.     CONFLICT 5,
  66.     /**
  67.            * Was a shift.  Precedence resolved conflict
  68.            */
  69.     SH_RESOLVED 6,
  70.     /**
  71.            * Was a reduce.  Precedence resolved conflict
  72.            */
  73.     RD_RESOLVED 7,
  74.     /**
  75.            * Deleted by compression
  76.            * @see PHP_ParserGenerator::CompressTables()
  77.            */
  78.     NOT_USED 8;
  79.     /**
  80.      * The look-ahead symbol that triggers this action
  81.      * @var PHP_ParserGenerator_Symbol 
  82.      */
  83.     public $sp;       /* The look-ahead symbol */
  84.     /**
  85.      * This defines the kind of action, and must be one
  86.      * of the class constants.
  87.      *
  88.      * - {@link PHP_ParserGenerator_Action::SHIFT}
  89.      * - {@link PHP_ParserGenerator_Action::ACCEPT}
  90.      * - {@link PHP_ParserGenerator_Action::REDUCE}
  91.      * - {@link PHP_ParserGenerator_Action::ERROR}
  92.      * - {@link PHP_ParserGenerator_Action::CONFLICT}
  93.      * - {@link PHP_ParserGenerator_Action::SH_RESOLVED}
  94.      * - {@link PHP_ParserGenerator_Action:: RD_RESOLVED}
  95.      * - {@link PHP_ParserGenerator_Action::NOT_USED}
  96.      */
  97.     public $type;
  98.     /**
  99.      * The new state, if this is a shift,
  100.      * the parser rule index, if this is a reduce.
  101.      *
  102.      * @var PHP_ParserGenerator_State|PHP_ParserGenerator_Rule
  103.      */
  104.     public $x;
  105.     /**
  106.      * The next action for this state.
  107.      * @var PHP_ParserGenerator_Action 
  108.      */
  109.     public $next;
  110.  
  111.     /**
  112.      * Compare two actions
  113.      * 
  114.      * This is used by {@link Action_sort()} to compare actions
  115.      */
  116.     static function actioncmp(PHP_ParserGenerator_Action $ap1,
  117.                               PHP_ParserGenerator_Action $ap2)
  118.     {
  119.         $rc $ap1->sp->index $ap2->sp->index;
  120.         if ($rc === 0{
  121.             $rc $ap1->type $ap2->type;
  122.         }
  123.         if ($rc === 0{
  124.             if ($ap1->type != self::REDUCE &&
  125.             $ap1->type != self::RD_RESOLVED &&
  126.             $ap1->type != self::CONFLICT{
  127.                 throw new Exception('action has not been processed: ' .
  128.                 $ap1->sp->name);
  129.             }
  130.             if ($ap2->type != self::REDUCE &&
  131.             $ap2->type != self::RD_RESOLVED &&
  132.             $ap2->type != self::CONFLICT{
  133.                 throw new Exception('action has not been processed: ' .
  134.                 $ap2->sp->name);
  135.             }
  136.             $rc $ap1->x->index $ap2->x->index;
  137.         }
  138.         return $rc;
  139.     }
  140.  
  141.     /**
  142.      * create linked list of PHP_ParserGenerator_Actions
  143.      *
  144.      * @param PHP_ParserGenerator_Action|null
  145.      * @param int one of the class constants from PHP_ParserGenerator_Action
  146.      * @param PHP_ParserGenerator_Symbol 
  147.      * @param PHP_ParserGenerator_Symbol|PHP_ParserGenerator_Rule
  148.      */
  149.     static function Action_add(&$app$typePHP_ParserGenerator_Symbol $sp$arg)
  150.     {
  151.         $new new PHP_ParserGenerator_Action;
  152.         $new->next $app;
  153.         $app $new;
  154.         $new->type $type;
  155.         $new->sp $sp;
  156.         $new->$arg;
  157.     }
  158.  
  159.     /**
  160.      * Sort parser actions
  161.      * @see PHP_ParserGenerator_Data::FindActions()
  162.      */
  163.     static function Action_sort(PHP_ParserGenerator_Action $ap)
  164.     {
  165.         $ap PHP_ParserGenerator::msort($ap'next'array('PHP_ParserGenerator_Action''actioncmp'));
  166.         return $ap;
  167.     }
  168.  
  169.     /**
  170.      * Print an action to the given file descriptor.  Return FALSE if
  171.      * nothing was actually printed.
  172.      * @see PHP_ParserGenerator_Data::ReportOutput()
  173.      */
  174.     function PrintAction($fp$indent)
  175.     {
  176.         $result 1;
  177.         switch ($this->type)
  178.         {
  179.             case self::SHIFT:
  180.                 fprintf($fp"%${indent}s shift  %d"$this->sp->name$this->x->statenum);
  181.                 break;
  182.             case self::REDUCE:
  183.                 fprintf($fp"%${indent}s reduce %d"$this->sp->name$this->x->index);
  184.                 break;
  185.             case self::ACCEPT:
  186.                 fprintf($fp"%${indent}s accept"$this->sp->name);
  187.                 break;
  188.             case self::ERROR:
  189.                 fprintf($fp"%${indent}s error"$this->sp->name);
  190.                 break;
  191.             case self::CONFLICT:
  192.                 fprintf($fp"%${indent}s reduce %-3d ** Parsing conflict **"$this->sp->name$this->x->index);
  193.                 break;
  194.             case self::SH_RESOLVED:
  195.             case self::RD_RESOLVED:
  196.             case self::NOT_USED:
  197.                 $result 0;
  198.                 break;
  199.         }
  200.         return $result;
  201.     }
  202. }
  203. ?>

Documentation generated on Sun, 02 Jul 2006 09:10:56 -0400 by phpDocumentor 1.3.0