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

Index of all elements

[ a ] [ b ] [ c ] [ d ] [ e ] [ f ] [ g ] [ h ] [ i ] [ k ] [ l ] [ m ] [ n ] [ o ] [ p ] [ q ] [ r ] [ s ] [ t ] [ u ] [ v ] [ w ] [ x ] [ y ] [ _ ]

a

$aAction
in file Main.php, variable LemonActtab::$aAction
$aAction
in file ActionTable.php, variable PHP_ParserGenerator_ActionTable::$aAction
    The $yy_action table under construction.
$accept
in file Main.php, variable LemonData::$accept
$accept
in file Data.php, variable PHP_ParserGenerator_Data::$accept
    Code to execute when the parser acccepts (completes parsing)
$acceptln
in file Data.php, variable PHP_ParserGenerator_Data::$acceptln
    Line number for the start of accept code
$acceptln
in file Main.php, variable LemonData::$acceptln
$alias
in file Parser.php, variable PHP_ParserGenerator_Parser::$alias
    Aliases for each RHS symbol name (or NULL)
$alias
in file Main.php, variable LemonParser::$alias
$aLookahead
in file ActionTable.php, variable PHP_ParserGenerator_ActionTable::$aLookahead
    A single new transaction set.
$aLookahead
in file Main.php, variable LemonActtab::$aLookahead
$ap
in file State.php, variable PHP_ParserGenerator_State::$ap
    Linked list of actions for this state.
$ap
in file Main.php, variable LemonState::$ap
$arg
in file Main.php, variable LemonData::$arg
$argv0
in file Main.php, variable LemonData::$argv0
$argv0
in file Data.php, variable PHP_ParserGenerator_Data::$argv0
    Name of the program
$assoc
in file Symbol.php, variable PHP_ParserGenerator_Symbol::$assoc
    Associativity if precedence is defined.
$assoc
in file Main.php, variable LemonSymbol::$assoc
$azDefine
in file Main.php, variable Lemon::$azDefine
$azDefine
in file ParserGenerator.php, variable PHP_ParserGenerator::$azDefine
ACCEPT
in file Action.php, class constant PHP_ParserGenerator_Action::ACCEPT
ACCEPT
in file Main.php, class constant LemonAction::ACCEPT
actioncmp
in file Main.php, method LemonAction::actioncmp()
actioncmp
in file Action.php, method PHP_ParserGenerator_Action::actioncmp()
    Compare two actions
Action_add
in file Action.php, method PHP_ParserGenerator_Action::Action_add()
    create linked list of PHP_ParserGenerator_Actions
Action_add
in file Main.php, method LemonAction::Action_add()
    create linked list of LemonActions
Action_sort
in file Main.php, method LemonAction::Action_sort()
Action_sort
in file Action.php, method PHP_ParserGenerator_Action::Action_sort()
    Sort parser actions
acttab_action
in file ActionTable.php, method PHP_ParserGenerator_ActionTable::acttab_action()
    Add a new action to the current transaction set
acttab_action
in file Main.php, method LemonActtab::acttab_action()
    Add a new action to the current transaction set
acttab_insert
in file Main.php, method LemonActtab::acttab_insert()
    Add the transaction set built up with prior calls to acttab_action() into the current action table. Then reset the transaction set back to an empty set in preparation for a new round of acttab_action() calls.
acttab_insert
in file ActionTable.php, method PHP_ParserGenerator_ActionTable::acttab_insert()
    Add the transaction set built up with prior calls to acttab_action() into the current action table. Then reset the transaction set back to an empty set in preparation for a new round of acttab_action() calls.
advance
in file Tokenizer.php, method PHP_Parser_Tokenizer::advance()
    The main advance call required by the parser
AMPERSAND
in file PHP.php, class constant PHPyyParser::AMPERSAND
append_str
in file Data.php, method PHP_ParserGenerator_Data::append_str()
    Append text to a dynamically allocated string. If zText is 0 then reset the string to be empty again. Always return the complete text of the string (which is overwritten with each call).
append_str
in file Main.php, method LemonData::append_str()
    Append text to a dynamically allocated string. If zText is 0 then reset the string to be empty again. Always return the complete text of the string (which is overwritten with each call).
AT
in file PHP.php, class constant PHPyyParser::AT
axset_compare
in file Main.php, method LemonData::axset_compare()
    Compare to axset structures for sorting purposes
axset_compare
in file Data.php, method PHP_ParserGenerator_Data::axset_compare()
    Compare to axset structures for sorting purposes
Action.php
procedural page Action.php
ActionTable.php
procedural page ActionTable.php
top

b

$basis
in file Config.php, variable PHP_ParserGenerator_Config::$basis
    Top of the list of basis configurations for the current state.
$basis
in file Main.php, variable LemonConfig::$basis
$basisend
in file Main.php, variable LemonConfig::$basisend
$basisend
in file Config.php, variable PHP_ParserGenerator_Config::$basisend
    Last on the list of basis configurations for the current state.
$basisflag
in file Data.php, variable PHP_ParserGenerator_Data::$basisflag
    Public only basis configurations
$basisflag
in file Main.php, variable LemonData::$basisflag
$bp
in file State.php, variable PHP_ParserGenerator_State::$bp
    The basis configurations for this state
$bp
in file Main.php, variable LemonState::$bp
$bp
in file Config.php, variable PHP_ParserGenerator_Config::$bp
    Index of the next basis configuration PHP_ParserGenerator_Config object
$bp
in file Main.php, variable LemonConfig::$bp
    Index of the next basis configuration LemonConfig object
$bplp
in file Main.php, variable LemonConfig::$bplp
$bplp
in file Config.php, variable PHP_ParserGenerator_Config::$bplp
    Follow-set backwards propagation links
BACKQUOTE
in file PHP.php, class constant PHPyyParser::BACKQUOTE
BAR
in file PHP.php, class constant PHPyyParser::BAR
top

c

$canReduce
in file Rule.php, variable PHP_ParserGenerator_Rule::$canReduce
    True if this rule is ever reduced
$canReduce
in file Main.php, variable LemonRule::$canReduce
$cfp
in file Main.php, variable LemonState::$cfp
$cfp
in file Main.php, variable LemonPlink::$cfp
$cfp
in file PropagationLink.php, variable PHP_ParserGenerator_PropagationLink::$cfp
    The configuration that defines this propagation link
$cfp
in file State.php, variable PHP_ParserGenerator_State::$cfp
    All configurations in this state
$code
in file Rule.php, variable PHP_ParserGenerator_Rule::$code
    The code executed when this rule is reduced
$code
in file Main.php, variable LemonRule::$code
$collide
in file Main.php, variable LemonAction::$collide
$current
in file Main.php, variable LemonConfig::$current
$current
in file Config.php, variable PHP_ParserGenerator_Config::$current
    Top of the list of configurations for the current state.
$currentend
in file Main.php, variable LemonConfig::$currentend
$currentend
in file Config.php, variable PHP_ParserGenerator_Config::$currentend
    Last on the list of configurations for the current state.
CARAT
in file PHP.php, class constant PHPyyParser::CARAT
CODE
in file Parser.php, class constant PHP_LexerGenerator_Parser::CODE
COLON
in file PHP.php, class constant PHPyyParser::COLON
COMMA
in file PHP.php, class constant PHPyyParser::COMMA
COMMENTEND
in file Parser.php, class constant PHP_LexerGenerator_Parser::COMMENTEND
COMMENTSTART
in file Parser.php, class constant PHP_LexerGenerator_Parser::COMMENTSTART
COMPLETE
in file Config.php, class constant PHP_ParserGenerator_Config::COMPLETE
COMPLETE
in file Main.php, class constant LemonConfig::COMPLETE
CompressTables
in file Main.php, method LemonData::CompressTables()
    Reduce the size of the action tables, if possible, by making use of defaults.
CompressTables
in file Data.php, method PHP_ParserGenerator_Data::CompressTables()
    Reduce the size of the action tables, if possible, by making use of defaults.
compute_action
in file Main.php, method LemonData::compute_action()
    Given an action, compute the integer value for that action which is to be put in the action table of the generated machine.
compute_action
in file Data.php, method PHP_ParserGenerator_Data::compute_action()
    Given an action, compute the integer value for that action which is to be put in the action table of the generated machine.
Configcmp
in file Main.php, method LemonConfig::Configcmp()
Configcmp
in file Config.php, method PHP_ParserGenerator_Config::Configcmp()
    Compare two configurations for sorting purposes.
Configlist_add
in file Main.php, method LemonConfig::Configlist_add()
    Add another configuration to the configuration list
Configlist_add
in file Config.php, method PHP_ParserGenerator_Config::Configlist_add()
    Add another configuration to the configuration list for this parser state.
Configlist_addbasis
in file Config.php, method PHP_ParserGenerator_Config::Configlist_addbasis()
    Add a basis configuration to the configuration list for this parser state.
Configlist_addbasis
in file Main.php, method LemonConfig::Configlist_addbasis()
    Add a basis configuration to the configuration list
Configlist_basis
in file Main.php, method LemonConfig::Configlist_basis()
    Return a pointer to the head of the basis list and
Configlist_basis
in file Config.php, method PHP_ParserGenerator_Config::Configlist_basis()
    Return a pointer to the head of the basis list and
Configlist_closure
in file Main.php, method LemonConfig::Configlist_closure()
Configlist_closure
in file Config.php, method PHP_ParserGenerator_Config::Configlist_closure()
    Compute the closure of the configuration list.
Configlist_eat
in file Config.php, method PHP_ParserGenerator_Config::Configlist_eat()
    Free all elements of the given configuration list
Configlist_eat
in file Main.php, method LemonConfig::Configlist_eat()
    Free all elements of the given configuration list
Configlist_init
in file Main.php, method LemonConfig::Configlist_init()
    Initialized the configuration list builder
Configlist_init
in file Config.php, method PHP_ParserGenerator_Config::Configlist_init()
    Initialize the configuration list builder for a new state.
Configlist_reset
in file Config.php, method PHP_ParserGenerator_Config::Configlist_reset()
    Reset the configuration list builder for a new state.
Configlist_reset
in file Main.php, method LemonConfig::Configlist_reset()
    Initialized the configuration list builder
Configlist_return
in file Main.php, method LemonConfig::Configlist_return()
    Return a pointer to the head of the configuration list and
Configlist_return
in file Config.php, method PHP_ParserGenerator_Config::Configlist_return()
    Return a pointer to the head of the configuration list and
Configlist_sort
in file Config.php, method PHP_ParserGenerator_Config::Configlist_sort()
    Sort the configuration list
Configlist_sort
in file Main.php, method LemonConfig::Configlist_sort()
    Sort the configuration list
Configlist_sortbasis
in file Main.php, method LemonConfig::Configlist_sortbasis()
    Sort the configuration list
Configlist_sortbasis
in file Config.php, method PHP_ParserGenerator_Config::Configlist_sortbasis()
    Sort the configuration list
ConfigPrint
in file Config.php, method PHP_ParserGenerator_Config::ConfigPrint()
    Print out information on this configuration.
ConfigPrint
in file Main.php, method LemonConfig::ConfigPrint()
Configshow
in file Main.php, method LemonConfig::Configshow()
Configshow
in file Config.php, method PHP_ParserGenerator_Config::Configshow()
    Display the current configuration for the .out file
Configtable_clear
in file Config.php, method PHP_ParserGenerator_Config::Configtable_clear()
    Remove all data from the associative array representation of configurations.
