oxref by Frank B. Brokken (f.b.brokken@rug.nl)
oxref V2.00.00 2012-2019

CREATED Thu, 14 Mar 2019 07:26:33 +0000
CROSS REFERENCE FOR: -t main -r replace -fxs tmp/main.o tmp/libmodules.a 

----------------------------------------------------------------------
CROSS REFERENCE LISTING:

accept(Options::PathType, char const*)
  Full name: Options::accept(Options::PathType, char const*)
  Source:    accept.cc 
  Used By:
    assign.cc: Options::assign(std::string*, Options::PathType, char const*)

actionCases(std::ostream&) const
  Full name: Generator::actionCases(std::ostream&) const
  Source:    actioncases.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

addElement(Symbol*)
  Full name: Rules::addElement(Symbol*)
  Source:    addelement.cc 
  Used By:
    handleproductionelement.cc: Parser::handleProductionElement(Meta_::SType&)
    handleproductionelements.cc: Parser::handleProductionElements(Meta_::SType&, Meta_::SType const&)
    nestedblock.cc: Parser::nestedBlock(Block&)
    augmentgrammar.cc: Rules::augmentGrammar(Symbol*)

addIncludeQuotes(std::string&)
  Full name: Options::addIncludeQuotes(std::string&)
  Source:    addincludequotes.cc 
  Used By:
    setquotedstrings.cc: Options::setQuotedStrings()

addKernelItem(StateItem const&)
  Full name: State::addKernelItem(StateItem const&)
  Source:    addkernelitem.cc 
  Used By:
    addstate.cc: State::addState(std::vector<Item> const&)
    initialstate.cc: State::initialState()

addNext(Symbol const*, unsigned long)
  Full name: State::addNext(Symbol const*, unsigned long)
  Source:    addnext.cc 
  Used By:
    notreducible.cc: State::notReducible(unsigned long)

addPolymorphic(std::string const&, std::string const&)
  Full name: Parser::addPolymorphic(std::string const&, std::string const&)
  Source:    addpolymorphic.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

addProduction(unsigned long)
  Full name: Rules::addProduction(unsigned long)
  Source:    addproduction.cc 
  Used By:
    openrule.cc: Parser::openRule(std::string const&)
    parse.cc: Parser::executeAction_(int)
    augmentgrammar.cc: Rules::augmentGrammar(Symbol*)

addProductions(Symbol const*)
  Full name: State::addProductions(Symbol const*)
  Source:    addproductions.cc 
  Used By:
    addnext.cc: State::addNext(Symbol const*, unsigned long)

addState(std::vector<Item> const&)
  Full name: State::addState(std::vector<Item> const&)
  Source:    addstate.cc 
  Used By:
    nextstate.cc: State::nextState(Next&)

addToKernel(std::vector<Next>&, Symbol const*, unsigned long)
  Full name: Next::addToKernel(std::vector<Next>&, Symbol const*, unsigned long)
  Source:    addtokernel.cc 
  Used By:
    notreducible.cc: State::notReducible(unsigned long)

allStates()
  Full name: State::allStates()
  Source:    allstates.cc 
  Used By:
    main.cc: main

assign(std::string*, Options::PathType, char const*)
  Full name: Options::assign(std::string*, Options::PathType, char const*)
  Source:    assign.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

assignment()
  Full name: Scanner::assignment()
  Source:    assignment.cc 
  Used By:
    lex.cc: Scanner::executeAction_(unsigned long)

assignNonTerminalNumbers()
  Full name: Rules::assignNonTerminalNumbers()
  Source:    assignnonterminalnumbers.cc 
  Used By:
    main.cc: main

atClassname() const
  Full name: Generator::atClassname() const
  Source:    atclassname.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

atDollar(unsigned long, std::string const&, bool, bool)
  Full name: Block::atDollar(unsigned long, std::string const&, bool, bool)
  Source:    atdollar.cc 
  Used By:
    assignment.cc: Scanner::assignment()
    lex.cc: Scanner::executeAction_(unsigned long)

AtDollar(unsigned long, unsigned long, std::string const&, bool)
  Full name: AtDollar::AtDollar(unsigned long, unsigned long, std::string const&, bool)
  Source:    atdollar1.cc 
  Used By:
    atdollar.cc: Block::atDollar(unsigned long, std::string const&, bool, bool)

atElse(bool&) const
  Full name: Generator::atElse(bool&) const
  Source:    atelse.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

atEnd(bool&) const
  Full name: Generator::atEnd(bool&) const
  Source:    atend.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

atLtype() const
  Full name: Generator::atLtype() const
  Source:    atltype.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

atMatchedTextFunction() const
  Full name: Generator::atMatchedTextFunction() const
  Source:    atmatchedtextfunction.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

atNameSpacedClassname() const
  Full name: Generator::atNameSpacedClassname() const
  Source:    atnamespacedclassname.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

atTokenFunction() const
  Full name: Generator::atTokenFunction() const
  Source:    attokenfunction.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

augmentGrammar(Symbol*)
  Full name: Rules::augmentGrammar(Symbol*)
  Source:    augmentgrammar.cc 
  Used By:
    cleanup.cc: Parser::cleanup()

baseClass(std::ostream&) const
  Full name: Generator::baseClass(std::ostream&) const
  Source:    baseclass.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

baseClassCode(std::ostream&) const
  Full name: Generator::baseClassCode(std::ostream&) const
  Source:    baseclasscode.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

baseClassHeader() const
  Full name: Generator::baseClassHeader() const
  Source:    baseclassheader.cc 
  Used By:
    main.cc: main

baseclassHeaderName() const
  Full name: Options::baseclassHeaderName() const
  Source:    baseclassheadername.cc 
  Used By:
    conflicts.cc: Generator::conflicts() const

becomesDerivable(Production const*)
  Full name: Grammar::becomesDerivable(Production const*)
  Source:    becomesderivable.cc 
  Used By:
    derivable.cc: Grammar::derivable(Symbol const*)

beyondDotIsNonTerminal() const
  Full name: Item::beyondDotIsNonTerminal() const
  Source:    beyonddotisnonterminal.cc 
  Used By:
    distributelasetof.cc: State::distributeLAsetOf(StateItem&)

blkAssign(std::string const&, Production const&)
  Full name: Parser::blkAssign(std::string const&, Production const&)
  Source:    blkassign.cc 
  Used By:
    blkassignw.cc: Parser::blkAssignW(std::string const&, Production const&)
    blkcheck.cc: Parser::blkCheck(std::string const&, Production const&)
    data.cc: GLOBALS data.cc 16data.o

blkAssignW(std::string const&, Production const&)
  Full name: Parser::blkAssignW(std::string const&, Production const&)
  Source:    blkassignw.cc 
  Used By:
    blkcheckw.cc: Parser::blkCheckW(std::string const&, Production const&)
    data.cc: GLOBALS data.cc 16data.o

blkCheck(std::string const&, Production const&)
  Full name: Parser::blkCheck(std::string const&, Production const&)
  Source:    blkcheck.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

blkCheckW(std::string const&, Production const&)
  Full name: Parser::blkCheckW(std::string const&, Production const&)
  Source:    blkcheckw.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

blkDirect(std::string const&, Production const&)
  Full name: Parser::blkDirect(std::string const&, Production const&)
  Source:    blkdirect.cc 
  Used By:
    blkdirectw.cc: Parser::blkDirectW(std::string const&, Production const&)
    data.cc: GLOBALS data.cc 16data.o

blkDirectW(std::string const&, Production const&)
  Full name: Parser::blkDirectW(std::string const&, Production const&)
  Source:    blkdirectw.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

blkErr(std::string const&, Production const&)
  Full name: Parser::blkErr(std::string const&, Production const&)
  Source:    blkerr.cc 
  Used By:
    blkcheck.cc: Parser::blkCheck(std::string const&, Production const&)
    blkcheckw.cc: Parser::blkCheckW(std::string const&, Production const&)
    data.cc: GLOBALS data.cc 16data.o

blkNop(std::string const&, Production const&)
  Full name: Parser::blkNop(std::string const&, Production const&)
  Source:    blknop.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

blkNopW(std::string const&, Production const&)
  Full name: Parser::blkNopW(std::string const&, Production const&)
  Source:    blknopw.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

blkSTYPE(std::string const&, Production const&)
  Full name: Parser::blkSTYPE(std::string const&, Production const&)
  Source:    blkstype.cc 
  Used By:
    blkstypew.cc: Parser::blkSTYPEW(std::string const&, Production const&)
    data.cc: GLOBALS data.cc 16data.o

blkSTYPEW(std::string const&, Production const&)
  Full name: Parser::blkSTYPEW(std::string const&, Production const&)
  Source:    blkstypew.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

bolAt(std::string&, bool&) const
  Full name: Generator::bolAt(std::string&, bool&) const
  Source:    bolat.cc 
  Used By:
    insert2.cc: Generator::insert(std::ostream&, unsigned long, char const*) const

buildKernel(std::vector<Item>*, std::vector<StateItem> const&)
  Full name: Next::buildKernel(std::vector<Item>*, std::vector<StateItem> const&)
  Source:    buildkernel.cc 
  Used By:
    nextstate.cc: State::nextState(Next&)

canonicalQuote()
  Full name: Scanner::canonicalQuote()
  Source:    canonicalquote.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)
    setprecedence.cc: Parser::setPrecedence(unsigned long)
    useterminal.cc: Parser::useTerminal()

checkConflicts()
  Full name: State::checkConflicts()
  Source:    checkconflicts.cc 
  Used By:
    define.cc: State::define(Rules const&)

checkEndOfRawString()
  Full name: Scanner::checkEndOfRawString()
  Source:    checkendofrawstring.cc 
  Used By:
    lex.cc: Scanner::executeAction_(unsigned long)

checkField(std::string const&)
  Full name: Parser::checkField(std::string const&)
  Source:    checkfield.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

checkFirstType()
  Full name: Parser::checkFirstType()
  Source:    checkfirsttype.cc 
  Used By:
    handleproductionelement.cc: Parser::handleProductionElement(Meta_::SType&)
    parse.cc: Parser::executeAction_(int)

checkRemoved(std::ostream&) const
  Full name: Next::checkRemoved(std::ostream&) const
  Source:    checkremoved.cc 
  Used By:
    transition.cc: Next::transition(std::ostream&) const
    transitionkernel.cc: Next::transitionKernel(std::ostream&) const

checkZeroNumber()
  Full name: Scanner::checkZeroNumber()
  Source:    checkzeronumber.cc 
  Used By:
    hexadecimal.cc: Scanner::hexadecimal()
    octal.cc: Scanner::octal()

classH(std::ostream&) const
  Full name: Generator::classH(std::ostream&) const
  Source:    classh.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

classHeader() const
  Full name: Generator::classHeader() const
  Source:    classheader.cc 
  Used By:
    main.cc: main

classIH(std::ostream&) const
  Full name: Generator::classIH(std::ostream&) const
  Source:    classih.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

cleanDir(std::string&, bool)
  Full name: Options::cleanDir(std::string&, bool)
  Source:    cleandir.cc 
  Used By:
    setbasicstrings.cc: Options::setBasicStrings()

cleanup()
  Full name: Parser::cleanup()
  Source:    cleanup.cc 
  Used By:
    main.cc: main

clear()
  Full name: Block::clear()
  Source:    clear.cc 
  Used By:
    expectrules.cc: Parser::expectRules()
    open.cc: Block::open(unsigned long, std::string const&)

close()
  Full name: Block::close()
  Source:    close.cc 
  Used By:
    lex.cc: Scanner::executeAction_(unsigned long)

comparePrecedence(Symbol const*, Symbol const*)
  Full name: Terminal::comparePrecedence(Symbol const*, Symbol const*)
  Source:    compareprecedence.cc 
  Used By:
    comparereductions.cc: RRConflict::compareReductions(unsigned long)
    solvebyprecedence.cc: Next::solveByPrecedence(Symbol const*) const

compareReductions(unsigned long)
  Full name: RRConflict::compareReductions(unsigned long)
  Source:    comparereductions.cc 
  Used By:
    visitreduction.cc: RRConflict::visitReduction(unsigned long)

computeLAsets()
  Full name: State::computeLAsets()
  Source:    computelasets.cc 
  Used By:
    determinelasets.cc: State::determineLAsets()

conflicts() const
  Full name: Generator::conflicts() const
  Source:    conflicts.cc 
  Used By:
    main.cc: main

construct()
  Full name: State::construct()
  Source:    construct.cc 
  Used By:
    define.cc: State::define(Rules const&)

containsKernelItem(Item const&, unsigned long, std::vector<StateItem> const&)
  Full name: StateItem::containsKernelItem(Item const&, unsigned long, std::vector<StateItem> const&)
  Source:    containskernelitem.cc 
  Used By:
    haskernel.cc: State::hasKernel(std::vector<Item> const&) const

debug(std::ostream&) const
  Full name: Generator::debug(std::ostream&) const
  Source:    debug.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

debugDecl(std::ostream&) const
  Full name: Generator::debugDecl(std::ostream&) const
  Source:    debugdecl.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

debugFunctions(std::ostream&) const
  Full name: Generator::debugFunctions(std::ostream&) const
  Source:    debugfunctions.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

debugIncludes(std::ostream&) const
  Full name: Generator::debugIncludes(std::ostream&) const
  Source:    debugincludes.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

debugLookup(std::ostream&) const
  Full name: Generator::debugLookup(std::ostream&) const
  Source:    debuglookup.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

defaultPolymorphicAction(Production const&)
  Full name: Parser::defaultPolymorphicAction(Production const&)
  Source:    defaultpolymorphicaction.cc 
  Used By:
    checkfirsttype.cc: Parser::checkFirstType()

define(Rules const&)
  Full name: State::define(Rules const&)
  Source:    define.cc 
  Used By:
    main.cc: main

defineNonTerminal(std::string const&, std::string const&)
  Full name: Parser::defineNonTerminal(std::string const&, std::string const&)
  Source:    definenonterminal.cc 
  Used By:
    nestedblock.cc: Parser::nestedBlock(Block&)

defineTerminal(std::string const&, Symbol::Type)
  Full name: Parser::defineTerminal(std::string const&, Symbol::Type)
  Source:    defineterminal.cc 
  Used By:
    definetokenname.cc: Parser::defineTokenName(std::string const&, bool)
    parse.cc: Parser::executeAction_(int)

defineTokenName(std::string const&, bool)
  Full name: Parser::defineTokenName(std::string const&, bool)
  Source:    definetokenname.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

derivable(Symbol const*)
  Full name: Grammar::derivable(Symbol const*)
  Source:    derivable.cc 
  Used By:
    becomesderivable.cc: Grammar::becomesDerivable(Production const*)
    derivesentence.cc: Grammar::deriveSentence()

deriveSentence()
  Full name: Grammar::deriveSentence()
  Source:    derivesentence.cc 
  Used By:
    main.cc: main

determineFirst()
  Full name: Rules::determineFirst()
  Source:    determinefirst.cc 
  Used By:
    main.cc: main

determineLAsets()
  Full name: State::determineLAsets()
  Source:    determinelasets.cc 
  Used By:
    define.cc: State::define(Rules const&)

distributeLAsetOf(StateItem&)
  Full name: State::distributeLAsetOf(StateItem&)
  Source:    distributelasetof.cc 
  Used By:
    computelasets.cc: State::computeLAsets()

dval(int, Block&, AtDollar const&)
  Full name: Parser::dval(int, Block&, AtDollar const&)
  Source:    dval.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

dvalMem(int, Block&, AtDollar const&)
  Full name: Parser::dvalMem(int, Block&, AtDollar const&)
  Source:    dvalmem.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

