File Source for Data.php

<?php
/**
* PHP_ParserGenerator, a php 5 parser generator.
*
* This is a direct port of the Lemon parser generator, found at
* {@link http://www.hwaci.com/sw/lemon/}
*
* PHP version 5
*
* LICENSE:
*
* Copyright (c) 2006, Gregory Beaver <cellog@php.net>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the distribution.
* * Neither the name of the PHP_ParserGenerator nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* @category php
* @package PHP_ParserGenerator
* @author Gregory Beaver <cellog@php.net>
* @copyright 2006 Gregory Beaver
* @license http://www.opensource.org/licenses/bsd-license.php New BSD License
* @version CVS: $Id$
* @since File available since Release 0.1.0
*/
/**
/**
* The state vector for the entire parser generator is recorded in
* this class.
*
* @package PHP_ParserGenerator
* @author Gregory Beaver <cellog@php.net>
* @copyright 2006 Gregory Beaver
* @license http://www.opensource.org/licenses/bsd-license.php New BSD License
* @version @package_version@
* @since Class available since Release 0.1.0
*/
class PHP_ParserGenerator_Data
{
/**
* Used for terminal and non-terminal offsets into the action table
* when their default should be used instead
*/
const NO_OFFSET = -2147483647;
/**
* Table of states sorted by state number
* @var array array of {@link PHP_ParserGenerator_State} objects
*/
public $sorted;
/**
* List of all rules
* @var PHP_ParserGenerator_Rule
*/
public $rule;
/**
* Number of states
* @var int
*/
public $nstate;
/**
* Number of rules
* @var int
*/
public $nrule;
/**
* Number of terminal and nonterminal symbols
* @var int
*/
public $nsymbol;
/**
* Number of terminal symbols (tokens)
* @var int
*/
public $nterminal;
/**
* Sorted array of pointers to symbols
* @var array array of {@link PHP_ParserGenerator_Symbol} objects
*/
public $symbols = array();
/**
* Number of errors
* @var int
*/
public $errorcnt;
/**
* The error symbol
* @var PHP_ParserGenerator_Symbol
*/
public $errsym;
/**
* Name of the generated parser
* @var string
*/
public $name;
/**
* Unused relic from the C version
*
* Type of terminal symbols in the parser stack
* @var string
*/
public $tokentype;
/**
* Unused relic from the C version
*
* The default type of non-terminal symbols
* @var string
*/
public $vartype;
/**
* Name of the start symbol for the grammar
* @var string
*/
public $start;
/**
* Size of the parser stack
*
* This is 100 by default, but is set with the %stack_size directive
* @var int
*/
public $stacksize;
/**
* Code to put at the start of the parser file
*
* This is set by the %include directive
* @var string
*/
public $include_code;
/**
* Line number for start of include code
* @var int
*/
public $includeln;
/**
* Code to put in the parser class
*
* This is set by the %include_class directive
* @var string
*/
public $include_classcode;
/**
* Line number for start of include code
* @var int
*/
public $include_classln;
/**
* any extends/implements code
*
* This is set by the %declare_class directive
* @var string
*/
/**
* Line number for class declaration code
* @var int
*/
public $declare_classcode;
/**
* Line number for start of class declaration code
* @var int
*/
public $declare_classln;
/**
* Code to execute when a syntax error is seen
*
* This is set by the %syntax_error directive
* @var string
*/
public $error;
/**
* Line number for start of error code
* @var int
*/
public $errorln;
/**
* Code to execute on a stack overflow
*
* This is set by the %stack_overflow directive
*/
public $overflow;
/**
* Line number for start of overflow code
* @var int
*/
public $overflowln;
/**
* Code to execute on parser failure
*
* This is set by the %parse_failure directive
* @var string
*/
public $failure;
/**
* Line number for start of failure code
* @var int
*/
public $failureln;
/**
* Code to execute when the parser acccepts (completes parsing)
*
* This is set by the %parse_accept directive
* @var string
*/
public $accept;
/**
* Line number for the start of accept code
* @var int
*/
public $acceptln;
/**
* Code appended to the generated file
*
* This is set by the %code directive
* @var string
*/
public $extracode;
/**
* Line number for the start of the extra code
* @var int
*/
public $extracodeln;
/**
* Code to execute to destroy token data
*
* This is set by the %token_destructor directive
* @var string
*/
public $tokendest;
/**
* Line number for token destroyer code
* @var int
*/
public $tokendestln;
/**
* Code for the default non-terminal destructor
*
* This is set by the %default_destructor directive
* @var string
*/
public $vardest;
/**
* Line number for default non-terminal destructor code
* @var int
*/
public $vardestln;
/**
* Name of the input file
* @var string
*/
public $filename;
/**
* Name of the input file without its extension
* @var string
*/
public $filenosuffix;
/**
* Name of the current output file
* @var string
*/
public $outname;
/**
* A prefix added to token names
* @var string
*/
public $tokenprefix;
/**
* Number of parsing conflicts
* @var int
*/
public $nconflict;
/**
* Size of the parse tables
* @var int
*/
public $tablesize;
/**
* Public only basis configurations
*/
public $basisflag;
/**
* True if any %fallback is seen in the grammer
* @var boolean
*/
public $has_fallback;
/**
* Name of the program
* @var string
*/
public $argv0;
/* Find a precedence symbol of every rule in the grammar.
*
* Those rules which have a precedence symbol coded in the input
* grammar using the "[symbol]" construct will already have the
* $rp->precsym field filled. Other rules take as their precedence
* symbol the first RHS symbol with a defined precedence. If there
* are not RHS symbols with a defined precedence, the precedence
* symbol field is left blank.
*/
function FindRulePrecedences()
{
for ($rp = $this->rule; $rp; $rp = $rp->next) {
if ($rp->precsym === 0) {
for ($i = 0; $i < $rp->nrhs && $rp->precsym === 0; $i++) {
$sp = $rp->rhs[$i];
if ($sp->type == PHP_ParserGenerator_Symbol::MULTITERMINAL) {
for ($j = 0; $j < $sp->nsubsym; $j++) {
if ($sp->subsym[$j]->prec >= 0) {
$rp->precsym = $sp->subsym[$j];
break;
}
}
} elseif ($sp->prec >= 0) {
$rp->precsym = $rp->rhs[$i];
}
}
}
}
}
/**
* Find all nonterminals which will generate the empty string.
* Then go back and compute the first sets of every nonterminal.
* The first set is the set of all terminal symbols which can begin
* a string generated by that nonterminal.
*/
function FindFirstSets()
{
for ($i = 0; $i < $this->nsymbol; $i++) {
$this->symbols[$i]->lambda = false;
}
for($i = $this->nterminal; $i < $this->nsymbol; $i++) {
$this->symbols[$i]->firstset = array();
}
/* First compute all lambdas */
do{
$progress = 0;
for ($rp = $this->rule; $rp; $rp = $rp->next) {
if ($rp->lhs->lambda) {
continue;
}
for ($i = 0; $i < $rp->nrhs; $i++) {
$sp = $rp->rhs[$i];
if ($sp->type != PHP_ParserGenerator_Symbol::TERMINAL || $sp->lambda === false) {
break;
}
}
if ($i === $rp->nrhs) {
$rp->lhs->lambda = true;
$progress = 1;
}
}
} while ($progress);
/* Now compute all first sets */
do {
$progress = 0;
for ($rp = $this->rule; $rp; $rp = $rp->next) {
$s1 = $rp->lhs;
for ($i = 0; $i < $rp->nrhs; $i++) {
$s2 = $rp->rhs[$i];
if ($s2->type == PHP_ParserGenerator_Symbol::TERMINAL) {
//progress += SetAdd(s1->firstset,s2->index);
$progress += isset($s1->firstset[$s2->index]) ? 0 : 1;
$s1->firstset[$s2->index] = 1;
break;
} elseif ($s2->type == PHP_ParserGenerator_Symbol::MULTITERMINAL) {
for ($j = 0; $j < $s2->nsubsym; $j++) {
//progress += SetAdd(s1->firstset,s2->subsym[j]->index);
$progress += isset($s1->firstset[$s2->subsym[$j]->index]) ? 0 : 1;
$s1->firstset[$s2->subsym[$j]->index] = 1;
}
break;
} elseif ($s1 === $s2) {
if ($s1->lambda === false) {
break;
}
} else {
//progress += SetUnion(s1->firstset,s2->firstset);
$test = array_diff_key($s2->firstset, $s1->firstset);
if (count($test)) {
$progress++;
$s1->firstset += $test;
}
if ($s2->lambda === false) {
break;
}
}
}
}
} while ($progress);
}
/**
* Compute all LR(0) states for the grammar. Links
* are added to between some states so that the LR(1) follow sets
* can be computed later.
*/
function FindStates()
{
PHP_ParserGenerator_Config::Configlist_init();
/* Find the start symbol */
if ($this->start) {
$sp = PHP_ParserGenerator_Symbol::Symbol_find($this->start);
if ($sp == 0) {
PHP_ParserGenerator::ErrorMsg($this->filename, 0,
"The specified start symbol \"%s\" is not " .
"in a nonterminal of the grammar. \"%s\" will be used as the start " .
"symbol instead.", $this->start, $this->rule->lhs->name);
$this->errorcnt++;
$sp = $this->rule->lhs;
}
} else {
$sp = $this->rule->lhs;
}
/* Make sure the start symbol doesn't occur on the right-hand side of
** any rule. Report an error if it does. (YACC would generate a new
** start symbol in this case.) */
for ($rp = $this->rule; $rp; $rp = $rp->next) {
for ($i = 0; $i < $rp->nrhs; $i++) {
if ($rp->rhs[$i]->type == PHP_ParserGenerator_Symbol::MULTITERMINAL) {
foreach ($rp->rhs[$i]->subsym as $subsp) {
if ($subsp === $sp) {
PHP_ParserGenerator::ErrorMsg($this->filename, 0,
"The start symbol \"%s\" occurs on the " .
"right-hand side of a rule. This will result in a parser which " .
"does not work properly.", $sp->name);
$this->errorcnt++;
}
}
} elseif ($rp->rhs[$i] === $sp) {
PHP_ParserGenerator::ErrorMsg($this->filename, 0,
"The start symbol \"%s\" occurs on the " .
"right-hand side of a rule. This will result in a parser which " .
"does not work properly.", $sp->name);
$this->errorcnt++;
}
}
}
/* The basis configuration set for the first state
** is all rules which have the start symbol as their
** left-hand side */
for ($rp = $sp->rule; $rp; $rp = $rp->nextlhs) {
$newcfp = PHP_ParserGenerator_Config::Configlist_addbasis($rp, 0);
$newcfp->fws[0] = 1;
}
/* Compute the first state. All other states will be
** computed automatically during the computation of the first one.
** The returned pointer to the first state is not used. */
$newstp = array();
$newstp = $this->getstate();
if (is_array($newstp)) {
$this->buildshifts($newstp[0]); /* Recursively compute successor states */
}
}
/**
* @return PHP_ParserGenerator_State
*/
private function getstate()
{
/* Extract the sorted basis of the new state. The basis was constructed
** by prior calls to "Configlist_addbasis()". */
PHP_ParserGenerator_Config::Configlist_sortbasis();
$bp = PHP_ParserGenerator_Config::Configlist_basis();
/* Get a state with the same basis */
$stp = PHP_ParserGenerator_State::State_find($bp);
if ($stp) {
/* A state with the same basis already exists! Copy all the follow-set
** propagation links from the state under construction into the
** preexisting state, then return a pointer to the preexisting state */
for($x = $bp, $y = $stp->bp; $x && $y; $x = $x->bp, $y = $y->bp) {
PHP_ParserGenerator_PropagationLink::Plink_copy($y->bplp, $x->bplp);
PHP_ParserGenerator_PropagationLink::Plink_delete($x->fplp);
$x->fplp = $x->bplp = 0;
}
$cfp = PHP_ParserGenerator_Config::Configlist_return();
PHP_ParserGenerator_Config::Configlist_eat($cfp);
} else {
/* This really is a new state. Construct all the details */
PHP_ParserGenerator_Config::Configlist_closure($this); /* Compute the configuration closure */
PHP_ParserGenerator_Config::Configlist_sort(); /* Sort the configuration closure */
$cfp = PHP_ParserGenerator_Config::Configlist_return(); /* Get a pointer to the config list */
$stp = new PHP_ParserGenerator_State; /* A new state structure */
$stp->bp = $bp; /* Remember the configuration basis */
$stp->cfp = $cfp; /* Remember the configuration closure */
$stp->statenum = $this->nstate++; /* Every state gets a sequence number */
$stp->ap = 0; /* No actions, yet. */
PHP_ParserGenerator_State::State_insert($stp, $stp->bp); /* Add to the state table */
// this can't work, recursion is too deep, move it into FindStates()
//$this->buildshifts($stp); /* Recursively compute successor states */
return array($stp);
}
return $stp;
}
/**
* Construct all successor states to the given state. A "successor"
* state is any state which can be reached by a shift action.
* @param PHP_ParserGenerator_Data
* @param PHP_ParserGenerator_State The state from which successors are computed
*/

	PHP_ParserGenerator

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

Source for file Data.php