Configtable_clear
in file Main.php, method LemonConfig::Configtable_clear()
    Remove all data from the table. Pass each data to the function "f"
Configtable_find
in file Config.php, method PHP_ParserGenerator_Config::Configtable_find()
    Return a pointer to data assigned to the given key. Return NULL if no such key.
Configtable_find
in file Main.php, method LemonConfig::Configtable_find()
    Return a pointer to data assigned to the given key. Return NULL if no such key.
Configtable_insert
in file Main.php, method LemonConfig::Configtable_insert()
    Insert a new record into the array. Return TRUE if successful.
Configtable_insert
in file Config.php, method PHP_ParserGenerator_Config::Configtable_insert()
    Insert a new record into the array. Return TRUE if successful.
Configtable_reset
in file Config.php, method PHP_ParserGenerator_Config::Configtable_reset()
    Remove all data from the table.
Configtable_reset
in file Main.php, method LemonConfig::Configtable_reset()
    Remove all data from the table. Pass each data to the function "f"
CONFLICT
in file Main.php, class constant LemonAction::CONFLICT
CONFLICT
in file Action.php, class constant PHP_ParserGenerator_Action::CONFLICT
cli.php
procedural page cli.php
Config.php
procedural page Config.php
top

d

$data
in file Main.php, variable LemonStateNode::$data
$data
in file State.php, variable PHP_ParserGenerator_StateNode::$data
$datatype
in file Main.php, variable LemonSymbol::$datatype
$datatype
in file Symbol.php, variable PHP_ParserGenerator_Symbol::$datatype
    Unused relic of the C version of Lemon.
$debug
in file Tokenizer.php, variable PHP_Parser_Tokenizer::$debug
    Debugging on/off
$declare_classcode
in file Data.php, variable PHP_ParserGenerator_Data::$declare_classcode
    Line number for class declaration code
$declare_classcode
in file Main.php, variable LemonData::$declare_classcode
$declare_classln
in file Main.php, variable LemonData::$declare_classln
$declare_classln
in file Data.php, variable PHP_ParserGenerator_Data::$declare_classln
    Line number for start of class declaration code
$declargslot
in file Main.php, variable LemonParser::$declargslot
$declargslot
in file Parser.php, variable PHP_ParserGenerator_Parser::$declargslot
    Where the declaration argument should be put
$declassoc
in file Parser.php, variable PHP_ParserGenerator_Parser::$declassoc
$declassoc
in file Main.php, variable LemonParser::$declassoc
$declkeyword
in file Main.php, variable LemonParser::$declkeyword
$declkeyword
in file Parser.php, variable PHP_ParserGenerator_Parser::$declkeyword
    Keyword of a declaration
$decllnslot
in file Parser.php, variable PHP_ParserGenerator_Parser::$decllnslot
    Where the declaration linenumber is put
$decllnslot
in file Main.php, variable LemonParser::$decllnslot
$destructor
in file Main.php, variable LemonSymbol::$destructor
$destructor
in file Symbol.php, variable PHP_ParserGenerator_Symbol::$destructor
    Code that executes whenever this symbol is popped from the stack during error processing.
$destructorln
in file Symbol.php, variable PHP_ParserGenerator_Symbol::$destructorln
    Line number of destructor code
$destructorln
in file Main.php, variable LemonSymbol::$destructorln
$dot
in file Config.php, variable PHP_ParserGenerator_Config::$dot
    The parse point.
$dot
in file Main.php, variable LemonConfig::$dot
$dtnum
in file Main.php, variable LemonSymbol::$dtnum
$dtnum
in file Symbol.php, variable PHP_ParserGenerator_Symbol::$dtnum
    Unused relic of the C version of Lemon.
DEBUG
in file Main.php, constant DEBUG
DEBUG
in file ParserGenerator.php, class constant PHP_ParserGenerator::DEBUG
    Set this to 1 to turn on debugging of Lemon's parsing of grammar files.
display
in file Action.php, method PHP_ParserGenerator_Action::display()
DIVIDE
in file PHP.php, class constant PHPyyParser::DIVIDE
DOLLAR
in file PHP.php, class constant PHPyyParser::DOLLAR
doParse
in file Lempar.php, function doParse()
    The main parser program.
doParse
in file Parser.php, method PHP_LexerGenerator_Parser::doParse()
    The main parser program.
doParse
in file oops.php, method ParseyyParser::doParse()
    The main parser program.
DOT
in file PHP.php, class constant PHPyyParser::DOT
DOUBLEQUOTE
in file PHP.php, class constant PHPyyParser::DOUBLEQUOTE
Data.php
procedural page Data.php
top

e

$error
in file Main.php, variable LemonData::$error
$error
in file Data.php, variable PHP_ParserGenerator_Data::$error
    Code to execute when a syntax error is seen
$errorcnt
in file Main.php, variable LemonParser::$errorcnt
$errorcnt
in file Parser.php, variable PHP_ParserGenerator_Parser::$errorcnt
    Number of parsing errors so far
$errorcnt
in file Main.php, variable LemonData::$errorcnt
$errorcnt
in file Data.php, variable PHP_ParserGenerator_Data::$errorcnt
    Number of errors
$errorln
in file Main.php, variable LemonData::$errorln
$errorln
in file Data.php, variable PHP_ParserGenerator_Data::$errorln
    Line number for start of error code
$errsym
in file Data.php, variable PHP_ParserGenerator_Data::$errsym
    The error symbol
$errsym
in file Main.php, variable LemonData::$errsym
$extracode
in file Main.php, variable LemonData::$extracode
$extracode
in file Data.php, variable PHP_ParserGenerator_Data::$extracode
    Code appended to the generated file
$extracodeln
in file Main.php, variable LemonData::$extracodeln
$extracodeln
in file Data.php, variable PHP_ParserGenerator_Data::$extracodeln
    Line number for the start of the extra code
emit_code
in file Data.php, method PHP_ParserGenerator_Data::emit_code()
    Generate code which executes when the rule "rp" is reduced. Write the code to "out". Make sure lineno stays up-to-date.
emit_code
in file Main.php, method LemonData::emit_code()
    Generate code which executes when the rule "rp" is reduced. Write the code to "out". Make sure lineno stays up-to-date.
emit_destructor_code
in file Data.php, method PHP_ParserGenerator_Data::emit_destructor_code()
    The following routine emits code for the destructor for the
emit_destructor_code
in file Main.php, method LemonData::emit_destructor_code()
    The following routine emits code for the destructor for the
EQUALS
in file PHP.php, class constant PHPyyParser::EQUALS
error
in file Parser.php, method PHP_LexerGenerator_Parser::error()
ERROR
in file Action.php, class constant PHP_ParserGenerator_Action::ERROR
ERROR
in file Main.php, class constant LemonAction::ERROR
ErrorMsg
in file Main.php, method Lemon::ErrorMsg()
ErrorMsg
in file ParserGenerator.php, method PHP_ParserGenerator::ErrorMsg()
EXCLAM
in file PHP.php, class constant PHPyyParser::EXCLAM
top

f

$failure
in file Data.php, variable PHP_ParserGenerator_Data::$failure
    Code to execute on parser failure
$failure
in file Main.php, variable LemonData::$failure
$failureln
in file Data.php, variable PHP_ParserGenerator_Data::$failureln
    Line number for start of failure code
$failureln
in file Main.php, variable LemonData::$failureln
$fallback
in file Main.php, variable LemonSymbol::$fallback
$fallback
in file Main.php, variable LemonParser::$fallback
$fallback
in file Parser.php, variable PHP_ParserGenerator_Parser::$fallback
    The fallback token
$fallback
in file Symbol.php, variable PHP_ParserGenerator_Symbol::$fallback
    Fallback token in case this token doesn't parse
$filename
in file Main.php, variable LemonData::$filename
$filename
in file Parser.php, variable PHP_ParserGenerator_Parser::$filename
    Name of the input file
$filename
in file Data.php, variable PHP_ParserGenerator_Data::$filename
    Name of the input file
$filename
in file Main.php, variable LemonParser::$filename
$filenosuffix
in file Main.php, variable LemonData::$filenosuffix
$filenosuffix
in file Data.php, variable PHP_ParserGenerator_Data::$filenosuffix
    Name of the input file without its extension
$firstrule
in file Main.php, variable LemonParser::$firstrule
$firstrule
in file Parser.php, variable PHP_ParserGenerator_Parser::$firstrule
$firstset
in file Symbol.php, variable PHP_ParserGenerator_Symbol::$firstset
    First-set for all rules of this symbol
$firstset
in file Main.php, variable LemonSymbol::$firstset
$fplp
in file Main.php, variable LemonConfig::$fplp
$fplp
in file Config.php, variable PHP_ParserGenerator_Config::$fplp
    Follow-set forward propagation links.
$from
in file Main.php, variable LemonStateNode::$from
$from
in file State.php, variable PHP_ParserGenerator_StateNode::$from
$fws
in file Main.php, variable LemonConfig::$fws
$fws
in file Config.php, variable PHP_ParserGenerator_Config::$fws
    Follow-set for this configuration only
FindActions
in file Data.php, method PHP_ParserGenerator_Data::FindActions()
    Compute the reduce actions, and resolve conflicts.
FindActions
in file Main.php, method LemonData::FindActions()
    Compute the reduce actions, and resolve conflicts.
findbreak
in file Main.php, method Lemon::findbreak()
findbreak
in file ParserGenerator.php, method PHP_ParserGenerator::findbreak()
FindFirstSets
in file Data.php, method PHP_ParserGenerator_Data::FindFirstSets()
    Find all nonterminals which will generate the empty string.
FindFirstSets
in file Main.php, method LemonData::FindFirstSets()
FindFollowSets
in file Data.php, method PHP_ParserGenerator_Data::FindFollowSets()
    Compute all followsets.
FindFollowSets
in file Main.php, method LemonData::FindFollowSets()
    Compute all followsets.
FindLinks
in file Data.php, method PHP_ParserGenerator_Data::FindLinks()
    Construct the propagation links
FindLinks
in file Main.php, method LemonData::FindLinks()
    Construct the propagation links
FindRulePrecedences
in file Data.php, method PHP_ParserGenerator_Data::FindRulePrecedences()
FindRulePrecedences
in file Main.php, method LemonData::FindRulePrecedences()
FindStates
in file Data.php, method PHP_ParserGenerator_Data::FindStates()
    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.
FindStates
in file Main.php, method LemonData::FindStates()
    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.
top

g

$gp
in file Parser.php, variable PHP_ParserGenerator_Parser::$gp
    Global state vector
$gp
in file Main.php, variable LemonParser::$gp
getLastComment
in file Tokenizer.php, method PHP_Parser_Tokenizer::getLastComment()
    get the last comment block (and reset it)
getValue
in file Tokenizer.php, method PHP_Parser_Tokenizer::getValue()
getWhitespace
in file Tokenizer.php, method PHP_Parser_Tokenizer::getWhitespace()
    Return the whitespace (if any) that preceded the current token
globalSearch
in file Tokenizer.php, method PHP_Parser_Tokenizer::globalSearch()
    Compare global variable to search value, to see if we've
GREATERTHAN
in file PHP.php, class constant PHPyyParser::GREATERTHAN
top

h

$has_fallback
in file Data.php, variable PHP_ParserGenerator_Data::$has_fallback
    True if any %fallback is seen in the grammer
$has_fallback
in file Main.php, variable LemonData::$has_fallback
haltLexing
in file Tokenizer.php, method PHP_Parser_Tokenizer::haltLexing()
handleflags
in file ParserGenerator.php, method PHP_ParserGenerator::handleflags()
    Process a flag command line argument.