dvalPar(int, Block&, AtDollar const&)
  Full name: Parser::dvalPar(int, Block&, AtDollar const&)
  Source:    dvalpar.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

dvalPoly(int, Block&, AtDollar const&)
  Full name: Parser::dvalPoly(int, Block&, AtDollar const&)
  Source:    dvalpoly.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

dvalPolyMem(int, Block&, AtDollar const&)
  Full name: Parser::dvalPolyMem(int, Block&, AtDollar const&)
  Source:    dvalpolymem.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

dvalPolyPar(int, Block&, AtDollar const&)
  Full name: Parser::dvalPolyPar(int, Block&, AtDollar const&)
  Source:    dvalpolypar.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

dvalPolyPtr(int, Block&, AtDollar const&)
  Full name: Parser::dvalPolyPtr(int, Block&, AtDollar const&)
  Source:    dvalpolyptr.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

dvalPolyReplace(bool, Block&, AtDollar const&, char const*)
  Full name: Parser::dvalPolyReplace(bool, Block&, AtDollar const&, char const*)
  Source:    dvalpolyreplace.cc 
  Used By:
    dvalpoly.cc: Parser::dvalPoly(int, Block&, AtDollar const&)
    dvalpolymem.cc: Parser::dvalPolyMem(int, Block&, AtDollar const&)
    dvalpolyptr.cc: Parser::dvalPolyPtr(int, Block&, AtDollar const&)

dvalPtr(int, Block&, AtDollar const&)
  Full name: Parser::dvalPtr(int, Block&, AtDollar const&)
  Source:    dvalptr.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

dvalRefUnion(int, Block&, AtDollar const&)
  Full name: Parser::dvalRefUnion(int, Block&, AtDollar const&)
  Source:    dvalrefunion.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

dvalReplace(bool, Block&, AtDollar const&, char const*)
  Full name: Parser::dvalReplace(bool, Block&, AtDollar const&, char const*)
  Source:    dvalreplace.cc 
  Used By:
    dval.cc: Parser::dval(int, Block&, AtDollar const&)
    dvalmem.cc: Parser::dvalMem(int, Block&, AtDollar const&)
    dvalpar.cc: Parser::dvalPar(int, Block&, AtDollar const&)
    dvalptr.cc: Parser::dvalPtr(int, Block&, AtDollar const&)
    dvalrefunion.cc: Parser::dvalRefUnion(int, Block&, AtDollar const&)
    dvalunionpar.cc: Parser::dvalUnionPar(int, Block&, AtDollar const&)

dvalUnion(int, Block&, AtDollar const&)
  Full name: Parser::dvalUnion(int, Block&, AtDollar const&)
  Source:    dvalunion.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

dvalUnionMem(int, Block&, AtDollar const&)
  Full name: Parser::dvalUnionMem(int, Block&, AtDollar const&)
  Source:    dvalunionmem.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

dvalUnionPar(int, Block&, AtDollar const&)
  Full name: Parser::dvalUnionPar(int, Block&, AtDollar const&)
  Source:    dvalunionpar.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

dvalUnionPtr(int, Block&, AtDollar const&)
  Full name: Parser::dvalUnionPtr(int, Block&, AtDollar const&)
  Source:    dvalunionptr.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

dvalUnionReplace(bool, Block&, AtDollar const&, char const*)
  Full name: Parser::dvalUnionReplace(bool, Block&, AtDollar const&, char const*)
  Source:    dvalunionreplace.cc 
  Used By:
    dvalrefunion.cc: Parser::dvalRefUnion(int, Block&, AtDollar const&)
    dvalunion.cc: Parser::dvalUnion(int, Block&, AtDollar const&)
    dvalunionmem.cc: Parser::dvalUnionMem(int, Block&, AtDollar const&)
    dvalunionptr.cc: Parser::dvalUnionPtr(int, Block&, AtDollar const&)

enlargeLA(LookaheadSet const&)
  Full name: StateItem::enlargeLA(LookaheadSet const&)
  Source:    enlargela.cc 
  Used By:
    distributelasetof.cc: State::distributeLAsetOf(StateItem&)
    inspecttransitions.cc: State::inspectTransitions(std::set<unsigned long, std::less<unsigned long>>&)

eoln()
  Full name: Scanner::eoln()
  Source:    eoln.cc 
  Used By:
    lex.cc: Scanner::executeAction_(unsigned long)

errExisting(std::string const&, std::string const&, std::string const&) const
  Full name: Generator::errExisting(std::string const&, std::string const&, std::string const&) const
  Source:    errexisting.cc 
  Used By:
    conflicts.cc: Generator::conflicts() const

errIndexTooLarge(AtDollar const&, int) const
  Full name: Parser::errIndexTooLarge(AtDollar const&, int) const
  Source:    errindextoolarge.cc 
  Used By:
    substituteblock.cc: Parser::substituteBlock(int, Block&)

errNoTag(int, Block&, AtDollar const&)
  Full name: Parser::errNoTag(int, Block&, AtDollar const&)
  Source:    errnotag.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

errNoUnionPtr(AtDollar const&)
  Full name: Parser::errNoUnionPtr(AtDollar const&)
  Source:    errnounionptr.cc 
  Used By:
    dvalunionreplace.cc: Parser::dvalUnionReplace(bool, Block&, AtDollar const&, char const*)
    svsunionreplace.cc: Parser::svsUnionReplace(int, Block&, AtDollar const&, char const*)

error()
  Full name: Parser::error()
  Source:    error.cc 
  Used By:
    parse.cc: Parser::errorRecovery_()

errorVerbose(std::ostream&) const
  Full name: Generator::errorVerbose(std::ostream&) const
  Source:    errorverbose.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

escape()
  Full name: Scanner::escape()
  Source:    escape.cc 
  Used By:
    lex.cc: Scanner::executeAction_(unsigned long)

executeActionCases(std::ostream&) const
  Full name: Generator::executeActionCases(std::ostream&) const
  Source:    executeactioncases.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

existingTag(AtDollar const&) const
  Full name: Parser::existingTag(AtDollar const&) const
  Source:    existingtag.cc 
  Used By:
    svspolytagreplace.cc: Parser::svsPolyTagReplace(int, Block&, AtDollar const&, char const*)

expectRules()
  Full name: Parser::expectRules()
  Source:    expectrules.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

filename(std::string const&)
  Full name: Generator::filename(std::string const&)
  Source:    filename.cc 
  Used By:
    baseclass.cc: Generator::baseClass(std::ostream&) const
    classh.cc: Generator::classH(std::ostream&) const
    classih.cc: Generator::classIH(std::ostream&) const

filter(std::istream&, std::ostream&, bool) const
  Full name: Generator::filter(std::istream&, std::ostream&, bool) const
  Source:    filter.cc 
  Used By:
    baseclassheader.cc: Generator::baseClassHeader() const
    classheader.cc: Generator::classHeader() const
    implementationheader.cc: Generator::implementationHeader() const
    parsefunction.cc: Generator::parseFunction() const
    polymorphic.cc: Generator::polymorphic(std::ostream&) const
    polymorphiccode.cc: Generator::polymorphicCode(std::ostream&) const

findKernel(std::vector<Item> const&) const
  Full name: State::findKernel(std::vector<Item> const&) const
  Source:    findkernel.cc 
  Used By:
    nextstate.cc: State::nextState(Next&)

firstBeyondDot(FirstSet*) const
  Full name: Item::firstBeyondDot(FirstSet*) const
  Source:    firstbeyonddot.cc 
  Used By:
    distributelasetof.cc: State::distributeLAsetOf(StateItem&)

FirstSet(Element const*)
  Full name: FirstSet::FirstSet(Element const*)
  Source:    firstset1.cc 
  Used By:
    terminal1.cc: Terminal::Terminal(std::string const&, Symbol::Type, unsigned long, Terminal::Association, std::string const&)
    terminal2.cc: Terminal::Terminal(std::string const&, std::string const&, Symbol::Type)

Generator(Rules const&, std::unordered_map<std::string, std::string> const&)
  Full name: Generator::Generator(Rules const&, std::unordered_map<std::string, std::string> const&)
  Source:    generator1.cc 
  Used By:
    main.cc: main

grep(std::string const&, std::string const&) const
  Full name: Generator::grep(std::string const&, std::string const&) const
  Source:    grep.cc 
  Used By:
    errexisting.cc: Generator::errExisting(std::string const&, std::string const&, std::string const&) const

handleProductionElement(Meta_::SType&)
  Full name: Parser::handleProductionElement(Meta_::SType&)
  Source:    handleproductionelement.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

handleProductionElements(Meta_::SType&, Meta_::SType const&)
  Full name: Parser::handleProductionElements(Meta_::SType&, Meta_::SType const&)
  Source:    handleproductionelements.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

handleSRconflict(Next::ConstIter  const&, unsigned long)
  Full name: SRConflict::handleSRconflict(Next::ConstIter  const&, unsigned long)
  Source:    handlesrconflict.cc 
  Used By:
    processshiftreduceconflict.cc: SRConflict::processShiftReduceConflict(Next::ConstIter  const&, unsigned long)

handleXstring(unsigned long)
  Full name: Scanner::handleXstring(unsigned long)
  Source:    handlexstring.cc 
  Used By:
    lex.cc: Scanner::executeAction_(unsigned long)

hasKernel(std::vector<Item> const&) const
  Full name: State::hasKernel(std::vector<Item> const&) const
  Source:    haskernel.cc 
  Used By:
    findkernel.cc: State::findKernel(std::vector<Item> const&) const

hexadecimal()
  Full name: Scanner::hexadecimal()
  Source:    hexadecimal.cc 
  Used By:
    lex.cc: Scanner::executeAction_(unsigned long)

idOfTag(std::ostream&) const
  Full name: Generator::idOfTag(std::ostream&) const
  Source:    idoftag.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

idOfTag_
  Full name: Meta_::idOfTag_
  Source:    parse.cc 
  Used By:
    handleproductionelement.cc: GLOBALS handleproductionelement.cc 16handleproductionelement.o
    handleproductionelements.cc: GLOBALS handleproductionelements.cc 16handleproductionelements.o

ifInsertStype(bool&) const
  Full name: Generator::ifInsertStype(bool&) const
  Source:    ifinsertstype.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

ifLtype(bool&) const
  Full name: Generator::ifLtype(bool&) const
  Source:    ifltype.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

ifPrintTokens(bool&) const
  Full name: Generator::ifPrintTokens(bool&) const
  Source:    ifprinttokens.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

implementationHeader() const
  Full name: Generator::implementationHeader() const
  Source:    implementationheader.cc 
  Used By:
    main.cc: main

indexToOffset(int, int) const
  Full name: Parser::indexToOffset(int, int) const
  Source:    indextooffset.cc 
  Used By:
    locel.cc: Parser::locEl(int, Block&, AtDollar const&)
    svselement.cc: Parser::svsElement(int, int) const

initialState()
  Full name: State::initialState()
  Source:    initialstate.cc 
  Used By:
    define.cc: State::define(Rules const&)

insert(NonTerminal*)
  Full name: Rules::insert(NonTerminal*)
  Source:    insert2.cc 
  Used By:
    definenonterminal.cc: Parser::defineNonTerminal(std::string const&, std::string const&)
    requirenonterminal.cc: Parser::requireNonTerminal(std::string const&)
    usesymbol.cc: Parser::useSymbol()
    augmentgrammar.cc: Rules::augmentGrammar(Symbol*)

insert(std::ostream&) const
  Full name: LookaheadSet::insert(std::ostream&) const
  Source:    insert.cc 
  Used By:
    operatorinsert.cc: operator<<(std::ostream&, LookaheadSet const&)

insert(std::ostream&) const
  Full name: FirstSet::insert(std::ostream&) const
  Source:    oinsert.cc 
  Used By:
    showfirst.cc: GLOBALS showfirst.cc 21showfirst.o
    insertext.cc: GLOBALS insertext.cc 3insertext.o

insert(std::ostream&) const
  Full name: RRConflict::insert(std::ostream&) const
  Source:    insert.cc 
  Used By:
    insertext.cc: State::insertExt(std::ostream&) const
    insertstd.cc: State::insertStd(std::ostream&) const

insert(std::ostream&) const
  Full name: Generator::insert(std::ostream&) const
  Source:    insert.cc 
  Used By:
    filter.cc: Generator::filter(std::istream&, std::ostream&, bool) const

insert(std::ostream&) const
  Full name: SRConflict::insert(std::ostream&) const
  Source:    insert.cc 
  Used By:
    insertext.cc: State::insertExt(std::ostream&) const
    insertstd.cc: State::insertStd(std::ostream&) const

insert(std::ostream&) const
  Full name: NonTerminal::insert(std::ostream&) const
  Source:    v.cc 
  Used By:
    destructor.cc: NonTerminal::~NonTerminal()

insert(std::ostream&, Production const*) const
  Full name: Item::insert(std::ostream&, Production const*) const
  Source:    insert.cc 
  Used By:
    plainitem.cc: Item::plainItem(std::ostream&) const
    pnrdotitem.cc: Item::pNrDotItem(std::ostream&) const

insert(std::ostream&, unsigned long, char const*) const
  Full name: Generator::insert(std::ostream&, unsigned long, char const*) const
  Source:    insert2.cc 
  Used By:
    debugdecl.cc: Generator::debugDecl(std::ostream&) const
    debugfunctions.cc: Generator::debugFunctions(std::ostream&) const
    debugincludes.cc: Generator::debugIncludes(std::ostream&) const
    debuglookup.cc: Generator::debugLookup(std::ostream&) const
    lex.cc: Generator::lex(std::ostream&) const
    ltype.cc: Generator::ltype(std::ostream&) const
    ltypedata.cc: Generator::ltypeData(std::ostream&) const
    print.cc: Generator::print(std::ostream&) const

insert(std::vector<Terminal const*> const&) const
  Full name: Writer::insert(std::vector<Terminal const*> const&) const
  Source:    insert.cc 
  Used By:
    tokens.cc: Generator::tokens(std::ostream&) const

insert(Terminal*, std::string const&)
  Full name: Rules::insert(Terminal*, std::string const&)
  Source:    insert1.cc 
  Used By:
    defineterminal.cc: Parser::defineTerminal(std::string const&, Symbol::Type)
    predefine.cc: Parser::predefine(Terminal const*)
    useterminal.cc: Parser::useTerminal()

insertAction(Production const*, std::ostream&, bool, unsigned long)
  Full name: Production::insertAction(Production const*, std::ostream&, bool, unsigned long)
  Source:    insertaction.cc 
  Used By:
    actioncases.cc: Generator::actionCases(std::ostream&) const

insertExt(std::ostream&) const
  Full name: State::insertExt(std::ostream&) const
  Source:    insertext.cc 
  Used By:
    allstates.cc: State::allStates()
    define.cc: State::define(Rules const&)

insertStd(std::ostream&) const
  Full name: State::insertStd(std::ostream&) const
  Source:    insertstd.cc 
  Used By:
    define.cc: State::define(Rules const&)

insertToken(Terminal const*, unsigned long&, std::ostream&)
  Full name: Writer::insertToken(Terminal const*, unsigned long&, std::ostream&)
  Source:    inserttoken.cc 
  Used By:
    insert.cc: Writer::insert(std::vector<Terminal const*> const&) const

insName(std::ostream&) const
  Full name: NonTerminal::insName(std::ostream&) const
  Source:    insname.cc 
  Used By:
    showfirst.cc: GLOBALS showfirst.cc 21showfirst.o
    insertext.cc: GLOBALS insertext.cc 3insertext.o

