{
	"0: data": {
		"srcIndexStart": "0", 
		"file": "docssrc/docs.APIRef.Language.tmpl", 
		"parseTreeMode": "true", 
		"srcLength": "15598", 
		"source": "[$name|Language$]
[$title|class Language$]
[$frame|HTMLPage.tmpl$]
[$desc|The main interface to GoldieLib$]

<ul>
<li>
	[$typeLink|Language| class Language $]
	<ul>
	<li>[$typeLink|Language_{languageName}| class Language_{languageName}$][$ident| : Language $]</li>
	</ul>
</li>
<li>[$pageLink|#Module| Module-Level Members $]</li>
</ul>

<p>
This is the main interface to GoldieLib.
</p>

[$apiSectionType| Language | goldie.lang | class Language $]
<div class=\"api-def\">
	<p>
	This class corresponds to a loaded [$pageLink|CGT| CGT file $],
	ie. a compiled grammar.
	This is used for [$pageLink|StatVsDyn|dynamic-style$].
	</p>

	[$apiHead| this() $]
	<div class=\"api-def\">
	<p>
		Creates a new blank [$ident|Language$].
	</p>
	<p>
		This should only be used if you're going to manually create a
		[$ident|Language$], which is an advanced feature.
		Normally, you would create a [$ident|Language$] via [$ident|Language.loadCGT$],
		[$pageTitle|StaticLang$] or possibly one of the [$ident|Language.compileGrammar*$]
		functions.
	</p>
	</div>
	
	[$apiHead| static Language loadCGT(string filename) $]
	<div class=\"api-def\">
	Loads a CGT compiled grammar file.
	</div>
	
	
	[$apiHead| static bool compileGrammarGoldCompatibility $]
	<div class=\"api-def\">
	<p>
		Used by the [$ident|Language.compileGrammar*$] functions. This is
		equivalent to the [$code|inline|-gold$] command-line switch in [$pageTitle|GRMC$].
		Default value is [$ident|false$].
	</p>
	</div>
	
	[$apiHead| static Language compileGrammar(string grammarDefinition, string filename=\"\") $]
	<div class=\"api-def\">
	<p>
		Compiles a grammar definition into a
		[$pageLink|StatVsDyn|dynamic-style$] [$ident|Language$].
		This uses the exact same code as [$pageTitle|GRMC$].
	</p>
	<p>
		The filename from which the grammar definition originated can be
		provided so any errors during compilation can report the
		grammar definition's filename.
	</p>
	<p>
		If there's an error in the grammar, instead of an exception being
		thrown, an error message will be sent to stdout and null will be
		returned. This will be fixed in a future version of Goldie.
	</p>
	<p>
		Because grammar compiling uses [$pageLink|StatVsDyn|static-style$]
		internally, the [$ident|compileGrammar$] functions cannot be used
		on DMD 2.057 due to DMD Issue
		[$link| http://d.puremagic.com/issues/show_bug.cgi?id=7375 | #7375 $].
	</p>
	</div>

	[$apiHead| static Language compileGrammarFile(string filename) $]
	<div class=\"api-def\">
	<p>
		Just like [$ident|compileGrammar$], but loads the grammar definition
		from a .grm file.
	</p>
	</div>

	[$apiHead| static Language compileGrammarDebug(string grammarDefinition, string filename=\"\", bool verbose=false) $]
	[$apiHead| static Language compileGrammarFileDebug(string filename, bool verbose=false) $]
	<div class=\"api-def\">
	Same as [$ident|compileGrammar$] and [$ident|compileGrammarFile$], except it 
	stores the lexer's NFA and DFA
	(in
	[$link| http://graphviz.org/ | Graphviz $]
	[$link| http://en.wikipedia.org/wiki/DOT_language | DOT $]
	format)
	into [$ident|Language.nfaDot$] and [$ident|Language.dfaDot$].
	Also, a verbose mode can optionally be enabled.
	</div>

	[$apiHead| void save(string cgtFilename) $]
	<div class=\"api-def\">
	<p>
		Saves this [$ident|Language$] to a
		[$pageLink|CGT|CGT file$].
	</p>
	</div>
		
	[$apiHead| string filename $]
	<div class=\"api-def\">
		The path and name of the [$pageLink|CGT| CGT file $] this Language was loaded from (if any).
	</div>

	[$apiHead|
	string name
	string ver
	string author
	string about
	bool caseSensitive
	$]
	<div class=\"api-def\">
		Metadata about the language.
		For more information, see GOLD's documentation for the 
		[$link|http://goldparser.org/doc/grammars/index.htm| grammar definition language $]
		and
		[$link|http://goldparser.org/doc/cgt/index.htm|CGT files$].
		Note that all of these, including [$ident|caseSensitive$], are <em>informational-only</em>
		and do not actually affect GoldieLib's behavior.
	</div>

	[$apiHead|[:
	Symbol[] symbolTable
	CharSet[] charSetTable
	Rule[] ruleTable
	DFAState[] dfaTable
	LALRState[] lalrTable

	int startSymbolIndex
	int initialDFAState
	int initialLALRState

	int eofSymbolIndex
	int errorSymbolIndex
	:]$]
	<div class=\"api-def\">
	<p>
		The actual language-defining information in the CGT file.
		See GOLD's
		[$link|http://goldparser.org/doc/cgt/index.htm|CGT documentation$]
		for more information.
	</p>
	<p>
		These are very low-level to the lexing/parsing process and most people
		will not need to access these directly.
		In particular, modifying any of these is an <em>advanced</em> feature
		that should only be done if you really know what you're doing.
	</p>
	</div>

	[$apiHead| @property Symbol eofSymbol $]
	<div class=\"api-def\">
		The [$typeName|Symbol$] for end-of-file.
	</div>

	[$apiHead| @property Symbol errorSymbol $]
	<div class=\"api-def\">
		The [$typeName|Symbol$] for a lexing error.
	</div>

	[$apiHead| string nfaDot $]
	[$apiHead| string dfaDot $]
	<div class=\"api-def\">
	<p>
		The lexer's NFA and DFA in
		[$link| http://graphviz.org/ | Graphviz $]
		[$link| http://en.wikipedia.org/wiki/DOT_language | DOT $]
		format.
	</p>
	<p>
		These are always empty unless the [$typeName|Language$] was created via
		[$ident|Language.compileGrammarDebug$] or
		[$ident|Language.compileGrammarFileDebug$].
		Languages loaded from a [$pageLink|CGT|CGT file$] or via
		[$pageTitle|StaticLang$] will never have these filled in.
	</p>
	</div>

	[$apiHead| int nfaNumStates $]
	<div class=\"api-def\">
	<p>
		The number of NFA states created when generating the lexer.
		The number of DFA and LALR states can always be found with
		[$ident|dfaTable.length$] and [$ident|lalrTable.length$].
	</p>
	<p>
		This is always 0 unless the [$typeName|Language$] was created via
		[$ident|Language.compileGrammarDebug$] or
		[$ident|Language.compileGrammarFileDebug$].
		Languages loaded from a [$pageLink|CGT|CGT file$] or via
		[$pageTitle|StaticLang$] will never have this filled in.
	</p>
	</div>
	
	<a name=\"Language_parseFileX\" />
	[$apiHead| Parser parseFileX(string filename) $]
	<div class=\"api-def\">
	<p>
		Loads a file, lexes and parses it with a new [$typeName|Lexer$]
		and a new [$typeName|Parser$], and returns the [$typeName|Parser$]
		which can then be used to obtain the parsing
		(and lexing) results or can be reused to parse something else.
	</p>
	<p>
		Throws a [$typeName|ParseException$] if the source contains an error.
	</p>
	</div>

	<a name=\"Language_parseCodeX\" />
	[$apiHead| Parser parseCodeX(string source, string filename=\"\") $]
	<div class=\"api-def\">
	<p>
		Creates a new [$typeName|Parser$] and a new [$typeName|Lexer$],
		uses them to lex and parse \"source\", and returns the [$typeName|Parser$]
		which can then be used to obtain the
		parsing (and lexing) results or can be reused to parse something else.
	</p>
	<p>
		Throws a [$typeName|ParseException$] if the source contains an error.
	</p>
	<p>
		The filename from which the source originated can be provided
		so the error messages upon any parsing or lexing errors can report the
		filename.
	</p>
	</div>

	[$apiHead|[: Parser parseTokensX(Token[] tokens, string filename=\"\", Lexer lexerUsed=null) :]$]
	<div class=\"api-def\">
	<p>
		Usually just called by the other parse functions.
	</p>
	<p>
		Creates a new [$typeName|Parser$], uses it to parse an already-lexed
		array of [$typeName|Token$]s, and returns the [$typeName|Parser$] which
		can then be used to obtain the parsing
		results or can be reused to parse something else.
	</p>
	<p>
		Throws a [$typeName|ParseException$] if the source contains an error.
	</p>
	<p>
		The filename from which the source originated can be provided
		so the error messages upon any parsing errors can report the filename.
	</p>
	<p>
		The [$typeName|Lexer$] that was used can be provided so that
		the [$typeName|Parser$] returned can provide access to the lexing results.
	</p>
	</div>

	[$apiHead| Lexer lexFileX(string filename) $]
	<div class=\"api-def\">
	<p>
		Usually just called by the parse functions.
	</p>
	<p>
		Loads a file, lexes it with a new [$typeName|Lexer$], and returns
		the [$typeName|Lexer$] which can then be used to obtain the lexing
		results or can be reused to lex something else.
	</p>
	<p>
		Throws a [$typeName|LexException$] if the source contains an error.
	</p>
	</div>

	[$apiHead| Lexer lexCodeX(string source, string filename=\"\") $]
	<div class=\"api-def\">
	<p>
		Usually just called by the parse functions.
	</p>
	<p>
		Creates a new [$typeName|Lexer$], uses it to lex \"source\", and returns
		the [$typeName|Lexer$] which can then be used to obtain the lexing
		results or can be reused to lex something else.
	</p>
	<p>
		Throws a [$typeName|LexException$] if the source contains an error.
	</p>
	<p>
		The filename from which the source originated can be provided
		so the error messages upon any lexing errors can report the filename.
	</p>
	</div>
	
	[$apiHead|[: string[] uniqueSymbolNames() :]$]
	<div class=\"api-def\">
		Returns an array of all valid symbol names. If
		more than one [$typeName|Symbol$] exists with the same name,
		the name is only included in the array once.
	</div>

	[$apiHead|[: Symbol[] symbolsByName(string name) :]$]
	<div class=\"api-def\">
	<p>
		Returns an array of every [$typeName|Symbol$] with the name \"name\".
	</p>
	<p>
		Note that GOLD, and therefore Goldie, allows multiple symbols with the
		same name as long as each symbol is of a different [$typeName|SymbolType$].
	</p>
	</div>
		
	[$apiHead|[: SymbolType[] symbolTypesByName(string name) :]$]
	<div class=\"api-def\">
		Just like [$ident|symbolsByName$] except this only returns
		the [$typeName|SymbolType$] of
		each symbol, rather than the [$typeName|Symbol$] itself.
	</div>
		
	[$apiHead| string symbolTypesStrByName(string name) $]
	<div class=\"api-def\">
		Like [$ident|symbolTypesByName$], but returns a human-readable list in string form.
	</div>
	

	[$apiHead| bool isSymbolNameValid(string name) $]
	<div class=\"api-def\">
		Returns true if <em>at least</em> one [$typeName|Symbol$] exists with the given name.
	</div>
		
	[$apiHead| bool isSymbolNameAmbiguous(string name) $]
	<div class=\"api-def\">
	<p>
		Returns true if <em>more than</em> one [$typeName|Symbol$] exists with the given name.
	</p>
	<p>
		Note that GOLD allows multiple symbols with the same name as long as each
		symbol is of a different [$typeName|SymbolType$].
	</p>
	</div>

	[$apiHead|[: int ruleIdOf(string parentSymbol, string[] subSymbols...) :]$]
	<div class=\"api-def\">
	<p>
		Returns an index into [$ident|ruleTable$] given the name of the reduction symbol
		and the names of the symbols being reduced.
	</p>
	<p>
		For example, if your grammar has a rule like this:
	</p>
	<div class=\"code-plain\">&lt;Add Exp&gt; ::= &lt;Add Exp&gt; '+' &lt;Mult Exp&gt;</div>
	<p>
		Then you can retrieve the corresponding [$typeName|Rule$] like this:
	</p>
	<div class=\"code-plain\">[:myLang.ruleTable[ myLang.ruleIdOf(\"&lt;Add Exp&gt;\", \"&lt;Add Exp&gt;\", \"+\", \"&lt;Mult Exp&gt;\") ]:]</div>
	<p>
		Throws if such a rule doesn't exist or if any of the given symbol names
		are ambiguous (ie, if more than one symbol exists with the given name).
	</p>
	<p>
		Note: This is just a quick-n-dirty implementation at the moment. It works,
		but it might run slow.
	</p>
	</div>

	[$apiHead|[: string ruleToString(int ruleId) :]$]
	<div class=\"api-def\">
	<p>
		Returns the given rule in a human-readable string.
		Note this might not actually be valid code for the
		[$pageLink|Grammar|grammar description language$].
	</p>
	<p>
		For example, if your grammar has a rule like this:
	</p>
	<div class=\"code-plain\">&lt;Add Exp&gt; ::= &lt;Add Exp&gt; '+' &lt;Mult Exp&gt;</div>
	<p>
		Then:
	</p>
[$code|plain|
[:auto ruleId = myLang.ruleIdOf(\"<Add Exp>\", \"<Add Exp>\", \"+\", \"<Mult Exp>\")
assert(myLang.ruleToString(ruleId) == \"<Add Exp> ::= <Add Exp> + <Mult Exp>\");:]
$]
	</div>
</div>

[$apiSectionType| Language_{languageName} | {user-specified package}.lang | class Language_{languageName} : Language $]
<div class=\"api-def\">
	<div class=\"api-head\">
		{languageName} = Name of static-style language
	</div>
	<p>
	This is the [$pageLink|StatVsDyn|static-style$] counterpart to
	[$typeName|Language$], generated by the
	[$pageName|StaticLang$] tool.
	</p>
	<p>
	If the name of a language is [$ident|foo$] (for example), then
	the name of this class will be [$ident|Language_foo$].
	</p>
	<p>
	All of the [$typeName|Language$] members are available, but alternate
	versions are added.
	</p>
	
	[$apiHead|[:
	static enum string staticName
	static enum string staticVer
	static enum string staticAuthor
	static enum string staticAbout
	static enum bool staticCaseSensitive

	static immutable Symbol[] staticSymbolTable
	static immutable CharSet[] staticCharSetTable
	static immutable Rule[] staticRuleTable
	static immutable DFAState[] staticDFATable
	static immutable LALRState[] staticLALRTable

	static enum int staticStartSymbolIndex
	static enum int staticInitialDFAState
	static enum int staticInitialLALRState
	static enum int staticEofSymbolIndex
	static enum int staticErrorSymbolIndex

	static immutable string[] staticUniqueSymbolNameArray
	static enum Symbol staticEofSymbol
	static enum Symbol staticErrorSymbol

	static bool staticIsSymbolNameValid(string name)
	static bool staticIsSymbolNameAmbiguous(string name)
	:]$]
	<div class=\"api-def\">
		Compile-time counterparts to the corresponding [$typeName|Language$]
		members.
	</div>

	[$apiHead|[:
	static enum string packageName
	static enum string shortPackageName
	:]$]
	<div class=\"api-def\">
		If [$pageTitle|StaticLang$] was passed, for example,
		[$code|inline|-pack:myApp.langs.myLang$], then
		[$ident|packageName$] is [$code|inline|\"myApp.langs.myLang\"$] and
		[$ident|shortPackageName$] is the name of the language: [$code|inline|\"myLang\"$].
	</div>

	[$apiHead|[:
	static enum string langInstanceName
	static enum string langClassName
	static enum string lexerClassName
	static enum string parserClassName
	static enum string tokenClassName
	:]$]
	<div class=\"api-def\">
		The names of the various classes [$pageTitle|StaticLang$] created for
		this language. For example, [$code|inline|\"language_myLang\"$],
		[$code|inline|\"Language_myLang\"$], [$code|inline|\"Lexer_myLang\"$],
		[$code|inline|\"Parser_myLang\"$], and [$code|inline|\"Token_myLang\"$].
	</div>

	<a name=\"Language_parseFile\" />
	<a name=\"Language_parseCode\" />
	[$apiHead| Parser_{languageName} parseFile(string filename) $]
	[$apiHead| Parser_{languageName} parseCode(string source, string filename=\"\") $]
	[$apiHead|[: Parser_{languageName} parseTokens(Token[] tokens, string filename=\"\", Lexer lexerUsed=null) :]$]
	[$apiHead| Lexer_{languageName} lexFile(string filename) $]
	[$apiHead| Lexer_{languageName} lexCode(string source, string filename=\"\") $]
	<div class=\"api-def\">
	<p>
	Type-safe [$pageLink|StatVsDyn|static-style$] counterparts to the
	respective \"X\"-suffixed lex and parse functions in [$typeName|Language$].
	</p>
	</div>
</div>

[$apiSection| Module | {user-specified package}.lang | Module-Level Members $]
<div class=\"api-def\">
	<p></p>
	
	[$apiHead|[: Language_{languageName} language_{languageName} :]$]
	<div class=\"api-def\">
	<p>
	A pre-instantiated instance of a [$typeName|Language_{languageName}$], 
	generated by [$pageName|StaticLang$] and only created
	for [$pageLink|StatVsDyn|static-style$] languages.
	</p>
	<p>
	For example, if the name of a language is [$ident|foo$], then
	the declaration of this will be:
	</p>
	[$code|highlight|Language_foo language_foo;$]
	</div>
</div>
", 
		"0: name": {
			"srcIndexStart": "0", 
			"data": "Language", 
			"srcLength": "17", 
			"0: data": {
				"srcIndexStart": "7", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"1: data": {
			"srcIndexStart": "17", 
			"data": "
", 
			"srcLength": "1"
		}, 
		"2: title": {
			"srcIndexStart": "18", 
			"data": "class Language", 
			"srcLength": "24", 
			"0: data": {
				"srcIndexStart": "26", 
				"data": "class Language", 
				"srcLength": "14"
			}
		}, 
		"3: data": {
			"srcIndexStart": "42", 
			"data": "
", 
			"srcLength": "1"
		}, 
		"4: frame": {
			"srcIndexStart": "43", 
			"data": "HTMLPage.tmpl", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "51", 
				"data": "HTMLPage.tmpl", 
				"srcLength": "13"
			}
		}, 
		"5: data": {
			"srcIndexStart": "66", 
			"data": "
", 
			"srcLength": "1"
		}, 
		"6: desc": {
			"srcIndexStart": "67", 
			"data": "The main interface to GoldieLib", 
			"srcLength": "40", 
			"0: data": {
				"srcIndexStart": "74", 
				"data": "The main interface to GoldieLib", 
				"srcLength": "31"
			}
		}, 
		"7: data": {
			"srcIndexStart": "107", 
			"data": "

<ul>
<li>
	", 
			"srcLength": "13"
		}, 
		"8: typeLink": {
			"srcIndexStart": "120", 
			"param 0": "Language", 
			"data": "class Language", 
			"srcLength": "38", 
			"0: data": {
				"srcIndexStart": "140", 
				"data": "class Language", 
				"srcLength": "16"
			}
		}, 
		"9: data": {
			"srcIndexStart": "158", 
			"data": "
	<ul>
	<li>", 
			"srcLength": "12"
		}, 
		"10: typeLink": {
			"srcIndexStart": "170", 
			"param 0": "Language_{languageName}", 
			"data": "class Language_{languageName}", 
			"srcLength": "67", 
			"0: data": {
				"srcIndexStart": "205", 
				"data": "class Language_{languageName}", 
				"srcLength": "30"
			}
		}, 
		"11: ident": {
			"srcIndexStart": "237", 
			"data": ": Language", 
			"srcLength": "22", 
			"0: data": {
				"srcIndexStart": "245", 
				"data": ": Language", 
				"srcLength": "12"
			}
		}, 
		"12: data": {
			"srcIndexStart": "259", 
			"data": "</li>
	</ul>
</li>
<li>", 
			"srcLength": "23"
		}, 
		"13: pageLink": {
			"srcIndexStart": "282", 
			"param 0": "#Module", 
			"data": "Module-Level Members", 
			"srcLength": "43", 
			"0: data": {
				"srcIndexStart": "301", 
				"data": "Module-Level Members", 
				"srcLength": "22"
			}
		}, 
		"14: data": {
			"srcIndexStart": "325", 
			"data": "</li>
</ul>

<p>
This is the main interface to GoldieLib.
</p>

", 
			"srcLength": "64"
		}, 
		"15: apiSectionType": {
			"srcIndexStart": "389", 
			"param 0": "Language", 
			"param 1": "goldie.lang", 
			"data": "class Language", 
			"srcLength": "60", 
			"0: data": {
				"srcIndexStart": "431", 
				"data": "class Language", 
				"srcLength": "16"
			}
		}, 
		"16: data": {
			"srcIndexStart": "449", 
			"data": "
<div class=\"api-def\">
	<p>
	This class corresponds to a loaded ", 
			"srcLength": "64"
		}, 
		"17: pageLink": {
			"srcIndexStart": "513", 
			"param 0": "CGT", 
			"data": "CGT file", 
			"srcLength": "27", 
			"0: data": {
				"srcIndexStart": "528", 
				"data": "CGT file", 
				"srcLength": "10"
			}
		}, 
		"18: data": {
			"srcIndexStart": "540", 
			"data": ",
	ie. a compiled grammar.
	This is used for ", 
			"srcLength": "45"
		}, 
		"19: pageLink": {
			"srcIndexStart": "585", 
			"param 0": "StatVsDyn", 
			"data": "dynamic-style", 
			"srcLength": "36", 
			"0: data": {
				"srcIndexStart": "606", 
				"data": "dynamic-style", 
				"srcLength": "13"
			}
		}, 
		"20: data": {
			"srcIndexStart": "621", 
			"data": ".
	</p>

	", 
			"srcLength": "10"
		}, 
		"21: apiHead": {
			"srcIndexStart": "631", 
			"data": "this()", 
			"srcLength": "20", 
			"0: data": {
				"srcIndexStart": "641", 
				"data": "this()", 
				"srcLength": "8"
			}
		}, 
		"22: data": {
			"srcIndexStart": "651", 
			"data": "
	<div class=\"api-def\">
	<p>
		Creates a new blank ", 
			"srcLength": "51"
		}, 
		"23: ident": {
			"srcIndexStart": "702", 
			"data": "Language", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "710", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"24: data": {
			"srcIndexStart": "720", 
			"data": ".
	</p>
	<p>
		This should only be used if you're going to manually create a
		", 
			"srcLength": "79"
		}, 
		"25: ident": {
			"srcIndexStart": "799", 
			"data": "Language", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "807", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"26: data": {
			"srcIndexStart": "817", 
			"data": ", which is an advanced feature.
		Normally, you would create a ", 
			"srcLength": "63"
		}, 
		"27: ident": {
			"srcIndexStart": "880", 
			"data": "Language", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "888", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"28: data": {
			"srcIndexStart": "898", 
			"data": " via ", 
			"srcLength": "5"
		}, 
		"29: ident": {
			"srcIndexStart": "903", 
			"data": "Language.loadCGT", 
			"srcLength": "26", 
			"0: data": {
				"srcIndexStart": "911", 
				"data": "Language.loadCGT", 
				"srcLength": "16"
			}
		}, 
		"30: data": {
			"srcIndexStart": "929", 
			"data": ",
		", 
			"srcLength": "4"
		}, 
		"31: pageTitle": {
			"srcIndexStart": "933", 
			"data": "StaticLang", 
			"srcLength": "24", 
			"0: data": {
				"srcIndexStart": "945", 
				"data": "StaticLang", 
				"srcLength": "10"
			}
		}, 
		"32: data": {
			"srcIndexStart": "957", 
			"data": " or possibly one of the ", 
			"srcLength": "24"
		}, 
		"33: ident": {
			"srcIndexStart": "981", 
			"data": "Language.compileGrammar*", 
			"srcLength": "34", 
			"0: data": {
				"srcIndexStart": "989", 
				"data": "Language.compileGrammar*", 
				"srcLength": "24"
			}
		}, 
		"34: data": {
			"srcIndexStart": "1015", 
			"data": "
		functions.
	</p>
	</div>
	
	", 
			"srcLength": "31"
		}, 
		"35: apiHead": {
			"srcIndexStart": "1046", 
			"data": "static Language loadCGT(string filename)", 
			"srcLength": "54", 
			"0: data": {
				"srcIndexStart": "1056", 
				"data": "static Language loadCGT(string filename)", 
				"srcLength": "42"
			}
		}, 
		"36: data": {
			"srcIndexStart": "1100", 
			"data": "
	<div class=\"api-def\">
	Loads a CGT compiled grammar file.
	</div>
	
	
	", 
			"srcLength": "73"
		}, 
		"37: apiHead": {
			"srcIndexStart": "1173", 
			"data": "static bool compileGrammarGoldCompatibility", 
			"srcLength": "57", 
			"0: data": {
				"srcIndexStart": "1183", 
				"data": "static bool compileGrammarGoldCompatibility", 
				"srcLength": "45"
			}
		}, 
		"38: data": {
			"srcIndexStart": "1230", 
			"data": "
	<div class=\"api-def\">
	<p>
		Used by the ", 
			"srcLength": "43"
		}, 
		"39: ident": {
			"srcIndexStart": "1273", 
			"data": "Language.compileGrammar*", 
			"srcLength": "34", 
			"0: data": {
				"srcIndexStart": "1281", 
				"data": "Language.compileGrammar*", 
				"srcLength": "24"
			}
		}, 
		"40: data": {
			"srcIndexStart": "1307", 
			"data": " functions. This is
		equivalent to the ", 
			"srcLength": "40"
		}, 
		"41: code": {
			"srcIndexStart": "1347", 
			"param 0": "inline", 
			"data": "-gold", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "1361", 
				"data": "-gold", 
				"srcLength": "5"
			}
		}, 
		"42: data": {
			"srcIndexStart": "1368", 
			"data": " command-line switch in ", 
			"srcLength": "24"
		}, 
		"43: pageTitle": {
			"srcIndexStart": "1392", 
			"data": "GRMC", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "1404", 
				"data": "GRMC", 
				"srcLength": "4"
			}
		}, 
		"44: data": {
			"srcIndexStart": "1410", 
			"data": ".
		Default value is ", 
			"srcLength": "21"
		}, 
		"45: ident": {
			"srcIndexStart": "1431", 
			"data": "false", 
			"srcLength": "15", 
			"0: data": {
				"srcIndexStart": "1439", 
				"data": "false", 
				"srcLength": "5"
			}
		}, 
		"46: data": {
			"srcIndexStart": "1446", 
			"data": ".
	</p>
	</div>
	
	", 
			"srcLength": "19"
		}, 
		"47: apiHead": {
			"srcIndexStart": "1465", 
			"data": "static Language compileGrammar(string grammarDefinition, string filename=\"\")", 
			"srcLength": "90", 
			"0: data": {
				"srcIndexStart": "1475", 
				"data": "static Language compileGrammar(string grammarDefinition, string filename=\"\")", 
				"srcLength": "78"
			}
		}, 
		"48: data": {
			"srcIndexStart": "1555", 
			"data": "
	<div class=\"api-def\">
	<p>
		Compiles a grammar definition into a
		", 
			"srcLength": "70"
		}, 
		"49: pageLink": {
			"srcIndexStart": "1625", 
			"param 0": "StatVsDyn", 
			"data": "dynamic-style", 
			"srcLength": "36", 
			"0: data": {
				"srcIndexStart": "1646", 
				"data": "dynamic-style", 
				"srcLength": "13"
			}
		}, 
		"50: data": {
			"srcIndexStart": "1661", 
			"data": " ", 
			"srcLength": "1"
		}, 
		"51: ident": {
			"srcIndexStart": "1662", 
			"data": "Language", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "1670", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"52: data": {
			"srcIndexStart": "1680", 
			"data": ".
		This uses the exact same code as ", 
			"srcLength": "37"
		}, 
		"53: pageTitle": {
			"srcIndexStart": "1717", 
			"data": "GRMC", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "1729", 
				"data": "GRMC", 
				"srcLength": "4"
			}
		}, 
		"54: data": {
			"srcIndexStart": "1735", 
			"data": ".
	</p>
	<p>
		The filename from which the grammar definition originated can be
		provided so any errors during compilation can report the
		grammar definition's filename.
	</p>
	<p>
		If there's an error in the grammar, instead of an exception being
		thrown, an error message will be sent to stdout and null will be
		returned. This will be fixed in a future version of Goldie.
	</p>
	<p>
		Because grammar compiling uses ", 
			"srcLength": "424"
		}, 
		"55: pageLink": {
			"srcIndexStart": "2159", 
			"param 0": "StatVsDyn", 
			"data": "static-style", 
			"srcLength": "35", 
			"0: data": {
				"srcIndexStart": "2180", 
				"data": "static-style", 
				"srcLength": "12"
			}
		}, 
		"56: data": {
			"srcIndexStart": "2194", 
			"data": "
		internally, the ", 
			"srcLength": "19"
		}, 
		"57: ident": {
			"srcIndexStart": "2213", 
			"data": "compileGrammar", 
			"srcLength": "24", 
			"0: data": {
				"srcIndexStart": "2221", 
				"data": "compileGrammar", 
				"srcLength": "14"
			}
		}, 
		"58: data": {
			"srcIndexStart": "2237", 
			"data": " functions cannot be used
		on DMD 2.057 due to DMD Issue
		", 
			"srcLength": "60"
		}, 
		"59: link": {
			"srcIndexStart": "2297", 
			"param 0": "http://d.puremagic.com/issues/show_bug.cgi?id=7375", 
			"data": "#7375", 
			"srcLength": "69", 
			"0: data": {
				"srcIndexStart": "2357", 
				"data": "#7375", 
				"srcLength": "7"
			}
		}, 
		"60: data": {
			"srcIndexStart": "2366", 
			"data": ".
	</p>
	</div>

	", 
			"srcLength": "18"
		}, 
		"61: apiHead": {
			"srcIndexStart": "2384", 
			"data": "static Language compileGrammarFile(string filename)", 
			"srcLength": "65", 
			"0: data": {
				"srcIndexStart": "2394", 
				"data": "static Language compileGrammarFile(string filename)", 
				"srcLength": "53"
			}
		}, 
		"62: data": {
			"srcIndexStart": "2449", 
			"data": "
	<div class=\"api-def\">
	<p>
		Just like ", 
			"srcLength": "41"
		}, 
		"63: ident": {
			"srcIndexStart": "2490", 
			"data": "compileGrammar", 
			"srcLength": "24", 
			"0: data": {
				"srcIndexStart": "2498", 
				"data": "compileGrammar", 
				"srcLength": "14"
			}
		}, 
		"64: data": {
			"srcIndexStart": "2514", 
			"data": ", but loads the grammar definition
		from a .grm file.
	</p>
	</div>

	", 
			"srcLength": "71"
		}, 
		"65: apiHead": {
			"srcIndexStart": "2585", 
			"data": "static Language compileGrammarDebug(string grammarDefinition, string filename=\"\", bool verbose=false)", 
			"srcLength": "115", 
			"0: data": {
				"srcIndexStart": "2595", 
				"data": "static Language compileGrammarDebug(string grammarDefinition, string filename=\"\", bool verbose=false)", 
				"srcLength": "103"
			}
		}, 
		"66: data": {
			"srcIndexStart": "2700", 
			"data": "
	", 
			"srcLength": "2"
		}, 
		"67: apiHead": {
			"srcIndexStart": "2702", 
			"data": "static Language compileGrammarFileDebug(string filename, bool verbose=false)", 
			"srcLength": "90", 
			"0: data": {
				"srcIndexStart": "2712", 
				"data": "static Language compileGrammarFileDebug(string filename, bool verbose=false)", 
				"srcLength": "78"
			}
		}, 
		"68: data": {
			"srcIndexStart": "2792", 
			"data": "
	<div class=\"api-def\">
	Same as ", 
			"srcLength": "33"
		}, 
		"69: ident": {
			"srcIndexStart": "2825", 
			"data": "compileGrammar", 
			"srcLength": "24", 
			"0: data": {
				"srcIndexStart": "2833", 
				"data": "compileGrammar", 
				"srcLength": "14"
			}
		}, 
		"70: data": {
			"srcIndexStart": "2849", 
			"data": " and ", 
			"srcLength": "5"
		}, 
		"71: ident": {
			"srcIndexStart": "2854", 
			"data": "compileGrammarFile", 
			"srcLength": "28", 
			"0: data": {
				"srcIndexStart": "2862", 
				"data": "compileGrammarFile", 
				"srcLength": "18"
			}
		}, 
		"72: data": {
			"srcIndexStart": "2882", 
			"data": ", except it 
	stores the lexer's NFA and DFA
	(in
	", 
			"srcLength": "51"
		}, 
		"73: link": {
			"srcIndexStart": "2933", 
			"param 0": "http://graphviz.org/", 
			"data": "Graphviz", 
			"srcLength": "42", 
			"0: data": {
				"srcIndexStart": "2963", 
				"data": "Graphviz", 
				"srcLength": "10"
			}
		}, 
		"74: data": {
			"srcIndexStart": "2975", 
			"data": "
	", 
			"srcLength": "2"
		}, 
		"75: link": {
			"srcIndexStart": "2977", 
			"param 0": "http://en.wikipedia.org/wiki/DOT_language", 
			"data": "DOT", 
			"srcLength": "58", 
			"0: data": {
				"srcIndexStart": "3028", 
				"data": "DOT", 
				"srcLength": "5"
			}
		}, 
		"76: data": {
			"srcIndexStart": "3035", 
			"data": "
	format)
	into ", 
			"srcLength": "16"
		}, 
		"77: ident": {
			"srcIndexStart": "3051", 
			"data": "Language.nfaDot", 
			"srcLength": "25", 
			"0: data": {
				"srcIndexStart": "3059", 
				"data": "Language.nfaDot", 
				"srcLength": "15"
			}
		}, 
		"78: data": {
			"srcIndexStart": "3076", 
			"data": " and ", 
			"srcLength": "5"
		}, 
		"79: ident": {
			"srcIndexStart": "3081", 
			"data": "Language.dfaDot", 
			"srcLength": "25", 
			"0: data": {
				"srcIndexStart": "3089", 
				"data": "Language.dfaDot", 
				"srcLength": "15"
			}
		}, 
		"80: data": {
			"srcIndexStart": "3106", 
			"data": ".
	Also, a verbose mode can optionally be enabled.
	</div>

	", 
			"srcLength": "61"
		}, 
		"81: apiHead": {
			"srcIndexStart": "3167", 
			"data": "void save(string cgtFilename)", 
			"srcLength": "43", 
			"0: data": {
				"srcIndexStart": "3177", 
				"data": "void save(string cgtFilename)", 
				"srcLength": "31"
			}
		}, 
		"82: data": {
			"srcIndexStart": "3210", 
			"data": "
	<div class=\"api-def\">
	<p>
		Saves this ", 
			"srcLength": "42"
		}, 
		"83: ident": {
			"srcIndexStart": "3252", 
			"data": "Language", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "3260", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"84: data": {
			"srcIndexStart": "3270", 
			"data": " to a
		", 
			"srcLength": "8"
		}, 
		"85: pageLink": {
			"srcIndexStart": "3278", 
			"param 0": "CGT", 
			"data": "CGT file", 
			"srcLength": "25", 
			"0: data": {
				"srcIndexStart": "3293", 
				"data": "CGT file", 
				"srcLength": "8"
			}
		}, 
		"86: data": {
			"srcIndexStart": "3303", 
			"data": ".
	</p>
	</div>
		
	", 
			"srcLength": "20"
		}, 
		"87: apiHead": {
			"srcIndexStart": "3323", 
			"data": "string filename", 
			"srcLength": "29", 
			"0: data": {
				"srcIndexStart": "3333", 
				"data": "string filename", 
				"srcLength": "17"
			}
		}, 
		"88: data": {
			"srcIndexStart": "3352", 
			"data": "
	<div class=\"api-def\">
		The path and name of the ", 
			"srcLength": "51"
		}, 
		"89: pageLink": {
			"srcIndexStart": "3403", 
			"param 0": "CGT", 
			"data": "CGT file", 
			"srcLength": "27", 
			"0: data": {
				"srcIndexStart": "3418", 
				"data": "CGT file", 
				"srcLength": "10"
			}
		}, 
		"90: data": {
			"srcIndexStart": "3430", 
			"data": " this Language was loaded from (if any).
	</div>

	", 
			"srcLength": "51"
		}, 
		"91: apiHead": {
			"srcIndexStart": "3481", 
			"data": "string name
	string ver
	string author
	string about
	bool caseSensitive", 
			"srcLength": "88", 
			"0: data": {
				"srcIndexStart": "3491", 
				"data": "string name
	string ver
	string author
	string about
	bool caseSensitive", 
				"srcLength": "76"
			}
		}, 
		"92: data": {
			"srcIndexStart": "3569", 
			"data": "
	<div class=\"api-def\">
		Metadata about the language.
		For more information, see GOLD's documentation for the 
		", 
			"srcLength": "115"
		}, 
		"93: link": {
			"srcIndexStart": "3684", 
			"param 0": "http://goldparser.org/doc/grammars/index.htm", 
			"data": "grammar definition language", 
			"srcLength": "83", 
			"0: data": {
				"srcIndexStart": "3736", 
				"data": "grammar definition language", 
				"srcLength": "29"
			}
		}, 
		"94: data": {
			"srcIndexStart": "3767", 
			"data": "
		and
		", 
			"srcLength": "9"
		}, 
		"95: link": {
			"srcIndexStart": "3776", 
			"param 0": "http://goldparser.org/doc/cgt/index.htm", 
			"data": "CGT files", 
			"srcLength": "58", 
			"0: data": {
				"srcIndexStart": "3823", 
				"data": "CGT files", 
				"srcLength": "9"
			}
		}, 
		"96: data": {
			"srcIndexStart": "3834", 
			"data": ".
		Note that all of these, including ", 
			"srcLength": "38"
		}, 
		"97: ident": {
			"srcIndexStart": "3872", 
			"data": "caseSensitive", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "3880", 
				"data": "caseSensitive", 
				"srcLength": "13"
			}
		}, 
		"98: data": {
			"srcIndexStart": "3895", 
			"data": ", are <em>informational-only</em>
		and do not actually affect GoldieLib's behavior.
	</div>

	", 
			"srcLength": "95"
		}, 
		"99: apiHead": {
			"srcIndexStart": "3990", 
			"data": "
	Symbol[] symbolTable
	CharSet[] charSetTable
	Rule[] ruleTable
	DFAState[] dfaTable
	LALRState[] lalrTable

	int startSymbolIndex
	int initialDFAState
	int initialLALRState

	int eofSymbolIndex
	int errorSymbolIndex
	", 
			"srcLength": "235", 
			"0: data": {
				"srcIndexStart": "4000", 
				"data": "
	Symbol[] symbolTable
	CharSet[] charSetTable
	Rule[] ruleTable
	DFAState[] dfaTable
	LALRState[] lalrTable

	int startSymbolIndex
	int initialDFAState
	int initialLALRState

	int eofSymbolIndex
	int errorSymbolIndex
	", 
				"srcLength": "223"
			}
		}, 
		"100: data": {
			"srcIndexStart": "4225", 
			"data": "
	<div class=\"api-def\">
	<p>
		The actual language-defining information in the CGT file.
		See GOLD's
		", 
			"srcLength": "104"
		}, 
		"101: link": {
			"srcIndexStart": "4329", 
			"param 0": "http://goldparser.org/doc/cgt/index.htm", 
			"data": "CGT documentation", 
			"srcLength": "66", 
			"0: data": {
				"srcIndexStart": "4376", 
				"data": "CGT documentation", 
				"srcLength": "17"
			}
		}, 
		"102: data": {
			"srcIndexStart": "4395", 
			"data": "
		for more information.
	</p>
	<p>
		These are very low-level to the lexing/parsing process and most people
		will not need to access these directly.
		In particular, modifying any of these is an <em>advanced</em> feature
		that should only be done if you really know what you're doing.
	</p>
	</div>

	", 
			"srcLength": "304"
		}, 
		"103: apiHead": {
			"srcIndexStart": "4699", 
			"data": "@property Symbol eofSymbol", 
			"srcLength": "40", 
			"0: data": {
				"srcIndexStart": "4709", 
				"data": "@property Symbol eofSymbol", 
				"srcLength": "28"
			}
		}, 
		"104: data": {
			"srcIndexStart": "4739", 
			"data": "
	<div class=\"api-def\">
		The ", 
			"srcLength": "30"
		}, 
		"105: typeName": {
			"srcIndexStart": "4769", 
			"data": "Symbol", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "4780", 
				"data": "Symbol", 
				"srcLength": "6"
			}
		}, 
		"106: data": {
			"srcIndexStart": "4788", 
			"data": " for end-of-file.
	</div>

	", 
			"srcLength": "28"
		}, 
		"107: apiHead": {
			"srcIndexStart": "4816", 
			"data": "@property Symbol errorSymbol", 
			"srcLength": "42", 
			"0: data": {
				"srcIndexStart": "4826", 
				"data": "@property Symbol errorSymbol", 
				"srcLength": "30"
			}
		}, 
		"108: data": {
			"srcIndexStart": "4858", 
			"data": "
	<div class=\"api-def\">
		The ", 
			"srcLength": "30"
		}, 
		"109: typeName": {
			"srcIndexStart": "4888", 
			"data": "Symbol", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "4899", 
				"data": "Symbol", 
				"srcLength": "6"
			}
		}, 
		"110: data": {
			"srcIndexStart": "4907", 
			"data": " for a lexing error.
	</div>

	", 
			"srcLength": "31"
		}, 
		"111: apiHead": {
			"srcIndexStart": "4938", 
			"data": "string nfaDot", 
			"srcLength": "27", 
			"0: data": {
				"srcIndexStart": "4948", 
				"data": "string nfaDot", 
				"srcLength": "15"
			}
		}, 
		"112: data": {
			"srcIndexStart": "4965", 
			"data": "
	", 
			"srcLength": "2"
		}, 
		"113: apiHead": {
			"srcIndexStart": "4967", 
			"data": "string dfaDot", 
			"srcLength": "27", 
			"0: data": {
				"srcIndexStart": "4977", 
				"data": "string dfaDot", 
				"srcLength": "15"
			}
		}, 
		"114: data": {
			"srcIndexStart": "4994", 
			"data": "
	<div class=\"api-def\">
	<p>
		The lexer's NFA and DFA in
		", 
			"srcLength": "60"
		}, 
		"115: link": {
			"srcIndexStart": "5054", 
			"param 0": "http://graphviz.org/", 
			"data": "Graphviz", 
			"srcLength": "42", 
			"0: data": {
				"srcIndexStart": "5084", 
				"data": "Graphviz", 
				"srcLength": "10"
			}
		}, 
		"116: data": {
			"srcIndexStart": "5096", 
			"data": "
		", 
			"srcLength": "3"
		}, 
		"117: link": {
			"srcIndexStart": "5099", 
			"param 0": "http://en.wikipedia.org/wiki/DOT_language", 
			"data": "DOT", 
			"srcLength": "58", 
			"0: data": {
				"srcIndexStart": "5150", 
				"data": "DOT", 
				"srcLength": "5"
			}
		}, 
		"118: data": {
			"srcIndexStart": "5157", 
			"data": "
		format.
	</p>
	<p>
		These are always empty unless the ", 
			"srcLength": "58"
		}, 
		"119: typeName": {
			"srcIndexStart": "5215", 
			"data": "Language", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "5226", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"120: data": {
			"srcIndexStart": "5236", 
			"data": " was created via
		", 
			"srcLength": "19"
		}, 
		"121: ident": {
			"srcIndexStart": "5255", 
			"data": "Language.compileGrammarDebug", 
			"srcLength": "38", 
			"0: data": {
				"srcIndexStart": "5263", 
				"data": "Language.compileGrammarDebug", 
				"srcLength": "28"
			}
		}, 
		"122: data": {
			"srcIndexStart": "5293", 
			"data": " or
		", 
			"srcLength": "6"
		}, 
		"123: ident": {
			"srcIndexStart": "5299", 
			"data": "Language.compileGrammarFileDebug", 
			"srcLength": "42", 
			"0: data": {
				"srcIndexStart": "5307", 
				"data": "Language.compileGrammarFileDebug", 
				"srcLength": "32"
			}
		}, 
		"124: data": {
			"srcIndexStart": "5341", 
			"data": ".
		Languages loaded from a ", 
			"srcLength": "28"
		}, 
		"125: pageLink": {
			"srcIndexStart": "5369", 
			"param 0": "CGT", 
			"data": "CGT file", 
			"srcLength": "25", 
			"0: data": {
				"srcIndexStart": "5384", 
				"data": "CGT file", 
				"srcLength": "8"
			}
		}, 
		"126: data": {
			"srcIndexStart": "5394", 
			"data": " or via
		", 
			"srcLength": "10"
		}, 
		"127: pageTitle": {
			"srcIndexStart": "5404", 
			"data": "StaticLang", 
			"srcLength": "24", 
			"0: data": {
				"srcIndexStart": "5416", 
				"data": "StaticLang", 
				"srcLength": "10"
			}
		}, 
		"128: data": {
			"srcIndexStart": "5428", 
			"data": " will never have these filled in.
	</p>
	</div>

	", 
			"srcLength": "50"
		}, 
		"129: apiHead": {
			"srcIndexStart": "5478", 
			"data": "int nfaNumStates", 
			"srcLength": "30", 
			"0: data": {
				"srcIndexStart": "5488", 
				"data": "int nfaNumStates", 
				"srcLength": "18"
			}
		}, 
		"130: data": {
			"srcIndexStart": "5508", 
			"data": "
	<div class=\"api-def\">
	<p>
		The number of NFA states created when generating the lexer.
		The number of DFA and LALR states can always be found with
		", 
			"srcLength": "154"
		}, 
		"131: ident": {
			"srcIndexStart": "5662", 
			"data": "dfaTable.length", 
			"srcLength": "25", 
			"0: data": {
				"srcIndexStart": "5670", 
				"data": "dfaTable.length", 
				"srcLength": "15"
			}
		}, 
		"132: data": {
			"srcIndexStart": "5687", 
			"data": " and ", 
			"srcLength": "5"
		}, 
		"133: ident": {
			"srcIndexStart": "5692", 
			"data": "lalrTable.length", 
			"srcLength": "26", 
			"0: data": {
				"srcIndexStart": "5700", 
				"data": "lalrTable.length", 
				"srcLength": "16"
			}
		}, 
		"134: data": {
			"srcIndexStart": "5718", 
			"data": ".
	</p>
	<p>
		This is always 0 unless the ", 
			"srcLength": "43"
		}, 
		"135: typeName": {
			"srcIndexStart": "5761", 
			"data": "Language", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "5772", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"136: data": {
			"srcIndexStart": "5782", 
			"data": " was created via
		", 
			"srcLength": "19"
		}, 
		"137: ident": {
			"srcIndexStart": "5801", 
			"data": "Language.compileGrammarDebug", 
			"srcLength": "38", 
			"0: data": {
				"srcIndexStart": "5809", 
				"data": "Language.compileGrammarDebug", 
				"srcLength": "28"
			}
		}, 
		"138: data": {
			"srcIndexStart": "5839", 
			"data": " or
		", 
			"srcLength": "6"
		}, 
		"139: ident": {
			"srcIndexStart": "5845", 
			"data": "Language.compileGrammarFileDebug", 
			"srcLength": "42", 
			"0: data": {
				"srcIndexStart": "5853", 
				"data": "Language.compileGrammarFileDebug", 
				"srcLength": "32"
			}
		}, 
		"140: data": {
			"srcIndexStart": "5887", 
			"data": ".
		Languages loaded from a ", 
			"srcLength": "28"
		}, 
		"141: pageLink": {
			"srcIndexStart": "5915", 
			"param 0": "CGT", 
			"data": "CGT file", 
			"srcLength": "25", 
			"0: data": {
				"srcIndexStart": "5930", 
				"data": "CGT file", 
				"srcLength": "8"
			}
		}, 
		"142: data": {
			"srcIndexStart": "5940", 
			"data": " or via
		", 
			"srcLength": "10"
		}, 
		"143: pageTitle": {
			"srcIndexStart": "5950", 
			"data": "StaticLang", 
			"srcLength": "24", 
			"0: data": {
				"srcIndexStart": "5962", 
				"data": "StaticLang", 
				"srcLength": "10"
			}
		}, 
		"144: data": {
			"srcIndexStart": "5974", 
			"data": " will never have this filled in.
	</p>
	</div>
	
	<a name=\"Language_parseFileX\" />
	", 
			"srcLength": "84"
		}, 
		"145: apiHead": {
			"srcIndexStart": "6058", 
			"data": "Parser parseFileX(string filename)", 
			"srcLength": "48", 
			"0: data": {
				"srcIndexStart": "6068", 
				"data": "Parser parseFileX(string filename)", 
				"srcLength": "36"
			}
		}, 
		"146: data": {
			"srcIndexStart": "6106", 
			"data": "
	<div class=\"api-def\">
	<p>
		Loads a file, lexes and parses it with a new ", 
			"srcLength": "76"
		}, 
		"147: typeName": {
			"srcIndexStart": "6182", 
			"data": "Lexer", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "6193", 
				"data": "Lexer", 
				"srcLength": "5"
			}
		}, 
		"148: data": {
			"srcIndexStart": "6200", 
			"data": "
		and a new ", 
			"srcLength": "13"
		}, 
		"149: typeName": {
			"srcIndexStart": "6213", 
			"data": "Parser", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "6224", 
				"data": "Parser", 
				"srcLength": "6"
			}
		}, 
		"150: data": {
			"srcIndexStart": "6232", 
			"data": ", and returns the ", 
			"srcLength": "18"
		}, 
		"151: typeName": {
			"srcIndexStart": "6250", 
			"data": "Parser", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "6261", 
				"data": "Parser", 
				"srcLength": "6"
			}
		}, 
		"152: data": {
			"srcIndexStart": "6269", 
			"data": "
		which can then be used to obtain the parsing
		(and lexing) results or can be reused to parse something else.
	</p>
	<p>
		Throws a ", 
			"srcLength": "135"
		}, 
		"153: typeName": {
			"srcIndexStart": "6404", 
			"data": "ParseException", 
			"srcLength": "27", 
			"0: data": {
				"srcIndexStart": "6415", 
				"data": "ParseException", 
				"srcLength": "14"
			}
		}, 
		"154: data": {
			"srcIndexStart": "6431", 
			"data": " if the source contains an error.
	</p>
	</div>

	<a name=\"Language_parseCodeX\" />
	", 
			"srcLength": "84"
		}, 
		"155: apiHead": {
			"srcIndexStart": "6515", 
			"data": "Parser parseCodeX(string source, string filename=\"\")", 
			"srcLength": "66", 
			"0: data": {
				"srcIndexStart": "6525", 
				"data": "Parser parseCodeX(string source, string filename=\"\")", 
				"srcLength": "54"
			}
		}, 
		"156: data": {
			"srcIndexStart": "6581", 
			"data": "
	<div class=\"api-def\">
	<p>
		Creates a new ", 
			"srcLength": "45"
		}, 
		"157: typeName": {
			"srcIndexStart": "6626", 
			"data": "Parser", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "6637", 
				"data": "Parser", 
				"srcLength": "6"
			}
		}, 
		"158: data": {
			"srcIndexStart": "6645", 
			"data": " and a new ", 
			"srcLength": "11"
		}, 
		"159: typeName": {
			"srcIndexStart": "6656", 
			"data": "Lexer", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "6667", 
				"data": "Lexer", 
				"srcLength": "5"
			}
		}, 
		"160: data": {
			"srcIndexStart": "6674", 
			"data": ",
		uses them to lex and parse \"source\", and returns the ", 
			"srcLength": "57"
		}, 
		"161: typeName": {
			"srcIndexStart": "6731", 
			"data": "Parser", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "6742", 
				"data": "Parser", 
				"srcLength": "6"
			}
		}, 
		"162: data": {
			"srcIndexStart": "6750", 
			"data": "
		which can then be used to obtain the
		parsing (and lexing) results or can be reused to parse something else.
	</p>
	<p>
		Throws a ", 
			"srcLength": "135"
		}, 
		"163: typeName": {
			"srcIndexStart": "6885", 
			"data": "ParseException", 
			"srcLength": "27", 
			"0: data": {
				"srcIndexStart": "6896", 
				"data": "ParseException", 
				"srcLength": "14"
			}
		}, 
		"164: data": {
			"srcIndexStart": "6912", 
			"data": " if the source contains an error.
	</p>
	<p>
		The filename from which the source originated can be provided
		so the error messages upon any parsing or lexing errors can report the
		filename.
	</p>
	</div>

	", 
			"srcLength": "210"
		}, 
		"165: apiHead": {
			"srcIndexStart": "7122", 
			"data": " Parser parseTokensX(Token[] tokens, string filename=\"\", Lexer lexerUsed=null) ", 
			"srcLength": "95", 
			"0: data": {
				"srcIndexStart": "7132", 
				"data": " Parser parseTokensX(Token[] tokens, string filename=\"\", Lexer lexerUsed=null) ", 
				"srcLength": "83"
			}
		}, 
		"166: data": {
			"srcIndexStart": "7217", 
			"data": "
	<div class=\"api-def\">
	<p>
		Usually just called by the other parse functions.
	</p>
	<p>
		Creates a new ", 
			"srcLength": "108"
		}, 
		"167: typeName": {
			"srcIndexStart": "7325", 
			"data": "Parser", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "7336", 
				"data": "Parser", 
				"srcLength": "6"
			}
		}, 
		"168: data": {
			"srcIndexStart": "7344", 
			"data": ", uses it to parse an already-lexed
		array of ", 
			"srcLength": "47"
		}, 
		"169: typeName": {
			"srcIndexStart": "7391", 
			"data": "Token", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "7402", 
				"data": "Token", 
				"srcLength": "5"
			}
		}, 
		"170: data": {
			"srcIndexStart": "7409", 
			"data": "s, and returns the ", 
			"srcLength": "19"
		}, 
		"171: typeName": {
			"srcIndexStart": "7428", 
			"data": "Parser", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "7439", 
				"data": "Parser", 
				"srcLength": "6"
			}
		}, 
		"172: data": {
			"srcIndexStart": "7447", 
			"data": " which
		can then be used to obtain the parsing
		results or can be reused to parse something else.
	</p>
	<p>
		Throws a ", 
			"srcLength": "122"
		}, 
		"173: typeName": {
			"srcIndexStart": "7569", 
			"data": "ParseException", 
			"srcLength": "27", 
			"0: data": {
				"srcIndexStart": "7580", 
				"data": "ParseException", 
				"srcLength": "14"
			}
		}, 
		"174: data": {
			"srcIndexStart": "7596", 
			"data": " if the source contains an error.
	</p>
	<p>
		The filename from which the source originated can be provided
		so the error messages upon any parsing errors can report the filename.
	</p>
	<p>
		The ", 
			"srcLength": "199"
		}, 
		"175: typeName": {
			"srcIndexStart": "7795", 
			"data": "Lexer", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "7806", 
				"data": "Lexer", 
				"srcLength": "5"
			}
		}, 
		"176: data": {
			"srcIndexStart": "7813", 
			"data": " that was used can be provided so that
		the ", 
			"srcLength": "45"
		}, 
		"177: typeName": {
			"srcIndexStart": "7858", 
			"data": "Parser", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "7869", 
				"data": "Parser", 
				"srcLength": "6"
			}
		}, 
		"178: data": {
			"srcIndexStart": "7877", 
			"data": " returned can provide access to the lexing results.
	</p>
	</div>

	", 
			"srcLength": "68"
		}, 
		"179: apiHead": {
			"srcIndexStart": "7945", 
			"data": "Lexer lexFileX(string filename)", 
			"srcLength": "45", 
			"0: data": {
				"srcIndexStart": "7955", 
				"data": "Lexer lexFileX(string filename)", 
				"srcLength": "33"
			}
		}, 
		"180: data": {
			"srcIndexStart": "7990", 
			"data": "
	<div class=\"api-def\">
	<p>
		Usually just called by the parse functions.
	</p>
	<p>
		Loads a file, lexes it with a new ", 
			"srcLength": "122"
		}, 
		"181: typeName": {
			"srcIndexStart": "8112", 
			"data": "Lexer", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "8123", 
				"data": "Lexer", 
				"srcLength": "5"
			}
		}, 
		"182: data": {
			"srcIndexStart": "8130", 
			"data": ", and returns
		the ", 
			"srcLength": "20"
		}, 
		"183: typeName": {
			"srcIndexStart": "8150", 
			"data": "Lexer", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "8161", 
				"data": "Lexer", 
				"srcLength": "5"
			}
		}, 
		"184: data": {
			"srcIndexStart": "8168", 
			"data": " which can then be used to obtain the lexing
		results or can be reused to lex something else.
	</p>
	<p>
		Throws a ", 
			"srcLength": "117"
		}, 
		"185: typeName": {
			"srcIndexStart": "8285", 
			"data": "LexException", 
			"srcLength": "25", 
			"0: data": {
				"srcIndexStart": "8296", 
				"data": "LexException", 
				"srcLength": "12"
			}
		}, 
		"186: data": {
			"srcIndexStart": "8310", 
			"data": " if the source contains an error.
	</p>
	</div>

	", 
			"srcLength": "50"
		}, 
		"187: apiHead": {
			"srcIndexStart": "8360", 
			"data": "Lexer lexCodeX(string source, string filename=\"\")", 
			"srcLength": "63", 
			"0: data": {
				"srcIndexStart": "8370", 
				"data": "Lexer lexCodeX(string source, string filename=\"\")", 
				"srcLength": "51"
			}
		}, 
		"188: data": {
			"srcIndexStart": "8423", 
			"data": "
	<div class=\"api-def\">
	<p>
		Usually just called by the parse functions.
	</p>
	<p>
		Creates a new ", 
			"srcLength": "102"
		}, 
		"189: typeName": {
			"srcIndexStart": "8525", 
			"data": "Lexer", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "8536", 
				"data": "Lexer", 
				"srcLength": "5"
			}
		}, 
		"190: data": {
			"srcIndexStart": "8543", 
			"data": ", uses it to lex \"source\", and returns
		the ", 
			"srcLength": "45"
		}, 
		"191: typeName": {
			"srcIndexStart": "8588", 
			"data": "Lexer", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "8599", 
				"data": "Lexer", 
				"srcLength": "5"
			}
		}, 
		"192: data": {
			"srcIndexStart": "8606", 
			"data": " which can then be used to obtain the lexing
		results or can be reused to lex something else.
	</p>
	<p>
		Throws a ", 
			"srcLength": "117"
		}, 
		"193: typeName": {
			"srcIndexStart": "8723", 
			"data": "LexException", 
			"srcLength": "25", 
			"0: data": {
				"srcIndexStart": "8734", 
				"data": "LexException", 
				"srcLength": "12"
			}
		}, 
		"194: data": {
			"srcIndexStart": "8748", 
			"data": " if the source contains an error.
	</p>
	<p>
		The filename from which the source originated can be provided
		so the error messages upon any lexing errors can report the filename.
	</p>
	</div>
	
	", 
			"srcLength": "198"
		}, 
		"195: apiHead": {
			"srcIndexStart": "8946", 
			"data": " string[] uniqueSymbolNames() ", 
			"srcLength": "46", 
			"0: data": {
				"srcIndexStart": "8956", 
				"data": " string[] uniqueSymbolNames() ", 
				"srcLength": "34"
			}
		}, 
		"196: data": {
			"srcIndexStart": "8992", 
			"data": "
	<div class=\"api-def\">
		Returns an array of all valid symbol names. If
		more than one ", 
			"srcLength": "89"
		}, 
		"197: typeName": {
			"srcIndexStart": "9081", 
			"data": "Symbol", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "9092", 
				"data": "Symbol", 
				"srcLength": "6"
			}
		}, 
		"198: data": {
			"srcIndexStart": "9100", 
			"data": " exists with the same name,
		the name is only included in the array once.
	</div>

	", 
			"srcLength": "85"
		}, 
		"199: apiHead": {
			"srcIndexStart": "9185", 
			"data": " Symbol[] symbolsByName(string name) ", 
			"srcLength": "53", 
			"0: data": {
				"srcIndexStart": "9195", 
				"data": " Symbol[] symbolsByName(string name) ", 
				"srcLength": "41"
			}
		}, 
		"200: data": {
			"srcIndexStart": "9238", 
			"data": "
	<div class=\"api-def\">
	<p>
		Returns an array of every ", 
			"srcLength": "57"
		}, 
		"201: typeName": {
			"srcIndexStart": "9295", 
			"data": "Symbol", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "9306", 
				"data": "Symbol", 
				"srcLength": "6"
			}
		}, 
		"202: data": {
			"srcIndexStart": "9314", 
			"data": " with the name \"name\".
	</p>
	<p>
		Note that GOLD, and therefore Goldie, allows multiple symbols with the
		same name as long as each symbol is of a different ", 
			"srcLength": "160"
		}, 
		"203: typeName": {
			"srcIndexStart": "9474", 
			"data": "SymbolType", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "9485", 
				"data": "SymbolType", 
				"srcLength": "10"
			}
		}, 
		"204: data": {
			"srcIndexStart": "9497", 
			"data": ".
	</p>
	</div>
		
	", 
			"srcLength": "20"
		}, 
		"205: apiHead": {
			"srcIndexStart": "9517", 
			"data": " SymbolType[] symbolTypesByName(string name) ", 
			"srcLength": "61", 
			"0: data": {
				"srcIndexStart": "9527", 
				"data": " SymbolType[] symbolTypesByName(string name) ", 
				"srcLength": "49"
			}
		}, 
		"206: data": {
			"srcIndexStart": "9578", 
			"data": "
	<div class=\"api-def\">
		Just like ", 
			"srcLength": "36"
		}, 
		"207: ident": {
			"srcIndexStart": "9614", 
			"data": "symbolsByName", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "9622", 
				"data": "symbolsByName", 
				"srcLength": "13"
			}
		}, 
		"208: data": {
			"srcIndexStart": "9637", 
			"data": " except this only returns
		the ", 
			"srcLength": "32"
		}, 
		"209: typeName": {
			"srcIndexStart": "9669", 
			"data": "SymbolType", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "9680", 
				"data": "SymbolType", 
				"srcLength": "10"
			}
		}, 
		"210: data": {
			"srcIndexStart": "9692", 
			"data": " of
		each symbol, rather than the ", 
			"srcLength": "35"
		}, 
		"211: typeName": {
			"srcIndexStart": "9727", 
			"data": "Symbol", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "9738", 
				"data": "Symbol", 
				"srcLength": "6"
			}
		}, 
		"212: data": {
			"srcIndexStart": "9746", 
			"data": " itself.
	</div>
		
	", 
			"srcLength": "21"
		}, 
		"213: apiHead": {
			"srcIndexStart": "9767", 
			"data": "string symbolTypesStrByName(string name)", 
			"srcLength": "54", 
			"0: data": {
				"srcIndexStart": "9777", 
				"data": "string symbolTypesStrByName(string name)", 
				"srcLength": "42"
			}
		}, 
		"214: data": {
			"srcIndexStart": "9821", 
			"data": "
	<div class=\"api-def\">
		Like ", 
			"srcLength": "31"
		}, 
		"215: ident": {
			"srcIndexStart": "9852", 
			"data": "symbolTypesByName", 
			"srcLength": "27", 
			"0: data": {
				"srcIndexStart": "9860", 
				"data": "symbolTypesByName", 
				"srcLength": "17"
			}
		}, 
		"216: data": {
			"srcIndexStart": "9879", 
			"data": ", but returns a human-readable list in string form.
	</div>
	

	", 
			"srcLength": "64"
		}, 
		"217: apiHead": {
			"srcIndexStart": "9943", 
			"data": "bool isSymbolNameValid(string name)", 
			"srcLength": "49", 
			"0: data": {
				"srcIndexStart": "9953", 
				"data": "bool isSymbolNameValid(string name)", 
				"srcLength": "37"
			}
		}, 
		"218: data": {
			"srcIndexStart": "9992", 
			"data": "
	<div class=\"api-def\">
		Returns true if <em>at least</em> one ", 
			"srcLength": "64"
		}, 
		"219: typeName": {
			"srcIndexStart": "10056", 
			"data": "Symbol", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "10067", 
				"data": "Symbol", 
				"srcLength": "6"
			}
		}, 
		"220: data": {
			"srcIndexStart": "10075", 
			"data": " exists with the given name.
	</div>
		
	", 
			"srcLength": "41"
		}, 
		"221: apiHead": {
			"srcIndexStart": "10116", 
			"data": "bool isSymbolNameAmbiguous(string name)", 
			"srcLength": "53", 
			"0: data": {
				"srcIndexStart": "10126", 
				"data": "bool isSymbolNameAmbiguous(string name)", 
				"srcLength": "41"
			}
		}, 
		"222: data": {
			"srcIndexStart": "10169", 
			"data": "
	<div class=\"api-def\">
	<p>
		Returns true if <em>more than</em> one ", 
			"srcLength": "70"
		}, 
		"223: typeName": {
			"srcIndexStart": "10239", 
			"data": "Symbol", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "10250", 
				"data": "Symbol", 
				"srcLength": "6"
			}
		}, 
		"224: data": {
			"srcIndexStart": "10258", 
			"data": " exists with the given name.
	</p>
	<p>
		Note that GOLD allows multiple symbols with the same name as long as each
		symbol is of a different ", 
			"srcLength": "143"
		}, 
		"225: typeName": {
			"srcIndexStart": "10401", 
			"data": "SymbolType", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "10412", 
				"data": "SymbolType", 
				"srcLength": "10"
			}
		}, 
		"226: data": {
			"srcIndexStart": "10424", 
			"data": ".
	</p>
	</div>

	", 
			"srcLength": "18"
		}, 
		"227: apiHead": {
			"srcIndexStart": "10442", 
			"data": " int ruleIdOf(string parentSymbol, string[] subSymbols...) ", 
			"srcLength": "75", 
			"0: data": {
				"srcIndexStart": "10452", 
				"data": " int ruleIdOf(string parentSymbol, string[] subSymbols...) ", 
				"srcLength": "63"
			}
		}, 
		"228: data": {
			"srcIndexStart": "10517", 
			"data": "
	<div class=\"api-def\">
	<p>
		Returns an index into ", 
			"srcLength": "53"
		}, 
		"229: ident": {
			"srcIndexStart": "10570", 
			"data": "ruleTable", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "10578", 
				"data": "ruleTable", 
				"srcLength": "9"
			}
		}, 
		"230: data": {
			"srcIndexStart": "10589", 
			"data": " given the name of the reduction symbol
		and the names of the symbols being reduced.
	</p>
	<p>
		For example, if your grammar has a rule like this:
	</p>
	<div class=\"code-plain\">&lt;Add Exp&gt; ::= &lt;Add Exp&gt; '+' &lt;Mult Exp&gt;</div>
	<p>
		Then you can retrieve the corresponding ", 
			"srcLength": "291"
		}, 
		"231: typeName": {
			"srcIndexStart": "10880", 
			"data": "Rule", 
			"srcLength": "17", 
			"0: data": {
				"srcIndexStart": "10891", 
				"data": "Rule", 
				"srcLength": "4"
			}
		}, 
		"232: data": {
			"srcIndexStart": "10897", 
			"data": " like this:
	</p>
	<div class=\"code-plain\">", 
			"srcLength": "43"
		}, 
		"233: data": {
			"srcIndexStart": "10940", 
			"data": "myLang.ruleTable[ myLang.ruleIdOf(\"&lt;Add Exp&gt;\", \"&lt;Add Exp&gt;\", \"+\", \"&lt;Mult Exp&gt;\") ]", 
			"srcLength": "102"
		}, 
		"234: data": {
			"srcIndexStart": "11042", 
			"data": "</div>
	<p>
		Throws if such a rule doesn't exist or if any of the given symbol names
		are ambiguous (ie, if more than one symbol exists with the given name).
	</p>
	<p>
		Note: This is just a quick-n-dirty implementation at the moment. It works,
		but it might run slow.
	</p>
	</div>

	", 
			"srcLength": "289"
		}, 
		"235: apiHead": {
			"srcIndexStart": "11331", 
			"data": " string ruleToString(int ruleId) ", 
			"srcLength": "49", 
			"0: data": {
				"srcIndexStart": "11341", 
				"data": " string ruleToString(int ruleId) ", 
				"srcLength": "37"
			}
		}, 
		"236: data": {
			"srcIndexStart": "11380", 
			"data": "
	<div class=\"api-def\">
	<p>
		Returns the given rule in a human-readable string.
		Note this might not actually be valid code for the
		", 
			"srcLength": "137"
		}, 
		"237: pageLink": {
			"srcIndexStart": "11517", 
			"param 0": "Grammar", 
			"data": "grammar description language", 
			"srcLength": "49", 
			"0: data": {
				"srcIndexStart": "11536", 
				"data": "grammar description language", 
				"srcLength": "28"
			}
		}, 
		"238: data": {
			"srcIndexStart": "11566", 
			"data": ".
	</p>
	<p>
		For example, if your grammar has a rule like this:
	</p>
	<div class=\"code-plain\">&lt;Add Exp&gt; ::= &lt;Add Exp&gt; '+' &lt;Mult Exp&gt;</div>
	<p>
		Then:
	</p>
", 
			"srcLength": "179"
		}, 
		"239: code": {
			"srcIndexStart": "11745", 
			"param 0": "plain", 
			"data": "auto ruleId = myLang.ruleIdOf(\"&lt;Add Exp&gt;\", \"&lt;Add Exp&gt;\", \"+\", \"&lt;Mult Exp&gt;\")
assert(myLang.ruleToString(ruleId) == \"&lt;Add Exp&gt; ::= &lt;Add Exp&gt; + &lt;Mult Exp&gt;\");", 
			"srcLength": "174", 
			"0: data": {
				"srcIndexStart": "11758", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "11759", 
				"data": "auto ruleId = myLang.ruleIdOf(\"<Add Exp>\", \"<Add Exp>\", \"+\", \"<Mult Exp>\")
assert(myLang.ruleToString(ruleId) == \"<Add Exp> ::= <Add Exp> + <Mult Exp>\");", 
				"srcLength": "157"
			}, 
			"2: data": {
				"srcIndexStart": "11916", 
				"data": "", 
				"srcLength": "1"
			}
		}, 
		"240: data": {
			"srcIndexStart": "11919", 
			"data": "
	</div>
</div>

", 
			"srcLength": "17"
		}, 
		"241: apiSectionType": {
			"srcIndexStart": "11936", 
			"param 0": "Language_{languageName}", 
			"param 1": "{user-specified package}.lang", 
			"data": "class Language_{languageName} : Language", 
			"srcLength": "119", 
			"0: data": {
				"srcIndexStart": "12011", 
				"data": "class Language_{languageName} : Language", 
				"srcLength": "42"
			}
		}, 
		"242: data": {
			"srcIndexStart": "12055", 
			"data": "
<div class=\"api-def\">
	<div class=\"api-head\">
		{languageName} = Name of static-style language
	</div>
	<p>
	This is the ", 
			"srcLength": "122"
		}, 
		"243: pageLink": {
			"srcIndexStart": "12177", 
			"param 0": "StatVsDyn", 
			"data": "static-style", 
			"srcLength": "35", 
			"0: data": {
				"srcIndexStart": "12198", 
				"data": "static-style", 
				"srcLength": "12"
			}
		}, 
		"244: data": {
			"srcIndexStart": "12212", 
			"data": " counterpart to
	", 
			"srcLength": "17"
		}, 
		"245: typeName": {
			"srcIndexStart": "12229", 
			"data": "Language", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "12240", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"246: data": {
			"srcIndexStart": "12250", 
			"data": ", generated by the
	", 
			"srcLength": "20"
		}, 
		"247: pageName": {
			"srcIndexStart": "12270", 
			"data": "StaticLang", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "12281", 
				"data": "StaticLang", 
				"srcLength": "10"
			}
		}, 
		"248: data": {
			"srcIndexStart": "12293", 
			"data": " tool.
	</p>
	<p>
	If the name of a language is ", 
			"srcLength": "48"
		}, 
		"249: ident": {
			"srcIndexStart": "12341", 
			"data": "foo", 
			"srcLength": "13", 
			"0: data": {
				"srcIndexStart": "12349", 
				"data": "foo", 
				"srcLength": "3"
			}
		}, 
		"250: data": {
			"srcIndexStart": "12354", 
			"data": " (for example), then
	the name of this class will be ", 
			"srcLength": "53"
		}, 
		"251: ident": {
			"srcIndexStart": "12407", 
			"data": "Language_foo", 
			"srcLength": "22", 
			"0: data": {
				"srcIndexStart": "12415", 
				"data": "Language_foo", 
				"srcLength": "12"
			}
		}, 
		"252: data": {
			"srcIndexStart": "12429", 
			"data": ".
	</p>
	<p>
	All of the ", 
			"srcLength": "25"
		}, 
		"253: typeName": {
			"srcIndexStart": "12454", 
			"data": "Language", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "12465", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"254: data": {
			"srcIndexStart": "12475", 
			"data": " members are available, but alternate
	versions are added.
	</p>
	
	", 
			"srcLength": "68"
		}, 
		"255: apiHead": {
			"srcIndexStart": "12543", 
			"data": "
	static enum string staticName
	static enum string staticVer
	static enum string staticAuthor
	static enum string staticAbout
	static enum bool staticCaseSensitive

	static immutable Symbol[] staticSymbolTable
	static immutable CharSet[] staticCharSetTable
	static immutable Rule[] staticRuleTable
	static immutable DFAState[] staticDFATable
	static immutable LALRState[] staticLALRTable

	static enum int staticStartSymbolIndex
	static enum int staticInitialDFAState
	static enum int staticInitialLALRState
	static enum int staticEofSymbolIndex
	static enum int staticErrorSymbolIndex

	static immutable string[] staticUniqueSymbolNameArray
	static enum Symbol staticEofSymbol
	static enum Symbol staticErrorSymbol

	static bool staticIsSymbolNameValid(string name)
	static bool staticIsSymbolNameAmbiguous(string name)
	", 
			"srcLength": "839", 
			"0: data": {
				"srcIndexStart": "12553", 
				"data": "
	static enum string staticName
	static enum string staticVer
	static enum string staticAuthor
	static enum string staticAbout
	static enum bool staticCaseSensitive

	static immutable Symbol[] staticSymbolTable
	static immutable CharSet[] staticCharSetTable
	static immutable Rule[] staticRuleTable
	static immutable DFAState[] staticDFATable
	static immutable LALRState[] staticLALRTable

	static enum int staticStartSymbolIndex
	static enum int staticInitialDFAState
	static enum int staticInitialLALRState
	static enum int staticEofSymbolIndex
	static enum int staticErrorSymbolIndex

	static immutable string[] staticUniqueSymbolNameArray
	static enum Symbol staticEofSymbol
	static enum Symbol staticErrorSymbol

	static bool staticIsSymbolNameValid(string name)
	static bool staticIsSymbolNameAmbiguous(string name)
	", 
				"srcLength": "827"
			}
		}, 
		"256: data": {
			"srcIndexStart": "13382", 
			"data": "
	<div class=\"api-def\">
		Compile-time counterparts to the corresponding ", 
			"srcLength": "73"
		}, 
		"257: typeName": {
			"srcIndexStart": "13455", 
			"data": "Language", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "13466", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"258: data": {
			"srcIndexStart": "13476", 
			"data": "
		members.
	</div>

	", 
			"srcLength": "22"
		}, 
		"259: apiHead": {
			"srcIndexStart": "13498", 
			"data": "
	static enum string packageName
	static enum string shortPackageName
	", 
			"srcLength": "87", 
			"0: data": {
				"srcIndexStart": "13508", 
				"data": "
	static enum string packageName
	static enum string shortPackageName
	", 
				"srcLength": "75"
			}
		}, 
		"260: data": {
			"srcIndexStart": "13585", 
			"data": "
	<div class=\"api-def\">
		If ", 
			"srcLength": "29"
		}, 
		"261: pageTitle": {
			"srcIndexStart": "13614", 
			"data": "StaticLang", 
			"srcLength": "24", 
			"0: data": {
				"srcIndexStart": "13626", 
				"data": "StaticLang", 
				"srcLength": "10"
			}
		}, 
		"262: data": {
			"srcIndexStart": "13638", 
			"data": " was passed, for example,
		", 
			"srcLength": "28"
		}, 
		"263: code": {
			"srcIndexStart": "13666", 
			"param 0": "inline", 
			"data": "-pack:myApp.langs.myLang", 
			"srcLength": "40", 
			"0: data": {
				"srcIndexStart": "13680", 
				"data": "-pack:myApp.langs.myLang", 
				"srcLength": "24"
			}
		}, 
		"264: data": {
			"srcIndexStart": "13706", 
			"data": ", then
		", 
			"srcLength": "9"
		}, 
		"265: ident": {
			"srcIndexStart": "13715", 
			"data": "packageName", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "13723", 
				"data": "packageName", 
				"srcLength": "11"
			}
		}, 
		"266: data": {
			"srcIndexStart": "13736", 
			"data": " is ", 
			"srcLength": "4"
		}, 
		"267: code": {
			"srcIndexStart": "13740", 
			"param 0": "inline", 
			"data": "\"myApp.langs.myLang\"", 
			"srcLength": "36", 
			"0: data": {
				"srcIndexStart": "13754", 
				"data": "\"myApp.langs.myLang\"", 
				"srcLength": "20"
			}
		}, 
		"268: data": {
			"srcIndexStart": "13776", 
			"data": " and
		", 
			"srcLength": "7"
		}, 
		"269: ident": {
			"srcIndexStart": "13783", 
			"data": "shortPackageName", 
			"srcLength": "26", 
			"0: data": {
				"srcIndexStart": "13791", 
				"data": "shortPackageName", 
				"srcLength": "16"
			}
		}, 
		"270: data": {
			"srcIndexStart": "13809", 
			"data": " is the name of the language: ", 
			"srcLength": "30"
		}, 
		"271: code": {
			"srcIndexStart": "13839", 
			"param 0": "inline", 
			"data": "\"myLang\"", 
			"srcLength": "24", 
			"0: data": {
				"srcIndexStart": "13853", 
				"data": "\"myLang\"", 
				"srcLength": "8"
			}
		}, 
		"272: data": {
			"srcIndexStart": "13863", 
			"data": ".
	</div>

	", 
			"srcLength": "12"
		}, 
		"273: apiHead": {
			"srcIndexStart": "13875", 
			"data": "
	static enum string langInstanceName
	static enum string langClassName
	static enum string lexerClassName
	static enum string parserClassName
	static enum string tokenClassName
	", 
			"srcLength": "195", 
			"0: data": {
				"srcIndexStart": "13885", 
				"data": "
	static enum string langInstanceName
	static enum string langClassName
	static enum string lexerClassName
	static enum string parserClassName
	static enum string tokenClassName
	", 
				"srcLength": "183"
			}
		}, 
		"274: data": {
			"srcIndexStart": "14070", 
			"data": "
	<div class=\"api-def\">
		The names of the various classes ", 
			"srcLength": "59"
		}, 
		"275: pageTitle": {
			"srcIndexStart": "14129", 
			"data": "StaticLang", 
			"srcLength": "24", 
			"0: data": {
				"srcIndexStart": "14141", 
				"data": "StaticLang", 
				"srcLength": "10"
			}
		}, 
		"276: data": {
			"srcIndexStart": "14153", 
			"data": " created for
		this language. For example, ", 
			"srcLength": "43"
		}, 
		"277: code": {
			"srcIndexStart": "14196", 
			"param 0": "inline", 
			"data": "\"language_myLang\"", 
			"srcLength": "33", 
			"0: data": {
				"srcIndexStart": "14210", 
				"data": "\"language_myLang\"", 
				"srcLength": "17"
			}
		}, 
		"278: data": {
			"srcIndexStart": "14229", 
			"data": ",
		", 
			"srcLength": "4"
		}, 
		"279: code": {
			"srcIndexStart": "14233", 
			"param 0": "inline", 
			"data": "\"Language_myLang\"", 
			"srcLength": "33", 
			"0: data": {
				"srcIndexStart": "14247", 
				"data": "\"Language_myLang\"", 
				"srcLength": "17"
			}
		}, 
		"280: data": {
			"srcIndexStart": "14266", 
			"data": ", ", 
			"srcLength": "2"
		}, 
		"281: code": {
			"srcIndexStart": "14268", 
			"param 0": "inline", 
			"data": "\"Lexer_myLang\"", 
			"srcLength": "30", 
			"0: data": {
				"srcIndexStart": "14282", 
				"data": "\"Lexer_myLang\"", 
				"srcLength": "14"
			}
		}, 
		"282: data": {
			"srcIndexStart": "14298", 
			"data": ",
		", 
			"srcLength": "4"
		}, 
		"283: code": {
			"srcIndexStart": "14302", 
			"param 0": "inline", 
			"data": "\"Parser_myLang\"", 
			"srcLength": "31", 
			"0: data": {
				"srcIndexStart": "14316", 
				"data": "\"Parser_myLang\"", 
				"srcLength": "15"
			}
		}, 
		"284: data": {
			"srcIndexStart": "14333", 
			"data": ", and ", 
			"srcLength": "6"
		}, 
		"285: code": {
			"srcIndexStart": "14339", 
			"param 0": "inline", 
			"data": "\"Token_myLang\"", 
			"srcLength": "30", 
			"0: data": {
				"srcIndexStart": "14353", 
				"data": "\"Token_myLang\"", 
				"srcLength": "14"
			}
		}, 
		"286: data": {
			"srcIndexStart": "14369", 
			"data": ".
	</div>

	<a name=\"Language_parseFile\" />
	<a name=\"Language_parseCode\" />
	", 
			"srcLength": "78"
		}, 
		"287: apiHead": {
			"srcIndexStart": "14447", 
			"data": "Parser_{languageName} parseFile(string filename)", 
			"srcLength": "62", 
			"0: data": {
				"srcIndexStart": "14457", 
				"data": "Parser_{languageName} parseFile(string filename)", 
				"srcLength": "50"
			}
		}, 
		"288: data": {
			"srcIndexStart": "14509", 
			"data": "
	", 
			"srcLength": "2"
		}, 
		"289: apiHead": {
			"srcIndexStart": "14511", 
			"data": "Parser_{languageName} parseCode(string source, string filename=\"\")", 
			"srcLength": "80", 
			"0: data": {
				"srcIndexStart": "14521", 
				"data": "Parser_{languageName} parseCode(string source, string filename=\"\")", 
				"srcLength": "68"
			}
		}, 
		"290: data": {
			"srcIndexStart": "14591", 
			"data": "
	", 
			"srcLength": "2"
		}, 
		"291: apiHead": {
			"srcIndexStart": "14593", 
			"data": " Parser_{languageName} parseTokens(Token[] tokens, string filename=\"\", Lexer lexerUsed=null) ", 
			"srcLength": "109", 
			"0: data": {
				"srcIndexStart": "14603", 
				"data": " Parser_{languageName} parseTokens(Token[] tokens, string filename=\"\", Lexer lexerUsed=null) ", 
				"srcLength": "97"
			}
		}, 
		"292: data": {
			"srcIndexStart": "14702", 
			"data": "
	", 
			"srcLength": "2"
		}, 
		"293: apiHead": {
			"srcIndexStart": "14704", 
			"data": "Lexer_{languageName} lexFile(string filename)", 
			"srcLength": "59", 
			"0: data": {
				"srcIndexStart": "14714", 
				"data": "Lexer_{languageName} lexFile(string filename)", 
				"srcLength": "47"
			}
		}, 
		"294: data": {
			"srcIndexStart": "14763", 
			"data": "
	", 
			"srcLength": "2"
		}, 
		"295: apiHead": {
			"srcIndexStart": "14765", 
			"data": "Lexer_{languageName} lexCode(string source, string filename=\"\")", 
			"srcLength": "77", 
			"0: data": {
				"srcIndexStart": "14775", 
				"data": "Lexer_{languageName} lexCode(string source, string filename=\"\")", 
				"srcLength": "65"
			}
		}, 
		"296: data": {
			"srcIndexStart": "14842", 
			"data": "
	<div class=\"api-def\">
	<p>
	Type-safe ", 
			"srcLength": "40"
		}, 
		"297: pageLink": {
			"srcIndexStart": "14882", 
			"param 0": "StatVsDyn", 
			"data": "static-style", 
			"srcLength": "35", 
			"0: data": {
				"srcIndexStart": "14903", 
				"data": "static-style", 
				"srcLength": "12"
			}
		}, 
		"298: data": {
			"srcIndexStart": "14917", 
			"data": " counterparts to the
	respective \"X\"-suffixed lex and parse functions in ", 
			"srcLength": "73"
		}, 
		"299: typeName": {
			"srcIndexStart": "14990", 
			"data": "Language", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "15001", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"300: data": {
			"srcIndexStart": "15011", 
			"data": ".
	</p>
	</div>
</div>

", 
			"srcLength": "24"
		}, 
		"301: apiSection": {
			"srcIndexStart": "15035", 
			"param 0": "Module", 
			"param 1": "{user-specified package}.lang", 
			"data": "Module-Level Members", 
			"srcLength": "78", 
			"0: data": {
				"srcIndexStart": "15089", 
				"data": "Module-Level Members", 
				"srcLength": "22"
			}
		}, 
		"302: data": {
			"srcIndexStart": "15113", 
			"data": "
<div class=\"api-def\">
	<p></p>
	
	", 
			"srcLength": "35"
		}, 
		"303: apiHead": {
			"srcIndexStart": "15148", 
			"data": " Language_{languageName} language_{languageName} ", 
			"srcLength": "65", 
			"0: data": {
				"srcIndexStart": "15158", 
				"data": " Language_{languageName} language_{languageName} ", 
				"srcLength": "53"
			}
		}, 
		"304: data": {
			"srcIndexStart": "15213", 
			"data": "
	<div class=\"api-def\">
	<p>
	A pre-instantiated instance of a ", 
			"srcLength": "63"
		}, 
		"305: typeName": {
			"srcIndexStart": "15276", 
			"data": "Language_{languageName}", 
			"srcLength": "36", 
			"0: data": {
				"srcIndexStart": "15287", 
				"data": "Language_{languageName}", 
				"srcLength": "23"
			}
		}, 
		"306: data": {
			"srcIndexStart": "15312", 
			"data": ", 
	generated by ", 
			"srcLength": "17"
		}, 
		"307: pageName": {
			"srcIndexStart": "15329", 
			"data": "StaticLang", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "15340", 
				"data": "StaticLang", 
				"srcLength": "10"
			}
		}, 
		"308: data": {
			"srcIndexStart": "15352", 
			"data": " and only created
	for ", 
			"srcLength": "23"
		}, 
		"309: pageLink": {
			"srcIndexStart": "15375", 
			"param 0": "StatVsDyn", 
			"data": "static-style", 
			"srcLength": "35", 
			"0: data": {
				"srcIndexStart": "15396", 
				"data": "static-style", 
				"srcLength": "12"
			}
		}, 
		"310: data": {
			"srcIndexStart": "15410", 
			"data": " languages.
	</p>
	<p>
	For example, if the name of a language is ", 
			"srcLength": "66"
		}, 
		"311: ident": {
			"srcIndexStart": "15476", 
			"data": "foo", 
			"srcLength": "13", 
			"0: data": {
				"srcIndexStart": "15484", 
				"data": "foo", 
				"srcLength": "3"
			}
		}, 
		"312: data": {
			"srcIndexStart": "15489", 
			"data": ", then
	the declaration of this will be:
	</p>
	", 
			"srcLength": "48"
		}, 
		"313: code": {
			"srcIndexStart": "15537", 
			"param 0": "highlight", 
			"data": "Language_foo language_foo;", 
			"srcLength": "45", 
			"0: data": {
				"srcIndexStart": "15554", 
				"data": "Language_foo language_foo;", 
				"srcLength": "26"
			}
		}, 
		"314: data": {
			"srcIndexStart": "15582", 
			"data": "
	</div>
</div>", 
			"srcLength": "16"
		}
	}
}