handleflags
in file Main.php, method Lemon::handleflags()
    Process a flag command line argument.
handleMessage
in file Tokenizer.php, method PHP_Parser_Tokenizer::handleMessage()
handleswitch
in file ParserGenerator.php, method PHP_ParserGenerator::handleswitch()
    Process a command line switch which has an argument.
handleswitch
in file Main.php, method Lemon::handleswitch()
    Process a command line switch which has an argument.
top

i

$iDflt
in file Main.php, variable LemonState::$iDflt
$iDflt
in file State.php, variable PHP_ParserGenerator_State::$iDflt
    Default action
$includeln
in file Data.php, variable PHP_ParserGenerator_Data::$includeln
    Line number for start of include code
$includeln
in file Main.php, variable LemonData::$includeln
$include_classcode
in file Data.php, variable PHP_ParserGenerator_Data::$include_classcode
    Code to put in the parser class
$include_classcode
in file Main.php, variable LemonData::$include_classcode
$include_classln
in file Data.php, variable PHP_ParserGenerator_Data::$include_classln
    Line number for start of include code
$include_classln
in file Main.php, variable LemonData::$include_classln
$include_code
in file Main.php, variable LemonData::$include_code
$include_code
in file Data.php, variable PHP_ParserGenerator_Data::$include_code
    Code to put at the start of the parser file
$index
in file Main.php, variable LemonRule::$index
$index
in file Symbol.php, variable PHP_ParserGenerator_Symbol::$index
    Index of this symbol.
$index
in file Main.php, variable LemonSymbol::$index
$index
in file Rule.php, variable PHP_ParserGenerator_Rule::$index
    An index number for this rule
$iNtOfst
in file State.php, variable PHP_ParserGenerator_State::$iNtOfst
$iNtOfst
in file Main.php, variable LemonState::$iNtOfst
$iTknOfst
in file Main.php, variable LemonState::$iTknOfst
$iTknOfst
in file State.php, variable PHP_ParserGenerator_State::$iTknOfst
    The offset into the $yy_action table for terminal tokens.
INCOMPLETE
in file Main.php, class constant LemonConfig::INCOMPLETE
INCOMPLETE
in file Config.php, class constant PHP_ParserGenerator_Config::INCOMPLETE
INITIALIZE
in file Main.php, class constant LemonParser::INITIALIZE
INITIALIZE
in file Parser.php, class constant PHP_ParserGenerator_Parser::INITIALIZE
IN_RHS
in file Main.php, class constant LemonParser::IN_RHS
IN_RHS
in file Parser.php, class constant PHP_ParserGenerator_Parser::IN_RHS
top

k

$key
in file State.php, variable PHP_ParserGenerator_StateNode::$key
$key
in file Main.php, variable LemonStateNode::$key
top

l

$lambda
in file Symbol.php, variable PHP_ParserGenerator_Symbol::$lambda
    True if this symbol is a non-terminal and can generate an empty result.
$lambda
in file Main.php, variable LemonSymbol::$lambda
$lastComment
in file Tokenizer.php, variable PHP_Parser_Tokenizer::$lastComment
    The string of the last Comment Token
$lastCommentLine
in file Tokenizer.php, variable PHP_Parser_Tokenizer::$lastCommentLine
    ID of the last Comment Token
$lastCommentToken
in file Tokenizer.php, variable PHP_Parser_Tokenizer::$lastCommentToken
    ID of the last Comment Token
$lastrule
in file Main.php, variable LemonParser::$lastrule
$lastrule
in file Parser.php, variable PHP_ParserGenerator_Parser::$lastrule
$lhs
in file Parser.php, variable PHP_ParserGenerator_Parser::$lhs
    Left-hand side of the current rule
$lhs
in file Main.php, variable LemonRule::$lhs
$lhs
in file Rule.php, variable PHP_ParserGenerator_Rule::$lhs
    Left-hand side of the rule
$lhs
in file Main.php, variable LemonParser::$lhs
$lhsalias
in file Rule.php, variable PHP_ParserGenerator_Rule::$lhsalias
    Alias for the LHS (NULL if none)
$lhsalias
in file Parser.php, variable PHP_ParserGenerator_Parser::$lhsalias
    Alias for the LHS
$lhsalias
in file Main.php, variable LemonRule::$lhsalias
$lhsalias
in file Main.php, variable LemonParser::$lhsalias
$line
in file Tokenizer.php, variable PHP_Parser_Tokenizer::$line
    Current line.
$line
in file Main.php, variable LemonRule::$line
$line
in file Rule.php, variable PHP_ParserGenerator_Rule::$line
    Line number at which code begins
LBRACKET
in file PHP.php, class constant PHPyyParser::LBRACKET
LCURLY
in file PHP.php, class constant PHPyyParser::LCURLY
LEFT
in file Symbol.php, class constant PHP_ParserGenerator_Symbol::LEFT
LEFT
in file Main.php, class constant LemonSymbol::LEFT
Lemon
in file Main.php, class Lemon
LemonAction
in file Main.php, class LemonAction
LemonActtab
in file Main.php, class LemonActtab
    The state of the yy_action table under construction is an instance of
LemonConfig
in file Main.php, class LemonConfig
LemonData
in file Main.php, class LemonData
LemonParser
in file Main.php, class LemonParser
LemonPlink
in file Main.php, class LemonPlink
LemonRule
in file Main.php, class LemonRule
LemonState
in file Main.php, class LemonState
LemonStateNode
in file Main.php, class LemonStateNode
LemonSymbol
in file Main.php, class LemonSymbol
LESSTHAN
in file PHP.php, class constant PHPyyParser::LESSTHAN
LHS_ALIAS_1
in file Main.php, class constant LemonParser::LHS_ALIAS_1
LHS_ALIAS_1
in file Parser.php, class constant PHP_ParserGenerator_Parser::LHS_ALIAS_1
LHS_ALIAS_2
in file Parser.php, class constant PHP_ParserGenerator_Parser::LHS_ALIAS_2
LHS_ALIAS_2
in file Main.php, class constant LemonParser::LHS_ALIAS_2
LHS_ALIAS_3
in file Parser.php, class constant PHP_ParserGenerator_Parser::LHS_ALIAS_3
LHS_ALIAS_3
in file Main.php, class constant LemonParser::LHS_ALIAS_3
LPAREN
in file PHP.php, class constant PHPyyParser::LPAREN
Lemon.php
procedural page Lemon.php
Lempar.php
procedural page Lempar.php
top

m

$major
in file PHP.php, variable PHPyyStackEntry::$major
$major
in file Parser.php, variable PHP_LexerGenerator_ParseryyStackEntry::$major
$major
in file oops.php, variable ParseyyStackEntry::$major
$metadata
in file Parser.php, variable PHP_LexerGenerator_ParseryyToken::$metadata
$metadata
in file Lempar.php, variable ParseyyToken::$metadata
$metadata
in file PHP_Parser.php, variable PHPyyToken::$metadata
$minor
in file Parser.php, variable PHP_LexerGenerator_ParseryyStackEntry::$minor
$minor
in file PHP.php, variable PHPyyStackEntry::$minor
$minor
in file oops.php, variable ParseyyStackEntry::$minor
$mnAction
in file Main.php, variable LemonActtab::$mnAction
$mnAction
in file ActionTable.php, variable PHP_ParserGenerator_ActionTable::$mnAction
    The action associated with the smallest lookahead token.
$mnLookahead
in file Main.php, variable LemonActtab::$mnLookahead
$mnLookahead
in file ActionTable.php, variable PHP_ParserGenerator_ActionTable::$mnLookahead
    The smallest (minimum) value of any lookahead token in $aLookahead
$mxLookahead
in file Main.php, variable LemonActtab::$mxLookahead
$mxLookahead
in file ActionTable.php, variable PHP_ParserGenerator_ActionTable::$mxLookahead
    The largest (maximum) value of any lookahead token in $aLookahead
main
in file ParserGenerator.php, method PHP_ParserGenerator::main()
    The main program. Parse the command line and do it...
main
in file Main.php, method Lemon::main()
    ************** From the file "main.c" ***********************************
MAXRHS
in file ParserGenerator.php, class constant PHP_ParserGenerator::MAXRHS
MAXRHS
in file Main.php, class constant Lemon::MAXRHS
merge
in file ParserGenerator.php, method PHP_ParserGenerator::merge()
    Merge in a merge sort for a linked list
merge
in file Main.php, method Lemon::merge()
    Merge in a merge sort for a linked list Inputs:
  • a: A sorted, null-terminated linked list. (May be null).
MINUS
in file PHP.php, class constant PHPyyParser::MINUS
msort
in file ParserGenerator.php, method PHP_ParserGenerator::msort()
    Side effects: The "next" pointers for elements in list are changed.
msort
in file Main.php, method Lemon::msort()
MULTITERMINAL
in file Symbol.php, class constant PHP_ParserGenerator_Symbol::MULTITERMINAL
    Multiple terminal symbols.
MULTITERMINAL
in file Main.php, class constant LemonSymbol::MULTITERMINAL
Main.php
procedural page Main.php
top

n

$N
in file Tokenizer.php, variable PHP_Parser_Tokenizer::$N
    Total Number of tokens.
$nAction
in file Main.php, variable LemonActtab::$nAction
$nAction
in file ActionTable.php, variable PHP_ParserGenerator_ActionTable::$nAction
    Number of used slots in $aAction
$name
in file Data.php, variable PHP_ParserGenerator_Data::$name
    Name of the generated parser
$name
in file Symbol.php, variable PHP_ParserGenerator_Symbol::$name
    Name of the symbol
$name
in file Main.php, variable LemonData::$name
$name
in file Main.php, variable LemonSymbol::$name
$nconflict
in file Main.php, variable LemonData::$nconflict
$nconflict
in file Data.php, variable PHP_ParserGenerator_Data::$nconflict
    Number of parsing conflicts
$next
in file Main.php, variable LemonConfig::$next
    Index of next LemonConfig object
$next
in file Main.php, variable LemonRule::$next
$next
in file Main.php, variable LemonPlink::$next
$next
in file Action.php, variable PHP_ParserGenerator_Action::$next
    The next action for this state.
$next
in file Main.php, variable LemonStateNode::$next
$next
in file Main.php, variable LemonAction::$next
$next
in file Rule.php, variable PHP_ParserGenerator_Rule::$next
    Next rule in the global list
$next
in file PropagationLink.php, variable PHP_ParserGenerator_PropagationLink::$next
    The next propagation link
$next
in file State.php, variable PHP_ParserGenerator_StateNode::$next
$next
in file Config.php, variable PHP_ParserGenerator_Config::$next
    Next configuration in the state.
$nextlhs
in file Rule.php, variable PHP_ParserGenerator_Rule::$nextlhs
    Next rule with the same left-hand side
$nextlhs
in file Main.php, variable LemonRule::$nextlhs
$nLookahead
in file ActionTable.php, variable PHP_ParserGenerator_ActionTable::$nLookahead
    The number of slots used in $aLookahead.
$nLookahead
in file Main.php, variable LemonActtab::$nLookahead
$nNtAct
in file State.php, variable PHP_ParserGenerator_State::$nNtAct
$nNtAct
in file Main.php, variable LemonState::$nNtAct
$nrhs
in file Rule.php, variable PHP_ParserGenerator_Rule::$nrhs
    Number of right-hand side symbols
$nrhs
in file Main.php, variable LemonRule::$nrhs
$nrhs
in file Parser.php, variable PHP_ParserGenerator_Parser::$nrhs
    Number of right-hand side symbols seen