inspect()
  Full name: RRConflict::inspect()
  Source:    inspect.cc 
  Used By:
    checkconflicts.cc: State::checkConflicts()

inspect()
  Full name: SRConflict::inspect()
  Source:    inspect.cc 
  Used By:
    checkconflicts.cc: State::checkConflicts()

inspectTransitions(std::set<unsigned long, std::less<unsigned long>>&)
  Full name: State::inspectTransitions(std::set<unsigned long, std::less<unsigned long>>&)
  Source:    inspecttransitions.cc 
  Used By:
    determinelasets.cc: State::determineLAsets()

installAction(Block&)
  Full name: Parser::installAction(Block&)
  Source:    installaction.cc 
  Used By:
    handleproductionelement.cc: Parser::handleProductionElement(Meta_::SType&)

installDefaultAction(Production const&, std::string const&)
  Full name: Parser::installDefaultAction(Production const&, std::string const&)
  Source:    installdefaultaction.cc 
  Used By:
    blkassign.cc: Parser::blkAssign(std::string const&, Production const&)
    blkdirect.cc: Parser::blkDirect(std::string const&, Production const&)
    blkstype.cc: Parser::blkSTYPE(std::string const&, Production const&)
    checkfirsttype.cc: Parser::checkFirstType()

instance()
  Full name: Options::instance()
  Source:    instance.cc 
  Used By:
    parser1.cc: Parser::Parser(Rules&)
    generator1.cc: Generator::Generator(Rules const&, std::unordered_map<std::string, std::string> const&)

intersection(LookaheadSet const&) const
  Full name: LookaheadSet::intersection(LookaheadSet const&) const
  Source:    intersection.cc 
  Used By:
    comparereductions.cc: RRConflict::compareReductions(unsigned long)

isDerivable(Production const*)
  Full name: Grammar::isDerivable(Production const*)
  Source:    isderivable.cc 
  Used By:
    derivable.cc: Grammar::derivable(Symbol const*)

isFirstStypeDefinition() const
  Full name: Options::isFirstStypeDefinition() const
  Source:    isfirststypedef.cc 
  Used By:
    setpolymorphicdecl.cc: Options::setPolymorphicDecl()
    setstype.cc: Options::setStype()
    setuniondecl.cc: Options::setUnionDecl(std::string const&)

Item()
  Full name: Item::Item()
  Source:    item0.cc 
  Used By:
    stateitem1.cc: StateItem::StateItem()

Item(Item const*, unsigned long)
  Full name: Item::Item(Item const*, unsigned long)
  Source:    item2.cc 
  Used By:
    buildkernel.cc: Next::buildKernel(std::vector<Item>*, std::vector<StateItem> const&)

Item(Production const*)
  Full name: Item::Item(Production const*)
  Source:    item1.cc 
  Used By:
    addproductions.cc: State::addProductions(Symbol const*)
    initialstate.cc: State::initialState()

itemContext(std::ostream&) const
  Full name: StateItem::itemContext(std::ostream&) const
  Source:    itemcontext.cc 
  Used By:
    insertext.cc: State::insertExt(std::ostream&) const

key(std::ostream&) const
  Full name: Generator::key(std::ostream&) const
  Source:    key.cc 
  Used By:
    actioncases.cc: Generator::actionCases(std::ostream&) const
    baseclass.cc: Generator::baseClass(std::ostream&) const
    baseclasscode.cc: Generator::baseClassCode(std::ostream&) const
    classh.cc: Generator::classH(std::ostream&) const
    classih.cc: Generator::classIH(std::ostream&) const
    debug.cc: Generator::debug(std::ostream&) const
    debugdecl.cc: Generator::debugDecl(std::ostream&) const
    debugfunctions.cc: Generator::debugFunctions(std::ostream&) const
    debugincludes.cc: Generator::debugIncludes(std::ostream&) const
    debuglookup.cc: Generator::debugLookup(std::ostream&) const
    errorverbose.cc: Generator::errorVerbose(std::ostream&) const
    executeactioncases.cc: Generator::executeActionCases(std::ostream&) const
    idoftag.cc: Generator::idOfTag(std::ostream&) const
    lex.cc: Generator::lex(std::ostream&) const
    ltype.cc: Generator::ltype(std::ostream&) const
    ltypeclear.cc: Generator::ltypeClear(std::ostream&) const
    ltypedata.cc: Generator::ltypeData(std::ostream&) const
    ltypepop.cc: Generator::ltypePop(std::ostream&) const
    ltypepush.cc: Generator::ltypePush(std::ostream&) const
    ltyperesize.cc: Generator::ltypeResize(std::ostream&) const
    ltypestack.cc: Generator::ltypeStack(std::ostream&) const
    namespaceclose.cc: Generator::namespaceClose(std::ostream&) const
    namespaceopen.cc: Generator::namespaceOpen(std::ostream&) const
    namespaceuse.cc: Generator::namespaceUse(std::ostream&) const
    polyincludes.cc: Generator::polyIncludes(std::ostream&) const
    polymorphic.cc: Generator::polymorphic(std::ostream&) const
    polymorphiccode.cc: Generator::polymorphicCode(std::ostream&) const
    polymorphicspecializations.cc: Generator::polymorphicSpecializations(std::ostream&) const
    preincludes.cc: Generator::preIncludes(std::ostream&) const
    print.cc: Generator::print(std::ostream&) const
    prompt.cc: Generator::prompt(std::ostream&) const
    scannerh.cc: Generator::scannerH(std::ostream&) const
    scannerobject.cc: Generator::scannerObject(std::ostream&) const
    staticdata.cc: Generator::staticData(std::ostream&) const
    stype.cc: Generator::stype(std::ostream&) const
    tokens.cc: Generator::tokens(std::ostream&) const
    warntagmismatches.cc: Generator::warnTagMismatches(std::ostream&) const

lex(std::ostream&) const
  Full name: Generator::lex(std::ostream&) const
  Source:    lex.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

lex_()
  Full name: Scanner::lex_()
  Source:    lex.cc 
  Used By:
    parse.cc: GLOBALS parse.cc 16parse.o

loc(int, Block&, AtDollar const&)
  Full name: Parser::loc(int, Block&, AtDollar const&)
  Source:    loc.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

locEl(int, Block&, AtDollar const&)
  Full name: Parser::locEl(int, Block&, AtDollar const&)
  Source:    locel.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

LookaheadSet(LookaheadSet const&)
  Full name: LookaheadSet::LookaheadSet(LookaheadSet const&)
  Source:    lookaheadset3.cc 
  Used By:
    rrdata1.cc: RRData::RRData(LookaheadSet)
    comparereductions.cc: GLOBALS comparereductions.cc 25comparereductions.o
    visitreduction.cc: SRConflict::visitReduction(unsigned long)
    addkernelitem.cc: GLOBALS addkernelitem.cc 3addkernelitem.o
    addproductions.cc: GLOBALS addproductions.cc 3addproductions.o

LookaheadSet(LookaheadSet::EndStatus)
  Full name: LookaheadSet::LookaheadSet(LookaheadSet::EndStatus)
  Source:    lookaheadset1.cc 
  Used By:
    distributelasetof.cc: State::distributeLAsetOf(StateItem&)
    initialstate.cc: State::initialState()
    stateitem1.cc: StateItem::StateItem()
    stateitem2.cc: StateItem::StateItem(Item const&)

lookup(std::string const&)
  Full name: Symtab::lookup(std::string const&)
  Source:    lookup.cc 
  Used By:
    cleanup.cc: Parser::cleanup()
    definenonterminal.cc: Parser::defineNonTerminal(std::string const&, std::string const&)
    defineterminal.cc: Parser::defineTerminal(std::string const&, Symbol::Type)
    requirenonterminal.cc: Parser::requireNonTerminal(std::string const&)
    setprecedence.cc: Parser::setPrecedence(unsigned long)
    usesymbol.cc: Parser::useSymbol()
    useterminal.cc: Parser::useTerminal()

ltype(std::ostream&) const
  Full name: Generator::ltype(std::ostream&) const
  Source:    ltype.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

ltypeClear(std::ostream&) const
  Full name: Generator::ltypeClear(std::ostream&) const
  Source:    ltypeclear.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

ltypeData(std::ostream&) const
  Full name: Generator::ltypeData(std::ostream&) const
  Source:    ltypedata.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

ltypePop(std::ostream&) const
  Full name: Generator::ltypePop(std::ostream&) const
  Source:    ltypepop.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

ltypePush(std::ostream&) const
  Full name: Generator::ltypePush(std::ostream&) const
  Source:    ltypepush.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

ltypeResize(std::ostream&) const
  Full name: Generator::ltypeResize(std::ostream&) const
  Source:    ltyperesize.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

ltypeStack(std::ostream&) const
  Full name: Generator::ltypeStack(std::ostream&) const
  Source:    ltypestack.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

multiCharQuote()
  Full name: Scanner::multiCharQuote()
  Source:    multicharquote.cc 
  Used By:
    lex.cc: Scanner::executeAction_(unsigned long)

multiplyDefined(Symbol const*)
  Full name: Parser::multiplyDefined(Symbol const*)
  Source:    multiplydefined.cc 
  Used By:
    definenonterminal.cc: Parser::defineNonTerminal(std::string const&, std::string const&)
    defineterminal.cc: Parser::defineTerminal(std::string const&, Symbol::Type)
    requirenonterminal.cc: Parser::requireNonTerminal(std::string const&)
    useterminal.cc: Parser::useTerminal()

nameOrValue(std::ostream&) const
  Full name: Terminal::nameOrValue(std::ostream&) const
  Source:    nameorvalue.cc 
  Used By:
    reductionsymbol.cc: Writer::reductionSymbol(Element const*, unsigned long, FBB::Table&)
    transition.cc: Writer::transition(Next const&, FBB::Table&)

namespaceClose(std::ostream&) const
  Full name: Generator::namespaceClose(std::ostream&) const
  Source:    namespaceclose.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

namespaceOpen(std::ostream&) const
  Full name: Generator::namespaceOpen(std::ostream&) const
  Source:    namespaceopen.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

namespaceUse(std::ostream&) const
  Full name: Generator::namespaceUse(std::ostream&) const
  Source:    namespaceuse.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

nestedBlock(Block&)
  Full name: Parser::nestedBlock(Block&)
  Source:    nestedblock.cc 
  Used By:
    handleproductionelements.cc: Parser::handleProductionElements(Meta_::SType&, Meta_::SType const&)

newRule(NonTerminal*, std::string const&, unsigned long)
  Full name: Rules::newRule(NonTerminal*, std::string const&, unsigned long)
  Source:    newrule.cc 
  Used By:
    openrule.cc: Parser::openRule(std::string const&)
    augmentgrammar.cc: Rules::augmentGrammar(Symbol*)

newState()
  Full name: State::newState()
  Source:    newstate.cc 
  Used By:
    addstate.cc: State::addState(std::vector<Item> const&)
    initialstate.cc: State::initialState()

Next(Symbol const*, unsigned long)
  Full name: Next::Next(Symbol const*, unsigned long)
  Source:    next2.cc 
  Used By:
    addnext.cc: State::addNext(Symbol const*, unsigned long)

nextFind(Symbol const*) const
  Full name: State::nextFind(Symbol const*) const
  Source:    nextfindfrom.cc 
  Used By:
    nexton.cc: State::nextOn(Symbol const*) const
    notreducible.cc: State::notReducible(unsigned long)

nextHiddenName()
  Full name: Parser::nextHiddenName()
  Source:    nexthiddenname.cc 
  Used By:
    nestedblock.cc: Parser::nestedBlock(Block&)

nextState(Next&)
  Full name: State::nextState(Next&)
  Source:    nextstate.cc 
  Used By:
    construct.cc: State::construct()

NonTerminal(std::string const&, std::string const&, Symbol::Type)
  Full name: NonTerminal::NonTerminal(std::string const&, std::string const&, Symbol::Type)
  Source:    nonterminal1.cc 
  Used By:
    definenonterminal.cc: Parser::defineNonTerminal(std::string const&, std::string const&)
    requirenonterminal.cc: Parser::requireNonTerminal(std::string const&)
    usesymbol.cc: Parser::useSymbol()
    augmentgrammar.cc: Rules::augmentGrammar(Symbol*)

nonTerminalSymbol(NonTerminal const*, std::ostream&)
  Full name: Writer::nonTerminalSymbol(NonTerminal const*, std::ostream&)
  Source:    nonterminalsymbol.cc 
  Used By:
    symbolicnames.cc: Writer::symbolicNames() const

notReducible(unsigned long)
  Full name: State::notReducible(unsigned long)
  Source:    notreducible.cc 
  Used By:
    setitems.cc: State::setItems()

octal()
  Full name: Scanner::octal()
  Source:    octal.cc 
  Used By:
    lex.cc: Scanner::executeAction_(unsigned long)

open(unsigned long, std::string const&)
  Full name: Block::open(unsigned long, std::string const&)
  Source:    open.cc 
  Used By:
    lex.cc: Scanner::executeAction_(unsigned long)
    installdefaultaction.cc: Parser::installDefaultAction(Production const&, std::string const&)

openRule(std::string const&)
  Full name: Parser::openRule(std::string const&)
  Source:    openrule.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

operator()(std::string const&)
  Full name: Block::operator()(std::string const&)
  Source:    opfuncharp.cc 
  Used By:
    lex.cc: Scanner::executeAction_(unsigned long)

operator+=(FirstSet const&)
  Full name: FirstSet::operator+=(FirstSet const&)
  Source:    operatorplusis1.cc 
  Used By:
    setfirst.cc: NonTerminal::setFirst(NonTerminal*)
    operatorplusis.cc: LookaheadSet::operator+=(LookaheadSet const&)
    operatorplusis2.cc: LookaheadSet::operator+=(FirstSet const&)
    firstbeyonddot.cc: Item::firstBeyondDot(FirstSet*) const

operator+=(LookaheadSet const&)
  Full name: LookaheadSet::operator+=(LookaheadSet const&)
  Source:    operatorplusis.cc 
  Used By:
    distributelasetof.cc: State::distributeLAsetOf(StateItem&)
    enlargela.cc: StateItem::enlargeLA(LookaheadSet const&)

operator+=(std::set<Element const*, std::less<Element const*>> const&)
  Full name: FirstSet::operator+=(std::set<Element const*, std::less<Element const*>> const&)
  Source:    operatorplusis2.cc 
  Used By:
    operatorplusis1.cc: FirstSet::operator+=(FirstSet const&)

operator-=(LookaheadSet const&)
  Full name: LookaheadSet::operator-=(LookaheadSet const&)
  Source:    operatorsubis.cc 
  Used By:
    removeconflicts.cc: RRConflict::removeConflicts(std::vector<StateItem>&)

operator-=(Symbol const*)
  Full name: LookaheadSet::operator-=(Symbol const*)
  Source:    operatorsubis2.cc 
  Used By:
    removereductions.cc: SRConflict::removeReductions(std::vector<StateItem>&)

operator<<(std::ostream&, AtDollar const&)
  Full name: operator<<(std::ostream&, AtDollar const&)
  Source:    operatorinsert.cc 
  Used By:
    operatorinsert.cc: operator<<(std::ostream&, Block const&)

operator<<(std::ostream&, LookaheadSet const&)
  Full name: operator<<(std::ostream&, LookaheadSet const&)
  Source:    operatorinsert.cc 
  Used By:
    insert.cc: RRConflict::insert(std::ostream&) const
    itemcontext.cc: StateItem::itemContext(std::ostream&) const

