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

CREATED Sun, 11 Sep 2022 11:58:56 +0000
CROSS REFERENCE FOR: -t main -r replace -fxs tmp/main.o tmp/libmodules.a 

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

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

accept(unsigned long)
  Full name: ScannerBase::accept(unsigned long)
  Source:    lex.cc 
  Used By:
    handleeolncomment.cc: Scanner::handleEOLNcomment()
    handlemulti.cc: Scanner::handleMulti(int)
    handlerawstring.cc: Scanner::handleRawString()
    secondsectiondelimiter.cc: Scanner::secondSectionDelimiter()
    block.cc: Parser::block()

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

activate(unsigned long)
  Full name: StartConditions::activate(unsigned long)
  Source:    activate.cc 
  Used By:
    addcatchall.cc: Rules::addCatchAll(unsigned long, unsigned long)
    handleloprule.cc: Rules::handleLopRule(unsigned long)

add(bool, Pattern const&, Block const&, FlexTypes::RuleType)
  Full name: Rules::add(bool, Pattern const&, Block const&, FlexTypes::RuleType)
  Source:    add.cc 
  Used By:
    handleloprule.cc: Rules::handleLopRule(unsigned long)
    handleloprules.cc: Rules::handleLopRules()
    addrule.cc: Parser::addRule(Pattern const&, bool)

add(std::string const&)
  Full name: Ranges::add(std::string const&)
  Source:    add.cc 
  Used By:
    add3.cc: Ranges::add(unsigned long)
    inspectstate.cc: Ranges::inspectState(State const&)

add(unsigned long)
  Full name: StartConditions::add(unsigned long)
  Source:    add2.cc 
  Used By:
    add.cc: Rules::add(bool, Pattern const&, Block const&, FlexTypes::RuleType)
    addcatchall.cc: Rules::addCatchAll(unsigned long, unsigned long)

add(unsigned long)
  Full name: Ranges::add(unsigned long)
  Source:    add3.cc 
  Used By:
    inspectstate.cc: Ranges::inspectState(State const&)

addCatchAll(unsigned long, unsigned long)
  Full name: Rules::addCatchAll(unsigned long, unsigned long)
  Source:    addcatchall.cc 
  Used By:
    handleloprules.cc: Rules::handleLopRules()

addChars(std::set<char>&, unsigned long, unsigned long) const
  Full name: CharClass::addChars(std::set<char>&, unsigned long, unsigned long) const
  Source:    addchars.cc 
  Used By:
    set.cc: CharClass::set()

addDefinition(std::string const&, FlexTypes::TextType)
  Full name: Scanner::addDefinition(std::string const&, FlexTypes::TextType)
  Source:    adddefinition.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

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

addRange(std::set<char>&, unsigned long) const
  Full name: CharClass::addRange(std::set<char>&, unsigned long) const
  Source:    addrange.cc 
  Used By:
    set.cc: CharClass::set()

addRule(Pattern const&, bool)
  Full name: Parser::addRule(Pattern const&, bool)
  Source:    addrule.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

addSC(std::string const&)
  Full name: StartConditions::addSC(std::string const&)
  Source:    addsc.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

allowNullMatches()
  Full name: Scanner::allowNullMatches()
  Source:    allownullmatches.cc 
  Used By:
    addrule.cc: Parser::addRule(Pattern const&, bool)

alternatives(States&, Pattern const&, Pattern const&)
  Full name: Pattern::alternatives(States&, Pattern const&, Pattern const&)
  Source:    alternatives.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

append(std::vector<std::string> const&)
  Full name: CharClass::append(std::vector<std::string> const&)
  Source:    append.cc 
  Used By:
    dot.cc: Pattern::dot(States&)
    parse.cc: Parser::executeAction_(int)
    negate2.cc: CharClass::negate(std::vector<std::string> const&)

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

assignBlock()
  Full name: Parser::assignBlock()
  Source:    assignblock.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

baseClassH(std::ostream&) const
  Full name: Generator::baseClassH(std::ostream&) const
  Source:    baseclassh.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.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:
    baseclassh.cc: Generator::baseClassH(std::ostream&) const
    conflicts.cc: Generator::conflicts() const

baseIncludes(std::ostream&) const
  Full name: Generator::baseIncludes(std::ostream&) const
  Source:    baseincludes.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

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

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

build()
  Full name: DFAs::build()
  Source:    build.cc 
  Used By:
    main.cc: main

build(std::string const&, std::vector<unsigned long> const&)
  Full name: DFA::build(std::string const&, std::vector<unsigned long> const&)
  Source:    build.cc 
  Used By:
    build.cc: DFAs::build()

canBeEmpty(States const&) const
  Full name: Pattern::canBeEmpty(States const&) const
  Source:    canbeempty.cc 
  Used By:
    addrule.cc: Parser::addRule(Pattern const&, bool)
    lookahead.cc: Parser::lookahead(Pattern const&, Pattern const&)

caseCheck(std::ostream&) const
  Full name: Generator::caseCheck(std::ostream&) const
  Source:    casecheck.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

characterClass(States&, CharClass&)
  Full name: Pattern::characterClass(States&, CharClass&)
  Source:    characterclass.cc 
  Used By:
    dot.cc: Pattern::dot(States&)
    parse.cc: Parser::executeAction_(int)

CharClass()
  Full name: CharClass::CharClass()
  Source:    charclass1.cc 
  Used By:
    dot.cc: Pattern::dot(States&)
    parse.cc: Parser::print_()
    difference.cc: CharClass::difference(CharClass&, CharClass&)
    unite.cc: CharClass::unite(CharClass&, CharClass&)

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

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

charsetToRanges(StateData&, unsigned long*)
  Full name: Ranges::charsetToRanges(StateData&, unsigned long*)
  Source:    charsettoranges.cc 
  Used By:
    finalizestate.cc: Ranges::finalizeState(State&)

chCollision(unsigned char, unsigned char&, unsigned long const*)
  Full name: Ranges::chCollision(unsigned char, unsigned char&, unsigned long const*)
  Source:    chcollision.cc 
  Used By:
    collision.cc: Ranges::collision(std::string const&, unsigned long const*)

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

classHead(std::ostream&) const
  Full name: Generator::classHead(std::ostream&) const
  Source:    classhead.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

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

classHeaderName() const
  Full name: Options::classHeaderName() const
  Source:    classheadername.cc 
  Used By:
    classh.cc: Generator::classH(std::ostream&) const
    conflicts.cc: Generator::conflicts() const

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

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

clear()
  Full name: Block::clear()
  Source:    clear.cc 
  Used By:
    noaction.cc: Rule::noAction()
    handleloprule.cc: Rules::handleLopRule(unsigned long)
    open.cc: Block::open(unsigned long, std::string const&)

close()
  Full name: Block::close()
  Source:    close.cc 
  Used By:
    block.cc: Parser::block()

collect(unsigned long)
  Full name: States::collect(unsigned long)
  Source:    collect.cc 
  Used By:
    concatenate.cc: Pattern::concatenate(States&, Pattern const&, Pattern const&)

collision(std::string const&, unsigned long const*)
  Full name: Ranges::collision(std::string const&, unsigned long const*)
  Source:    collision.cc 
  Used By:
    update.cc: Ranges::update(std::string const&, unsigned long const*)

concatenate(States&, Pattern const&, Pattern const&)
  Full name: Pattern::concatenate(States&, Pattern const&, Pattern const&)
  Source:    concatenate.cc 
  Used By:
    join.cc: Pattern::join(States&, Pattern&, unsigned long, std::vector<std::pair<unsigned long, unsigned long>> const&)
    pattern2.cc: Pattern::Pattern(States&, Pattern const&, Pattern const&, unsigned long)
    pattern3.cc: Pattern::Pattern(States&, unsigned long, Pattern const&, Pattern const&)
    parse.cc: Parser::executeAction_(int)

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

construction(States const&)
  Full name: Generator::construction(States const&)
  Source:    construction.cc 
  Used By:
    main.cc: main

contains(unsigned long) const
  Full name: State::contains(unsigned long) const
  Source:    contains.cc 
  Used By:
    transit.cc: DFARow::transit(unsigned long, unsigned long, std::set<unsigned long>&)

copy(States&, Pattern&, unsigned long, unsigned long)
  Full name: Pattern::copy(States&, Pattern&, unsigned long, unsigned long)
  Source:    copy.cc 
  Used By:
    interval.cc: Pattern::interval(States&, Pattern&, Interval const&)

copyPattern(States&, unsigned long, std::vector<std::pair<unsigned long, unsigned long>>&)
  Full name: Pattern::copyPattern(States&, unsigned long, std::vector<std::pair<unsigned long, unsigned long>>&)
  Source:    copypattern1.cc 
  Used By:
    copy.cc: Pattern::copy(States&, Pattern&, unsigned long, unsigned long)

copyPattern(States&, unsigned long, unsigned long, FBB::LinearMap<unsigned long, unsigned long>&, std::vector<std::pair<unsigned long, unsigned long>>&)
  Full name: Pattern::copyPattern(States&, unsigned long, unsigned long, FBB::LinearMap<unsigned long, unsigned long>&, std::vector<std::pair<unsigned long, unsigned long>>&)
  Source:    copypattern2.cc 
  Used By:
    optionalpatterns.cc: Pattern::optionalPatterns(States&, Pattern&, unsigned long, unsigned long, std::vector<std::pair<unsigned long, unsigned long>>&)

countRanges(unsigned long&, std::vector<unsigned long>&)
  Full name: Ranges::countRanges(unsigned long&, std::vector<unsigned long>&)
  Source:    countranges.cc 
  Used By:
    update.cc: Ranges::update(std::string const&, unsigned long const*)

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

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

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

debugTest() const
  Full name: Generator::debugTest() const
  Source:    debugtest.cc 
  Used By:
    debug.cc: Generator::debug(std::ostream&) const
    startcondimpl.cc: Generator::startCondImpl(std::ostream&) const

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

define(std::string const&)
  Full name: StartConditions::define(std::string const&)
  Source:    define.cc 
  Used By:
    addlopstartconditions.cc: Parser::addLopStartConditions()
    parse.cc: Parser::executeAction_(int)

determineSubsets()
  Full name: Ranges::determineSubsets()
  Source:    determinesubsets.cc 
  Used By:
    main.cc: main

DFA(Ranges&, Rules&, States&)
  Full name: DFA::DFA(Ranges&, Rules&, States&)
  Source:    dfa1.cc 
  Used By:
    build.cc: DFAs::build()