$nrhs
in file Main.php, variable LemonParser::$nrhs
$nrule
in file Data.php, variable PHP_ParserGenerator_Data::$nrule
    Number of rules
$nrule
in file Main.php, variable LemonData::$nrule
$nstate
in file Main.php, variable LemonData::$nstate
$nstate
in file Data.php, variable PHP_ParserGenerator_Data::$nstate
    Number of states
$nsubsym
in file Symbol.php, variable PHP_ParserGenerator_Symbol::$nsubsym
    Number of terminal symbols in the MULTITERMINAL
$nsubsym
in file Main.php, variable LemonSymbol::$nsubsym
$nsymbol
in file Main.php, variable LemonData::$nsymbol
$nsymbol
in file Data.php, variable PHP_ParserGenerator_Data::$nsymbol
    Number of terminal and nonterminal symbols
$nterminal
in file Data.php, variable PHP_ParserGenerator_Data::$nterminal
    Number of terminal symbols (tokens)
$nterminal
in file Main.php, variable LemonData::$nterminal
$nTknAct
in file State.php, variable PHP_ParserGenerator_State::$nTknAct
    Number of terminal (token) actions
$nTknAct
in file Main.php, variable LemonState::$nTknAct
NONE
in file Main.php, class constant LemonSymbol::NONE
NONE
in file Symbol.php, class constant PHP_ParserGenerator_Symbol::NONE
NONTERMINAL
in file Symbol.php, class constant PHP_ParserGenerator_Symbol::NONTERMINAL
    Symbols that start with a lower-case letter like foo.
NONTERMINAL
in file Main.php, class constant LemonSymbol::NONTERMINAL
NOT_USED
in file Main.php, class constant LemonAction::NOT_USED
NOT_USED
in file Action.php, class constant PHP_ParserGenerator_Action::NOT_USED
NO_OFFSET
in file Main.php, constant NO_OFFSET
NO_OFFSET
in file Data.php, class constant PHP_ParserGenerator_Data::NO_OFFSET
    Used for terminal and non-terminal offsets into the action table
top

o

$outname
in file Data.php, variable PHP_ParserGenerator_Data::$outname
    Name of the current output file
$outname
in file Main.php, variable LemonData::$outname
$overflow
in file Main.php, variable LemonData::$overflow
$overflow
in file Data.php, variable PHP_ParserGenerator_Data::$overflow
    Code to execute on a stack overflow
$overflowln
in file Main.php, variable LemonData::$overflowln
$overflowln
in file Data.php, variable PHP_ParserGenerator_Data::$overflowln
    Line number for start of overflow code
offsetExists
in file PHP_Parser.php, method PHPyyToken::offsetExists()
offsetExists
in file Lempar.php, method ParseyyToken::offsetExists()
offsetExists
in file Parser.php, method PHP_LexerGenerator_ParseryyToken::offsetExists()
offsetGet
in file Parser.php, method PHP_LexerGenerator_ParseryyToken::offsetGet()
offsetGet
in file Lempar.php, method ParseyyToken::offsetGet()
offsetGet
in file PHP_Parser.php, method PHPyyToken::offsetGet()
offsetSet
in file Lempar.php, method ParseyyToken::offsetSet()
offsetSet
in file PHP_Parser.php, method PHPyyToken::offsetSet()
offsetSet
in file Parser.php, method PHP_LexerGenerator_ParseryyToken::offsetSet()
offsetUnset
in file Parser.php, method PHP_LexerGenerator_ParseryyToken::offsetUnset()
offsetUnset
in file Lempar.php, method ParseyyToken::offsetUnset()
offsetUnset
in file PHP_Parser.php, method PHPyyToken::offsetUnset()
OptInit
in file ParserGenerator.php, method PHP_ParserGenerator::OptInit()
    OptInit
OptInit
in file Main.php, method Lemon::OptInit()
OptNArgs
in file ParserGenerator.php, method PHP_ParserGenerator::OptNArgs()
OptNArgs
in file Main.php, method Lemon::OptNArgs()
OptPrint
in file Main.php, method Lemon::OptPrint()
    Print out command-line options
OptPrint
in file ParserGenerator.php, method PHP_ParserGenerator::OptPrint()
    Print out command-line options
OPT_DBL
in file Main.php, class constant Lemon::OPT_DBL
OPT_DBL
in file ParserGenerator.php, class constant PHP_ParserGenerator::OPT_DBL
OPT_FDBL
in file Main.php, class constant Lemon::OPT_FDBL
OPT_FDBL
in file ParserGenerator.php, class constant PHP_ParserGenerator::OPT_FDBL
OPT_FFLAG
in file Main.php, class constant Lemon::OPT_FFLAG
OPT_FFLAG
in file ParserGenerator.php, class constant PHP_ParserGenerator::OPT_FFLAG
OPT_FINT
in file ParserGenerator.php, class constant PHP_ParserGenerator::OPT_FINT
OPT_FINT
in file Main.php, class constant Lemon::OPT_FINT
OPT_FLAG
in file ParserGenerator.php, class constant PHP_ParserGenerator::OPT_FLAG
OPT_FLAG
in file Main.php, class constant Lemon::OPT_FLAG
OPT_FSTR
in file ParserGenerator.php, class constant PHP_ParserGenerator::OPT_FSTR
OPT_FSTR
in file Main.php, class constant Lemon::OPT_FSTR
OPT_INT
in file Main.php, class constant Lemon::OPT_INT
OPT_INT
in file ParserGenerator.php, class constant PHP_ParserGenerator::OPT_INT
OPT_STR
in file ParserGenerator.php, class constant PHP_ParserGenerator::OPT_STR
OPT_STR
in file Main.php, class constant Lemon::OPT_STR
outputRules
in file Parser.php, method PHP_LexerGenerator_Parser::outputRules()
oops.php
procedural page oops.php
top

p

$parser_template
in file Data.php, variable PHP_ParserGenerator_Data::$parser_template
    Alternate parser template file
$pos
in file Tokenizer.php, variable PHP_Parser_Tokenizer::$pos
    Current token position.
$prec
in file Symbol.php, variable PHP_ParserGenerator_Symbol::$prec
    Precendence, if defined.
$prec
in file Main.php, variable LemonSymbol::$prec
$preccounter
in file Main.php, variable LemonParser::$preccounter
$preccounter
in file Parser.php, variable PHP_ParserGenerator_Parser::$preccounter
$precsym
in file Main.php, variable LemonRule::$precsym
$precsym
in file Rule.php, variable PHP_ParserGenerator_Rule::$precsym
    Precedence symbol for this rule
$prevrule
in file Main.php, variable LemonParser::$prevrule
$prevrule
in file Parser.php, variable PHP_ParserGenerator_Parser::$prevrule
    Previous rule parsed
Parse
in file Main.php, method LemonParser::Parse()
    In spite of its name, this function is really a scanner.
Parse
in file Parser.php, method PHP_ParserGenerator_Parser::Parse()
    In spite of its name, this function is really a scanner.
ParseARG_DECL
in file oops.php, class constant ParseyyParser::ParseARG_DECL
parseError
in file Tokenizer.php, method PHP_Parser_Tokenizer::parseError()
    return something useful, when a parse error occurs.
parseonetoken
in file Parser.php, method PHP_ParserGenerator_Parser::parseonetoken()
    Parse a single token
parseonetoken
in file Main.php, method LemonParser::parseonetoken()
    Parse a single token
ParseTokenName
in file oops.php, method ParseyyParser::ParseTokenName()
    This function returns the symbolic name associated with a token value.
ParseyyParser
in file oops.php, class ParseyyParser
    The state of the parser is completely contained in an instance of
ParseyyStackEntry
in file oops.php, class ParseyyStackEntry
    The following structure represents a single element of the parser's stack. Information stored includes:
ParseyyToken
in file Lempar.php, class ParseyyToken
    This can be used to store both the string representation of a token, and any useful meta-data associated with the token.
PATTERN
in file Parser.php, class constant PHP_LexerGenerator_Parser::PATTERN
PERCENT
in file PHP.php, class constant PHPyyParser::PERCENT
PHPCODE
in file Parser.php, class constant PHP_LexerGenerator_Parser::PHPCODE
PHPyyParser
in file PHP.php, class PHPyyParser
    The state of the parser is completely contained in an instance of
PHPyyStackEntry
in file PHP.php, class PHPyyStackEntry
    The following structure represents a single element of the parser's stack. Information stored includes:
PHPyyToken
in file PHP_Parser.php, class PHPyyToken
    This can be used to store both the string representation of a token, and any useful meta-data associated with the token.
PHP_LexerGenerator_Parser
in file Parser.php, class PHP_LexerGenerator_Parser
    The state of the parser is completely contained in an instance of
PHP_LexerGenerator_ParserARG_DECL
in file Parser.php, class constant PHP_LexerGenerator_Parser::PHP_LexerGenerator_ParserARG_DECL
PHP_LexerGenerator_ParseryyStackEntry
in file Parser.php, class PHP_LexerGenerator_ParseryyStackEntry
    The following structure represents a single element of the parser's stack. Information stored includes:
PHP_LexerGenerator_ParseryyToken
in file Parser.php, class PHP_LexerGenerator_ParseryyToken
    This can be used to store both the string representation of a token, and any useful meta-data associated with the token.
PHP_ParserGenerator
in file ParserGenerator.php, class PHP_ParserGenerator
    The basic home class for the parser generator
Parser.php
procedural page Parser.php
parsephp.php
procedural page parsephp.php
Parser.php
procedural page Parser.php
PropagationLink.php
procedural page PropagationLink.php
ParserGenerator.php
procedural page ParserGenerator.php
PHP.php
procedural page PHP.php
PHP_Parser.php
procedural page PHP_Parser.php
PHP_ParserGenerator_Action
in file Action.php, class PHP_ParserGenerator_Action
    Every shift or reduce operation is stored as one of the following objects.
PHP_ParserGenerator_ActionTable
in file ActionTable.php, class PHP_ParserGenerator_ActionTable
    The state of the yy_action table under construction is an instance of the following structure
PHP_ParserGenerator_Config
in file Config.php, class PHP_ParserGenerator_Config
    a mark (dot) showing how much of that rule has been processed so far.
PHP_ParserGenerator_Data
in file Data.php, class PHP_ParserGenerator_Data
    The state vector for the entire parser generator is recorded in this class.
PHP_ParserGenerator_Parser
in file Parser.php, class PHP_ParserGenerator_Parser
    The grammar parser for lemon grammar files.
PHP_ParserGenerator_PropagationLink
in file PropagationLink.php, class PHP_ParserGenerator_PropagationLink
    A followset propagation link indicates that the contents of one configuration followset should be propagated to another whenever the first changes.
PHP_ParserGenerator_Rule
in file Rule.php, class PHP_ParserGenerator_Rule
    Each production rule in the grammar is stored in this class
PHP_ParserGenerator_State
in file State.php, class PHP_ParserGenerator_State
    Each state of the generated parser's finite state machine is encoded as an instance of this class
PHP_ParserGenerator_StateNode
in file State.php, class PHP_ParserGenerator_StateNode
    The structure used to represent a state in the associative array for a PHP_ParserGenerator_Config.
PHP_ParserGenerator_Symbol
in file Symbol.php, class PHP_ParserGenerator_Symbol
    Symbols (terminals and nonterminals) of the grammar are stored in this class