operator==(Item const&) const
  Full name: Item::operator==(Item const&) const
  Source:    operatorequal.cc 
  Used By:
    containskernelitem.cc: StateItem::containsKernelItem(Item const&, unsigned long, std::vector<StateItem> const&)

operator>=(LookaheadSet const&) const
  Full name: LookaheadSet::operator>=(LookaheadSet const&) const
  Source:    operatorgreaterequal.cc 
  Used By:
    enlargela.cc: StateItem::enlargeLA(LookaheadSet const&)

Options()
  Full name: Options::Options()
  Source:    options1.cc 
  Used By:
    instance.cc: Options::instance()

parse()
  Full name: Parser::parse()
  Source:    parse.cc 
  Used By:
    main.cc: main

parseFunction() const
  Full name: Generator::parseFunction() const
  Source:    parsefunction.cc 
  Used By:
    main.cc: main

Parser(Rules&)
  Full name: Parser::Parser(Rules&)
  Source:    parser1.cc 
  Used By:
    main.cc: main

ParserBase()
  Full name: ParserBase::ParserBase()
  Source:    parse.cc 
  Used By:
    parser1.cc: Parser::Parser(Rules&)

plainItem(std::ostream&) const
  Full name: Item::plainItem(std::ostream&) const
  Source:    plainitem.cc 
  Used By:
    data.cc: GLOBALS data.cc 8data.o

plainItem(std::ostream&) const
  Full name: StateItem::plainItem(std::ostream&) const
  Source:    plainitem.cc 
  Used By:
    data.cc: GLOBALS data.cc 6data.o

plainWarnings()
  Full name: Global::plainWarnings()
  Source:    plainwarnings.cc 
  Used By:
    setaccessorvariables.cc: Options::setAccessorVariables()

pNrDotItem(std::ostream&) const
  Full name: Item::pNrDotItem(std::ostream&) const
  Source:    pnrdotitem.cc 
  Used By:
    insertext.cc: State::insertExt(std::ostream&) const

polyIncludes(std::ostream&) const
  Full name: Generator::polyIncludes(std::ostream&) const
  Source:    polyincludes.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

polymorphic(std::ostream&) const
  Full name: Generator::polymorphic(std::ostream&) const
  Source:    polymorphic.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

polymorphicCode(std::ostream&) const
  Full name: Generator::polymorphicCode(std::ostream&) const
  Source:    polymorphiccode.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

polymorphicSpecializations(std::ostream&) const
  Full name: Generator::polymorphicSpecializations(std::ostream&) const
  Source:    polymorphicspecializations.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

popStream()
  Full name: ScannerBase::popStream()
  Source:    lex.cc 
  Used By:
    popstream.cc: Scanner::popStream()

popStream()
  Full name: Scanner::popStream()
  Source:    popstream.cc 
  Used By:
    lex.cc: Scanner::lex_()

predefine(Terminal const*)
  Full name: Parser::predefine(Terminal const*)
  Source:    predefine.cc 
  Used By:
    parser1.cc: Parser::Parser(Rules&)

preIncludes(std::ostream&) const
  Full name: Generator::preIncludes(std::ostream&) const
  Source:    preincludes.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

print(std::ostream&) const
  Full name: Generator::print(std::ostream&) const
  Source:    print.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

processShiftReduceConflict(Next::ConstIter  const&, unsigned long)
  Full name: SRConflict::processShiftReduceConflict(Next::ConstIter  const&, unsigned long)
  Source:    processshiftreduceconflict.cc 
  Used By:
    visitreduction.cc: SRConflict::visitReduction(unsigned long)

Production(Symbol const*, unsigned long)
  Full name: Production::Production(Symbol const*, unsigned long)
  Source:    production1.cc 
  Used By:
    addproduction.cc: Rules::addProduction(unsigned long)
    sethiddenaction.cc: Rules::setHiddenAction(Block const&)

productionInfo(Production const*, std::ostream&)
  Full name: Writer::productionInfo(Production const*, std::ostream&)
  Source:    productioninfo.cc 
  Used By:
    productions.cc: Writer::productions() const

productions() const
  Full name: Writer::productions() const
  Source:    productions.cc 
  Used By:
    staticdata.cc: Generator::staticData(std::ostream&) const

prompt(std::ostream&) const
  Full name: Generator::prompt(std::ostream&) const
  Source:    prompt.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

pushStream(std::string const&)
  Full name: ScannerBase::pushStream(std::string const&)
  Source:    lex.cc 
  Used By:
    handlexstring.cc: Scanner::handleXstring(unsigned long)

quotedName(std::ostream&) const
  Full name: Terminal::quotedName(std::ostream&) const
  Source:    quotedname.cc 
  Used By:
    setprecedence.cc: Rules::setPrecedence(Terminal const*)

rawString()
  Full name: Scanner::rawString()
  Source:    handlerawstring.cc 
  Used By:
    lex.cc: Scanner::executeAction_(unsigned long)

redo(unsigned long)
  Full name: ScannerBase::redo(unsigned long)
  Source:    lex.cc 
  Used By:
    handlexstring.cc: Scanner::handleXstring(unsigned long)

reduction(FBB::Table&, StateItem const&)
  Full name: Writer::reduction(FBB::Table&, StateItem const&)
  Source:    reduction.cc 
  Used By:
    reductions.cc: Writer::reductions(FBB::Table&, State const&)

reductions(FBB::Table&, State const&)
  Full name: Writer::reductions(FBB::Table&, State const&)
  Source:    reductions.cc 
  Used By:
    srtable.cc: Writer::srTable(State const*, FBB::Table&, std::ostream&)

reductionSymbol(Element const*, unsigned long, FBB::Table&)
  Full name: Writer::reductionSymbol(Element const*, unsigned long, FBB::Table&)
  Source:    reductionsymbol.cc 
  Used By:
    reduction.cc: Writer::reduction(FBB::Table&, StateItem const&)

removeConflicts(std::vector<StateItem>&)
  Full name: RRConflict::removeConflicts(std::vector<StateItem>&)
  Source:    removeconflicts.cc 
  Used By:
    checkconflicts.cc: State::checkConflicts()

removeReductions(std::vector<StateItem>&)
  Full name: SRConflict::removeReductions(std::vector<StateItem>&)
  Source:    removereductions.cc 
  Used By:
    checkconflicts.cc: State::checkConflicts()

removeShift(RmShift const&, std::vector<Next>&, unsigned long*)
  Full name: Next::removeShift(RmShift const&, std::vector<Next>&, unsigned long*)
  Source:    removeshift.cc 
  Used By:
    removeshifts.cc: SRConflict::removeShifts(std::vector<Next>&)

removeShifts(std::vector<Next>&)
  Full name: SRConflict::removeShifts(std::vector<Next>&)
  Source:    removeshifts.cc 
  Used By:
    checkconflicts.cc: State::checkConflicts()

replace(std::string&, char, std::string const&)
  Full name: Generator::replace(std::string&, char, std::string const&)
  Source:    replace.cc 
  Used By:
    conflicts.cc: Generator::conflicts() const

replaceBaseFlag(std::string&) const
  Full name: Generator::replaceBaseFlag(std::string&) const
  Source:    replacebaseflag.cc 
  Used By:
    filter.cc: Generator::filter(std::istream&, std::ostream&, bool) const
    insert2.cc: Generator::insert(std::ostream&, unsigned long, char const*) const

requireNonTerminal(std::string const&)
  Full name: Parser::requireNonTerminal(std::string const&)
  Source:    requirenonterminal.cc 
  Used By:
    openrule.cc: Parser::openRule(std::string const&)

reRead(std::string const&, unsigned long)
  Full name: ScannerBase::Input::reRead(std::string const&, unsigned long)
  Source:    lex.cc 
  Used By:
    assignment.cc: Scanner::assignment()

reRead(unsigned long)
  Full name: ScannerBase::Input::reRead(unsigned long)
  Source:    lex.cc 
  Used By:
    returntypespec.cc: Scanner::returnTypeSpec()

returnQuoted(void (Scanner::*)())
  Full name: Scanner::returnQuoted(void (Scanner::*)())
  Source:    returnquoted.cc 
  Used By:
    lex.cc: Scanner::executeAction_(unsigned long)

returnTypeSpec()
  Full name: Scanner::returnTypeSpec()
  Source:    returntypespec.cc 
  Used By:
    lex.cc: Scanner::executeAction_(unsigned long)

RmReduction(unsigned long, unsigned long, Symbol const*, bool)
  Full name: RmReduction::RmReduction(unsigned long, unsigned long, Symbol const*, bool)
  Source:    rmreduction1.cc 
  Used By:
    handlesrconflict.cc: SRConflict::handleSRconflict(Next::ConstIter  const&, unsigned long)

RmShift(unsigned long, bool)
  Full name: RmShift::RmShift(unsigned long, bool)
  Source:    rmshift1.cc 
  Used By:
    handlesrconflict.cc: SRConflict::handleSRconflict(Next::ConstIter  const&, unsigned long)

RRConflict(std::vector<StateItem> const&, std::vector<unsigned long> const&)
  Full name: RRConflict::RRConflict(std::vector<StateItem> const&, std::vector<unsigned long> const&)
  Source:    rrconflict1.cc 
  Used By:
    state1.cc: State::State(unsigned long)

RRData(LookaheadSet)
  Full name: RRData::RRData(LookaheadSet)
  Source:    rrdata1.cc 
  Used By:
    comparereductions.cc: RRConflict::compareReductions(unsigned long)

s_acceptProductionNr
  Full name: Rules::s_acceptProductionNr
  Source:    data.cc 
  Used By:
    augmentgrammar.cc: Rules::augmentGrammar(Symbol*)

s_acceptState
  Full name: State::s_acceptState
  Source:    data.cc 
  Used By:
    srtable.cc: Writer::srTable(State const*, FBB::Table&, std::ostream&)
    define.cc: State::define(Rules const&)

s_at
  Full name: Generator::s_at
  Source:    data.cc 
  Used By:
    replaceatkey.cc: Generator::replaceAtKey(std::string&, unsigned long) const
    replacebaseflag.cc: Generator::replaceBaseFlag(std::string&) const

s_atBol
  Full name: Generator::s_atBol
  Source:    data.cc 
  Used By:
    bolat.cc: Generator::bolAt(std::string&, bool&) const

s_atFlag
  Full name: Generator::s_atFlag
  Source:    data.cc 
  Used By:
    replacebaseflag.cc: Generator::replaceBaseFlag(std::string&) const

s_autoTypeLabel
  Full name: Parser::s_autoTypeLabel
  Source:    data.cc 
  Used By:
    warnautotag.cc: Parser::warnAutoTag(bool, AtDollar const&) const

s_counter
  Full name: NonTerminal::s_counter
  Source:    data.cc 
  Used By:
    setfirst.cc: NonTerminal::setFirst(NonTerminal*)
    determinefirst.cc: Rules::determineFirst()

s_debug_
  Full name: ScannerBase::s_debug_
  Source:    lex.cc 
  Used By:
    checkendofrawstring.cc: Scanner::checkEndOfRawString()
    eoln.cc: Scanner::eoln()
    handlerawstring.cc: Scanner::rawString()
    handlexstring.cc: Scanner::handleXstring(unsigned long)
    returnquoted.cc: Scanner::returnQuoted(void (Scanner::*)())
    returntypespec.cc: Scanner::returnTypeSpec()
    parse.cc: Parser::executeAction_(int)

s_defaultAction
  Full name: Parser::s_defaultAction
  Source:    data.cc 
  Used By:
    defaultpolymorphicaction.cc: Parser::defaultPolymorphicAction(Production const&)

s_defaultBaseClassSkeleton
  Full name: Options::s_defaultBaseClassSkeleton
  Source:    data.cc 
  Used By:
    setskeletons.cc: Options::setSkeletons()

s_defaultClassName
  Full name: Options::s_defaultClassName
  Source:    data.cc 
  Used By:
    setbasicstrings.cc: Options::setBasicStrings()

s_defaultClassSkeleton
  Full name: Options::s_defaultClassSkeleton
  Source:    data.cc 
  Used By:
    setskeletons.cc: Options::setSkeletons()

s_defaultImplementationSkeleton
  Full name: Options::s_defaultImplementationSkeleton
  Source:    data.cc 
  Used By:
    setskeletons.cc: Options::setSkeletons()

s_defaultParsefunSkeleton
  Full name: Options::s_defaultParsefunSkeleton
  Source:    data.cc 
  Used By:
    setskeletons.cc: Options::setSkeletons()

s_defaultParsefunSource
  Full name: Options::s_defaultParsefunSource
  Source:    data.cc 
  Used By:
    setpathstrings.cc: Options::setPathStrings()

s_defaultPolymorphicCodeSkeleton
  Full name: Options::s_defaultPolymorphicCodeSkeleton
  Source:    data.cc 
  Used By:
    setskeletons.cc: Options::setSkeletons()

s_defaultPolymorphicSkeleton
  Full name: Options::s_defaultPolymorphicSkeleton
  Source:    data.cc 
  Used By:
    setskeletons.cc: Options::setSkeletons()

s_defaultScannerClassName
  Full name: Options::s_defaultScannerClassName
  Source:    data.cc 
  Used By:
    setbasicstrings.cc: Options::setBasicStrings()

s_defaultScannerMatchedTextFunction
  Full name: Options::s_defaultScannerMatchedTextFunction
  Source:    data.cc 
  Used By:
    setbasicstrings.cc: Options::setBasicStrings()

s_defaultScannerTokenFunction
  Full name: Options::s_defaultScannerTokenFunction
  Source:    data.cc 
  Used By:
    setbasicstrings.cc: Options::setBasicStrings()

s_defaultSkeletonDirectory
  Full name: Options::s_defaultSkeletonDirectory
  Source:    data.cc 
  Used By:
    setbasicstrings.cc: Options::setBasicStrings()

s_defaultStackExpansion
  Full name: Options::s_defaultStackExpansion
  Source:    data.cc 
  Used By:
    staticdata.cc: Generator::staticData(std::ostream&) const
    setaccessorvariables.cc: Options::setAccessorVariables()
    setstackexpansion.cc: Options::setStackExpansion(unsigned long)

s_dfaBase_
  Full name: ScannerBase::s_dfaBase_
  Source:    lex.cc 
  Used By:
    checkendofrawstring.cc: Scanner::checkEndOfRawString()
    eoln.cc: Scanner::eoln()
    handlerawstring.cc: Scanner::rawString()
    handlexstring.cc: Scanner::handleXstring(unsigned long)
    returnquoted.cc: Scanner::returnQuoted(void (Scanner::*)())
    returntypespec.cc: Scanner::returnTypeSpec()
    parse.cc: Parser::executeAction_(int)

s_eofTerminal
  Full name: Rules::s_eofTerminal
  Source:    data.cc 
  Used By:
    parser1.cc: Parser::Parser(Rules&)
    selectsymbolic.cc: Generator::selectSymbolic(Terminal const*, std::vector<Terminal const*>&)
    operatorsubis2.cc: LookaheadSet::operator-=(Symbol const*)
    reduction.cc: Writer::reduction(FBB::Table&, StateItem const&)
    srtable.cc: Writer::srTable(State const*, FBB::Table&, std::ostream&)

s_errorTerminal
  Full name: Rules::s_errorTerminal
  Source:    data.cc 
  Used By:
    parser1.cc: Parser::Parser(Rules&)
    notreducible.cc: State::notReducible(unsigned long)

s_fileName
  Full name: Production::s_fileName
  Source:    data.cc 
  Used By:
    production1.cc: Production::Production(Symbol const*, unsigned long)
    storeFilename.cc: Production::storeFilename(std::string const&)
    installdefaultaction.cc: Parser::installDefaultAction(Production const&, std::string const&)
    showconflicts.cc: RRConflict::showConflicts(Rules const&) const
    showconflicts.cc: SRConflict::showConflicts(Rules const&) const