dfa(std::pair<std::string, DFA*> const&, std::ostream&, std::vector<std::string>&, std::vector<unsigned long>&)
  Full name: Generator::dfa(std::pair<std::string, DFA*> const&, std::ostream&, std::vector<std::string>&, std::vector<unsigned long>&)
  Source:    dfa.cc 
  Used By:
    dfas.cc: Generator::dfas(std::ostream&) const

DFAbases(std::ostream&) const
  Full name: Generator::DFAbases(std::ostream&) const
  Source:    dfabases.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

dfaRow(DFARow const&, unsigned long&, std::ostream&)
  Full name: Generator::dfaRow(DFARow const&, unsigned long&, std::ostream&)
  Source:    dfarow.cc 
  Used By:
    dfa.cc: Generator::dfa(std::pair<std::string, DFA*> const&, std::ostream&, std::vector<std::string>&, std::vector<unsigned long>&)

DFARow(Rules&, States&, std::vector<std::set<unsigned long>>&, unsigned long, unsigned long, std::vector<bool>*)
  Full name: DFARow::DFARow(Rules&, States&, std::vector<std::set<unsigned long>>&, unsigned long, unsigned long, std::vector<bool>*)
  Source:    dfarow1.cc 
  Used By:
    build.cc: DFA::build(std::string const&, std::vector<unsigned long> const&)

dfaRules(DFARow const&, std::ostream&)
  Full name: Generator::dfaRules(DFARow const&, std::ostream&)
  Source:    dfarules.cc 
  Used By:
    dfarow.cc: Generator::dfaRow(DFARow const&, unsigned long&, std::ostream&)

DFAs(Rules&, States&, Ranges&)
  Full name: DFAs::DFAs(Rules&, States&, Ranges&)
  Source:    dfas1.cc 
  Used By:
    main.cc: main

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

dfaTransitions(DFARow const&, std::ostream&)
  Full name: Generator::dfaTransitions(DFARow const&, std::ostream&)
  Source:    dfatransitions.cc 
  Used By:
    dfarow.cc: Generator::dfaRow(DFARow const&, unsigned long&, std::ostream&)

dflush_(std::ostream&)
  Full name: ParserBase::dflush_(std::ostream&)
  Source:    parse.cc 
  Used By:
    lookahead.cc: GLOBALS lookahead.cc 2lookahead.o
    quotes.cc: Parser::quotes()

difference(CharClass&, CharClass&)
  Full name: CharClass::difference(CharClass&, CharClass&)
  Source:    difference.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

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

dot(States&)
  Full name: Pattern::dot(States&)
  Source:    dot.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

dup(State const&, unsigned long, unsigned long)
  Full name: State::dup(State const&, unsigned long, unsigned long)
  Source:    dup.cc 
  Used By:
    duppattern.cc: Pattern::dupPattern(FBB::LinearMap<unsigned long, unsigned long>&, States&, unsigned long)

duplicate(States&) const
  Full name: Pattern::duplicate(States&) const
  Source:    duplicate.cc 
  Used By:
    pattern2.cc: Pattern::Pattern(States&, Pattern const&, Pattern const&, unsigned long)

dupPattern(FBB::LinearMap<unsigned long, unsigned long>&, States&, unsigned long)
  Full name: Pattern::dupPattern(FBB::LinearMap<unsigned long, unsigned long>&, States&, unsigned long)
  Source:    duppattern.cc 
  Used By:
    copypattern1.cc: Pattern::copyPattern(States&, unsigned long, std::vector<std::pair<unsigned long, unsigned long>>&)
    copypattern2.cc: Pattern::copyPattern(States&, unsigned long, unsigned long, FBB::LinearMap<unsigned long, unsigned long>&, std::vector<std::pair<unsigned long, unsigned long>>&)
    duplicate.cc: Pattern::duplicate(States&) const

eClosure(std::set<unsigned long>&) const
  Full name: States::eClosure(std::set<unsigned long>&) const
  Source:    eclosure.cc 
  Used By:
    build.cc: DFA::build(std::string const&, std::vector<unsigned long> const&)
    transitions.cc: DFARow::transitions()

empty(std::set<unsigned long>&, States const&, unsigned long)
  Full name: Pattern::empty(std::set<unsigned long>&, States const&, unsigned long)
  Source:    empty.cc 
  Used By:
    canbeempty.cc: Pattern::canBeEmpty(States const&) const

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

eof(States&)
  Full name: Pattern::eof(States&)
  Source:    eof.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

eolnDollar()
  Full name: Parser::eolnDollar()
  Source:    eolndollar.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

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

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

escape(States&, std::string const&)
  Full name: Pattern::escape(States&, std::string const&)
  Source:    escape.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

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

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

filter(std::istream&, std::ostream&) const
  Full name: Generator::filter(std::istream&, std::ostream&) const
  Source:    filter.cc 
  Used By:
    baseclassheader.cc: Generator::baseclassHeader() const
    classheader.cc: Generator::classHeader() const
    implementationheader.cc: Generator::implementationHeader() const
    lexsource.cc: Generator::lexSource() const

finalizeState(State&)
  Full name: Ranges::finalizeState(State&)
  Source:    finalizestate.cc 
  Used By:
    finalizestates.cc: Ranges::finalizeStates()

finalizeStates()
  Full name: Ranges::finalizeStates()
  Source:    finalizestates.cc 
  Used By:
    main.cc: main

Generator(Rules const&, Ranges const&, DFAs const&)
  Full name: Generator::Generator(Rules const&, Ranges const&, DFAs const&)
  Source:    generator1.cc 
  Used By:
    main.cc: main

getLOP(std::ostream&) const
  Full name: Generator::getLOP(std::ostream&) const
  Source:    getlop.cc 
  Used By:
    lopimplementation.cc: Generator::lopImplementation(std::ostream&) const

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

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

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

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

handleFixedTailLopRule(Rule&)
  Full name: Rules::handleFixedTailLopRule(Rule&)
  Source:    handlefixedtailloprule.cc 
  Used By:
    handleloprules.cc: Rules::handleLopRules()

handleLopRule(unsigned long)
  Full name: Rules::handleLopRule(unsigned long)
  Source:    handleloprule.cc 
  Used By:
    handleloprules.cc: Rules::handleLopRules()

handleLopRules()
  Full name: Rules::handleLopRules()
  Source:    handleloprules.cc 
  Used By:
    main.cc: main

handleMinusAndEscape()
  Full name: CharClass::handleMinusAndEscape()
  Source:    handleminusandescape.cc 
  Used By:
    set.cc: CharClass::set()

handleMulti(int)
  Full name: Scanner::handleMulti(int)
  Source:    handlemulti.cc 
  Used By:
    lex.cc: Scanner::executeAction_(unsigned long)

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

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

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

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

implementationHeaderName() const
  Full name: Options::implementationHeaderName() const
  Source:    implementationheadername.cc 
  Used By:
    classih.cc: Generator::classIH(std::ostream&) const

inlineLexFunction(std::ostream&) const
  Full name: Generator::inlineLexFunction(std::ostream&) const
  Source:    inlinelexfunction.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

inputDeclaration(std::ostream&) const
  Full name: Generator::inputDeclaration(std::ostream&) const
  Source:    inputdeclaration.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

inputImplementation(std::ostream&) const
  Full name: Generator::inputImplementation(std::ostream&) const
  Source:    inputimplementation.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

inputInterface(std::ostream&) const
  Full name: Generator::inputInterface(std::ostream&) const
  Source:    inputinterface.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

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

insertedCatchAll()
  Full name: Scanner::insertedCatchAll()
  Source:    insertedcatchall.cc 
  Used By:
    moreinput.cc: Scanner::moreInput()
    secondsectiondelimiter.cc: Scanner::secondSectionDelimiter()

insertSstream(std::ostream&) const
  Full name: Generator::insertSstream(std::ostream&) const
  Source:    insertsstream.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

inspect(TypeVector::iterator)
  Full name: CharClass::inspect(TypeVector::iterator)
  Source:    inspect.cc 
  Used By:
    handleminusandescape.cc: CharClass::handleMinusAndEscape()

inspectRows(std::vector<unsigned long>&)
  Full name: DFA::inspectRows(std::vector<unsigned long>&)
  Source:    inspectrows.cc 
  Used By:
    keepuniquerows.cc: DFA::keepUniqueRows()

inspectState(State const&)
  Full name: Ranges::inspectState(State const&)
  Source:    inspectstate.cc 
  Used By:
    determinesubsets.cc: Ranges::determineSubsets()

instance()
  Full name: Options::instance()
  Source:    instance.cc 
  Used By:
    setcasesensitive.cc: Scanner::setCaseSensitive()
    parser1.cc: Parser::Parser(Rules&, States&)
    dfa1.cc: DFA::DFA(Ranges&, Rules&, States&)
    generator1.cc: Generator::Generator(Rules const&, Ranges const&, DFAs const&)

interactiveDecl(std::ostream&) const
  Full name: Generator::interactiveDecl(std::ostream&) const
  Source:    interactivedecl.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

interactiveInit(std::ostream&) const
  Full name: Generator::interactiveInit(std::ostream&) const
  Source:    interactiveinit.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

interactiveLex(std::ostream&) const
  Full name: Generator::interactiveLex(std::ostream&) const
  Source:    interactivelex.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

interval(Pattern&, Interval const&)
  Full name: Parser::interval(Pattern&, Interval const&)
  Source:    interval.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

interval(States&, Pattern&, Interval const&)
  Full name: Pattern::interval(States&, Pattern&, Interval const&)
  Source:    interval.cc 
  Used By:
    interval.cc: Parser::interval(Pattern&, Interval const&)

inversedRange(unsigned long) const
  Full name: CharClass::inversedRange(unsigned long) const
  Source:    inversedrange.cc 
  Used By:
    validrange.cc: CharClass::validRange(TagIter) const

isPredefined(unsigned long) const
  Full name: CharClass::isPredefined(unsigned long) const
  Source:    ispredefined.cc 
  Used By:
    predefinedafter.cc: CharClass::predefinedAfter(unsigned long) const
    predefinedbefore.cc: CharClass::predefinedBefore(unsigned long) const

join(States&, Pattern&, unsigned long, std::vector<std::pair<unsigned long, unsigned long>> const&)
  Full name: Pattern::join(States&, Pattern&, unsigned long, std::vector<std::pair<unsigned long, unsigned long>> const&)
  Source:    join.cc 
  Used By:
    optionalpatterns.cc: Pattern::optionalPatterns(States&, Pattern&, unsigned long, unsigned long, std::vector<std::pair<unsigned long, unsigned long>>&)
    optrepeatlastpattern.cc: Pattern::optRepeatLastPattern(States&, Pattern&, unsigned long, std::vector<std::pair<unsigned long, unsigned long>>&)