PHP_Parser_Tokenizer
in file Tokenizer.php, class PHP_Parser_Tokenizer
    The tokenizer wrapper for parser - implements the 'standard?' yylex interface
PI
in file Parser.php, class constant PHP_LexerGenerator_Parser::PI
Plink_add
in file Main.php, method LemonPlink::Plink_add()
    Add a plink to a plink list
Plink_add
in file PropagationLink.php, method PHP_ParserGenerator_PropagationLink::Plink_add()
    Add a propagation link to the current list
Plink_copy
in file PropagationLink.php, method PHP_ParserGenerator_PropagationLink::Plink_copy()
    Transfer every propagation link on the list "from" to the list "to"
Plink_copy
in file Main.php, method LemonPlink::Plink_copy()
Plink_delete
in file PropagationLink.php, method PHP_ParserGenerator_PropagationLink::Plink_delete()
    Delete every propagation link on the list
Plink_delete
in file Main.php, method LemonPlink::Plink_delete()
    Delete every plink on the list
PLUS
in file PHP.php, class constant PHPyyParser::PLUS
PRECEDENCE_MARK_1
in file Parser.php, class constant PHP_ParserGenerator_Parser::PRECEDENCE_MARK_1
PRECEDENCE_MARK_1
in file Main.php, class constant LemonParser::PRECEDENCE_MARK_1
PRECEDENCE_MARK_2
in file Main.php, class constant LemonParser::PRECEDENCE_MARK_2
PRECEDENCE_MARK_2
in file Parser.php, class constant PHP_ParserGenerator_Parser::PRECEDENCE_MARK_2
PrintAction
in file Action.php, method PHP_ParserGenerator_Action::PrintAction()
    Print an action to the given file descriptor. Return FALSE if nothing was actually printed.
PrintAction
in file Main.php, method LemonAction::PrintAction()
    Print an action to the given file descriptor. Return FALSE if nothing was actually printed.