s_hiddenName
  Full name: Parser::s_hiddenName
  Source:    data.cc 
  Used By:
    nexthiddenname.cc: Parser::nextHiddenName()

s_insert
  Full name: Generator::s_insert
  Source:    data.cc 
  Used By:
    insert.cc: Generator::insert(std::ostream&) const

s_insert
  Full name: State::s_insert
  Source:    data.cc 
  Used By:
    allstates.cc: State::allStates()
    define.cc: State::define(Rules const&)

s_insertPtr
  Full name: Next::s_insertPtr
  Source:    data.cc 
  Used By:
    insertext.cc: State::insertExt(std::ostream&) const
    insertstd.cc: State::insertStd(std::ostream&) const

s_insertPtr
  Full name: StateItem::s_insertPtr
  Source:    data.cc 
  Used By:
    insertext.cc: State::insertExt(std::ostream&) const
    insertstd.cc: State::insertStd(std::ostream&) const

s_insertPtr
  Full name: NonTerminal::s_insertPtr
  Source:    data.cc 
  Used By:
    multiplydefined.cc: Parser::multiplyDefined(Symbol const*)
    v.cc: NonTerminal::insert(std::ostream&) const
    showfirst.cc: Rules::showFirst() const
    reductionsymbol.cc: Writer::reductionSymbol(Element const*, unsigned long, FBB::Table&)
    transition.cc: Writer::transition(Next const&, FBB::Table&)
    insertext.cc: State::insertExt(std::ostream&) const
    transitionkernel.cc: Next::transitionKernel(std::ostream&) const
    insert.cc: Item::insert(std::ostream&, Production const*) const

s_insertPtr
  Full name: Item::s_insertPtr
  Source:    data.cc 
  Used By:
    insertext.cc: State::insertExt(std::ostream&) const
    itemcontext.cc: StateItem::itemContext(std::ostream&) const
    plainitem.cc: StateItem::plainItem(std::ostream&) const

s_insertPtr
  Full name: Terminal::s_insertPtr
  Source:    data.cc 
  Used By:
    standard.cc: GLOBALS standard.cc 11standard.o
    multiplydefined.cc: GLOBALS multiplydefined.cc 16multiplydefined.o
    destructor.cc: GLOBALS destructor.cc 19destructor.o
    setvalue.cc: GLOBALS setvalue.cc 19setvalue.o
    unused.cc: GLOBALS unused.cc 19unused.o
    filter.cc: Generator::filter(std::istream&, std::ostream&, bool) const
    setprecedence.cc: GLOBALS setprecedence.cc 21setprecedence.o
    showfirst.cc: Rules::showFirst() const
    showterminals.cc: GLOBALS showterminals.cc 21showterminals.o
    showunusedrules.cc: Rules::showUnusedRules() const
    showunusedterminals.cc: Rules::showUnusedTerminals() const
    insert.cc: GLOBALS insert.cc 22insert.o
    insert.cc: GLOBALS insert.cc 27insert.o
    showconflicts.cc: GLOBALS showconflicts.cc 27showconflicts.o
    inserttoken.cc: GLOBALS inserttoken.cc 28inserttoken.o
    reductionsymbol.cc: Writer::reductionSymbol(Element const*, unsigned long, FBB::Table&)
    srtable.cc: Writer::srTable(State const*, FBB::Table&, std::ostream&)
    terminalsymbol.cc: GLOBALS terminalsymbol.cc 28terminalsymbol.o
    transition.cc: Writer::transition(Next const&, FBB::Table&)
    insertext.cc: State::insertExt(std::ostream&) const
    transition.cc: GLOBALS transition.cc 4transition.o
    transitionkernel.cc: GLOBALS transitionkernel.cc 4transitionkernel.o
    insert.cc: GLOBALS insert.cc 8insert.o
    derivesentence.cc: GLOBALS derivesentence.cc 9derivesentence.o

s_lastLineNr
  Full name: Rules::s_lastLineNr
  Source:    data.cc 
  Used By:
    addproduction.cc: Rules::addProduction(unsigned long)
    newrule.cc: Rules::newRule(NonTerminal*, std::string const&, unsigned long)
    sethiddenaction.cc: Rules::setHiddenAction(Block const&)

s_locationValue
  Full name: Parser::s_locationValue
  Source:    data.cc 
  Used By:
    loc.cc: Parser::loc(int, Block&, AtDollar const&)

s_locationValueStack
  Full name: Parser::s_locationValueStack
  Source:    data.cc 
  Used By:
    locel.cc: Parser::locEl(int, Block&, AtDollar const&)

s_maxValue
  Full name: Terminal::s_maxValue
  Source:    data.cc 
  Used By:
    terminal1.cc: Terminal::Terminal(std::string const&, Symbol::Type, unsigned long, Terminal::Association, std::string const&)
    assignnonterminalnumbers.cc: Rules::assignNonTerminalNumbers()

s_nConflicts
  Full name: SRConflict::s_nConflicts
  Source:    data.cc 
  Used By:
    handlesrconflict.cc: SRConflict::handleSRconflict(Next::ConstIter  const&, unsigned long)
    define.cc: State::define(Rules const&)

s_nConflicts
  Full name: RRConflict::s_nConflicts
  Source:    data.cc 
  Used By:
    comparereductions.cc: RRConflict::compareReductions(unsigned long)
    define.cc: State::define(Rules const&)

s_nExpectedConflicts
  Full name: Rules::s_nExpectedConflicts
  Source:    data.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)
    define.cc: State::define(Rules const&)

s_nHidden
  Full name: Parser::s_nHidden
  Source:    data.cc 
  Used By:
    nexthiddenname.cc: Parser::nextHiddenName()

s_nr
  Full name: Production::s_nr
  Source:    data.cc 
  Used By:
    production1.cc: Production::Production(Symbol const*, unsigned long)

s_number
  Full name: NonTerminal::s_number
  Source:    data.cc 
  Used By:
    assignnonterminalnumbers.cc: Rules::assignNonTerminalNumbers()

s_options
  Full name: Options::s_options
  Source:    data.cc 
  Used By:
    instance.cc: Options::instance()

s_out_
  Full name: ScannerBase::s_out_
  Source:    lex.cc 
  Used By:
    checkendofrawstring.cc: Scanner::checkEndOfRawString()
    eoln.cc: Scanner::eoln()
    handlerawstring.cc: Scanner::rawString()
    handlexstring.cc: Scanner::handleXstring(unsigned long)
    returnquoted.cc: Scanner::returnQuoted(void (Scanner::*)())
    returntypespec.cc: Scanner::returnTypeSpec()
    parse.cc: Parser::executeAction_(int)

s_polymorphic
  Full name: Parser::s_polymorphic
  Source:    data.cc 
  Used By:
    setpolymorphicdecl.cc: Parser::setPolymorphicDecl()

s_precedence
  Full name: Terminal::s_precedence
  Source:    data.cc 
  Used By:
    expectrules.cc: Parser::expectRules()
    parse.cc: Parser::executeAction_(int)
    terminal1.cc: Terminal::Terminal(std::string const&, Symbol::Type, unsigned long, Terminal::Association, std::string const&)
    terminal2.cc: Terminal::Terminal(std::string const&, std::string const&, Symbol::Type)

s_semanticValue
  Full name: Parser::s_semanticValue
  Source:    data.cc 
  Used By:
    dvalpolypar.cc: Parser::dvalPolyPar(int, Block&, AtDollar const&)
    dvalpolyreplace.cc: Parser::dvalPolyReplace(bool, Block&, AtDollar const&, char const*)
    dvalreplace.cc: Parser::dvalReplace(bool, Block&, AtDollar const&, char const*)
    dvalunionreplace.cc: Parser::dvalUnionReplace(bool, Block&, AtDollar const&, char const*)
    installdefaultaction.cc: Parser::installDefaultAction(Production const&, std::string const&)

s_semanticValueStack
  Full name: Parser::s_semanticValueStack
  Source:    data.cc 
  Used By:
    svselement.cc: Parser::svsElement(int, int) const

s_single
  Full name: Parser::s_single
  Source:    data.cc 
  Used By:
    parser1.cc: Parser::Parser(Rules&)

s_startProduction
  Full name: Production::s_startProduction
  Source:    data.cc 
  Used By:
    main.cc: main
    initialstate.cc: State::initialState()

s_startSymbol
  Full name: Rules::s_startSymbol
  Source:    data.cc 
  Used By:
    augmentgrammar.cc: Rules::augmentGrammar(Symbol*)
    derivesentence.cc: Grammar::deriveSentence()

s_state
  Full name: State::s_state
  Source:    data.cc 
  Used By:
    srtables.cc: Writer::srTables() const
    statesarray.cc: Writer::statesArray() const
    allstates.cc: State::allStates()
    define.cc: State::define(Rules const&)
    determinelasets.cc: State::determineLAsets()
    findkernel.cc: State::findKernel(std::vector<Item> const&) const
    inspecttransitions.cc: State::inspectTransitions(std::set<unsigned long, std::less<unsigned long>>&)
    newstate.cc: State::newState()
    nextstate.cc: State::nextState(Next&)

s_stateName
  Full name: StateType::s_stateName
  Source:    data.cc 
  Used By:
    srtable.cc: Writer::srTable(State const*, FBB::Table&, std::ostream&)

s_stype
  Full name: Parser::s_stype
  Source:    data.cc 
  Used By:
    blkstype.cc: Parser::blkSTYPE(std::string const&, Production const&)
    checkfield.cc: Parser::checkField(std::string const&)
    svspolyreplace.cc: Parser::svsPolyReplace(int, Block&, AtDollar const&, char const*)
    typeindex.cc: Parser::typeIndex(std::string const&)

s_threadConst
  Full name: Writer::s_threadConst
  Source:    data.cc 
  Used By:
    srtable.cc: Writer::srTable(State const*, FBB::Table&, std::ostream&)
    statesarray.cc: Writer::statesArray() const
    writer0.cc: Writer::Writer(std::string const&, Rules const&)

s_undefined
  Full name: NonTerminal::s_undefined
  Source:    data.cc 
  Used By:
    undefined.cc: NonTerminal::undefined(NonTerminal const*)
    showunusednonterminals.cc: Rules::showUnusedNonTerminals() const

s_undefined
  Full name: Parser::s_undefined
  Source:    data.cc 
  Used By:
    blkerr.cc: Parser::blkErr(std::string const&, Production const&)

s_union
  Full name: Parser::s_union
  Source:    data.cc 
  Used By:
    setuniondecl.cc: Parser::setUnionDecl()

s_unused
  Full name: Production::s_unused
  Source:    data.cc 
  Used By:
    unused.cc: Production::unused(Production const*)
    showunusedrules.cc: Rules::showUnusedRules() const

s_unused
  Full name: NonTerminal::s_unused
  Source:    data.cc 
  Used By:
    unused.cc: NonTerminal::unused(NonTerminal const*)
    showunusednonterminals.cc: Rules::showUnusedNonTerminals() const

s_value
  Full name: Terminal::s_value
  Source:    data.cc 
  Used By:
    setvalue.cc: Terminal::setValue(unsigned long)
    terminal1.cc: Terminal::Terminal(std::string const&, Symbol::Type, unsigned long, Terminal::Association, std::string const&)

s_value
  Full name: Options::s_value
  Source:    data.cc 
  Used By:
    valueof.cc: Options::valueOf(std::string const&, Options::Value, unsigned int)

s_valueSet
  Full name: Terminal::s_valueSet
  Source:    data.cc 
  Used By:
    setunique.cc: Terminal::setUnique(unsigned long)
    setvalue.cc: Terminal::setValue(unsigned long)

s_yylex
  Full name: Options::s_yylex
  Source:    data.cc 
  Used By:
    setbasicstrings.cc: Options::setBasicStrings()

s_YYText
  Full name: Options::s_YYText
  Source:    data.cc 
  Used By:
    setbasicstrings.cc: Options::setBasicStrings()

Scanner(std::string const&)
  Full name: Scanner::Scanner(std::string const&)
  Source:    scanner1.cc 
  Used By:
    parser1.cc: Parser::Parser(Rules&)

ScannerBase(std::string const&, std::string const&)
  Full name: ScannerBase::ScannerBase(std::string const&, std::string const&)
  Source:    lex.cc 
  Used By:
    scanner1.cc: Scanner::Scanner(std::string const&)

scannerH(std::ostream&) const
  Full name: Generator::scannerH(std::ostream&) const
  Source:    scannerh.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

scannerObject(std::ostream&) const
  Full name: Generator::scannerObject(std::ostream&) const
  Source:    scannerobject.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

selectSymbolic(Terminal const*, std::vector<Terminal const*>&)
  Full name: Generator::selectSymbolic(Terminal const*, std::vector<Terminal const*>&)
  Source:    selectsymbolic.cc 
  Used By:
    tokens.cc: Generator::tokens(std::ostream&) const

setAccessorVariables()
  Full name: Options::setAccessorVariables()
  Source:    setaccessorvariables.cc 
  Used By:
    cleanup.cc: Parser::cleanup()

setAtPatterns()
  Full name: AtDollar::setAtPatterns()
  Source:    setatpatterns.cc 
  Used By:
    atdollar1.cc: AtDollar::AtDollar(unsigned long, unsigned long, std::string const&, bool)

setBasicStrings()
  Full name: Options::setBasicStrings()
  Source:    setbasicstrings.cc 
  Used By:
    setaccessorvariables.cc: Options::setAccessorVariables()

setBooleans()
  Full name: Options::setBooleans()
  Source:    setbooleans.cc 
  Used By:
    setaccessorvariables.cc: Options::setAccessorVariables()

setConstructorChecks(std::string const&, std::string const&, unsigned long)
  Full name: Options::setConstructorChecks(std::string const&, std::string const&, unsigned long)
  Source:    setconstructorchecks.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

setDebug(bool)
  Full name: ParserBase::setDebug(bool)
  Source:    parse.cc 
  Used By:
    parser1.cc: Parser::Parser(Rules&)

setDebug(bool)
  Full name: ScannerBase::setDebug(bool)
  Source:    lex.cc 
  Used By:
    parser1.cc: Parser::Parser(Rules&)

setDefaultAction(std::string const&, std::string const&, unsigned long)
  Full name: Options::setDefaultAction(std::string const&, std::string const&, unsigned long)
  Source:    setdefaultaction.cc 
  Used By:
    expectrules.cc: Parser::expectRules()
    parse.cc: Parser::executeAction_(int)
    setparsingoptions.cc: Options::setParsingOptions()

setDollarDollarPatterns()
  Full name: AtDollar::setDollarDollarPatterns()
  Source:    setdollardollarpatterns.cc 
  Used By:
    setdollarpatterns.cc: AtDollar::setDollarPatterns()

setDollarPatterns()
  Full name: AtDollar::setDollarPatterns()
  Source:    setdollarpatterns.cc 
  Used By:
    atdollar1.cc: AtDollar::AtDollar(unsigned long, unsigned long, std::string const&, bool)

setFirst(NonTerminal*)
  Full name: NonTerminal::setFirst(NonTerminal*)
  Source:    setfirst.cc 
  Used By:
    determinefirst.cc: Rules::determineFirst()

setHiddenAction(Block const&)
  Full name: Rules::setHiddenAction(Block const&)
  Source:    sethiddenaction.cc 
  Used By:
    nestedblock.cc: Parser::nestedBlock(Block&)