jumpToEnd(States&, std::vector<std::pair<unsigned long, unsigned long>>&, unsigned long, unsigned long, FBB::LinearMap<unsigned long, unsigned long>&)
  Full name: Pattern::jumpToEnd(States&, std::vector<std::pair<unsigned long, unsigned long>>&, unsigned long, unsigned long, FBB::LinearMap<unsigned long, unsigned long>&)
  Source:    jumptoend.cc 
  Used By:
    optionalpatterns.cc: Pattern::optionalPatterns(States&, Pattern&, unsigned long, unsigned long, std::vector<std::pair<unsigned long, unsigned long>>&)

keepUniqueRows()
  Full name: DFA::keepUniqueRows()
  Source:    keepuniquerows.cc 
  Used By:
    build.cc: DFA::build(std::string const&, std::vector<unsigned long> const&)

key(std::ostream&) const
  Full name: Generator::key(std::ostream&) const
  Source:    key.cc 
  Used By:
    actions.cc: Generator::actions(std::ostream&) const
    baseclassh.cc: Generator::baseClassH(std::ostream&) const
    baseincludes.cc: Generator::baseIncludes(std::ostream&) const
    casecheck.cc: Generator::caseCheck(std::ostream&) const
    classh.cc: Generator::classH(std::ostream&) const
    classhead.cc: Generator::classHead(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
    inlinelexfunction.cc: Generator::inlineLexFunction(std::ostream&) const
    inputdeclaration.cc: Generator::inputDeclaration(std::ostream&) const
    inputimplementation.cc: Generator::inputImplementation(std::ostream&) const
    inputinterface.cc: Generator::inputInterface(std::ostream&) const
    insertsstream.cc: Generator::insertSstream(std::ostream&) const
    interactivedecl.cc: Generator::interactiveDecl(std::ostream&) const
    interactiveinit.cc: Generator::interactiveInit(std::ostream&) const
    interactivelex.cc: Generator::interactiveLex(std::ostream&) const
    lexfunctiondecl.cc: Generator::lexFunctionDecl(std::ostream&) const
    lopimplementation.cc: Generator::lopImplementation(std::ostream&) const
    namespaceclose.cc: Generator::namespaceClose(std::ostream&) const
    namespaceopen.cc: Generator::namespaceOpen(std::ostream&) const
    namespaceuse.cc: Generator::namespaceUse(std::ostream&) const
    print.cc: Generator::print(std::ostream&) const
    scannerconstructors.cc: Generator::scannerConstructors(std::ostream&) const
    startconddecl.cc: Generator::startCondDecl(std::ostream&) const
    startcondenum.cc: Generator::startCondEnum(std::ostream&) const
    startcondimpl.cc: Generator::startCondImpl(std::ostream&) const
    startcondinfo.cc: Generator::startCondInfo(std::ostream&) const

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

lex_()
  Full name: Scanner::lex_()
  Source:    lex.cc 
  Used By:
    plex.cc: Scanner::pLex()
    block.cc: Parser::block()

lexFunctionDecl(std::ostream&) const
  Full name: Generator::lexFunctionDecl(std::ostream&) const
  Source:    lexfunctiondecl.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

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

lookahead(Pattern const&, Pattern const&)
  Full name: Parser::lookahead(Pattern const&, Pattern const&)
  Source:    lookahead.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

lop1(std::ostream&) const
  Full name: Generator::lop1(std::ostream&) const
  Source:    lop1.cc 
  Used By:
    lopimplementation.cc: Generator::lopImplementation(std::ostream&) const

lop2(std::ostream&) const
  Full name: Generator::lop2(std::ostream&) const
  Source:    lop2.cc 
  Used By:
    lopimplementation.cc: Generator::lopImplementation(std::ostream&) const

lop3(std::ostream&) const
  Full name: Generator::lop3(std::ostream&) const
  Source:    lop3.cc 
  Used By:
    lopimplementation.cc: Generator::lopImplementation(std::ostream&) const

lop4(std::ostream&) const
  Full name: Generator::lop4(std::ostream&) const
  Source:    lop4.cc 
  Used By:
    lopimplementation.cc: Generator::lopImplementation(std::ostream&) const

lopf(std::ostream&) const
  Full name: Generator::lopf(std::ostream&) const
  Source:    lopf.cc 
  Used By:
    lopimplementation.cc: Generator::lopImplementation(std::ostream&) const

lopImplementation(std::ostream&) const
  Full name: Generator::lopImplementation(std::ostream&) const
  Source:    lopimplementation.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

lowerBound(std::string const&)
  Full name: Interval::lowerBound(std::string const&)
  Source:    lowerbound.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

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

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

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

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

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

negate()
  Full name: CharClass::negate()
  Source:    negate1.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)
    negate2.cc: CharClass::negate(std::vector<std::string> const&)

negate(std::string const&)
  Full name: CharRange::negate(std::string const&)
  Source:    negate.cc 
  Used By:
    predefined.cc: CharRange::predefined(std::string const&)
    negate1.cc: CharClass::negate()

negate(std::vector<std::string> const&)
  Full name: CharClass::negate(std::vector<std::string> const&)
  Source:    negate2.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

newDefinition()
  Full name: Scanner::newDefinition()
  Source:    newdefinition.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

next()
  Full name: States::next()
  Source:    next.cc 
  Used By:
    copypattern2.cc: Pattern::copyPattern(States&, unsigned long, unsigned long, FBB::LinearMap<unsigned long, unsigned long>&, std::vector<std::pair<unsigned long, unsigned long>>&)
    duppattern.cc: Pattern::dupPattern(FBB::LinearMap<unsigned long, unsigned long>&, States&, unsigned long)
    questionmark.cc: Pattern::questionMark(States&, Pattern const&)
    next2.cc: States::next2()
    next3.cc: States::next(unsigned long)

next(unsigned long)
  Full name: States::next(unsigned long)
  Source:    next3.cc 
  Used By:
    rawtext.cc: Pattern::rawText(States&, std::string const&)

next1() const
  Full name: State::next1() const
  Source:    next1.cc 
  Used By:
    empty.cc: Pattern::empty(std::set<unsigned long>&, States const&, unsigned long)
    setstates.cc: Rule::setStates(std::vector<unsigned long>&, States const&, unsigned long, unsigned long)
    setrule.cc: Rules::setRule(unsigned long, unsigned long)
    operatorinsert.cc: operator<<(std::ostream&, State const&)
    eclosure.cc: States::eClosure(std::set<unsigned long>&) const
    transit.cc: DFARow::transit(unsigned long, unsigned long, std::set<unsigned long>&)

next2()
  Full name: States::next2()
  Source:    next2.cc 
  Used By:
    alternatives.cc: Pattern::alternatives(States&, Pattern const&, Pattern const&)
    characterclass.cc: Pattern::characterClass(States&, CharClass&)
    eof.cc: Pattern::eof(States&)
    escape.cc: Pattern::escape(States&, std::string const&)
    interval.cc: Pattern::interval(States&, Pattern&, Interval const&)
    plus.cc: Pattern::plus(States&, Pattern const&)
    rawtext.cc: Pattern::rawText(States&, std::string const&)
    star.cc: Pattern::star(States&, Pattern const&)

next2() const
  Full name: State::next2() const
  Source:    next2.cc 
  Used By:
    empty.cc: Pattern::empty(std::set<unsigned long>&, States const&, unsigned long)
    setstates.cc: Rule::setStates(std::vector<unsigned long>&, States const&, unsigned long, unsigned long)
    setrule.cc: Rules::setRule(unsigned long, unsigned long)
    operatorinsert.cc: operator<<(std::ostream&, State const&)
    eclosure.cc: States::eClosure(std::set<unsigned long>&) const
    transit.cc: DFARow::transit(unsigned long, unsigned long, std::set<unsigned long>&)

noAction()
  Full name: Rule::noAction()
  Source:    noaction.cc 
  Used By:
    noactions.cc: Rules::noActions()

noActions()
  Full name: Rules::noActions()
  Source:    noactions.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

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

operator()(char const*) const
  Full name: Options::operator()(char const*) const
  Source:    operatorfun2.cc 
  Used By:
    baseclassheader.cc: Generator::baseclassHeader() const

operator()(int) const
  Full name: Options::operator()(int) const
  Source:    operatorfun1.cc 
  Used By:
    parser1.cc: Parser::Parser(Rules&, States&)
    construction.cc: Generator::construction(States const&)
    debugdecl.cc: Generator::debugDecl(std::ostream&) const
    debugfunctions.cc: Generator::debugFunctions(std::ostream&) const
    debugtest.cc: Generator::debugTest() const

operator+=(std::string const&)
  Full name: Block::operator+=(std::string const&)
  Source:    operatorplusis.cc 
  Used By:
    handlefixedtailloprule.cc: Rules::handleFixedTailLopRule(Rule&)
    handleloprule.cc: Rules::handleLopRule(unsigned long)
    block.cc: Parser::block()

operator<<(FBB::Table&, DFARow const&)
  Full name: operator<<(FBB::Table&, DFARow const&)
  Source:    operatorinsert.cc 
  Used By:
    operatorinsert.cc: operator<<(std::ostream&, DFA const&)

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

operator<<(std::ostream&, DFAs const&)
  Full name: operator<<(std::ostream&, DFAs const&)
  Source:    operatorinsert.cc 
  Used By:
    construction.cc: Generator::construction(States const&)

operator<<(std::ostream&, Ranges const&)
  Full name: operator<<(std::ostream&, Ranges const&)
  Source:    operatorinsert.cc 
  Used By:
    construction.cc: Generator::construction(States const&)

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

operator<<(std::ostream&, Rules const&)
  Full name: operator<<(std::ostream&, Rules const&)
  Source:    operatorinsert.cc 
  Used By:
    construction.cc: Generator::construction(States const&)

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

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

operator<<(std::ostream&, States const&)
  Full name: operator<<(std::ostream&, States const&)
  Source:    operatorinsert.cc 
  Used By:
    construction.cc: Generator::construction(States const&)

operator=(std::pair<unsigned long, unsigned long> const&)
  Full name: Pattern::operator=(std::pair<unsigned long, unsigned long> const&)
  Source:    operatorassign.cc 
  Used By:
    rawtext.cc: Pattern::rawText(States&, std::string const&)

operator==(DFARow const&) const
  Full name: DFARow::operator==(DFARow const&) const
  Source:    operatorequal.cc 
  Used By:
    inspectrows.cc: DFA::inspectRows(std::vector<unsigned long>&)