PrintTrace
in file Parser.php, method PHP_LexerGenerator_Parser::PrintTrace()
PrintTrace
in file Lempar.php, function PrintTrace()
    Output debug information to output (php://output stream)
top

q

QUESTION
in file PHP.php, class constant PHPyyParser::QUESTION
QUOTE
in file Parser.php, class constant PHP_LexerGenerator_Parser::QUOTE
top

r

$rhs
in file Main.php, variable LemonRule::$rhs
$rhs
in file Main.php, variable LemonParser::$rhs
$rhs
in file Parser.php, variable PHP_ParserGenerator_Parser::$rhs
    Right-hand side symbols
$rhs
in file Rule.php, variable PHP_ParserGenerator_Rule::$rhs
    The right-hand side symbols
$rhsalias
in file Rule.php, variable PHP_ParserGenerator_Rule::$rhsalias
    Aliases for each right-hand side symbol, or null if no alis.
$rhsalias
in file Main.php, variable LemonRule::$rhsalias
$rp
in file Main.php, variable LemonConfig::$rp
$rp
in file Config.php, variable PHP_ParserGenerator_Config::$rp
    The parser rule upon with the configuration is based.
$rule
in file Main.php, variable LemonData::$rule
$rule
in file Symbol.php, variable PHP_ParserGenerator_Symbol::$rule
    Linked list of rules that use this symbol, if it is a non-terminal.
$rule
in file Main.php, variable LemonSymbol::$rule
$rule
in file Data.php, variable PHP_ParserGenerator_Data::$rule
    List of all rules
$ruleline
in file Rule.php, variable PHP_ParserGenerator_Rule::$ruleline
    Line number for the rule
$ruleline
in file Main.php, variable LemonRule::$ruleline
Rule.php
procedural page Rule.php
RBRACKET
in file PHP.php, class constant PHPyyParser::RBRACKET
RCURLY
in file PHP.php, class constant PHPyyParser::RCURLY
RD_RESOLVED
in file Action.php, class constant PHP_ParserGenerator_Action::RD_RESOLVED
RD_RESOLVED
in file Main.php, class constant LemonAction::RD_RESOLVED
REDUCE
in file Main.php, class constant LemonAction::REDUCE
REDUCE
in file Action.php, class constant PHP_ParserGenerator_Action::REDUCE
ReportOutput
in file Main.php, method LemonData::ReportOutput()
    Generate the "y.output" log file
ReportOutput
in file Data.php, method PHP_ParserGenerator_Data::ReportOutput()
    Generate the "Parse.out" log file
ReportTable
in file Main.php, method LemonData::ReportTable()
    Generate C source code for the parser
ReportTable
in file Data.php, method PHP_ParserGenerator_Data::ReportTable()
    Generate C source code for the parser
Reprint
in file ParserGenerator.php, method PHP_ParserGenerator::Reprint()
    Duplicate the input file without comments and without actions on rules
Reprint
in file Main.php, method Lemon::Reprint()
    Duplicate the input file without comments and without actions
resolve_conflict
in file Data.php, method PHP_ParserGenerator_Data::resolve_conflict()
    Resolve a conflict between the two given actions. If the conflict can't be resolve, return non-zero.
resolve_conflict
in file Main.php, method LemonData::resolve_conflict()
    Resolve a conflict between the two given actions. If the conflict can't be resolve, return non-zero.
ResortStates
in file Main.php, method LemonData::ResortStates()
    Renumber and resort states so that states with fewer choices occur at the end. Except, keep state 0 as the first state.
ResortStates
in file Data.php, method PHP_ParserGenerator_Data::ResortStates()
    Renumber and resort states so that states with fewer choices occur at the end. Except, keep state 0 as the first state.
RESYNC_AFTER_DECL_ERROR
in file Parser.php, class constant PHP_ParserGenerator_Parser::RESYNC_AFTER_DECL_ERROR
RESYNC_AFTER_DECL_ERROR
in file Main.php, class constant LemonParser::RESYNC_AFTER_DECL_ERROR
RESYNC_AFTER_RULE_ERROR
in file Main.php, class constant LemonParser::RESYNC_AFTER_RULE_ERROR
RESYNC_AFTER_RULE_ERROR
in file Parser.php, class constant PHP_ParserGenerator_Parser::RESYNC_AFTER_RULE_ERROR
RHS_ALIAS_1
in file Main.php, class constant LemonParser::RHS_ALIAS_1
RHS_ALIAS_1
in file Parser.php, class constant PHP_ParserGenerator_Parser::RHS_ALIAS_1
RHS_ALIAS_2
in file Main.php, class constant LemonParser::RHS_ALIAS_2
RHS_ALIAS_2
in file Parser.php, class constant PHP_ParserGenerator_Parser::RHS_ALIAS_2
RIGHT
in file Main.php, class constant LemonSymbol::RIGHT
RIGHT
in file Symbol.php, class constant PHP_ParserGenerator_Symbol::RIGHT
RPAREN
in file PHP.php, class constant PHPyyParser::RPAREN
top

s

$sorted
in file Data.php, variable PHP_ParserGenerator_Data::$sorted
    Table of states sorted by state number
$sorted
in file Main.php, variable LemonData::$sorted
$sp
in file Main.php, variable LemonAction::$sp
$sp
in file Action.php, variable PHP_ParserGenerator_Action::$sp
    The look-ahead symbol that triggers this action
$stacksize
in file Data.php, variable PHP_ParserGenerator_Data::$stacksize
    Size of the parser stack
$stacksize
in file Main.php, variable LemonData::$stacksize
$start
in file Main.php, variable LemonData::$start
$start
in file Data.php, variable PHP_ParserGenerator_Data::$start
    Name of the start symbol for the grammar
$state
in file Parser.php, variable PHP_ParserGenerator_Parser::$state
    Parser state (one of the class constants for this class)
$state
in file Main.php, variable LemonParser::$state
$stateno
in file oops.php, variable ParseyyStackEntry::$stateno
$stateno
in file PHP.php, variable PHPyyStackEntry::$stateno
$stateno
in file Parser.php, variable PHP_LexerGenerator_ParseryyStackEntry::$stateno
$statenum
in file State.php, variable PHP_ParserGenerator_State::$statenum
    Sequential number for this state
$statenum
in file Main.php, variable LemonState::$statenum
$states
in file State.php, variable PHP_ParserGenerator_State::$states
    Array of PHP_ParserGenerator_State objects
$states
in file Main.php, variable LemonState::$states
$status
in file Config.php, variable PHP_ParserGenerator_Config::$status
    Status during followset and shift computations.
$status
in file Main.php, variable LemonConfig::$status
$stp
in file Config.php, variable PHP_ParserGenerator_Config::$stp
    State that contains this configuration
$stp
in file Main.php, variable LemonConfig::$stp
$string
in file Lempar.php, variable ParseyyToken::$string
$string
in file Parser.php, variable PHP_LexerGenerator_ParseryyToken::$string
$string
in file PHP_Parser.php, variable PHPyyToken::$string
$subsym
in file Main.php, variable LemonSymbol::$subsym
$subsym
in file Symbol.php, variable PHP_ParserGenerator_Symbol::$subsym
    Array of terminal symbols in the MULTITERMINAL
$symbols
in file Main.php, variable LemonData::$symbols
$symbols
in file Data.php, variable PHP_ParserGenerator_Data::$symbols
    Sorted array of pointers to symbols
State.php
procedural page State.php
Symbol.php
procedural page Symbol.php
same_symbol
in file Symbol.php, method PHP_ParserGenerator_Symbol::same_symbol()
    Return true if two symbols are the same.
same_symbol
in file Main.php, method LemonSymbol::same_symbol()
    Return true if two symbols are the same.
SEMI
in file PHP.php, class constant PHPyyParser::SEMI
SetSize
in file Main.php, method Lemon::SetSize()
SetSize
in file ParserGenerator.php, method PHP_ParserGenerator::SetSize()
    SetSize
SHIFT
in file Main.php, class constant LemonAction::SHIFT
SHIFT
in file Action.php, class constant PHP_ParserGenerator_Action::SHIFT
SH_RESOLVED
in file Action.php, class constant PHP_ParserGenerator_Action::SH_RESOLVED
SH_RESOLVED
in file Main.php, class constant LemonAction::SH_RESOLVED
SINGLEQUOTE
in file PHP.php, class constant PHPyyParser::SINGLEQUOTE
sortSymbols
in file Symbol.php, method PHP_ParserGenerator_Symbol::sortSymbols()
    Sort function helper for symbols
sortSymbols
in file Main.php, method LemonSymbol::sortSymbols()
    Sort function helper for symbols
statecmp
in file State.php, method PHP_ParserGenerator_State::statecmp()
    Compare two states based on their configurations
statecmp
in file Main.php, method LemonState::statecmp()
stateResortCompare
in file State.php, method PHP_ParserGenerator_State::stateResortCompare()
    Compare two states for sorting purposes. The smaller state is the one with the most non-terminal actions. If they have the same number of non-terminal actions, then the smaller is the one with the most token actions.
stateResortCompare
in file Main.php, method LemonState::stateResortCompare()
    Compare two states for sorting purposes. The smaller state is the one with the most non-terminal actions. If they have the same number of non-terminal actions, then the smaller is the one with the most token actions.
State_arrayof
in file State.php, method PHP_ParserGenerator_State::State_arrayof()
    Get an array indexed by state number
State_arrayof
in file Main.php, method LemonState::State_arrayof()
State_find
in file Main.php, method LemonState::State_find()
    Return a pointer to data assigned to the given key. Return NULL if no such key.
State_find
in file State.php, method PHP_ParserGenerator_State::State_find()
    Return a pointer to data assigned to the given key. Return NULL if no such key.
State_insert
in file State.php, method PHP_ParserGenerator_State::State_insert()
    Insert a new record into the array. Return TRUE if successful.
State_insert
in file Main.php, method LemonState::State_insert()
    Insert a new record into the array. Return TRUE if successful.
stopTrackingWhitespace
in file Tokenizer.php, method PHP_Parser_Tokenizer::stopTrackingWhitespace()
SUBPATTERN
in file Parser.php, class constant PHP_LexerGenerator_Parser::SUBPATTERN
Symbol_arrayof
in file Main.php, method LemonSymbol::Symbol_arrayof()
Symbol_arrayof
in file Symbol.php, method PHP_ParserGenerator_Symbol::Symbol_arrayof()
Symbol_count
in file Symbol.php, method PHP_ParserGenerator_Symbol::Symbol_count()
    Return the number of unique symbols
Symbol_count
in file Main.php, method LemonSymbol::Symbol_count()
    Return the number of unique symbols
Symbol_find
in file Symbol.php, method PHP_ParserGenerator_Symbol::Symbol_find()
Symbol_find
in file Main.php, method LemonSymbol::Symbol_find()
Symbol_new
in file Main.php, method LemonSymbol::Symbol_new()
    Return a pointer to the (terminal or nonterminal) symbol "x".
Symbol_new
in file Symbol.php, method PHP_ParserGenerator_Symbol::Symbol_new()
    Return a pointer to the (terminal or nonterminal) symbol "x".
top

t

$tablesize
in file Main.php, variable LemonData::$tablesize
$tablesize
in file Data.php, variable PHP_ParserGenerator_Data::$tablesize
    Size of the parse tables
$token
in file Tokenizer.php, variable PHP_Parser_Tokenizer::$token
    The current token (either a ord(';') or token numer - see php tokenizer.
$tokendest
in file Main.php, variable LemonData::$tokendest
$tokendest
in file Data.php, variable PHP_ParserGenerator_Data::$tokendest
    Code to execute to destroy token data
$tokendestln
in file Main.php, variable LemonData::$tokendestln
$tokendestln
in file Data.php, variable PHP_ParserGenerator_Data::$tokendestln
    Line number for token destroyer code
$tokenlineno
in file Main.php, variable LemonParser::$tokenlineno
$tokenlineno
in file Parser.php, variable PHP_ParserGenerator_Parser::$tokenlineno
    Linenumber at which current token starts
$tokenprefix
in file Data.php, variable PHP_ParserGenerator_Data::$tokenprefix
    A prefix added to token names
$tokenprefix
in file Main.php, variable LemonData::$tokenprefix
$tokens
in file Tokenizer.php, variable PHP_Parser_Tokenizer::$tokens
    Tokens - array of all the tokens.
$tokenstart
in file Main.php, variable LemonParser::$tokenstart
$tokenstart
in file Parser.php, variable PHP_ParserGenerator_Parser::$tokenstart
    Index of current token within the input string
$tokentype
in file Data.php, variable PHP_ParserGenerator_Data::$tokentype
    Unused relic from the C version
$tokentype
in file Main.php, variable LemonData::$tokentype
$transTable
in file Parser.php, variable PHP_LexerGenerator_Parser::$transTable
$transTable
in file PHP.php, variable PHPyyParser::$transTable
$type
in file Symbol.php, variable PHP_ParserGenerator_Symbol::$type
    Symbol type
$type
in file Action.php, variable PHP_ParserGenerator_Action::$type
    This defines the kind of action, and must be one of the class constants.
$type
in file Main.php, variable LemonSymbol::$type
$type
in file Main.php, variable LemonAction::$type
test.php
procedural page test.php
Tokenizer.php
procedural page Tokenizer.php
TERMINAL
in file Symbol.php, class constant PHP_ParserGenerator_Symbol::TERMINAL
    Symbols that start with a capital letter like FOO.
TERMINAL
in file Main.php, class constant LemonSymbol::TERMINAL
TILDE
in file PHP.php, class constant PHPyyParser::TILDE
TIMES
in file PHP.php, class constant PHPyyParser::TIMES
tokenName
in file Parser.php, method PHP_LexerGenerator_Parser::tokenName()
    This function returns the symbolic name associated with a token value.
tokenName
in file Lempar.php, function tokenName()
    This function returns the symbolic name associated with a token value.
Trace
in file Lempar.php, function Trace()
    Turn parser tracing on by giving a stream to which to write the trace and a prompt to preface each trace message. Tracing is turned off by making either argument NULL
Trace
in file oops.php, method ParseyyParser::Trace()
    Turn parser tracing on by giving a stream to which to write the trace and a prompt to preface each trace message. Tracing is turned off by making either argument NULL
Trace
in file Parser.php, method PHP_LexerGenerator_Parser::Trace()
    Turn parser tracing on by giving a stream to which to write the trace and a prompt to preface each trace message. Tracing is turned off by making either argument NULL
trackWhitespace
in file Tokenizer.php, method PHP_Parser_Tokenizer::trackWhitespace()
translate_code
in file Main.php, method LemonData::translate_code()
    zCode is a string that is the action associated with a rule. Expand the symbols in this string so that the refer to elements of the parser stack.
translate_code
in file Data.php, method PHP_ParserGenerator_Data::translate_code()
    zCode is a string that is the action associated with a rule. Expand the symbols in this string so that the refer to elements of the parser stack.
T_ABSTRACT
in file PHP.php, class constant PHPyyParser::T_ABSTRACT
T_AND_EQUAL
in file PHP.php, class constant PHPyyParser::T_AND_EQUAL
T_ARRAY
in file PHP.php, class constant PHPyyParser::T_ARRAY
T_ARRAY_CAST
in file PHP.php, class constant PHPyyParser::T_ARRAY_CAST
T_AS
in file PHP.php, class constant PHPyyParser::T_AS
T_BAD_CHARACTER
in file PHP.php, class constant PHPyyParser::T_BAD_CHARACTER
T_BOOLEAN_AND
in file PHP.php, class constant PHPyyParser::T_BOOLEAN_AND
T_BOOLEAN_OR
in file PHP.php, class constant PHPyyParser::T_BOOLEAN_OR
T_BOOL_CAST
in file PHP.php, class constant PHPyyParser::T_BOOL_CAST
T_BREAK
in file PHP.php, class constant PHPyyParser::T_BREAK
T_CASE
in file PHP.php, class constant PHPyyParser::T_CASE
T_CATCH
in file PHP.php, class constant PHPyyParser::T_CATCH
T_CHARACTER
in file PHP.php, class constant PHPyyParser::T_CHARACTER
T_CLASS
in file PHP.php, class constant PHPyyParser::T_CLASS
T_CLASS_C
in file oops.php, class constant ParseyyParser::T_CLASS_C
T_CLASS_C
in file PHP.php, class constant PHPyyParser::T_CLASS_C
T_CLONE
in file PHP.php, class constant PHPyyParser::T_CLONE
T_CONCAT_EQUAL
in file PHP.php, class constant PHPyyParser::T_CONCAT_EQUAL
T_CONST
in file PHP.php, class constant PHPyyParser::T_CONST
T_CONSTANT_ENCAPSED_STRING
in file PHP.php, class constant PHPyyParser::T_CONSTANT_ENCAPSED_STRING
T_CONSTANT_ENCAPSED_STRING
in file oops.php, class constant ParseyyParser::T_CONSTANT_ENCAPSED_STRING
T_CONTINUE
in file PHP.php, class constant PHPyyParser::T_CONTINUE
T_CURLY_OPEN
in file PHP.php, class constant PHPyyParser::T_CURLY_OPEN
T_DEC
in file PHP.php, class constant PHPyyParser::T_DEC
T_DECLARE
in file PHP.php, class constant PHPyyParser::T_DECLARE
T_DEFAULT
in file PHP.php, class constant PHPyyParser::T_DEFAULT
T_DIV_EQUAL
in file PHP.php, class constant PHPyyParser::T_DIV_EQUAL
T_DNUMBER
in file oops.php, class constant ParseyyParser::T_DNUMBER
T_DNUMBER
in file PHP.php, class constant PHPyyParser::T_DNUMBER
T_DO
in file PHP.php, class constant PHPyyParser::T_DO
T_DOLLAR_OPEN_CURLY_BRACES
in file PHP.php, class constant PHPyyParser::T_DOLLAR_OPEN_CURLY_BRACES
T_DOUBLE_ARROW
in file PHP.php, class constant PHPyyParser::T_DOUBLE_ARROW
T_DOUBLE_CAST
in file PHP.php, class constant PHPyyParser::T_DOUBLE_CAST
T_ECHO
in file PHP.php, class constant PHPyyParser::T_ECHO
T_ELSE
in file PHP.php, class constant PHPyyParser::T_ELSE
T_ELSEIF
in file PHP.php, class constant PHPyyParser::T_ELSEIF
T_EMPTY
in file PHP.php, class constant PHPyyParser::T_EMPTY
T_ENCAPSED_AND_WHITESPACE
in file PHP.php, class constant PHPyyParser::T_ENCAPSED_AND_WHITESPACE
T_ENDDECLARE
in file PHP.php, class constant PHPyyParser::T_ENDDECLARE
T_ENDFOR
in file PHP.php, class constant PHPyyParser::T_ENDFOR
T_ENDFOREACH
in file PHP.php, class constant PHPyyParser::T_ENDFOREACH
T_ENDIF
in file PHP.php, class constant PHPyyParser::T_ENDIF
T_ENDSWITCH
in file PHP.php, class constant PHPyyParser::T_ENDSWITCH
T_ENDWHILE
in file PHP.php, class constant PHPyyParser::T_ENDWHILE
T_END_HEREDOC
in file PHP.php, class constant PHPyyParser::T_END_HEREDOC
T_EVAL
in file PHP.php, class constant PHPyyParser::T_EVAL
T_EXIT
in file PHP.php, class constant PHPyyParser::T_EXIT
T_EXTENDS
in file PHP.php, class constant PHPyyParser::T_EXTENDS
T_FILE
in file PHP.php, class constant PHPyyParser::T_FILE
T_FILE
in file oops.php, class constant ParseyyParser::T_FILE
T_FINAL
in file PHP.php, class constant PHPyyParser::T_FINAL
T_FOR
in file PHP.php, class constant PHPyyParser::T_FOR
T_FOREACH
in file PHP.php, class constant PHPyyParser::T_FOREACH
T_FUNCTION
in file PHP.php, class constant PHPyyParser::T_FUNCTION
T_FUNC_C
in file oops.php, class constant ParseyyParser::T_FUNC_C
T_FUNC_C
in file PHP.php, class constant PHPyyParser::T_FUNC_C
T_GLOBAL
in file PHP.php, class constant PHPyyParser::T_GLOBAL
T_HALT_COMPILER
in file PHP.php, class constant PHPyyParser::T_HALT_COMPILER
T_IF
in file PHP.php, class constant PHPyyParser::T_IF
T_IMPLEMENTS
in file PHP.php, class constant PHPyyParser::T_IMPLEMENTS
T_INC
in file PHP.php, class constant PHPyyParser::T_INC
T_INCLUDE
in file PHP.php, class constant PHPyyParser::T_INCLUDE
T_INCLUDE_ONCE
in file PHP.php, class constant PHPyyParser::T_INCLUDE_ONCE
T_INLINE_HTML
in file PHP.php, class constant PHPyyParser::T_INLINE_HTML
T_INSTANCEOF
in file PHP.php, class constant PHPyyParser::T_INSTANCEOF
T_INTERFACE
in file PHP.php, class constant PHPyyParser::T_INTERFACE
T_INT_CAST
in file PHP.php, class constant PHPyyParser::T_INT_CAST
T_ISSET
in file PHP.php, class constant PHPyyParser::T_ISSET
T_IS_EQUAL
in file PHP.php, class constant PHPyyParser::T_IS_EQUAL
T_IS_GREATER_OR_EQUAL
in file PHP.php, class constant PHPyyParser::T_IS_GREATER_OR_EQUAL
T_IS_IDENTICAL
in file PHP.php, class constant PHPyyParser::T_IS_IDENTICAL
T_IS_NOT_EQUAL
in file PHP.php, class constant PHPyyParser::T_IS_NOT_EQUAL
T_IS_NOT_IDENTICAL
in file PHP.php, class constant PHPyyParser::T_IS_NOT_IDENTICAL
T_IS_SMALLER_OR_EQUAL
in file PHP.php, class constant PHPyyParser::T_IS_SMALLER_OR_EQUAL
T_LINE
in file PHP.php, class constant PHPyyParser::T_LINE
T_LINE
in file oops.php, class constant ParseyyParser::T_LINE
T_LIST
in file PHP.php, class constant PHPyyParser::T_LIST
T_LNUMBER
in file PHP.php, class constant PHPyyParser::T_LNUMBER
T_LNUMBER
in file oops.php, class constant ParseyyParser::T_LNUMBER
T_LOGICAL_AND
in file PHP.php, class constant PHPyyParser::T_LOGICAL_AND
T_LOGICAL_OR
in file PHP.php, class constant PHPyyParser::T_LOGICAL_OR
T_LOGICAL_XOR
in file PHP.php, class constant PHPyyParser::T_LOGICAL_XOR
T_METHOD_C
in file PHP.php, class constant PHPyyParser::T_METHOD_C
T_METHOD_C
in file oops.php, class constant ParseyyParser::T_METHOD_C
T_MINUS_EQUAL
in file PHP.php, class constant PHPyyParser::T_MINUS_EQUAL
T_MOD_EQUAL
in file PHP.php, class constant PHPyyParser::T_MOD_EQUAL
T_MUL_EQUAL
in file PHP.php, class constant PHPyyParser::T_MUL_EQUAL
T_NEW
in file PHP.php, class constant PHPyyParser::T_NEW
T_NUM_STRING
in file PHP.php, class constant PHPyyParser::T_NUM_STRING
T_OBJECT_CAST
in file PHP.php, class constant PHPyyParser::T_OBJECT_CAST
T_OBJECT_OPERATOR
in file PHP.php, class constant PHPyyParser::T_OBJECT_OPERATOR
T_OR_EQUAL
in file PHP.php, class constant PHPyyParser::T_OR_EQUAL
T_PAAMAYIM_NEKUDOTAYIM
in file PHP.php, class constant PHPyyParser::T_PAAMAYIM_NEKUDOTAYIM
T_PLUS_EQUAL
in file PHP.php, class constant PHPyyParser::T_PLUS_EQUAL
T_PRINT
in file PHP.php, class constant PHPyyParser::T_PRINT
T_PRIVATE
in file PHP.php, class constant PHPyyParser::T_PRIVATE
T_PROTECTED
in file PHP.php, class constant PHPyyParser::T_PROTECTED
T_PUBLIC
in file PHP.php, class constant PHPyyParser::T_PUBLIC
T_REQUIRE
in file PHP.php, class constant PHPyyParser::T_REQUIRE
T_REQUIRE_ONCE
in file PHP.php, class constant PHPyyParser::T_REQUIRE_ONCE
T_RETURN
in file PHP.php, class constant PHPyyParser::T_RETURN
T_SL
in file PHP.php, class constant PHPyyParser::T_SL
T_SL_EQUAL
in file PHP.php, class constant PHPyyParser::T_SL_EQUAL
T_SR
in file PHP.php, class constant PHPyyParser::T_SR
T_SR_EQUAL
in file PHP.php, class constant PHPyyParser::T_SR_EQUAL
T_START_HEREDOC
in file PHP.php, class constant PHPyyParser::T_START_HEREDOC
T_STATIC
in file PHP.php, class constant PHPyyParser::T_STATIC
T_STRING
in file PHP.php, class constant PHPyyParser::T_STRING
T_STRING_CAST
in file PHP.php, class constant PHPyyParser::T_STRING_CAST
T_STRING_VARNAME
in file PHP.php, class constant PHPyyParser::T_STRING_VARNAME
T_SWITCH
in file PHP.php, class constant PHPyyParser::T_SWITCH
T_THROW
in file PHP.php, class constant PHPyyParser::T_THROW
T_TRY
in file PHP.php, class constant PHPyyParser::T_TRY
T_UNSET
in file PHP.php, class constant PHPyyParser::T_UNSET
T_UNSET_CAST
in file PHP.php, class constant PHPyyParser::T_UNSET_CAST
T_USE
in file PHP.php, class constant PHPyyParser::T_USE
T_VAR
in file PHP.php, class constant PHPyyParser::T_VAR
T_VARIABLE
in file PHP.php, class constant PHPyyParser::T_VARIABLE
T_WHILE
in file PHP.php, class constant PHPyyParser::T_WHILE
T_XOR_EQUAL
in file PHP.php, class constant PHPyyParser::T_XOR_EQUAL
top

u

UNK
in file Symbol.php, class constant PHP_ParserGenerator_Symbol::UNK
UNK
in file Main.php, class constant LemonSymbol::UNK
top

v

$value
in file Tokenizer.php, variable PHP_Parser_Tokenizer::$value
    The value associated with a token - eg. for T_STRING it's the string
$valueWithWhitespace
in file Tokenizer.php, variable PHP_Parser_Tokenizer::$valueWithWhitespace
    The value associated with a token plus preceding whitespace, if any
$vardest
in file Data.php, variable PHP_ParserGenerator_Data::$vardest
    Code for the default non-terminal destructor
$vardest
in file Main.php, variable LemonData::$vardest
$vardestln
in file Main.php, variable LemonData::$vardestln
$vardestln
in file Data.php, variable PHP_ParserGenerator_Data::$vardestln
    Line number for default non-terminal destructor code
$vartype
in file Main.php, variable LemonData::$vartype
$vartype
in file Data.php, variable PHP_ParserGenerator_Data::$vartype
    Unused relic from the C version
top

w

WAITING_FOR_ARROW
in file Parser.php, class constant PHP_ParserGenerator_Parser::WAITING_FOR_ARROW
WAITING_FOR_ARROW
in file Main.php, class constant LemonParser::WAITING_FOR_ARROW
WAITING_FOR_DATATYPE_SYMBOL
in file Parser.php, class constant PHP_ParserGenerator_Parser::WAITING_FOR_DATATYPE_SYMBOL
WAITING_FOR_DATATYPE_SYMBOL
in file Main.php, class constant LemonParser::WAITING_FOR_DATATYPE_SYMBOL
WAITING_FOR_DECL_ARG
in file Main.php, class constant LemonParser::WAITING_FOR_DECL_ARG
WAITING_FOR_DECL_ARG
in file Parser.php, class constant PHP_ParserGenerator_Parser::WAITING_FOR_DECL_ARG
WAITING_FOR_DECL_KEYWORD
in file Parser.php, class constant PHP_ParserGenerator_Parser::WAITING_FOR_DECL_KEYWORD
WAITING_FOR_DECL_KEYWORD
in file Main.php, class constant LemonParser::WAITING_FOR_DECL_KEYWORD
WAITING_FOR_DECL_OR_RULE
in file Parser.php, class constant PHP_ParserGenerator_Parser::WAITING_FOR_DECL_OR_RULE
WAITING_FOR_DECL_OR_RULE
in file Main.php, class constant LemonParser::WAITING_FOR_DECL_OR_RULE
WAITING_FOR_DESTRUCTOR_SYMBOL
in file Parser.php, class constant PHP_ParserGenerator_Parser::WAITING_FOR_DESTRUCTOR_SYMBOL
WAITING_FOR_DESTRUCTOR_SYMBOL
in file Main.php, class constant LemonParser::WAITING_FOR_DESTRUCTOR_SYMBOL
WAITING_FOR_FALLBACK_ID
in file Parser.php, class constant PHP_ParserGenerator_Parser::WAITING_FOR_FALLBACK_ID
WAITING_FOR_FALLBACK_ID
in file Main.php, class constant LemonParser::WAITING_FOR_FALLBACK_ID
WAITING_FOR_PRECEDENCE_SYMBOL
in file Parser.php, class constant PHP_ParserGenerator_Parser::WAITING_FOR_PRECEDENCE_SYMBOL
WAITING_FOR_PRECEDENCE_SYMBOL
in file Main.php, class constant LemonParser::WAITING_FOR_PRECEDENCE_SYMBOL
top

x

$x
in file Action.php, variable PHP_ParserGenerator_Action::$x
    The new state, if this is a shift, the parser rule index, if this is a reduce.
$x
in file Main.php, variable LemonAction::$x
$x3a
in file State.php, variable PHP_ParserGenerator_State::$x3a
    Associative array of PHP_ParserGenerator_State objects
$x3a
in file Main.php, variable LemonState::$x3a
$x4a
in file Main.php, variable LemonConfig::$x4a
$x4a
in file Config.php, variable PHP_ParserGenerator_Config::$x4a
    Associative array representation of the linked list of configurations found in $current
top

y

$yyerrcnt
in file oops.php, variable ParseyyParser::$yyerrcnt
$yyerrcnt
in file Parser.php, variable PHP_LexerGenerator_Parser::$yyerrcnt
$yyExpectedTokens
in file Parser.php, variable PHP_LexerGenerator_Parser::$yyExpectedTokens
$yyFallback
in file oops.php, variable ParseyyParser::$yyFallback
    The next table maps tokens into fallback tokens. If a construct like the following:
$yyFallback
in file Parser.php, variable PHP_LexerGenerator_Parser::$yyFallback
    The next table maps tokens into fallback tokens. If a construct like the following:
$yyidx
in file oops.php, variable ParseyyParser::$yyidx
$yyidx
in file Parser.php, variable PHP_LexerGenerator_Parser::$yyidx
$yyReduceMap
in file Parser.php, variable PHP_LexerGenerator_Parser::$yyReduceMap
    The following table contains a mapping of reduce action to method name that handles the reduction.
$yyReduceMap
in file oops.php, variable ParseyyParser::$yyReduceMap
    The following table contains a mapping of reduce action to method name that handles the reduction.
$yyRuleInfo
in file oops.php, variable ParseyyParser::$yyRuleInfo
    The following table contains information about every rule that is used during the reduce.
$yyRuleInfo
in file Parser.php, variable PHP_LexerGenerator_Parser::$yyRuleInfo
    The following table contains information about every rule that is used during the reduce.
$yyRuleName
in file Parser.php, variable PHP_LexerGenerator_Parser::$yyRuleName
    For tracing reduce actions, the names of all rules are required.
$yyRuleName
in file oops.php, variable ParseyyParser::$yyRuleName
    For tracing reduce actions, the names of all rules are required.
$yystack
in file oops.php, variable ParseyyParser::$yystack
$yystack
in file Parser.php, variable PHP_LexerGenerator_Parser::$yystack
$yyTokenName
in file Parser.php, variable PHP_LexerGenerator_Parser::$yyTokenName
    For tracing shifts, the names of all terminals and nonterminals
$yyTokenName
in file oops.php, variable ParseyyParser::$yyTokenName
    For tracing shifts, the names of all terminals and nonterminals
$yyTraceFILE
in file oops.php, variable ParseyyParser::$yyTraceFILE
$yyTraceFILE
in file Parser.php, variable PHP_LexerGenerator_Parser::$yyTraceFILE
$yyTracePrompt
in file oops.php, variable ParseyyParser::$yyTracePrompt
$yyTracePrompt
in file Parser.php, variable PHP_LexerGenerator_Parser::$yyTracePrompt
$yy_action
in file Parser.php, variable PHP_LexerGenerator_Parser::$yy_action
$yy_action
in file oops.php, variable ParseyyParser::$yy_action
$yy_default
in file Parser.php, variable PHP_LexerGenerator_Parser::$yy_default
$yy_default
in file oops.php, variable ParseyyParser::$yy_default
$yy_lookahead
in file Parser.php, variable PHP_LexerGenerator_Parser::$yy_lookahead
$yy_lookahead
in file oops.php, variable ParseyyParser::$yy_lookahead
$yy_reduce_ofst
in file Parser.php, variable PHP_LexerGenerator_Parser::$yy_reduce_ofst
$yy_reduce_ofst
in file oops.php, variable ParseyyParser::$yy_reduce_ofst
$yy_shift_ofst
in file Parser.php, variable PHP_LexerGenerator_Parser::$yy_shift_ofst
$yy_shift_ofst
in file oops.php, variable ParseyyParser::$yy_shift_ofst
YYERRORSYMBOL
in file oops.php, class constant ParseyyParser::YYERRORSYMBOL
YYERRORSYMBOL
in file Parser.php, class constant PHP_LexerGenerator_Parser::YYERRORSYMBOL
YYERRSYMDT
in file Parser.php, class constant PHP_LexerGenerator_Parser::YYERRSYMDT
YYERRSYMDT
in file oops.php, class constant ParseyyParser::YYERRSYMDT
YYFALLBACK
in file Parser.php, class constant PHP_LexerGenerator_Parser::YYFALLBACK
YYNOCODE
in file Parser.php, class constant PHP_LexerGenerator_Parser::YYNOCODE
YYNOCODE
in file oops.php, class constant ParseyyParser::YYNOCODE
YYNRULE
in file Parser.php, class constant PHP_LexerGenerator_Parser::YYNRULE
YYNRULE
in file oops.php, class constant ParseyyParser::YYNRULE
YYNSTATE
in file oops.php, class constant ParseyyParser::YYNSTATE
YYNSTATE
in file Parser.php, class constant PHP_LexerGenerator_Parser::YYNSTATE
YYSTACKDEPTH
in file Parser.php, class constant PHP_LexerGenerator_Parser::YYSTACKDEPTH
YYSTACKDEPTH
in file oops.php, class constant ParseyyParser::YYSTACKDEPTH
yy_accept
in file oops.php, method ParseyyParser::yy_accept()
yy_accept
in file Parser.php, method PHP_LexerGenerator_Parser::yy_accept()
yy_accept
in file Lempar.php, function yy_accept()
    The following is executed when the parser accepts
YY_ACCEPT_ACTION
in file Parser.php, class constant PHP_LexerGenerator_Parser::YY_ACCEPT_ACTION
YY_ACCEPT_ACTION
in file oops.php, class constant ParseyyParser::YY_ACCEPT_ACTION
YY_ACCEPT_ACTION
in file PHP.php, class constant PHPyyParser::YY_ACCEPT_ACTION
yy_destructor
in file Lempar.php, function yy_destructor()
    The following function deletes the value associated with a symbol. The symbol can be either a terminal or nonterminal.
yy_destructor
in file oops.php, method ParseyyParser::yy_destructor()
yy_destructor
in file Parser.php, method PHP_LexerGenerator_Parser::yy_destructor()
YY_ERROR_ACTION
in file oops.php, class constant ParseyyParser::YY_ERROR_ACTION
YY_ERROR_ACTION
in file PHP.php, class constant PHPyyParser::YY_ERROR_ACTION
YY_ERROR_ACTION
in file Parser.php, class constant PHP_LexerGenerator_Parser::YY_ERROR_ACTION
yy_find_reduce_action
in file Lempar.php, function yy_find_reduce_action()
    Find the appropriate action for a parser given the non-terminal look-ahead token $iLookAhead.
yy_find_reduce_action
in file Parser.php, method PHP_LexerGenerator_Parser::yy_find_reduce_action()
    Find the appropriate action for a parser given the non-terminal look-ahead token iLookAhead.
yy_find_reduce_action
in file oops.php, method ParseyyParser::yy_find_reduce_action()
    Find the appropriate action for a parser given the non-terminal look-ahead token iLookAhead.
yy_find_shift_action
in file oops.php, method ParseyyParser::yy_find_shift_action()
    Find the appropriate action for a parser given the terminal look-ahead token iLookAhead.
yy_find_shift_action
in file Parser.php, method PHP_LexerGenerator_Parser::yy_find_shift_action()
    Find the appropriate action for a parser given the terminal look-ahead token iLookAhead.
yy_find_shift_action
in file Lempar.php, function yy_find_shift_action()
    Find the appropriate action for a parser given the terminal look-ahead token iLookAhead.
yy_get_expected_tokens
in file Parser.php, method PHP_LexerGenerator_Parser::yy_get_expected_tokens()
yy_get_expected_tokens
in file Lempar.php, function yy_get_expected_tokens()
    Based on the current state and parser stack, get a list of all
yy_is_expected_token
in file Parser.php, method PHP_LexerGenerator_Parser::yy_is_expected_token()
yy_is_expected_token
in file Lempar.php, function yy_is_expected_token()
    Based on the parser state and current parser stack, determine whether the lookahead token is possible.
YY_NO_ACTION
in file PHP.php, class constant PHPyyParser::YY_NO_ACTION
YY_NO_ACTION
in file oops.php, class constant ParseyyParser::YY_NO_ACTION
YY_NO_ACTION
in file Parser.php, class constant PHP_LexerGenerator_Parser::YY_NO_ACTION
yy_parse_failed
in file Lempar.php, function yy_parse_failed()
    The following code executes when the parse fails
yy_parse_failed
in file oops.php, method ParseyyParser::yy_parse_failed()
    The following code executes when the parse fails
yy_parse_failed
in file Parser.php, method PHP_LexerGenerator_Parser::yy_parse_failed()
    The following code executes when the parse fails
yy_pop_parser_stack
in file Parser.php, method PHP_LexerGenerator_Parser::yy_pop_parser_stack()
    Pop the parser's stack once.
yy_pop_parser_stack
in file oops.php, method ParseyyParser::yy_pop_parser_stack()
    Pop the parser's stack once.
yy_pop_parser_stack
in file Lempar.php, function yy_pop_parser_stack()
    Pop the parser's stack once.
yy_r0
in file oops.php, method ParseyyParser::yy_r0()
yy_r1
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r1()
yy_r2
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r2()
yy_r3
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r3()
yy_r4
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r4()
yy_r5
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r5()
yy_r6
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r6()
yy_r7
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r7()
yy_r9
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r9()
yy_r11
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r11()
yy_r12
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r12()
yy_r13
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r13()
yy_r14
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r14()
yy_r15
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r15()
yy_r16
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r16()
yy_r17
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r17()
yy_r18
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r18()
yy_r19
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r19()
yy_r20
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r20()
yy_r21
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r21()
yy_r22
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r22()
yy_r23
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r23()
yy_r24
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r24()
yy_r25
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r25()
yy_r26
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r26()
yy_r28
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r28()
yy_r30
in file Parser.php, method PHP_LexerGenerator_Parser::yy_r30()
yy_reduce
in file Lempar.php, function yy_reduce()
    Perform a reduce action and the shift that must immediately follow the reduce.
yy_reduce
in file Parser.php, method PHP_LexerGenerator_Parser::yy_reduce()
    Perform a reduce action and the shift that must immediately follow the reduce.
yy_reduce
in file oops.php, method ParseyyParser::yy_reduce()
    Perform a reduce action and the shift that must immediately follow the reduce.
YY_REDUCE_MAX
in file Parser.php, class constant PHP_LexerGenerator_Parser::YY_REDUCE_MAX
YY_REDUCE_MAX
in file oops.php, class constant ParseyyParser::YY_REDUCE_MAX
YY_REDUCE_USE_DFLT
in file oops.php, class constant ParseyyParser::YY_REDUCE_USE_DFLT
YY_REDUCE_USE_DFLT
in file Parser.php, class constant PHP_LexerGenerator_Parser::YY_REDUCE_USE_DFLT
yy_shift
in file oops.php, method ParseyyParser::yy_shift()
    Perform a shift action.
yy_shift
in file Lempar.php, function yy_shift()
    Perform a shift action.
yy_shift
in file Parser.php, method PHP_LexerGenerator_Parser::yy_shift()
    Perform a shift action.
YY_SHIFT_MAX
in file Parser.php, class constant PHP_LexerGenerator_Parser::YY_SHIFT_MAX
YY_SHIFT_MAX
in file oops.php, class constant ParseyyParser::YY_SHIFT_MAX
YY_SHIFT_USE_DFLT
in file Parser.php, class constant PHP_LexerGenerator_Parser::YY_SHIFT_USE_DFLT
YY_SHIFT_USE_DFLT
in file oops.php, class constant ParseyyParser::YY_SHIFT_USE_DFLT
yy_syntax_error
in file Lempar.php, function yy_syntax_error()
    The following code executes when a syntax error first occurs.
yy_syntax_error
in file Parser.php, method PHP_LexerGenerator_Parser::yy_syntax_error()
    The following code executes when a syntax error first occurs.
yy_syntax_error
in file oops.php, method ParseyyParser::yy_syntax_error()
    The following code executes when a syntax error first occurs.
YY_SZ_ACTTAB
in file oops.php, class constant ParseyyParser::YY_SZ_ACTTAB
YY_SZ_ACTTAB
in file Parser.php, class constant PHP_LexerGenerator_Parser::YY_SZ_ACTTAB
top

_

__construct
in file Parser.php, method PHP_LexerGenerator_ParseryyToken::__construct()
__construct
in file PHP.php, method PHPyyParser::__construct()
__construct
in file PHP_Parser.php, method PHPyyToken::__construct()
__construct
in file Tokenizer.php, method PHP_Parser_Tokenizer::__construct()
    Constructor
__construct
in file Parser.php, method PHP_ParserGenerator_Parser::__construct()
__construct
in file Parser.php, method PHP_LexerGenerator_Parser::__construct()
__construct
in file Main.php, method LemonParser::__construct()
__construct
in file Lempar.php, method ParseyyToken::__construct()
__destruct
in file Lempar.php, function __destruct()
    Deallocate and destroy a parser. Destructors are all called for all stack elements before shutting the parser down.
__destruct
in file oops.php, method ParseyyParser::__destruct()
    Deallocate and destroy a parser. Destructors are all called for all stack elements before shutting the parser down.
__destruct
in file Parser.php, method PHP_LexerGenerator_Parser::__destruct()
    Deallocate and destroy a parser. Destructors are all called for all stack elements before shutting the parser down.
__toString
in file PHP_Parser.php, method PHPyyToken::__toString()
__toString
in file Parser.php, method PHP_LexerGenerator_ParseryyToken::__toString()
__toString
in file Lempar.php, method ParseyyToken::__toString()
top
Documentation generated on Mon, 11 Mar 2019 15:40:54 -0400 by phpDocumentor 1.4.4. PEAR Logo Copyright © PHP Group 2004.