setIdx(RRData::Keep, unsigned long, unsigned long)
  Full name: RRData::setIdx(RRData::Keep, unsigned long, unsigned long)
  Source:    setidx.cc 
  Used By:
    comparereductions.cc: RRConflict::compareReductions(unsigned long)

setItems()
  Full name: State::setItems()
  Source:    setitems.cc 
  Used By:
    construct.cc: State::construct()

setLineNrs() const
  Full name: Scanner::setLineNrs() const
  Source:    setlinenrs.cc 
  Used By:
    eoln.cc: Scanner::eoln()
    handlexstring.cc: Scanner::handleXstring(unsigned long)
    lex.cc: Scanner::executeAction_(unsigned long)
    settags.cc: Scanner::setTags() const

setLocationDecl(std::string const&)
  Full name: Options::setLocationDecl(std::string const&)
  Source:    setlocationdecl.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

setLtype()
  Full name: Options::setLtype()
  Source:    setltype.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

setNonTerminalTypes()
  Full name: Rules::setNonTerminalTypes()
  Source:    setnonterminaltypes.cc 
  Used By:
    expectrules.cc: Parser::expectRules()

setNumberPatterns()
  Full name: AtDollar::setNumberPatterns()
  Source:    setnumberpatterns.cc 
  Used By:
    setdollarpatterns.cc: AtDollar::setDollarPatterns()

setOpt(std::string*, char const*, std::string const&)
  Full name: Options::setOpt(std::string*, char const*, std::string const&)
  Source:    setopt.cc 
  Used By:
    setbasicstrings.cc: Options::setBasicStrings()

setParsingOptions()
  Full name: Options::setParsingOptions()
  Source:    setparsingoptions.cc 
  Used By:
    expectrules.cc: Parser::expectRules()

setPath(std::string*, int, std::string const&, char const*, char const*)
  Full name: Options::setPath(std::string*, int, std::string const&, char const*, char const*)
  Source:    setpath2.cc 
  Used By:
    setpathstrings.cc: Options::setPathStrings()

setPathStrings()
  Full name: Options::setPathStrings()
  Source:    setpathstrings.cc 
  Used By:
    setaccessorvariables.cc: Options::setAccessorVariables()

setPolymorphicDecl()
  Full name: Parser::setPolymorphicDecl()
  Source:    setpolymorphicdecl.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

setPolymorphicDecl()
  Full name: Options::setPolymorphicDecl()
  Source:    setpolymorphicdecl.cc 
  Used By:
    setpolymorphicdecl.cc: Parser::setPolymorphicDecl()

setPrecedence(Terminal const*)
  Full name: Production::setPrecedence(Terminal const*)
  Source:    setprecedence.cc 
  Used By:
    setprecedence.cc: Rules::setPrecedence(Terminal const*)
    updateprecedence.cc: Rules::updatePrecedence(Production*)

setPrecedence(Terminal const*)
  Full name: Rules::setPrecedence(Terminal const*)
  Source:    setprecedence.cc 
  Used By:
    setprecedence.cc: Parser::setPrecedence(unsigned long)

setPrecedence(unsigned long)
  Full name: Parser::setPrecedence(unsigned long)
  Source:    setprecedence.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

setPrintTokens()
  Full name: Options::setPrintTokens()
  Source:    setprinttokens.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

setQuotedStrings()
  Full name: Options::setQuotedStrings()
  Source:    setquotedstrings.cc 
  Used By:
    setaccessorvariables.cc: Options::setAccessorVariables()

setRefPatterns()
  Full name: AtDollar::setRefPatterns()
  Source:    setrefpatterns.cc 
  Used By:
    atdollar1.cc: AtDollar::AtDollar(unsigned long, unsigned long, std::string const&, bool)

setRequiredTokens(unsigned long)
  Full name: Options::setRequiredTokens(unsigned long)
  Source:    setrequiredtokens.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

setSkeletons()
  Full name: Options::setSkeletons()
  Source:    setskeletons.cc 
  Used By:
    setaccessorvariables.cc: Options::setAccessorVariables()

setStackExpansion(unsigned long)
  Full name: Options::setStackExpansion(unsigned long)
  Source:    setstackexpansion.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

setStart()
  Full name: Parser::setStart()
  Source:    setstart.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

setStype()
  Full name: Options::setStype()
  Source:    setstype.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

setTagMismatches(std::string const&, std::string const&, unsigned long)
  Full name: Options::setTagMismatches(std::string const&, std::string const&, unsigned long)
  Source:    settagmismatches.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)
    setparsingoptions.cc: Options::setParsingOptions()

setTagNr(unsigned long)
  Full name: AtDollar::setTagNr(unsigned long)
  Source:    settagnr.cc 
  Used By:
    settagpatterns.cc: AtDollar::setTagPatterns()

setTagPatterns()
  Full name: AtDollar::setTagPatterns()
  Source:    settagpatterns.cc 
  Used By:
    setdollarpatterns.cc: AtDollar::setDollarPatterns()

setTags() const
  Full name: Scanner::setTags() const
  Source:    settags.cc 
  Used By:
    handlexstring.cc: Scanner::handleXstring(unsigned long)
    popstream.cc: Scanner::popStream()
    scanner1.cc: Scanner::Scanner(std::string const&)

setUnionDecl()
  Full name: Parser::setUnionDecl()
  Source:    setuniondecl.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

setUnionDecl(std::string const&)
  Full name: Options::setUnionDecl(std::string const&)
  Source:    setuniondecl.cc 
  Used By:
    setuniondecl.cc: Parser::setUnionDecl()

setUnique(unsigned long)
  Full name: Terminal::setUnique(unsigned long)
  Source:    setunique.cc 
  Used By:
    setvalue.cc: Terminal::setValue(unsigned long)

setValue(unsigned long)
  Full name: Terminal::setValue(unsigned long)
  Source:    setvalue.cc 
  Used By:
    definetokenname.cc: Parser::defineTokenName(std::string const&, bool)

setVerbosity()
  Full name: Options::setVerbosity()
  Source:    setverbosity.cc 
  Used By:
    cleanup.cc: Parser::cleanup()

showConflicts(Rules const&) const
  Full name: RRConflict::showConflicts(Rules const&) const
  Source:    showconflicts.cc 
  Used By:
    define.cc: State::define(Rules const&)

showConflicts(Rules const&) const
  Full name: SRConflict::showConflicts(Rules const&) const
  Source:    showconflicts.cc 
  Used By:
    define.cc: State::define(Rules const&)

showFilenames() const
  Full name: Options::showFilenames() const
  Source:    showfilenames.cc 
  Used By:
    cleanup.cc: Parser::cleanup()

showFirst() const
  Full name: Rules::showFirst() const
  Source:    showfirst.cc 
  Used By:
    main.cc: main

showRules() const
  Full name: Rules::showRules() const
  Source:    showrules.cc 
  Used By:
    main.cc: main

showTerminals() const
  Full name: Rules::showTerminals() const
  Source:    showterminals.cc 
  Used By:
    main.cc: main

showUnusedNonTerminals() const
  Full name: Rules::showUnusedNonTerminals() const
  Source:    showunusednonterminals.cc 
  Used By:
    main.cc: main

showUnusedRules() const
  Full name: Rules::showUnusedRules() const
  Source:    showunusedrules.cc 
  Used By:
    main.cc: main

showUnusedTerminals() const
  Full name: Rules::showUnusedTerminals() const
  Source:    showunusedterminals.cc 
  Used By:
    main.cc: main

solveByAssociation() const
  Full name: Next::solveByAssociation() const
  Source:    solvebyassociation.cc 
  Used By:
    handlesrconflict.cc: SRConflict::handleSRconflict(Next::ConstIter  const&, unsigned long)

solveByPrecedence(Symbol const*) const
  Full name: Next::solveByPrecedence(Symbol const*) const
  Source:    solvebyprecedence.cc 
  Used By:
    handlesrconflict.cc: SRConflict::handleSRconflict(Next::ConstIter  const&, unsigned long)

SRConflict(std::vector<Next> const&, std::vector<StateItem> const&, std::vector<unsigned long> const&)
  Full name: SRConflict::SRConflict(std::vector<Next> const&, std::vector<StateItem> const&, std::vector<unsigned long> const&)
  Source:    srconflict1.cc 
  Used By:
    state1.cc: State::State(unsigned long)

srTable(State const*, FBB::Table&, std::ostream&)
  Full name: Writer::srTable(State const*, FBB::Table&, std::ostream&)
  Source:    srtable.cc 
  Used By:
    srtables.cc: Writer::srTables() const

srTables() const
  Full name: Writer::srTables() const
  Source:    srtables.cc 
  Used By:
    staticdata.cc: Generator::staticData(std::ostream&) const

stackElement() const
  Full name: AtDollar::stackElement() const
  Source:    stackelement.cc 
  Used By:
    errindextoolarge.cc: Parser::errIndexTooLarge(AtDollar const&, int) const

standard(std::ostream&) const
  Full name: Production::standard(std::ostream&) const
  Source:    standard.cc 
  Used By:
    unused.cc: Production::unused(Production const*)
    blkassignw.cc: Parser::blkAssignW(std::string const&, Production const&)
    blkdirectw.cc: Parser::blkDirectW(std::string const&, Production const&)
    blkerr.cc: Parser::blkErr(std::string const&, Production const&)
    blknopw.cc: Parser::blkNopW(std::string const&, Production const&)
    blkstypew.cc: Parser::blkSTYPEW(std::string const&, Production const&)
    errindextoolarge.cc: Parser::errIndexTooLarge(AtDollar const&, int) const
    stdemsg.cc: Parser::stdEmsg(AtDollar const&) const
    stdwmsg.cc: Parser::stdWmsg(AtDollar const&) const
    warndefaultaction.cc: Parser::warnDefaultAction(Production const&)
    warnmissingsemval.cc: Parser::warnMissingSemval() const
    showrules.cc: Rules::showRules() const
    productioninfo.cc: Writer::productionInfo(Production const*, std::ostream&)

State(unsigned long)
  Full name: State::State(unsigned long)
  Source:    state1.cc 
  Used By:
    newstate.cc: State::newState()

StateItem(Item const&)
  Full name: StateItem::StateItem(Item const&)
  Source:    stateitem2.cc 
  Used By:
    addproductions.cc: State::addProductions(Symbol const*)
    addstate.cc: State::addState(std::vector<Item> const&)
    initialstate.cc: State::initialState()

statesArray() const
  Full name: Writer::statesArray() const
  Source:    statesarray.cc 
  Used By:
    staticdata.cc: Generator::staticData(std::ostream&) const

staticData(std::ostream&) const
  Full name: Generator::staticData(std::ostream&) const
  Source:    staticdata.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

stdEmsg(AtDollar const&) const
  Full name: Parser::stdEmsg(AtDollar const&) const
  Source:    stdemsg.cc 
  Used By:
    errnotag.cc: Parser::errNoTag(int, Block&, AtDollar const&)
    errnounionptr.cc: Parser::errNoUnionPtr(AtDollar const&)
    existingtag.cc: Parser::existingTag(AtDollar const&) const

stdWmsg(AtDollar const&) const
  Full name: Parser::stdWmsg(AtDollar const&) const
  Source:    stdwmsg.cc 
  Used By:
    warnautotag.cc: Parser::warnAutoTag(bool, AtDollar const&) const
    warnnegativedollarindices.cc: Parser::warnNegativeDollarIndices(AtDollar const&) const

storeFilename(std::string const&)
  Full name: Production::storeFilename(std::string const&)
  Source:    storeFilename.cc 
  Used By:
    newrule.cc: Rules::newRule(NonTerminal*, std::string const&, unsigned long)

stype(std::ostream&) const
  Full name: Generator::stype(std::ostream&) const
  Source:    stype.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

sType(unsigned long) const
  Full name: Rules::sType(unsigned long) const
  Source:    stype.cc 
  Used By:
    svspolyreplace.cc: Parser::svsPolyReplace(int, Block&, AtDollar const&, char const*)
    svsunionreplace.cc: Parser::svsUnionReplace(int, Block&, AtDollar const&, char const*)
    warnautotag.cc: Parser::warnAutoTag(bool, AtDollar const&) const

substituteBlock(int, Block&)
  Full name: Parser::substituteBlock(int, Block&)
  Source:    substituteblock.cc 
  Used By:
    installaction.cc: Parser::installAction(Block&)
    nestedblock.cc: Parser::nestedBlock(Block&)

summarizeActions()
  Full name: State::summarizeActions()
  Source:    summarizeactions.cc 
  Used By:
    define.cc: State::define(Rules const&)

svs(int, Block&, AtDollar const&)
  Full name: Parser::svs(int, Block&, AtDollar const&)
  Source:    svs.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

svsElement(int, int) const
  Full name: Parser::svsElement(int, int) const
  Source:    svselement.cc 
  Used By:
    blkassign.cc: Parser::blkAssign(std::string const&, Production const&)
    blkdirect.cc: Parser::blkDirect(std::string const&, Production const&)
    checkfirsttype.cc: Parser::checkFirstType()
    svspolyreplace.cc: Parser::svsPolyReplace(int, Block&, AtDollar const&, char const*)
    svspolytagreplace.cc: Parser::svsPolyTagReplace(int, Block&, AtDollar const&, char const*)
    svsreplace.cc: Parser::svsReplace(int, Block&, AtDollar const&, char const*)
    svsunionreplace.cc: Parser::svsUnionReplace(int, Block&, AtDollar const&, char const*)
    svsuniontagreplace.cc: Parser::svsUnionTagReplace(int, Block&, AtDollar const&, char const*)

svsMem(int, Block&, AtDollar const&)
  Full name: Parser::svsMem(int, Block&, AtDollar const&)
  Source:    svsmem.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

svsPoly(int, Block&, AtDollar const&)
  Full name: Parser::svsPoly(int, Block&, AtDollar const&)
  Source:    svspoly.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

svsPolyMem(int, Block&, AtDollar const&)
  Full name: Parser::svsPolyMem(int, Block&, AtDollar const&)
  Source:    svspolymem.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

svsPolyPtr(int, Block&, AtDollar const&)
  Full name: Parser::svsPolyPtr(int, Block&, AtDollar const&)
  Source:    svspolyptr.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

svsPolyReplace(int, Block&, AtDollar const&, char const*)
  Full name: Parser::svsPolyReplace(int, Block&, AtDollar const&, char const*)
  Source:    svspolyreplace.cc 
  Used By:
    svspoly.cc: Parser::svsPoly(int, Block&, AtDollar const&)
    svspolymem.cc: Parser::svsPolyMem(int, Block&, AtDollar const&)
    svspolyptr.cc: Parser::svsPolyPtr(int, Block&, AtDollar const&)

svsPolyTag(int, Block&, AtDollar const&)
  Full name: Parser::svsPolyTag(int, Block&, AtDollar const&)
  Source:    svspolytag.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

svsPolyTagMem(int, Block&, AtDollar const&)
  Full name: Parser::svsPolyTagMem(int, Block&, AtDollar const&)
  Source:    svspolytagmem.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

svsPolyTagPtr(int, Block&, AtDollar const&)
  Full name: Parser::svsPolyTagPtr(int, Block&, AtDollar const&)
  Source:    svspolytagptr.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

svsPolyTagReplace(int, Block&, AtDollar const&, char const*)
  Full name: Parser::svsPolyTagReplace(int, Block&, AtDollar const&, char const*)
  Source:    svspolytagreplace.cc 
  Used By:
    svspolytag.cc: Parser::svsPolyTag(int, Block&, AtDollar const&)
    svspolytagmem.cc: Parser::svsPolyTagMem(int, Block&, AtDollar const&)
    svspolytagptr.cc: Parser::svsPolyTagPtr(int, Block&, AtDollar const&)