optionalPatterns(States&, Pattern&, unsigned long, unsigned long, std::vector<std::pair<unsigned long, unsigned long>>&)
  Full name: Pattern::optionalPatterns(States&, Pattern&, unsigned long, unsigned long, std::vector<std::pair<unsigned long, unsigned long>>&)
  Source:    optionalpatterns.cc 
  Used By:
    copy.cc: Pattern::copy(States&, Pattern&, unsigned long, unsigned long)

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

optRepeatLastPattern(States&, Pattern&, unsigned long, std::vector<std::pair<unsigned long, unsigned long>>&)
  Full name: Pattern::optRepeatLastPattern(States&, Pattern&, unsigned long, std::vector<std::pair<unsigned long, unsigned long>>&)
  Source:    optrepeatlastpattern.cc 
  Used By:
    copy.cc: Pattern::copy(States&, Pattern&, unsigned long, unsigned long)

outChar(std::ostream&, unsigned long)
  Full name: Ranges::outChar(std::ostream&, unsigned long)
  Source:    outchar.cc 
  Used By:
    operatorinsert.cc: operator<<(std::ostream&, Ranges const&)

outDFAbase(std::string const&, unsigned long)
  Full name: Generator::outDFAbase(std::string const&, unsigned long)
  Source:    outdfabase.cc 
  Used By:
    dfabases.cc: Generator::DFAbases(std::ostream&) const

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

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

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

Pattern(States&, Pattern const&, Pattern const&, unsigned long)
  Full name: Pattern::Pattern(States&, Pattern const&, Pattern const&, unsigned long)
  Source:    pattern2.cc 
  Used By:
    lookahead.cc: Parser::lookahead(Pattern const&, Pattern const&)

Pattern(States&, unsigned long, Pattern const&, Pattern const&)
  Full name: Pattern::Pattern(States&, unsigned long, Pattern const&, Pattern const&)
  Source:    pattern3.cc 
  Used By:
    lookahead.cc: Parser::lookahead(Pattern const&, Pattern const&)

Pattern(std::pair<unsigned long, unsigned long> const&)
  Full name: Pattern::Pattern(std::pair<unsigned long, unsigned long> const&)
  Source:    pattern1.cc 
  Used By:
    alternatives.cc: Pattern::alternatives(States&, Pattern const&, Pattern const&)
    characterclass.cc: Pattern::characterClass(States&, CharClass&)
    concatenate.cc: Pattern::concatenate(States&, Pattern const&, Pattern const&)
    duplicate.cc: Pattern::duplicate(States&) const
    eof.cc: Pattern::eof(States&)
    escape.cc: Pattern::escape(States&, std::string const&)
    interval.cc: Pattern::interval(States&, Pattern&, Interval const&)
    join.cc: Pattern::join(States&, Pattern&, unsigned long, std::vector<std::pair<unsigned long, unsigned long>> const&)
    optionalpatterns.cc: Pattern::optionalPatterns(States&, Pattern&, unsigned long, unsigned long, std::vector<std::pair<unsigned long, unsigned long>>&)
    optrepeatlastpattern.cc: Pattern::optRepeatLastPattern(States&, Pattern&, unsigned long, std::vector<std::pair<unsigned long, unsigned long>>&)
    pattern3.cc: Pattern::Pattern(States&, unsigned long, Pattern const&, Pattern const&)
    plus.cc: Pattern::plus(States&, Pattern const&)
    quantifier.cc: Pattern::quantifier(States&, Pattern const&, unsigned long)
    questionmark.cc: Pattern::questionMark(States&, Pattern const&)
    rawtext.cc: Pattern::rawText(States&, std::string const&)
    star.cc: Pattern::star(States&, Pattern const&)
    handleloprule.cc: Rules::handleLopRule(unsigned long)
    rules1.cc: Rules::Rules(States&)
    lookahead.cc: Parser::lookahead(Pattern const&, Pattern const&)
    parse.cc: Parser::print_()

pLex()
  Full name: Scanner::pLex()
  Source:    plex.cc 
  Used By:
    lex.cc: Parser::lex()

plus(States&, Pattern const&)
  Full name: Pattern::plus(States&, Pattern const&)
  Source:    plus.cc 
  Used By:
    interval.cc: Pattern::interval(States&, Pattern&, Interval const&)
    optrepeatlastpattern.cc: Pattern::optRepeatLastPattern(States&, Pattern&, unsigned long, std::vector<std::pair<unsigned long, unsigned long>>&)
    quantifier.cc: Pattern::quantifier(States&, Pattern const&, unsigned long)

popSc(int)
  Full name: Scanner::popSc(int)
  Source:    popsc.cc 
  Used By:
    lex.cc: Scanner::executeAction_(unsigned long)

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

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

predefined(std::string const&)
  Full name: CharClass::predefined(std::string const&)
  Source:    predefined.cc 
  Used By:
    dot.cc: Pattern::dot(States&)
    parse.cc: Parser::executeAction_(int)

predefined(std::string const&)
  Full name: CharRange::predefined(std::string const&)
  Source:    predefined.cc 
  Used By:
    predefined.cc: CharClass::predefined(std::string const&)

predefinedAfter(unsigned long) const
  Full name: CharClass::predefinedAfter(unsigned long) const
  Source:    predefinedafter.cc 
  Used By:
    validrange.cc: CharClass::validRange(TagIter) const

predefinedBefore(unsigned long) const
  Full name: CharClass::predefinedBefore(unsigned long) const
  Source:    predefinedbefore.cc 
  Used By:
    validrange.cc: CharClass::validRange(TagIter) const

print()
  Full name: Parser::print()
  Source:    print.cc 
  Used By:
    lex.cc: Parser::lex()
    parse.cc: Parser::nextToken_()

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

processCatchAllRule()
  Full name: Rules::processCatchAllRule()
  Source:    processcatchallrule.cc 
  Used By:
    addlopstartconditions.cc: Parser::addLopStartConditions()

push(ScannerBase::StartCondition_)
  Full name: Scanner::push(ScannerBase::StartCondition_)
  Source:    push.cc 
  Used By:
    handledquote.cc: Scanner::handleDquote()
    handlerawstring.cc: Scanner::handleRawString()
    handlestdcomment.cc: Scanner::handleStdComment()
    newdefinition.cc: Scanner::newDefinition()
    scanner1.cc: Scanner::Scanner(std::string const&)
    parse.cc: Parser::executeAction_(int)

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

pushStream(std::string const&)
  Full name: ScannerBase::pushStream(std::string const&)
  Source:    lex.cc 
  Used By:
    maybeswitchstream.cc: Scanner::maybeSwitchStream()

quantifier(States&, Pattern const&, unsigned long)
  Full name: Pattern::quantifier(States&, Pattern const&, unsigned long)
  Source:    quantifier.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

questionMark(States&, Pattern const&)
  Full name: Pattern::questionMark(States&, Pattern const&)
  Source:    questionmark.cc 
  Used By:
    interval.cc: Pattern::interval(States&, Pattern&, Interval const&)
    quantifier.cc: Pattern::quantifier(States&, Pattern const&, unsigned long)

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

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

rangeAfterRange(TagIter) const
  Full name: CharClass::rangeAfterRange(TagIter) const
  Source:    rangeafterrange.cc 
  Used By:
    validrange.cc: CharClass::validRange(TagIter) const

Ranges(Ranges const&)
  Full name: Ranges::Ranges(Ranges const&)
  Source:    ranges2.cc 
  Used By:
    operatorassign.cc: Ranges::operator=(Ranges const&)

Ranges(Ranges&&)
  Full name: Ranges::Ranges(Ranges&&)
  Source:    ranges3.cc 
  Used By:
    operatorassign2.cc: Ranges::operator=(Ranges&&)

Ranges(States&, unsigned long)
  Full name: Ranges::Ranges(States&, unsigned long)
  Source:    ranges1.cc 
  Used By:
    main.cc: main

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

rangeString(unsigned long) const
  Full name: CharClass::rangeString(unsigned long) const
  Source:    rangestring.cc 
  Used By:
    inversedrange.cc: CharClass::inversedRange(unsigned long) const
    rangeafterrange.cc: CharClass::rangeAfterRange(TagIter) const

rawString()
  Full name: Parser::rawString()
  Source:    rawstring.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

rawStringContents() const
  Full name: Scanner::rawStringContents() const
  Source:    rawstringcontents.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)
    rawstring.cc: Parser::rawString()

rawText(States&, std::string const&)
  Full name: Pattern::rawText(States&, std::string const&)
  Source:    rawtext.cc 
  Used By:
    boln.cc: Parser::boln()
    dollar.cc: Parser::dollar()
    eolndollar.cc: Parser::eolnDollar()
    parse.cc: Parser::print_()
    quotes.cc: Parser::quotes()

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

remove(unsigned long)
  Full name: StartConditions::remove(unsigned long)
  Source:    remove.cc 
  Used By:
    processcatchallrule.cc: Rules::processCatchAllRule()

removeRules(DFA const&, std::set<unsigned long>&) const
  Full name: DFAs::removeRules(DFA const&, std::set<unsigned long>&) const
  Source:    removerules.cc 
  Used By:
    warnnonviable.cc: DFAs::warnNonViable() const

replace(std::string, TypeVector::iterator, unsigned long)
  Full name: CharClass::replace(std::string, TypeVector::iterator, unsigned long)
  Source:    replace.cc 
  Used By:
    inspect.cc: CharClass::inspect(TypeVector::iterator)

reRead(std::string const&, unsigned long)
  Full name: ScannerBase::Input::reRead(std::string const&, unsigned long)
  Source:    lex.cc 
  Used By:
    insertedcatchall.cc: Scanner::insertedCatchAll()
    pushnameexpansion.cc: Scanner::pushNameExpansion()
    eolndollar.cc: Parser::eolnDollar()

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

Rule(States&, bool, Pattern const&, Block const&, FlexTypes::RuleType)
  Full name: Rule::Rule(States&, bool, Pattern const&, Block const&, FlexTypes::RuleType)
  Source:    rule1.cc 
  Used By:
    add.cc: Rules::add(bool, Pattern const&, Block const&, FlexTypes::RuleType)

ruleAction(Block const&, std::ostream&, unsigned long) const
  Full name: Generator::ruleAction(Block const&, std::ostream&, unsigned long) const
  Source:    ruleaction.cc 
  Used By:
    actions.cc: Generator::actions(std::ostream&) const

ruleFromFinalState(unsigned long) const
  Full name: Rules::ruleFromFinalState(unsigned long) const
  Source:    rulefromfinalstate.cc 
  Used By:
    transit.cc: DFARow::transit(unsigned long, unsigned long, std::set<unsigned long>&)

Rules(States&)
  Full name: Rules::Rules(States&)
  Source:    rules1.cc 
  Used By:
    main.cc: main

s_all
  Full name: CharRange::s_all
  Source:    data.cc 
  Used By:
    negate.cc: CharRange::negate(std::string const&)

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

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

s_defaultClassName
  Full name: Options::s_defaultClassName
  Source:    data.cc 
  Used By:
    setaccessorvariables.cc: Options::setAccessorVariables()

s_defaultLexFunctionName
  Full name: Options::s_defaultLexFunctionName
  Source:    data.cc 
  Used By:
    setaccessorvariables.cc: Options::setAccessorVariables()

s_defaultSkeletonDirectory
  Full name: Options::s_defaultSkeletonDirectory
  Source:    data.cc 
  Used By:
    setaccessorvariables.cc: Options::setAccessorVariables()

s_defaultStartConditionName
  Full name: Options::s_defaultStartConditionName
  Source:    data.cc 
  Used By:
    setaccessorvariables.cc: Options::setAccessorVariables()

s_dfaBase_
  Full name: ScannerBase::s_dfaBase_
  Source:    lex.cc 
  Used By:
    popsc.cc: Scanner::popSc(int)
    push.cc: Scanner::push(ScannerBase::StartCondition_)
    switchtoinitial.cc: Scanner::switchToINITIAL()

s_funHash
  Full name: CharRange::s_funHash
  Source:    data.cc 
  Used By:
    predefined.cc: CharRange::predefined(std::string const&)

s_hash
  Full name: CharRange::s_hash
  Source:    data.cc 
  Used By:
    predefined.cc: CharRange::predefined(std::string const&)

s_ignoreToken
  Full name: Parser::s_ignoreToken
  Source:    data.cc 
  Used By:
    parser1.cc: Parser::Parser(Rules&, States&)
    print.cc: Parser::print()

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

s_lastMsg
  Full name: Parser::s_lastMsg
  Source:    data.cc 
  Used By:
    error.cc: Parser::error()
    reset.cc: Parser::reset()

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

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

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

s_out_
  Full name: ParserBase::s_out_
  Source:    parse.cc 
  Used By:
    lookahead.cc: GLOBALS lookahead.cc 2lookahead.o
    quotes.cc: Parser::quotes()

s_regexCall
  Full name: Options::s_regexCall
  Source:    data.cc 
  Used By:
    options1.cc: Options::Options()
    alternatives.cc: Pattern::alternatives(States&, Pattern const&, Pattern const&)
    concatenate.cc: Pattern::concatenate(States&, Pattern const&, Pattern const&)
    quantifier.cc: Pattern::quantifier(States&, Pattern const&, unsigned long)
    interval.cc: Parser::interval(Pattern&, Interval const&)
    lookahead.cc: Parser::lookahead(Pattern const&, Pattern const&)
    parse.cc: Parser::executeAction_(int)

s_verbose
  Full name: DFA::s_verbose
  Source:    data.cc 
  Used By:
    build.cc: DFA::build(std::string const&, std::vector<unsigned long> const&)
    dfa1.cc: DFA::DFA(Ranges&, Rules&, States&)
    keepuniquerows.cc: DFA::keepUniqueRows()
    setverbose.cc: DFA::setVerbose(bool)
    shrinkdfa.cc: DFA::shrinkDFA(std::vector<unsigned long>&)

s_warnOptions
  Full name: Options::s_warnOptions
  Source:    data.cc 
  Used By:
    assign.cc: Options::assign(FlexTypes::TextType, std::string*, Options::PathType, char const*)
    setaccessorvariables.cc: Options::setAccessorVariables()
    setclassname.cc: Options::setClassName(FlexTypes::TextType)
    setoptionpath.cc: Options::setOptionPath(std::string*, int, std::string const&, char const*, char const*)
    setstartconditionname.cc: Options::setStartConditionName(FlexTypes::TextType)
    errexisting.cc: Generator::errExisting(std::string const&, std::string const&, std::string const&) const

sameTransits(FBB::LinearMap<unsigned long, unsigned long> const&, FBB::LinearMap<unsigned long, unsigned long> const&)
  Full name: DFARow::sameTransits(FBB::LinearMap<unsigned long, unsigned long> const&, FBB::LinearMap<unsigned long, unsigned long> const&)
  Source:    sametransits.cc 
  Used By:
    operatorequal.cc: DFARow::operator==(DFARow const&) const

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

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

scannerConstructors(std::ostream&) const
  Full name: Generator::scannerConstructors(std::ostream&) const
  Source:    scannerconstructors.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

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

set()
  Full name: CharClass::set()
  Source:    set.cc 
  Used By:
    difference.cc: CharClass::difference(CharClass&, CharClass&)
    str.cc: CharClass::str()
    unite.cc: CharClass::unite(CharClass&, CharClass&)

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

setCaseSensitive()
  Full name: Scanner::setCaseSensitive()
  Source:    setcasesensitive.cc 
  Used By:
    reset.cc: Parser::reset()

setClassName(FlexTypes::TextType)
  Full name: Options::setClassName(FlexTypes::TextType)
  Source:    setclassname.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&, States&)

setFilenames(FlexTypes::TextType)
  Full name: Options::setFilenames(FlexTypes::TextType)
  Source:    setfilenames.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

setFinal(unsigned long)
  Full name: DFARow::setFinal(unsigned long)
  Source:    setfinal.cc 
  Used By:
    transit.cc: DFARow::transit(unsigned long, unsigned long, std::set<unsigned long>&)

setLexFunctionName(FlexTypes::TextType)
  Full name: Options::setLexFunctionName(FlexTypes::TextType)
  Source:    setlexfunctionname.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

setLineTags(std::string const&) const
  Full name: Scanner::setLineTags(std::string const&) const
  Source:    setlinetags.cc 
  Used By:
    maybeswitchstream.cc: Scanner::maybeSwitchStream()
    popstream.cc: Scanner::popStream()
    scanner1.cc: Scanner::Scanner(std::string const&)

setLopBlocks()
  Full name: Rules::setLopBlocks()
  Source:    setlopblocks.cc 
  Used By:
    handleloprules.cc: Rules::handleLopRules()

setNameSpaceIdentifier()
  Full name: Options::setNameSpaceIdentifier()
  Source:    setnamespaceidentifier.cc 
  Used By:
    setaccessorvariables.cc: Options::setAccessorVariables()

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

setParserInfo(std::string const&, std::string const&)
  Full name: Options::setParserInfo(std::string const&, std::string const&)
  Source:    setparserinfo.cc 
  Used By:
    parser1.cc: Parser::Parser(Rules&, States&)

setPathStrings()
  Full name: Options::setPathStrings()
  Source:    setpathstrings.cc 
  Used By:
    cleanup.cc: Parser::cleanup()

setRule(unsigned long, unsigned long)
  Full name: Rules::setRule(unsigned long, unsigned long)
  Source:    setrule.cc 
  Used By:
    add.cc: Rules::add(bool, Pattern const&, Block const&, FlexTypes::RuleType)

setStartConditionName(FlexTypes::TextType)
  Full name: Options::setStartConditionName(FlexTypes::TextType)
  Source:    setstartconditionname.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

setVerbose(bool)
  Full name: DFA::setVerbose(bool)
  Source:    setverbose.cc 
  Used By:
    main.cc: main

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

shrinkDFA(std::vector<unsigned long>&)
  Full name: DFA::shrinkDFA(std::vector<unsigned long>&)
  Source:    shrinkdfa.cc 
  Used By:
    keepuniquerows.cc: DFA::keepUniqueRows()

star(States&, Pattern const&)
  Full name: Pattern::star(States&, Pattern const&)
  Source:    star.cc 
  Used By:
    interval.cc: Pattern::interval(States&, Pattern&, Interval const&)
    quantifier.cc: Pattern::quantifier(States&, Pattern const&, unsigned long)

startCondDecl(std::ostream&) const
  Full name: Generator::startCondDecl(std::ostream&) const
  Source:    startconddecl.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

startCondEnum(std::ostream&) const
  Full name: Generator::startCondEnum(std::ostream&) const
  Source:    startcondenum.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

startCondImpl(std::ostream&) const
  Full name: Generator::startCondImpl(std::ostream&) const
  Source:    startcondimpl.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

startCondInfo(std::ostream&) const
  Full name: Generator::startCondInfo(std::ostream&) const
  Source:    startcondinfo.cc 
  Used By:
    data.cc: GLOBALS data.cc 9data.o

StartConditions()
  Full name: StartConditions::StartConditions()
  Source:    startconditions1.cc 
  Used By:
    rules1.cc: Rules::Rules(States&)

State()
  Full name: State::State()
  Source:    state1.cc 
  Used By:
    next.cc: GLOBALS next.cc 18next.o
    states1.cc: States::States()

State(unsigned char, unsigned long)
  Full name: State::State(unsigned char, unsigned long)
  Source:    state6.cc 
  Used By:
    escape.cc: Pattern::escape(States&, std::string const&)
    rawtext.cc: Pattern::rawText(States&, std::string const&)

State(unsigned long, StateData*)
  Full name: State::State(unsigned long, StateData*)
  Source:    state3.cc 
  Used By:
    state4.cc: State::State(unsigned long, unsigned long, unsigned long)
    state5.cc: State::State(unsigned long, std::string const&, unsigned long, unsigned long)
    state6.cc: State::State(unsigned char, unsigned long)

State(unsigned long, std::string const&, unsigned long, unsigned long)
  Full name: State::State(unsigned long, std::string const&, unsigned long, unsigned long)
  Source:    state5.cc 
  Used By:
    characterclass.cc: Pattern::characterClass(States&, CharClass&)

State(unsigned long, unsigned long, unsigned long)
  Full name: State::State(unsigned long, unsigned long, unsigned long)
  Source:    state4.cc 
  Used By:
    alternatives.cc: Pattern::alternatives(States&, Pattern const&, Pattern const&)
    eof.cc: Pattern::eof(States&)
    interval.cc: Pattern::interval(States&, Pattern&, Interval const&)
    jumptoend.cc: Pattern::jumpToEnd(States&, std::vector<std::pair<unsigned long, unsigned long>>&, unsigned long, unsigned long, FBB::LinearMap<unsigned long, unsigned long>&)
    plus.cc: Pattern::plus(States&, Pattern const&)
    questionmark.cc: Pattern::questionMark(States&, Pattern const&)
    rawtext.cc: Pattern::rawText(States&, std::string const&)
    star.cc: Pattern::star(States&, Pattern const&)
    next2.cc: States::next2()
    next3.cc: States::next(unsigned long)