svsPtr(int, Block&, AtDollar const&)
  Full name: Parser::svsPtr(int, Block&, AtDollar const&)
  Source:    svsptr.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

svsRefUnion(int, Block&, AtDollar const&)
  Full name: Parser::svsRefUnion(int, Block&, AtDollar const&)
  Source:    svsrefunion.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

svsReplace(int, Block&, AtDollar const&, char const*)
  Full name: Parser::svsReplace(int, Block&, AtDollar const&, char const*)
  Source:    svsreplace.cc 
  Used By:
    svs.cc: Parser::svs(int, Block&, AtDollar const&)
    svsmem.cc: Parser::svsMem(int, Block&, AtDollar const&)
    svsptr.cc: Parser::svsPtr(int, Block&, AtDollar const&)
    svsrefunion.cc: Parser::svsRefUnion(int, Block&, AtDollar const&)

svsUnion(int, Block&, AtDollar const&)
  Full name: Parser::svsUnion(int, Block&, AtDollar const&)
  Source:    svsunion.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

svsUnionMem(int, Block&, AtDollar const&)
  Full name: Parser::svsUnionMem(int, Block&, AtDollar const&)
  Source:    svsunionmem.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

svsUnionPtr(int, Block&, AtDollar const&)
  Full name: Parser::svsUnionPtr(int, Block&, AtDollar const&)
  Source:    svsunionptr.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

svsUnionReplace(int, Block&, AtDollar const&, char const*)
  Full name: Parser::svsUnionReplace(int, Block&, AtDollar const&, char const*)
  Source:    svsunionreplace.cc 
  Used By:
    svsrefunion.cc: Parser::svsRefUnion(int, Block&, AtDollar const&)
    svsunion.cc: Parser::svsUnion(int, Block&, AtDollar const&)
    svsunionmem.cc: Parser::svsUnionMem(int, Block&, AtDollar const&)
    svsunionptr.cc: Parser::svsUnionPtr(int, Block&, AtDollar const&)

svsUnionTag(int, Block&, AtDollar const&)
  Full name: Parser::svsUnionTag(int, Block&, AtDollar const&)
  Source:    svsuniontag.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

svsUnionTagMem(int, Block&, AtDollar const&)
  Full name: Parser::svsUnionTagMem(int, Block&, AtDollar const&)
  Source:    svsuniontagmem.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

svsUnionTagPtr(int, Block&, AtDollar const&)
  Full name: Parser::svsUnionTagPtr(int, Block&, AtDollar const&)
  Source:    svsuniontagptr.cc 
  Used By:
    data.cc: GLOBALS data.cc 16data.o

svsUnionTagReplace(int, Block&, AtDollar const&, char const*)
  Full name: Parser::svsUnionTagReplace(int, Block&, AtDollar const&, char const*)
  Source:    svsuniontagreplace.cc 
  Used By:
    svsuniontag.cc: Parser::svsUnionTag(int, Block&, AtDollar const&)
    svsuniontagmem.cc: Parser::svsUnionTagMem(int, Block&, AtDollar const&)
    svsuniontagptr.cc: Parser::svsUnionTagPtr(int, Block&, AtDollar const&)

Symbol(std::string const&, Symbol::Type, std::string const&)
  Full name: Symbol::Symbol(std::string const&, Symbol::Type, std::string const&)
  Source:    symbol1.cc 
  Used By:
    terminal1.cc: Terminal::Terminal(std::string const&, Symbol::Type, unsigned long, Terminal::Association, std::string const&)
    terminal2.cc: Terminal::Terminal(std::string const&, std::string const&, Symbol::Type)
    nonterminal1.cc: NonTerminal::NonTerminal(std::string const&, std::string const&, Symbol::Type)

symbolicNames() const
  Full name: Writer::symbolicNames() const
  Source:    symbolicnames.cc 
  Used By:
    staticdata.cc: Generator::staticData(std::ostream&) const

t_nErrors
  Full name: Meta_::t_nErrors
  Source:    parse.cc 
  Used By:
    handleproductionelement.cc: GLOBALS handleproductionelement.cc 16handleproductionelement.o
    handleproductionelements.cc: GLOBALS handleproductionelements.cc 16handleproductionelements.o

Terminal(std::string const&, std::string const&, Symbol::Type)
  Full name: Terminal::Terminal(std::string const&, std::string const&, Symbol::Type)
  Source:    terminal2.cc 
  Used By:
    data.cc: GLOBALS data.cc 21data.o

Terminal(std::string const&, Symbol::Type, unsigned long, Terminal::Association, std::string const&)
  Full name: Terminal::Terminal(std::string const&, Symbol::Type, unsigned long, Terminal::Association, std::string const&)
  Source:    terminal1.cc 
  Used By:
    defineterminal.cc: Parser::defineTerminal(std::string const&, Symbol::Type)
    useterminal.cc: Parser::useTerminal()

terminalSymbol(Terminal const*, std::ostream&)
  Full name: Writer::terminalSymbol(Terminal const*, std::ostream&)
  Source:    terminalsymbol.cc 
  Used By:
    symbolicnames.cc: Writer::symbolicNames() const

termToNonterm(Symbol*, Symbol*)
  Full name: Rules::termToNonterm(Symbol*, Symbol*)
  Source:    termtononterm.cc 
  Used By:
    requirenonterminal.cc: Parser::requireNonTerminal(std::string const&)

tokens(std::ostream&) const
  Full name: Generator::tokens(std::ostream&) const
  Source:    tokens.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

transition(Next const&, FBB::Table&)
  Full name: Writer::transition(Next const&, FBB::Table&)
  Source:    transition.cc 
  Used By:
    transitions.cc: Writer::transitions(FBB::Table&, std::vector<Next> const&)

transition(std::ostream&) const
  Full name: Next::transition(std::ostream&) const
  Source:    transition.cc 
  Used By:
    data.cc: GLOBALS data.cc 4data.o

transitionKernel(std::ostream&) const
  Full name: Next::transitionKernel(std::ostream&) const
  Source:    transitionkernel.cc 
  Used By:
    insertext.cc: State::insertExt(std::ostream&) const

transitions(FBB::Table&, std::vector<Next> const&)
  Full name: Writer::transitions(FBB::Table&, std::vector<Next> const&)
  Source:    transitions.cc 
  Used By:
    srtable.cc: Writer::srTable(State const*, FBB::Table&, std::ostream&)

typeIndex(std::string const&)
  Full name: Parser::typeIndex(std::string const&)
  Source:    typeindex.cc 
  Used By:
    defaultpolymorphicaction.cc: Parser::defaultPolymorphicAction(Production const&)

undefined(NonTerminal const*)
  Full name: NonTerminal::undefined(NonTerminal const*)
  Source:    undefined.cc 
  Used By:
    showunusednonterminals.cc: Rules::showUnusedNonTerminals() const

undelimit(std::string const&)
  Full name: Options::undelimit(std::string const&)
  Source:    undelimit.cc 
  Used By:
    handlexstring.cc: Scanner::handleXstring(unsigned long)
    definepathname.cc: Parser::definePathname(std::string*)
    cleandir.cc: Options::cleanDir(std::string&, bool)
    setopt.cc: Options::setOpt(std::string*, char const*, std::string const&)

unused(NonTerminal const*)
  Full name: NonTerminal::unused(NonTerminal const*)
  Source:    unused.cc 
  Used By:
    showunusednonterminals.cc: Rules::showUnusedNonTerminals() const

unused(Production const*)
  Full name: Production::unused(Production const*)
  Source:    unused.cc 
  Used By:
    showunusedrules.cc: Rules::showUnusedRules() const

unused(Terminal const*)
  Full name: Terminal::unused(Terminal const*)
  Source:    unused.cc 
  Used By:
    showunusedterminals.cc: Rules::showUnusedTerminals() const

updateDefaultActionLineNr()
  Full name: Parser::updateDefaultActionLineNr()
  Source:    updatedefaultactionlinenr.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

updateDefaultActionLineNr(unsigned long)
  Full name: Rules::updateDefaultActionLineNr(unsigned long)
  Source:    updatedefaultactionlinenr.cc 
  Used By:
    updatedefaultactionlinenr.cc: Parser::updateDefaultActionLineNr()
    addproduction.cc: Rules::addProduction(unsigned long)

updatePrecedence(Production*)
  Full name: Rules::updatePrecedence(Production*)
  Source:    updateprecedence.cc 
  Used By:
    updateprecedences.cc: Rules::updatePrecedences()

updatePrecedences()
  Full name: Rules::updatePrecedences()
  Source:    updateprecedences.cc 
  Used By:
    main.cc: main

usage(std::string const&)
  Full name: usage(std::string const&)
  Source:    usage.cc 
  Used By:
    main.cc: main

useSymbol()
  Full name: Parser::useSymbol()
  Source:    usesymbol.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

useTerminal()
  Full name: Parser::useTerminal()
  Source:    useterminal.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

v_firstSet() const
  Full name: NonTerminal::v_firstSet() const
  Source:    v.cc 
  Used By:
    destructor.cc: NonTerminal::~NonTerminal()

v_value() const
  Full name: NonTerminal::v_value() const
  Source:    v.cc 
  Used By:
    destructor.cc: NonTerminal::~NonTerminal()

valueOf(std::string const&, Options::Value, unsigned int)
  Full name: Options::valueOf(std::string const&, Options::Value, unsigned int)
  Source:    valueof.cc 
  Used By:
    setconstructorchecks.cc: Options::setConstructorChecks(std::string const&, std::string const&, unsigned long)
    setdefaultaction.cc: Options::setDefaultAction(std::string const&, std::string const&, unsigned long)
    settagmismatches.cc: Options::setTagMismatches(std::string const&, std::string const&, unsigned long)

valueQuotedName(std::ostream&) const
  Full name: Terminal::valueQuotedName(std::ostream&) const
  Source:    valuequotedname.cc 
  Used By:
    showterminals.cc: Rules::showTerminals() const
    showunusedterminals.cc: Rules::showUnusedTerminals() const

vectorIdx(unsigned long) const
  Full name: Production::vectorIdx(unsigned long) const
  Source:    vectoridx.cc 
  Used By:
    blkassign.cc: Parser::blkAssign(std::string const&, Production const&)
    blkcheck.cc: Parser::blkCheck(std::string const&, Production const&)
    blkcheckw.cc: Parser::blkCheckW(std::string const&, Production const&)
    blkerr.cc: Parser::blkErr(std::string const&, Production const&)
    defaultpolymorphicaction.cc: Parser::defaultPolymorphicAction(Production const&)
    stype.cc: Rules::sType(unsigned long) const
    notreducible.cc: State::notReducible(unsigned long)
    beyonddotisnonterminal.cc: Item::beyondDotIsNonTerminal() const
    firstbeyonddot.cc: Item::firstBeyondDot(FirstSet*) const
    hasrightofdot.cc: Item::hasRightOfDot(Symbol const&) const

version
  Full name: version
  Source:    version.cc 
  Used By:
    main.cc: main
    usage.cc: usage(std::string const&)
    filter.cc: Generator::filter(std::istream&, std::ostream&, bool) const

visitReduction(unsigned long)
  Full name: RRConflict::visitReduction(unsigned long)
  Source:    visitreduction.cc 
  Used By:
    inspect.cc: RRConflict::inspect()

visitReduction(unsigned long)
  Full name: SRConflict::visitReduction(unsigned long)
  Source:    visitreduction.cc 
  Used By:
    inspect.cc: SRConflict::inspect()

warnAutoTag(bool, AtDollar const&) const
  Full name: Parser::warnAutoTag(bool, AtDollar const&) const
  Source:    warnautotag.cc 
  Used By:
    dvalpolypar.cc: Parser::dvalPolyPar(int, Block&, AtDollar const&)
    dvalpolyreplace.cc: Parser::dvalPolyReplace(bool, Block&, AtDollar const&, char const*)
    dvalreplace.cc: Parser::dvalReplace(bool, Block&, AtDollar const&, char const*)
    dvalunionreplace.cc: Parser::dvalUnionReplace(bool, Block&, AtDollar const&, char const*)

warnForceLSP(unsigned long) const
  Full name: Parser::warnForceLSP(unsigned long) const
  Source:    warnforcelsp.cc 
  Used By:
    loc.cc: Parser::loc(int, Block&, AtDollar const&)
    locel.cc: Parser::locEl(int, Block&, AtDollar const&)

warnMissingSemval() const
  Full name: Parser::warnMissingSemval() const
  Source:    warnmissingsemval.cc 
  Used By:
    substituteblock.cc: Parser::substituteBlock(int, Block&)

warnNegativeDollarIndices(AtDollar const&) const
  Full name: Parser::warnNegativeDollarIndices(AtDollar const&) const
  Source:    warnnegativedollarindices.cc 
  Used By:
    svsreplace.cc: Parser::svsReplace(int, Block&, AtDollar const&, char const*)

warnTagMismatches(std::ostream&) const
  Full name: Generator::warnTagMismatches(std::ostream&) const
  Source:    warntagmismatches.cc 
  Used By:
    data.cc: GLOBALS data.cc 1data.o

Writer(std::string const&, Rules const&)
  Full name: Writer::Writer(std::string const&, Rules const&)
  Source:    writer0.cc 
  Used By:
    generator1.cc: Generator::Generator(Rules const&, std::unordered_map<std::string, std::string> const&)

year
  Full name: year
  Source:    version.cc 
  Used By:
    usage.cc: usage(std::string const&)

~Base()
  Full name: Meta_::Base::~Base()
  Source:    parse.cc 
  Used By:
    handleproductionelement.cc: GLOBALS handleproductionelement.cc 16handleproductionelement.o
    handleproductionelements.cc: GLOBALS handleproductionelements.cc 16handleproductionelements.o

~Element()
  Full name: Element::~Element()
  Source:    destructor.cc 
  Used By:
    destructor.cc: Symbol::~Symbol()
    symbol1.cc: Symbol::Symbol(std::string const&, Symbol::Type, std::string const&)

~Symbol()
  Full name: Symbol::~Symbol()
  Source:    destructor.cc 
  Used By:
    destructor.cc: Terminal::~Terminal()
    terminal1.cc: Terminal::Terminal(std::string const&, Symbol::Type, unsigned long, Terminal::Association, std::string const&)
    terminal2.cc: Terminal::Terminal(std::string const&, std::string const&, Symbol::Type)
    destructor.cc: NonTerminal::~NonTerminal()

~Terminal()
  Full name: Terminal::~Terminal()
  Source:    destructor.cc 
  Used By:
    data.cc: GLOBALS data.cc 21data.o


----------------------------------------------------------------------
CALL TREE FOR: main