StateData(unsigned long, unsigned long)
  Full name: StateData::StateData(unsigned long, unsigned long)
  Source:    statedata1.cc 
  Used By:
    state4.cc: State::State(unsigned long, unsigned long, unsigned long)
    state6.cc: State::State(unsigned char, unsigned long)
    vclone.cc: StateData::v_clone() const
    statestring1.cc: StateString::StateString(std::string const&, unsigned long, unsigned long)

States()
  Full name: States::States()
  Source:    states1.cc 
  Used By:
    main.cc: main

StateString(std::string const&, unsigned long, unsigned long)
  Full name: StateString::StateString(std::string const&, unsigned long, unsigned long)
  Source:    statestring1.cc 
  Used By:
    state5.cc: State::State(unsigned long, std::string const&, unsigned long, unsigned long)
    vclone.cc: StateString::v_clone() const

str()
  Full name: CharClass::str()
  Source:    str.cc 
  Used By:
    characterclass.cc: Pattern::characterClass(States&, CharClass&)
    negate1.cc: CharClass::negate()

subsetCount()
  Full name: Ranges::subsetCount()
  Source:    subsetcount.cc 
  Used By:
    update.cc: Ranges::update(std::string const&, unsigned long const*)

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

symbol_(int) const
  Full name: ParserBase::symbol_(int) const
  Source:    parse.cc 
  Used By:
    print.cc: Parser::print()

tabulate(FBB::Table&) const
  Full name: DFARow::tabulate(FBB::Table&) const
  Source:    tabulate.cc 
  Used By:
    operatorinsert.cc: operator<<(FBB::Table&, DFARow const&)

tabulateFinals(FBB::Table&) const
  Full name: DFARow::tabulateFinals(FBB::Table&) const
  Source:    tabulatefinals.cc 
  Used By:
    tabulate.cc: DFARow::tabulate(FBB::Table&) const

tabulateTransitions(FBB::Table&) const
  Full name: DFARow::tabulateTransitions(FBB::Table&) const
  Source:    tabulatetransitions.cc 
  Used By:
    tabulate.cc: DFARow::tabulate(FBB::Table&) const

tagMinuses(unsigned long, std::string const&, unsigned long)
  Full name: CharClass::tagMinuses(unsigned long, std::string const&, unsigned long)
  Source:    tagminuses.cc 
  Used By:
    inspect.cc: CharClass::inspect(TypeVector::iterator)

textOf(FlexTypes::TextType)
  Full name: Options::textOf(FlexTypes::TextType)
  Source:    textof.cc 
  Used By:
    assign.cc: Options::assign(FlexTypes::TextType, std::string*, Options::PathType, char const*)
    setclassname.cc: Options::setClassName(FlexTypes::TextType)
    setfilenames.cc: Options::setFilenames(FlexTypes::TextType)
    setlexfunctionname.cc: Options::setLexFunctionName(FlexTypes::TextType)
    setstartconditionname.cc: Options::setStartConditionName(FlexTypes::TextType)

transit(unsigned long, unsigned long, std::set<unsigned long>&)
  Full name: DFARow::transit(unsigned long, unsigned long, std::set<unsigned long>&)
  Source:    transit.cc 
  Used By:
    transitions.cc: DFARow::transitions()

transitions()
  Full name: DFARow::transitions()
  Source:    transitions.cc 
  Used By:
    build.cc: DFA::build(std::string const&, std::vector<unsigned long> const&)

uniqueMap(std::vector<unsigned long> const&)
  Full name: DFARow::uniqueMap(std::vector<unsigned long> const&)
  Source:    uniquemap.cc 
  Used By:
    keepuniquerows.cc: DFA::keepUniqueRows()

unite(CharClass&, CharClass&)
  Full name: CharClass::unite(CharClass&, CharClass&)
  Source:    unite.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

update(std::string const&, unsigned long const*)
  Full name: Ranges::update(std::string const&, unsigned long const*)
  Source:    update.cc 
  Used By:
    add.cc: Ranges::add(std::string const&)

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

useAll()
  Full name: StartConditions::useAll()
  Source:    useall.cc 
  Used By:
    parse.cc: Parser::executeAction_(int)

v_clone() const
  Full name: StateData::v_clone() const
  Source:    vclone.cc 
  Used By:
    destructor.cc: StateData::~StateData()

v_clone() const
  Full name: StateString::v_clone() const
  Source:    vclone.cc 
  Used By:
    add.cc: Ranges::add(std::string const&)
    add3.cc: Ranges::add(unsigned long)
    charsettoranges.cc: Ranges::charsetToRanges(StateData&, unsigned long*)
    chcollision.cc: Ranges::chCollision(unsigned char, unsigned char&, unsigned long const*)
    collision.cc: Ranges::collision(std::string const&, unsigned long const*)
    countranges.cc: Ranges::countRanges(unsigned long&, std::vector<unsigned long>&)
    destructor.cc: Ranges::~Ranges()
    determinesubsets.cc: Ranges::determineSubsets()
    finalizestate.cc: Ranges::finalizeState(State&)
    finalizestates.cc: Ranges::finalizeStates()
    inspectstate.cc: Ranges::inspectState(State const&)
    operatorassign.cc: Ranges::operator=(Ranges const&)
    operatorassign2.cc: Ranges::operator=(Ranges&&)
    operatorinsert.cc: operator<<(std::ostream&, Ranges const&)
    outchar.cc: Ranges::outChar(std::ostream&, unsigned long)
    ranges1.cc: Ranges::Ranges(States&, unsigned long)
    ranges2.cc: Ranges::Ranges(Ranges const&)
    ranges3.cc: Ranges::Ranges(Ranges&&)
    reassign.cc: Ranges::reassign(unsigned long&, std::vector<unsigned long>&)
    subsetcount.cc: Ranges::subsetCount()
    update.cc: Ranges::update(std::string const&, unsigned long const*)
    contains.cc: State::contains(unsigned long) const
    dup.cc: State::dup(State const&, unsigned long, unsigned long)
    next1.cc: State::next1() const
    next2.cc: State::next2() const
    operatorinsert.cc: operator<<(std::ostream&, State const&)
    state1.cc: State::State()
    state2.cc: State::State(unsigned long)
    state3.cc: State::State(unsigned long, StateData*)
    state4.cc: State::State(unsigned long, unsigned long, unsigned long)
    state5.cc: State::State(unsigned long, std::string const&, unsigned long, unsigned long)
    state6.cc: State::State(unsigned char, unsigned long)
    statestring1.cc: StateString::StateString(std::string const&, unsigned long, unsigned long)

validRange(TagIter) const
  Full name: CharClass::validRange(TagIter) const
  Source:    validrange.cc 
  Used By:
    set.cc: CharClass::set()

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&) const

warnNonViable() const
  Full name: DFAs::warnNonViable() const
  Source:    warnnonviable.cc 
  Used By:
    main.cc: main

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

~DFAs()
  Full name: DFAs::~DFAs()
  Source:    destructor.cc 
  Used By:
    main.cc: main

~Ranges()
  Full name: Ranges::~Ranges()
  Source:    destructor.cc 
  Used By:
    main.cc: main
    operatorassign.cc: Ranges::operator=(Ranges const&)
    operatorassign2.cc: Ranges::operator=(Ranges&&)

~StateData()
  Full name: StateData::~StateData()
  Source:    destructor.cc 
  Used By:
    add.cc: GLOBALS add.cc 13add.o
    add3.cc: GLOBALS add3.cc 13add3.o
    charsettoranges.cc: GLOBALS charsettoranges.cc 13charsettoranges.o
    chcollision.cc: GLOBALS chcollision.cc 13chcollision.o
    collision.cc: GLOBALS collision.cc 13collision.o
    countranges.cc: GLOBALS countranges.cc 13countranges.o
    destructor.cc: GLOBALS destructor.cc 13destructor.o
    determinesubsets.cc: GLOBALS determinesubsets.cc 13determinesubsets.o
    finalizestate.cc: GLOBALS finalizestate.cc 13finalizestate.o
    finalizestates.cc: GLOBALS finalizestates.cc 13finalizestates.o
    inspectstate.cc: GLOBALS inspectstate.cc 13inspectstate.o
    operatorassign.cc: GLOBALS operatorassign.cc 13operatorassign.o
    operatorassign2.cc: GLOBALS operatorassign2.cc 13operatorassign2.o
    operatorinsert.cc: GLOBALS operatorinsert.cc 13operatorinsert.o
    outchar.cc: GLOBALS outchar.cc 13outchar.o
    ranges1.cc: GLOBALS ranges1.cc 13ranges1.o
    ranges2.cc: GLOBALS ranges2.cc 13ranges2.o
    ranges3.cc: GLOBALS ranges3.cc 13ranges3.o
    reassign.cc: GLOBALS reassign.cc 13reassign.o
    subsetcount.cc: GLOBALS subsetcount.cc 13subsetcount.o
    update.cc: GLOBALS update.cc 13update.o
    contains.cc: GLOBALS contains.cc 17contains.o
    dup.cc: GLOBALS dup.cc 17dup.o
    next1.cc: GLOBALS next1.cc 17next1.o
    next2.cc: GLOBALS next2.cc 17next2.o
    operatorinsert.cc: GLOBALS operatorinsert.cc 17operatorinsert.o
    state1.cc: GLOBALS state1.cc 17state1.o
    state2.cc: GLOBALS state2.cc 17state2.o
    state3.cc: GLOBALS state3.cc 17state3.o
    state4.cc: GLOBALS state4.cc 17state4.o
    state5.cc: GLOBALS state5.cc 17state5.o
    state6.cc: GLOBALS state6.cc 17state6.o
    statestring1.cc: GLOBALS statestring1.cc 20statestring1.o
    vclone.cc: StateString::v_clone() const


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

main
+-usage(std::string const&)
| +-version
| +-year
+-version
+-DFA::setVerbose(bool)
| +-DFA::s_verbose
+-States::States()
| +-State::State()
|   +-StateString::v_clone() const
|     +-StateData::~StateData()
|     | +-StateData::v_clone() const
|     |   +-StateData::StateData(unsigned long, unsigned long)
|     +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|       +-StateString::v_clone() const ==> 3
|       +-StateData::StateData(unsigned long, unsigned long)
+-Rules::Rules(States&)
| +-Pattern::Pattern(std::pair<unsigned long, unsigned long> const&)
| +-StartConditions::StartConditions()
+-Parser::Parser(Rules&, States&)
| +-Options::instance()
| | +-Options::s_options
| | +-Options::Options()
| |   +-Options::s_regexCall
| +-Options::operator()(int) const
| +-Options::setParserInfo(std::string const&, std::string const&)
| +-Scanner::Scanner(std::string const&)
| | +-Scanner::push(ScannerBase::StartCondition_)
| | | +-ScannerBase::s_dfaBase_
| | +-ScannerBase::ScannerBase(std::string const&, std::string const&, bool)
| | +-Scanner::setLineTags(std::string const&) const
| +-Parser::s_ignoreToken
| +-ParserBase::ParserBase()
| +-ParserBase::setDebug(bool)
+-Parser::parse()
+-Parser::addLopStartConditions()
| +-Rules::processCatchAllRule()
| | +-StartConditions::remove(unsigned long)
| +-StartConditions::define(std::string const&)
+-Parser::cleanup()
| +-Options::setAccessorVariables()
| | +-Options::s_warnOptions
| | +-Options::s_defaultStartConditionName
| | +-Options::s_defaultClassName
| | +-Options::s_defaultLexFunctionName
| | +-Options::s_defaultSkeletonDirectory
| | +-Options::setNameSpaceIdentifier()
| +-Options::setPathStrings()
| | +-Options::setOptionPath(std::string*, int, std::string const&, char const*, char const*)
| |   +-Options::s_warnOptions
| +-Options::showFilenames() const
+-Rules::handleLopRules()
| +-Rules::add(bool, Pattern const&, Block const&, FlexTypes::RuleType)
| | +-Rule::Rule(States&, bool, Pattern const&, Block const&, FlexTypes::RuleType)
| | +-Rules::setRule(unsigned long, unsigned long)
| | | +-State::next1() const
| | | | +-StateString::v_clone() const
| | | |   +-StateData::~StateData()
| | | |   | +-StateData::v_clone() const
| | | |   |   +-StateData::StateData(unsigned long, unsigned long)
| | | |   +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| | | |     +-StateString::v_clone() const ==> 5
| | | |     +-StateData::StateData(unsigned long, unsigned long)
| | | +-State::next2() const
| | |   +-StateString::v_clone() const
| | |     +-StateData::~StateData()
| | |     | +-StateData::v_clone() const
| | |     |   +-StateData::StateData(unsigned long, unsigned long)
| | |     +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| | |       +-StateString::v_clone() const ==> 5
| | |       +-StateData::StateData(unsigned long, unsigned long)
| | +-StartConditions::add(unsigned long)
| +-Rules::addCatchAll(unsigned long, unsigned long)
| | +-StartConditions::add(unsigned long)
| | +-StartConditions::activate(unsigned long)
| +-Rules::handleFixedTailLopRule(Rule&)
| | +-Block::operator+=(std::string const&)
| +-Rules::handleLopRule(unsigned long)
| | +-Pattern::Pattern(std::pair<unsigned long, unsigned long> const&)
| | +-Block::clear()
| | +-Rules::add(bool, Pattern const&, Block const&, FlexTypes::RuleType)
| | | +-Rule::Rule(States&, bool, Pattern const&, Block const&, FlexTypes::RuleType)
| | | +-Rules::setRule(unsigned long, unsigned long)
| | | | +-State::next1() const
| | | | | +-StateString::v_clone() const
| | | | |   +-StateData::~StateData()
| | | | |   | +-StateData::v_clone() const
| | | | |   |   +-StateData::StateData(unsigned long, unsigned long)
| | | | |   +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| | | | |     +-StateString::v_clone() const ==> 6
| | | | |     +-StateData::StateData(unsigned long, unsigned long)
| | | | +-State::next2() const
| | | |   +-StateString::v_clone() const
| | | |     +-StateData::~StateData()
| | | |     | +-StateData::v_clone() const
| | | |     |   +-StateData::StateData(unsigned long, unsigned long)
| | | |     +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| | | |       +-StateString::v_clone() const ==> 6
| | | |       +-StateData::StateData(unsigned long, unsigned long)
| | | +-StartConditions::add(unsigned long)
| | +-StartConditions::activate(unsigned long)
| | +-Block::operator+=(std::string const&)
| +-Rules::setLopBlocks()
+-Ranges::Ranges(States&, unsigned long)
| +-StateString::v_clone() const
|   +-StateData::~StateData()
|   | +-StateData::v_clone() const
|   |   +-StateData::StateData(unsigned long, unsigned long)
|   +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|     +-StateString::v_clone() const ==> 2
|     +-StateData::StateData(unsigned long, unsigned long)
+-Ranges::determineSubsets()
| +-StateString::v_clone() const
| | +-StateData::~StateData()
| | | +-StateData::v_clone() const
| | |   +-StateData::StateData(unsigned long, unsigned long)
| | +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| |   +-StateString::v_clone() const ==> 2
| |   +-StateData::StateData(unsigned long, unsigned long)
| +-Ranges::inspectState(State const&)
|   +-Ranges::add(std::string const&)
|   | +-Ranges::update(std::string const&, unsigned long const*)
|   | | +-StateString::v_clone() const
|   | | | +-StateData::~StateData()
|   | | | | +-StateData::v_clone() const
|   | | | |   +-StateData::StateData(unsigned long, unsigned long)
|   | | | +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|   | | |   +-StateString::v_clone() const ==> 5
|   | | |   +-StateData::StateData(unsigned long, unsigned long)
|   | | +-Ranges::collision(std::string const&, unsigned long const*)
|   | | | +-StateString::v_clone() const
|   | | | | +-StateData::~StateData()
|   | | | | | +-StateData::v_clone() const
|   | | | | |   +-StateData::StateData(unsigned long, unsigned long)
|   | | | | +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|   | | | |   +-StateString::v_clone() const ==> 6
|   | | | |   +-StateData::StateData(unsigned long, unsigned long)
|   | | | +-Ranges::chCollision(unsigned char, unsigned char&, unsigned long const*)
|   | | |   +-StateString::v_clone() const
|   | | |     +-StateData::~StateData()
|   | | |     | +-StateData::v_clone() const
|   | | |     |   +-StateData::StateData(unsigned long, unsigned long)
|   | | |     +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|   | | |       +-StateString::v_clone() const ==> 7
|   | | |       +-StateData::StateData(unsigned long, unsigned long)
|   | | +-Ranges::countRanges(unsigned long&, std::vector<unsigned long>&)
|   | | | +-StateString::v_clone() const
|   | | |   +-StateData::~StateData()
|   | | |   | +-StateData::v_clone() const
|   | | |   |   +-StateData::StateData(unsigned long, unsigned long)
|   | | |   +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|   | | |     +-StateString::v_clone() const ==> 6
|   | | |     +-StateData::StateData(unsigned long, unsigned long)
|   | | +-Ranges::subsetCount()
|   | |   +-StateString::v_clone() const
|   | |     +-StateData::~StateData()
|   | |     | +-StateData::v_clone() const
|   | |     |   +-StateData::StateData(unsigned long, unsigned long)
|   | |     +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|   | |       +-StateString::v_clone() const ==> 6
|   | |       +-StateData::StateData(unsigned long, unsigned long)
|   | +-StateString::v_clone() const
|   |   +-StateData::~StateData()
|   |   | +-StateData::v_clone() const
|   |   |   +-StateData::StateData(unsigned long, unsigned long)
|   |   +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|   |     +-StateString::v_clone() const ==> 4
|   |     +-StateData::StateData(unsigned long, unsigned long)
|   +-StateString::v_clone() const
|   | +-StateData::~StateData()
|   | | +-StateData::v_clone() const
|   | |   +-StateData::StateData(unsigned long, unsigned long)
|   | +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|   |   +-StateString::v_clone() const ==> 3
|   |   +-StateData::StateData(unsigned long, unsigned long)
|   +-Ranges::add(unsigned long)
|     +-Ranges::add(std::string const&)
|     | +-Ranges::update(std::string const&, unsigned long const*)
|     | | +-StateString::v_clone() const
|     | | | +-StateData::~StateData()
|     | | | | +-StateData::v_clone() const
|     | | | |   +-StateData::StateData(unsigned long, unsigned long)
|     | | | +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|     | | |   +-StateString::v_clone() const ==> 6
|     | | |   +-StateData::StateData(unsigned long, unsigned long)
|     | | +-Ranges::collision(std::string const&, unsigned long const*)
|     | | | +-StateString::v_clone() const
|     | | | | +-StateData::~StateData()
|     | | | | | +-StateData::v_clone() const
|     | | | | |   +-StateData::StateData(unsigned long, unsigned long)
|     | | | | +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|     | | | |   +-StateString::v_clone() const ==> 7
|     | | | |   +-StateData::StateData(unsigned long, unsigned long)
|     | | | +-Ranges::chCollision(unsigned char, unsigned char&, unsigned long const*)
|     | | |   +-StateString::v_clone() const
|     | | |     +-StateData::~StateData()
|     | | |     | +-StateData::v_clone() const
|     | | |     |   +-StateData::StateData(unsigned long, unsigned long)
|     | | |     +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|     | | |       +-StateString::v_clone() const ==> 8
|     | | |       +-StateData::StateData(unsigned long, unsigned long)
|     | | +-Ranges::countRanges(unsigned long&, std::vector<unsigned long>&)
|     | | | +-StateString::v_clone() const
|     | | |   +-StateData::~StateData()
|     | | |   | +-StateData::v_clone() const
|     | | |   |   +-StateData::StateData(unsigned long, unsigned long)
|     | | |   +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|     | | |     +-StateString::v_clone() const ==> 7
|     | | |     +-StateData::StateData(unsigned long, unsigned long)
|     | | +-Ranges::subsetCount()
|     | |   +-StateString::v_clone() const
|     | |     +-StateData::~StateData()
|     | |     | +-StateData::v_clone() const
|     | |     |   +-StateData::StateData(unsigned long, unsigned long)
|     | |     +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|     | |       +-StateString::v_clone() const ==> 7
|     | |       +-StateData::StateData(unsigned long, unsigned long)
|     | +-StateString::v_clone() const
|     |   +-StateData::~StateData()
|     |   | +-StateData::v_clone() const
|     |   |   +-StateData::StateData(unsigned long, unsigned long)
|     |   +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|     |     +-StateString::v_clone() const ==> 5
|     |     +-StateData::StateData(unsigned long, unsigned long)
|     +-StateString::v_clone() const
|       +-StateData::~StateData()
|       | +-StateData::v_clone() const
|       |   +-StateData::StateData(unsigned long, unsigned long)
|       +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|         +-StateString::v_clone() const ==> 4
|         +-StateData::StateData(unsigned long, unsigned long)
+-Ranges::finalizeStates()
| +-StateString::v_clone() const
| | +-StateData::~StateData()
| | | +-StateData::v_clone() const
| | |   +-StateData::StateData(unsigned long, unsigned long)
| | +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| |   +-StateString::v_clone() const ==> 2
| |   +-StateData::StateData(unsigned long, unsigned long)
| +-Ranges::finalizeState(State&)
|   +-StateString::v_clone() const
|   | +-StateData::~StateData()
|   | | +-StateData::v_clone() const
|   | |   +-StateData::StateData(unsigned long, unsigned long)
|   | +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|   |   +-StateString::v_clone() const ==> 3
|   |   +-StateData::StateData(unsigned long, unsigned long)
|   +-Ranges::charsetToRanges(StateData&, unsigned long*)
|     +-StateString::v_clone() const
|       +-StateData::~StateData()
|       | +-StateData::v_clone() const
|       |   +-StateData::StateData(unsigned long, unsigned long)
|       +-StateString::StateString(std::string const&, unsigned long, unsigned long)
|         +-StateString::v_clone() const ==> 4
|         +-StateData::StateData(unsigned long, unsigned long)
+-DFAs::DFAs(Rules&, States&, Ranges&)
+-DFAs::build()
| +-DFA::build(std::string const&, std::vector<unsigned long> const&)
| | +-States::eClosure(std::set<unsigned long>&) const
| | | +-State::next1() const
| | | | +-StateString::v_clone() const
| | | |   +-StateData::~StateData()
| | | |   | +-StateData::v_clone() const
| | | |   |   +-StateData::StateData(unsigned long, unsigned long)
| | | |   +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| | | |     +-StateString::v_clone() const ==> 5
| | | |     +-StateData::StateData(unsigned long, unsigned long)
| | | +-State::next2() const
| | |   +-StateString::v_clone() const
| | |     +-StateData::~StateData()
| | |     | +-StateData::v_clone() const
| | |     |   +-StateData::StateData(unsigned long, unsigned long)
| | |     +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| | |       +-StateString::v_clone() const ==> 5
| | |       +-StateData::StateData(unsigned long, unsigned long)
| | +-DFA::s_verbose
| | +-DFARow::DFARow(Rules&, States&, std::vector<std::set<unsigned long>>&, unsigned long, unsigned long, std::vector<bool>*)
| | +-DFARow::transitions()
| | | +-States::eClosure(std::set<unsigned long>&) const
| | | | +-State::next1() const
| | | | | +-StateString::v_clone() const
| | | | |   +-StateData::~StateData()
| | | | |   | +-StateData::v_clone() const
| | | | |   |   +-StateData::StateData(unsigned long, unsigned long)
| | | | |   +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| | | | |     +-StateString::v_clone() const ==> 6
| | | | |     +-StateData::StateData(unsigned long, unsigned long)
| | | | +-State::next2() const
| | | |   +-StateString::v_clone() const
| | | |     +-StateData::~StateData()
| | | |     | +-StateData::v_clone() const
| | | |     |   +-StateData::StateData(unsigned long, unsigned long)
| | | |     +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| | | |       +-StateString::v_clone() const ==> 6
| | | |       +-StateData::StateData(unsigned long, unsigned long)
| | | +-DFARow::transit(unsigned long, unsigned long, std::set<unsigned long>&)
| | |   +-State::next1() const
| | |   | +-StateString::v_clone() const
| | |   |   +-StateData::~StateData()
| | |   |   | +-StateData::v_clone() const
| | |   |   |   +-StateData::StateData(unsigned long, unsigned long)
| | |   |   +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| | |   |     +-StateString::v_clone() const ==> 6
| | |   |     +-StateData::StateData(unsigned long, unsigned long)
| | |   +-State::next2() const
| | |   | +-StateString::v_clone() const
| | |   |   +-StateData::~StateData()
| | |   |   | +-StateData::v_clone() const
| | |   |   |   +-StateData::StateData(unsigned long, unsigned long)
| | |   |   +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| | |   |     +-StateString::v_clone() const ==> 6
| | |   |     +-StateData::StateData(unsigned long, unsigned long)
| | |   +-Rules::ruleFromFinalState(unsigned long) const
| | |   +-State::contains(unsigned long) const
| | |   | +-StateString::v_clone() const
| | |   |   +-StateData::~StateData()
| | |   |   | +-StateData::v_clone() const
| | |   |   |   +-StateData::StateData(unsigned long, unsigned long)
| | |   |   +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| | |   |     +-StateString::v_clone() const ==> 6
| | |   |     +-StateData::StateData(unsigned long, unsigned long)
| | |   +-DFARow::setFinal(unsigned long)
| | +-DFA::keepUniqueRows()
| |   +-DFA::s_verbose
| |   +-DFA::inspectRows(std::vector<unsigned long>&)
| |   | +-DFARow::operator==(DFARow const&) const
| |   |   +-DFARow::sameTransits(FBB::LinearMap<unsigned long, unsigned long> const&, FBB::LinearMap<unsigned long, unsigned long> const&)
| |   +-DFARow::uniqueMap(std::vector<unsigned long> const&)
| |   +-DFA::shrinkDFA(std::vector<unsigned long>&)
| |     +-DFA::s_verbose
| +-DFA::DFA(Ranges&, Rules&, States&)
|   +-Options::instance()
|   | +-Options::s_options
|   | +-Options::Options()
|   |   +-Options::s_regexCall
|   +-DFA::s_verbose
+-DFAs::warnNonViable() const
| +-DFAs::removeRules(DFA const&, std::set<unsigned long>&) const
+-Generator::Generator(Rules const&, Ranges const&, DFAs const&)
| +-Options::instance()
|   +-Options::s_options
|   +-Options::Options()
|     +-Options::s_regexCall
+-Generator::conflicts() const
| +-Options::baseclassHeaderName() const
| +-Options::classHeaderName() const
| +-Generator::errExisting(std::string const&, std::string const&, std::string const&) const
|   +-Options::s_warnOptions
|   +-Generator::grep(std::string const&, std::string const&) const
+-Generator::construction(States const&)
| +-Options::operator()(int) const
| +-operator<<(std::ostream&, Ranges const&)
| | +-StateString::v_clone() const
| | | +-StateData::~StateData()
| | | | +-StateData::v_clone() const
| | | |   +-StateData::StateData(unsigned long, unsigned long)
| | | +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| | |   +-StateString::v_clone() const ==> 3
| | |   +-StateData::StateData(unsigned long, unsigned long)
| | +-Ranges::outChar(std::ostream&, unsigned long)
| |   +-StateString::v_clone() const
| |     +-StateData::~StateData()
| |     | +-StateData::v_clone() const
| |     |   +-StateData::StateData(unsigned long, unsigned long)
| |     +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| |       +-StateString::v_clone() const ==> 4
| |       +-StateData::StateData(unsigned long, unsigned long)
| +-operator<<(std::ostream&, Rules const&)
| | +-operator<<(std::ostream&, Rule const&)
| | +-operator<<(std::ostream&, StartConditions const&)
| +-operator<<(std::ostream&, States const&)
| | +-operator<<(std::ostream&, State const&)
| |   +-State::next1() const
| |   | +-StateString::v_clone() const
| |   |   +-StateData::~StateData()
| |   |   | +-StateData::v_clone() const
| |   |   |   +-StateData::StateData(unsigned long, unsigned long)
| |   |   +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| |   |     +-StateString::v_clone() const ==> 5
| |   |     +-StateData::StateData(unsigned long, unsigned long)
| |   +-State::next2() const
| |   | +-StateString::v_clone() const
| |   |   +-StateData::~StateData()
| |   |   | +-StateData::v_clone() const
| |   |   |   +-StateData::StateData(unsigned long, unsigned long)
| |   |   +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| |   |     +-StateString::v_clone() const ==> 5
| |   |     +-StateData::StateData(unsigned long, unsigned long)
| |   +-StateString::v_clone() const
| |     +-StateData::~StateData()
| |     | +-StateData::v_clone() const
| |     |   +-StateData::StateData(unsigned long, unsigned long)
| |     +-StateString::StateString(std::string const&, unsigned long, unsigned long)
| |       +-StateString::v_clone() const ==> 4
| |       +-StateData::StateData(unsigned long, unsigned long)
| +-operator<<(std::ostream&, DFAs const&)
|   +-operator<<(std::ostream&, DFA const&)
|     +-operator<<(FBB::Table&, DFARow const&)
|       +-DFARow::tabulate(FBB::Table&) const
|         +-DFARow::tabulateTransitions(FBB::Table&) const
|         +-DFARow::tabulateFinals(FBB::Table&) const
+-Generator::lexSource() const
| +-Generator::filter(std::istream&, std::ostream&) const
|   +-version
|   +-Generator::s_namespaceBaseFlagSize
|   +-Generator::s_namespaceBaseFlag
|   +-Generator::s_baseFlagSize
|   +-Generator::s_baseFlag
|   +-Generator::insert(std::ostream&) const
|     +-Generator::s_insert
+-Generator::baseclassHeader() const
| +-Options::operator()(char const*) const
| +-Generator::filter(std::istream&, std::ostream&) const
|   +-version
|   +-Generator::s_namespaceBaseFlagSize
|   +-Generator::s_namespaceBaseFlag
|   +-Generator::s_baseFlagSize
|   +-Generator::s_baseFlag
|   +-Generator::insert(std::ostream&) const
|     +-Generator::s_insert
+-Generator::classHeader() const
| +-Generator::filter(std::istream&, std::ostream&) const
| | +-version
| | +-Generator::s_namespaceBaseFlagSize
| | +-Generator::s_namespaceBaseFlag
| | +-Generator::s_baseFlagSize
| | +-Generator::s_baseFlag
| | +-Generator::insert(std::ostream&) const
| |   +-Generator::s_insert
| +-Generator::grep(std::string const&, std::string const&) const
+-Generator::implementationHeader() const
| +-Generator::filter(std::istream&, std::ostream&) const
|   +-version
|   +-Generator::s_namespaceBaseFlagSize
|   +-Generator::s_namespaceBaseFlag
|   +-Generator::s_baseFlagSize
|   +-Generator::s_baseFlag
|   +-Generator::insert(std::ostream&) const
|     +-Generator::s_insert
+-DFAs::~DFAs()
+-Ranges::~Ranges()
  +-StateString::v_clone() const
    +-StateData::~StateData()
    | +-StateData::v_clone() const
    |   +-StateData::StateData(unsigned long, unsigned long)
    +-StateString::StateString(std::string const&, unsigned long, unsigned long)
      +-StateString::v_clone() const ==> 2
      +-StateData::StateData(unsigned long, unsigned long)