main
+-usage(std::string const&)
| +-version
| +-year
+-version
+-Parser::Parser(Rules&)
| +-ScannerBase::setDebug(bool)
| +-Scanner::Scanner(std::string const&)
| | +-Scanner::setTags() const
| | | +-Scanner::setLineNrs() const
| | +-ScannerBase::ScannerBase(std::string const&, std::string const&)
| +-Parser::s_single
| +-ParserBase::ParserBase()
| +-ParserBase::setDebug(bool)
| +-Options::instance()
| | +-Options::s_options
| | +-Options::Options()
| +-Rules::s_errorTerminal
| +-Parser::predefine(Terminal const*)
| | +-Rules::insert(Terminal*, std::string const&)
| +-Rules::s_eofTerminal
+-Parser::parse()
+-Parser::cleanup()
| +-Symtab::lookup(std::string const&)
| +-Options::setAccessorVariables()
| | +-Global::plainWarnings()
| | +-Options::s_defaultStackExpansion
| | +-Options::setBooleans()
| | +-Options::setBasicStrings()
| | | +-Options::cleanDir(std::string&, bool)
| | | | +-Options::undelimit(std::string const&)
| | | +-Options::s_yylex
| | | +-Options::s_defaultScannerTokenFunction
| | | +-Options::s_YYText
| | | +-Options::s_defaultScannerMatchedTextFunction
| | | +-Options::s_defaultScannerClassName
| | | +-Options::s_defaultClassName
| | | +-Options::s_defaultSkeletonDirectory
| | | +-Options::setOpt(std::string*, char const*, std::string const&)
| | |   +-Options::undelimit(std::string const&)
| | +-Options::setPathStrings()
| | | +-Options::s_defaultParsefunSource
| | | +-Options::setPath(std::string*, int, std::string const&, char const*, char const*)
| | +-Options::setQuotedStrings()
| | | +-Options::addIncludeQuotes(std::string&)
| | +-Options::setSkeletons()
| |   +-Options::s_defaultPolymorphicCodeSkeleton
| |   +-Options::s_defaultPolymorphicSkeleton
| |   +-Options::s_defaultParsefunSkeleton
| |   +-Options::s_defaultImplementationSkeleton
| |   +-Options::s_defaultClassSkeleton
| |   +-Options::s_defaultBaseClassSkeleton
| +-Rules::augmentGrammar(Symbol*)
| | +-NonTerminal::NonTerminal(std::string const&, std::string const&, Symbol::Type)
| | | +-Symbol::Symbol(std::string const&, Symbol::Type, std::string const&)
| | |   +-Element::~Element()
| | +-Rules::insert(NonTerminal*)
| | +-Rules::addElement(Symbol*)
| | +-Rules::newRule(NonTerminal*, std::string const&, unsigned long)
| | | +-Production::storeFilename(std::string const&)
| | | | +-Production::s_fileName
| | | +-Rules::s_lastLineNr
| | +-Rules::addProduction(unsigned long)
| | | +-Production::Production(Symbol const*, unsigned long)
| | | | +-Production::s_fileName
| | | | +-Production::s_nr
| | | +-Rules::updateDefaultActionLineNr(unsigned long)
| | | +-Rules::s_lastLineNr
| | +-Rules::s_startSymbol
| | +-Rules::s_acceptProductionNr
| +-Options::setVerbosity()
| +-Options::showFilenames() const
+-Rules::updatePrecedences()
| +-Rules::updatePrecedence(Production*)
|   +-Production::setPrecedence(Terminal const*)
+-Rules::showRules() const
| +-Production::standard(std::ostream&) const
+-Rules::showTerminals() const
| +-Terminal::valueQuotedName(std::ostream&) const
+-Rules::determineFirst()
| +-NonTerminal::s_counter
| +-NonTerminal::setFirst(NonTerminal*)
|   +-FirstSet::operator+=(FirstSet const&)
|   | +-FirstSet::operator+=(std::set<Element const*, std::less<Element const*>> const&)
|   +-NonTerminal::s_counter
+-Rules::showFirst() const
| +-Terminal::s_insertPtr
| +-NonTerminal::s_insertPtr
+-Production::s_startProduction
+-State::define(Rules const&)
| +-Rules::s_nExpectedConflicts
| +-RRConflict::s_nConflicts
| +-RRConflict::showConflicts(Rules const&) const
| | +-Production::s_fileName
| +-SRConflict::s_nConflicts
| +-SRConflict::showConflicts(Rules const&) const
| | +-Production::s_fileName
| +-State::s_acceptState
| +-State::s_state
| +-State::insertExt(std::ostream&) const
| | +-Terminal::s_insertPtr
| | +-NonTerminal::s_insertPtr
| | +-RRConflict::insert(std::ostream&) const
| | | +-operator<<(std::ostream&, LookaheadSet const&)
| | |   +-LookaheadSet::insert(std::ostream&) const
| | +-SRConflict::insert(std::ostream&) const
| | +-StateItem::s_insertPtr
| | +-Item::pNrDotItem(std::ostream&) const
| | | +-Item::insert(std::ostream&, Production const*) const
| | |   +-NonTerminal::s_insertPtr
| | +-Item::s_insertPtr
| | +-StateItem::itemContext(std::ostream&) const
| | | +-operator<<(std::ostream&, LookaheadSet const&)
| | | | +-LookaheadSet::insert(std::ostream&) const
| | | +-Item::s_insertPtr
| | +-Next::transitionKernel(std::ostream&) const
| | | +-NonTerminal::s_insertPtr
| | | +-Next::checkRemoved(std::ostream&) const
| | +-Next::s_insertPtr
| +-State::s_insert
| +-State::checkConflicts()
| | +-RRConflict::inspect()
| | | +-RRConflict::visitReduction(unsigned long)
| | |   +-RRConflict::compareReductions(unsigned long)
| | |     +-Terminal::comparePrecedence(Symbol const*, Symbol const*)
| | |     +-LookaheadSet::intersection(LookaheadSet const&) const
| | |     +-RRData::RRData(LookaheadSet)
| | |     | +-LookaheadSet::LookaheadSet(LookaheadSet const&)
| | |     +-RRData::setIdx(RRData::Keep, unsigned long, unsigned long)
| | |     +-RRConflict::s_nConflicts
| | +-RRConflict::removeConflicts(std::vector<StateItem>&)
| | | +-LookaheadSet::operator-=(LookaheadSet const&)
| | +-SRConflict::inspect()
| | | +-SRConflict::visitReduction(unsigned long)
| | |   +-LookaheadSet::LookaheadSet(LookaheadSet const&)
| | |   +-SRConflict::processShiftReduceConflict(Next::ConstIter  const&, unsigned long)
| | |     +-SRConflict::handleSRconflict(Next::ConstIter  const&, unsigned long)
| | |       +-RmShift::RmShift(unsigned long, bool)
| | |       +-SRConflict::s_nConflicts
| | |       +-Next::solveByPrecedence(Symbol const*) const
| | |       | +-Terminal::comparePrecedence(Symbol const*, Symbol const*)
| | |       +-RmReduction::RmReduction(unsigned long, unsigned long, Symbol const*, bool)
| | |       +-Next::solveByAssociation() const
| | +-SRConflict::removeReductions(std::vector<StateItem>&)
| | | +-LookaheadSet::operator-=(Symbol const*)
| | |   +-Rules::s_eofTerminal
| | +-SRConflict::removeShifts(std::vector<Next>&)
| |   +-Next::removeShift(RmShift const&, std::vector<Next>&, unsigned long*)
| +-State::construct()
| | +-State::setItems()
| | | +-State::notReducible(unsigned long)
| | |   +-Production::vectorIdx(unsigned long) const
| | |   +-Rules::s_errorTerminal
| | |   +-State::addNext(Symbol const*, unsigned long)
| | |   | +-Next::Next(Symbol const*, unsigned long)
| | |   | +-State::addProductions(Symbol const*)
| | |   |   +-Item::Item(Production const*)
| | |   |   +-StateItem::StateItem(Item const&)
| | |   |     +-LookaheadSet::LookaheadSet(LookaheadSet::EndStatus)
| | |   +-State::nextFind(Symbol const*) const
| | |   +-Next::addToKernel(std::vector<Next>&, Symbol const*, unsigned long)
| | +-State::nextState(Next&)
| |   +-State::s_state
| |   +-State::addState(std::vector<Item> const&)
| |   | +-State::addKernelItem(StateItem const&)
| |   | +-StateItem::StateItem(Item const&)
| |   | | +-LookaheadSet::LookaheadSet(LookaheadSet::EndStatus)
| |   | +-State::newState()
| |   |   +-State::s_state
| |   |   +-State::State(unsigned long)
| |   |     +-RRConflict::RRConflict(std::vector<StateItem> const&, std::vector<unsigned long> const&)
| |   |     +-SRConflict::SRConflict(std::vector<Next> const&, std::vector<StateItem> const&, std::vector<unsigned long> const&)
| |   +-State::findKernel(std::vector<Item> const&) const
| |   | +-State::s_state
| |   | +-State::hasKernel(std::vector<Item> const&) const
| |   |   +-StateItem::containsKernelItem(Item const&, unsigned long, std::vector<StateItem> const&)
| |   |     +-Item::operator==(Item const&) const
| |   +-Next::buildKernel(std::vector<Item>*, std::vector<StateItem> const&)
| |     +-Item::Item(Item const*, unsigned long)
| +-State::initialState()
| | +-Production::s_startProduction
| | +-LookaheadSet::LookaheadSet(LookaheadSet::EndStatus)
| | +-State::addKernelItem(StateItem const&)
| | +-Item::Item(Production const*)
| | +-StateItem::StateItem(Item const&)
| | | +-LookaheadSet::LookaheadSet(LookaheadSet::EndStatus)
| | +-State::newState()
| |   +-State::s_state
| |   +-State::State(unsigned long)
| |     +-RRConflict::RRConflict(std::vector<StateItem> const&, std::vector<unsigned long> const&)
| |     +-SRConflict::SRConflict(std::vector<Next> const&, std::vector<StateItem> const&, std::vector<unsigned long> const&)
| +-State::determineLAsets()
| | +-State::s_state
| | +-State::computeLAsets()
| | | +-State::distributeLAsetOf(StateItem&)
| | |   +-LookaheadSet::LookaheadSet(LookaheadSet::EndStatus)
| | |   +-LookaheadSet::operator+=(LookaheadSet const&)
| | |   | +-FirstSet::operator+=(FirstSet const&)
| | |   |   +-FirstSet::operator+=(std::set<Element const*, std::less<Element const*>> const&)
| | |   +-Item::beyondDotIsNonTerminal() const
| | |   | +-Production::vectorIdx(unsigned long) const
| | |   +-Item::firstBeyondDot(FirstSet*) const
| | |   | +-Production::vectorIdx(unsigned long) const
| | |   | +-FirstSet::operator+=(FirstSet const&)
| | |   |   +-FirstSet::operator+=(std::set<Element const*, std::less<Element const*>> const&)
| | |   +-StateItem::enlargeLA(LookaheadSet const&)
| | |     +-LookaheadSet::operator>=(LookaheadSet const&) const
| | |     +-LookaheadSet::operator+=(LookaheadSet const&)
| | |       +-FirstSet::operator+=(FirstSet const&)
| | |         +-FirstSet::operator+=(std::set<Element const*, std::less<Element const*>> const&)
| | +-State::inspectTransitions(std::set<unsigned long, std::less<unsigned long>>&)
| |   +-State::s_state
| |   +-StateItem::enlargeLA(LookaheadSet const&)
| |     +-LookaheadSet::operator>=(LookaheadSet const&) const
| |     +-LookaheadSet::operator+=(LookaheadSet const&)
| |       +-FirstSet::operator+=(FirstSet const&)
| |         +-FirstSet::operator+=(std::set<Element const*, std::less<Element const*>> const&)
| +-State::summarizeActions()
| +-State::insertStd(std::ostream&) const
|   +-RRConflict::insert(std::ostream&) const
|   | +-operator<<(std::ostream&, LookaheadSet const&)
|   |   +-LookaheadSet::insert(std::ostream&) const
|   +-SRConflict::insert(std::ostream&) const
|   +-StateItem::s_insertPtr
|   +-Next::s_insertPtr
+-Rules::assignNonTerminalNumbers()
| +-Terminal::s_maxValue
| +-NonTerminal::s_number
+-Rules::showUnusedTerminals() const
| +-Terminal::s_insertPtr
| +-Terminal::unused(Terminal const*)
| +-Terminal::valueQuotedName(std::ostream&) const
+-Rules::showUnusedNonTerminals() const
| +-NonTerminal::s_undefined
| +-NonTerminal::s_unused
| +-NonTerminal::undefined(NonTerminal const*)
| | +-NonTerminal::s_undefined
| +-NonTerminal::unused(NonTerminal const*)
|   +-NonTerminal::s_unused
+-Rules::showUnusedRules() const
| +-Production::s_unused
| +-Terminal::s_insertPtr
| +-Production::unused(Production const*)
|   +-Production::s_unused
|   +-Production::standard(std::ostream&) const
+-State::allStates()
| +-State::s_state
| +-State::insertExt(std::ostream&) const
| | +-Terminal::s_insertPtr
| | +-NonTerminal::s_insertPtr
| | +-RRConflict::insert(std::ostream&) const
| | | +-operator<<(std::ostream&, LookaheadSet const&)
| | |   +-LookaheadSet::insert(std::ostream&) const
| | +-SRConflict::insert(std::ostream&) const
| | +-StateItem::s_insertPtr
| | +-Item::pNrDotItem(std::ostream&) const
| | | +-Item::insert(std::ostream&, Production const*) const
| | |   +-NonTerminal::s_insertPtr
| | +-Item::s_insertPtr
| | +-StateItem::itemContext(std::ostream&) const
| | | +-operator<<(std::ostream&, LookaheadSet const&)
| | | | +-LookaheadSet::insert(std::ostream&) const
| | | +-Item::s_insertPtr
| | +-Next::transitionKernel(std::ostream&) const
| | | +-NonTerminal::s_insertPtr
| | | +-Next::checkRemoved(std::ostream&) const
| | +-Next::s_insertPtr
| +-State::s_insert
+-Grammar::deriveSentence()
| +-Rules::s_startSymbol
| +-Grammar::derivable(Symbol const*)
|   +-Grammar::becomesDerivable(Production const*)
|   | +-Grammar::derivable(Symbol const*) ==> 2
|   +-Grammar::isDerivable(Production const*)
+-Generator::Generator(Rules const&, std::unordered_map<std::string, std::string> const&)
| +-Options::instance()
| | +-Options::s_options
| | +-Options::Options()
| +-Writer::Writer(std::string const&, Rules const&)
|   +-Writer::s_threadConst
+-Generator::conflicts() const
| +-Generator::errExisting(std::string const&, std::string const&, std::string const&) const
| | +-Generator::grep(std::string const&, std::string const&) const
| +-Options::baseclassHeaderName() const
| +-Generator::replace(std::string&, char, std::string const&)
+-Generator::baseClassHeader() const
| +-Generator::filter(std::istream&, std::ostream&, bool) const
|   +-version
|   +-Terminal::s_insertPtr
|   +-Generator::replaceBaseFlag(std::string&) const
|   | +-Generator::s_at
|   | +-Generator::s_atFlag
|   +-Generator::insert(std::ostream&) const
|     +-Generator::s_insert
+-Generator::classHeader() const
| +-Generator::filter(std::istream&, std::ostream&, bool) const
|   +-version
|   +-Terminal::s_insertPtr
|   +-Generator::replaceBaseFlag(std::string&) const
|   | +-Generator::s_at
|   | +-Generator::s_atFlag
|   +-Generator::insert(std::ostream&) const
|     +-Generator::s_insert
+-Generator::implementationHeader() const
| +-Generator::filter(std::istream&, std::ostream&, bool) const
|   +-version
|   +-Terminal::s_insertPtr
|   +-Generator::replaceBaseFlag(std::string&) const
|   | +-Generator::s_at
|   | +-Generator::s_atFlag
|   +-Generator::insert(std::ostream&) const
|     +-Generator::s_insert
+-Generator::parseFunction() const
  +-Generator::filter(std::istream&, std::ostream&, bool) const
    +-version
    +-Terminal::s_insertPtr
    +-Generator::replaceBaseFlag(std::string&) const
    | +-Generator::s_at
    | +-Generator::s_atFlag
    +-Generator::insert(std::ostream&) const
      +-Generator::s_insert
