{
	"0: data": {
		"srcIndexStart": "0", 
		"file": "docssrc/docs.APIRef.Base.tmpl", 
		"parseTreeMode": "true", 
		"srcLength": "11777", 
		"source": "[$name|Base$]
[$title|Base$]
[$frame|HTMLPage.tmpl$]

<ul>
<li>[$typeLink| CharPair     | struct CharPair      $]</li>
<li>[$typeLink| CharSet      | struct CharSet       $]</li>
<li>[$pageLink| #Symbol      | struct Symbol        $]</li>
<li>[$typeLink| Rule         | struct Rule          $]</li>
<li>[$typeLink| DFAState     | struct DFAState      $]</li>
<li>[$typeLink| DFAStateEdge | struct DFAStateEdge  $]</li>
<li>[$typeLink| LALRState    | struct LALRState     $]</li>
<li>[$typeLink| LALRAction   | struct LALRAction    $]</li>
<li>[$pageLink| #Module      | Module-Level Members $]</li>
</ul>

<p>
These types store the information contained in a
[$pageLink| CGT | CGT file $].
For more information on what these actually mean, see GOLD's documentation on
[$link| http://goldparser.org/articles/dfa.htm | DFA Lexing $],
[$link| http://goldparser.org/articles/lalr.htm | LALR(1) Parsing $],
and the
[$link| http://goldparser.org/doc/cgt/index.htm | CGT file format $].
</p>
<p>
Most users of GoldieLib will only need to deal directly with [$typeName|Symbol$].
</p>

[$apiSectionType| CharPair | goldie.base | struct CharPair $]
<div class=\"api-def\">
	[$apiHead|[:
		dchar start 
		dchar end
	:]$]
	<div class=\"api-def\">
		The start and end points of a range of UTF-32 code points.
		Both [$ident|start$] and [$ident|end$] are inclusive.
	</div>

	[$apiHead|[: const bool opEquals(ref const CharPair s) :]$]
	<div class=\"api-def\">
		Comparison operator.
	</div>
	
	[$apiHead|[: string toString() :]$]
	<div class=\"api-def\">
		The result of this is valid D code representing a struct literal.
		For example:
[$code|highlight|
[:auto charPair = CharPair('A', 'Z');
assert(charPair.toString() == `CharPair('\\U00000041','\\U0000005A')`);:]
$]
	</div>
</div>

[$apiSectionType| CharSet | goldie.base | struct CharSet $]
<div class=\"api-def\">
	[$apiHead|[: CharPair[] pairs :]$]
	<div class=\"api-def\">
		This array defines all the UTF-32 code points
		contained in this character set.
	</div>

	[$apiHead|[: this(dstring str) :]$]
	<div class=\"api-def\">
	<p>
		Constructor.
	</p>
	<p>
		Automatically converts an unsorted array of UTF-32 code points
		(with possible duplicates) to the internal, sorted and canonical,
		[$code|inline|[:CharPair[]:]$] representation.
	</p>
	</div>
	
	[$apiHead|[: this(CharPair[] pairs) :]$]
	<div class=\"api-def\">
	<p>
		Constructor.
	</p>
	<p>
		This <em>should</em> be sorted and canonical. For instance,
		a set containing \"ABC123\" <em>should</em> be laid out exactly
		like this:
	</p>
[$code|highlight|
[:CharSet([ CharPair('1','3'), CharPair('A','C') ]);:]$]
	<p>
		Any other equivalent set <em>might not</em> be properly handled by
		when comparing with another CharSet. See [$ident|opEquals$] below
		for specifics.
	</p>
	<p>
		If you're not passing the CharSet into Goldie, and you don't need
		comparisons to be properly set-based, then this isn't required to be
		sorted or canonical.
	</p>
	</div>

	[$apiHead|[: const bool opEquals(ref const CharSet s) :]$]
	<div class=\"api-def\">
	<p>
		Comparison operator.
	</p>
	<p>
		Only checks that the [$ident|pairs$] arrays are equal.
		Doesn't check for set equivalence:
	</p>
[$code|highlight|
[:auto a = CharSet([ CharPair('A','D') ]);
auto b = CharSet([ CharPair('A','B'), CharPair('C','D') ]);
auto c = CharSet([ CharPair('C','D'), CharPair('A','B') ]);
auto d = CharSet([ CharPair('A','C'), CharPair('B','D') ]);
assert(a == b); // Fails!
assert(a == c); // Fails!
assert(a == d); // Fails!
assert(b == c); // Fails!
assert(b == d); // Fails!
assert(c == d); // Fails!
:]$]
	</div>
	
	[$apiHead|[: string toString() :]$]
	<div class=\"api-def\">
		The result of this is valid D code representing a struct literal.
		For example:
[$code|highlight|
[:auto charSet = CharSet(\"123ABC\"d);
assert(
	charSet.toString() ==
	`CharSet(CharPair('\\U00000031','\\U00000033'),CharPair('\\U00000041','\\U00000043'))`
);
:]$]
	</div>

	[$apiHead|[: dstring toRawChars() :]$]
	<div class=\"api-def\">
	<p>
		Returns an array of all the UTF-32 code points in this set.
	</p>
	<p>
		Not guaranteed to be sorted or to lack duplicates unless the
		internal [$ident|pairs$] array is sorted and canonical.
	</p>
	</div>

	[$apiHead|[: CharSet dup() const :]$]
	<div class=\"api-def\">
		Returns a deep (not shallow) duplicate of this CharSet.
	</div>

	[$apiHead|[: bool matches(dchar ch) :]$]
	<div class=\"api-def\">
		Checks whether a UTF-32 code point is included in this set.
[$code|highlight|
[:auto charSet = CharSet([ CharPair('1','3'), CharPair('A','C') ]);
assert(charSet.matches('B'));:]$]
	</div>
</div>

[$apiSection| Symbol | goldie.base | struct Symbol $]
<div class=\"api-def\">
	See the [$pageTitle|Symbol$] page.
</div>

[$apiSectionType| Rule | goldie.base | struct Rule $]
<div class=\"api-def\">
	[$apiHead|[: int symbolIndex :]$]
	<div class=\"api-def\">
	<p>
		The nonterminal symbol this rule reduces to.
	</p>
	<p>
		This is an index into [$typeName|Language$][$ident|.symbolTable$].
	</p>
	</div>

	[$apiHead|[: int[] subSymbolIndicies :]$]
	<div class=\"api-def\">
	<p>
		The symbols that get reduced by this rule.
	</p>
	<p>
		These are indicies into [$typeName|Language$][$ident|.symbolTable$].
	</p>
	</div>

	[$apiHead|[: string toString() :]$]
	<div class=\"api-def\">
		The result of this is valid D code representing a struct literal.
		For example:
[$code|highlight|
[:auto rule = Rule(10, [2, 3, 4]);
assert(rule.toString() == `Rule( 10, [2, 3, 4] )`);
:]$]
	</div>

	[$apiHead|[: Rule dup() const :]$]
	<div class=\"api-def\">
		Returns a deep (not shallow) duplicate of this Rule.
	</div>
</div>

[$apiSectionType| DFAState | goldie.base | struct DFAState $]
<div class=\"api-def\">
	[$apiHead|[: bool accept :]$]
	<div class=\"api-def\">
		Is this an \"accept\" state?
	</div>

	[$apiHead|[: int acceptSymbolIndex :]$]
	<div class=\"api-def\">
	<p>
		If this is an accept state, [$ident|acceptSymbolIndex$] refers to
		the symbol that has been found.
	</p>
	<p>
		This is an index into [$typeName|Language$][$ident|.symbolTable$].
	</p>
	</div>

	[$apiHead|[: DFAStateEdge[] edges :]$]
	<div class=\"api-def\">
	<p>
		The DFA edges leading away from this state.
	</p>
	<p>
		For more information,
		see [$typeName|DFAStateEdge$] and GOLD's documentation on both
		[$link| http://goldparser.org/articles/dfa.htm | DFA Lexing $]
		and the
		[$link| http://goldparser.org/doc/cgt/index.htm | CGT file format $].
	</p>
	</div>

	[$apiHead|[: string toString() :]$]
	<div class=\"api-def\">
		The result of this is valid D code representing a struct literal.
		For example:
[$code|highlight|
[:auto dfaState = DFAState(true, 5, [ DFAStateEdge(3, 8) ]);
assert(dfaState.toString() == `DFAState( true, 5, [DFAStateEdge(3,8)] )`);
:]$]
	</div>

	[$apiHead|[: DFAState dup() const :]$]
	<div class=\"api-def\">
		Returns a deep (not shallow) duplicate of this DFAState.
	</div>
</div>

[$apiSectionType| DFAStateEdge | goldie.base | struct DFAStateEdge $]
<div class=\"api-def\">
	<p>
		If the current character being scanned by the [$typeName|Lexer$]
		is in the character set referred to by [$ident|charSetIndex$],
		then the [$typeName|Lexer$] moves to the DFA state referred to by
		[$ident|targetDFAStateIndex$].
	</p>
	<p>
		For more information, see GOLD's documentation on
		[$link| http://goldparser.org/articles/dfa.htm | DFA Lexing $]
		and the
		[$link| http://goldparser.org/doc/cgt/index.htm | CGT file format $].
	</p>
	[$apiHead|[: int charSetIndex :]$]
	<div class=\"api-def\">
		This is an index into [$typeName|Language$][$ident|.charSetTable$].
	</div>

	[$apiHead|[: int targetDFAStateIndex :]$]
	<div class=\"api-def\">
		This is an index into [$typeName|Language$][$ident|.dfaTable$].
	</div>

	[$apiHead|[: string toString() :]$]
	<div class=\"api-def\">
		The result of this is valid D code representing a struct literal.
		For example:
[$code|highlight|
[:auto dfaEdge = DFAStateEdge(3, 8);
assert(dfaEdge.toString() == `DFAStateEdge(3,8)`);
:]$]
	</div>
</div>

[$apiSectionType| LALRState | goldie.base | struct LALRState $]
<div class=\"api-def\">
	[$apiHead|[: LALRAction[] actions :]$]
	<div class=\"api-def\">
	<p>
		The possible LALR actions associated with this state.
	</p>
	<p>
		For more information, see GOLD's documentation on
		[$link| http://goldparser.org/articles/lalr.htm | LALR Parsing $]
		and the
		[$link| http://goldparser.org/doc/cgt/index.htm | CGT file format $].
	</p>
	</div>

	[$apiHead|[: string toString() :]$]
	<div class=\"api-def\">
		The result of this is valid D code representing a struct literal.
		For example:
[$code|highlight|
[:auto lalrState = LALRState([ LALRAction(7, LALRAction.Type.Shift, 10) ]);
assert(lalrState.toString() == `LALRState( [LALRAction(7,LALRAction.Type.Shift,10)] )`);
:]$]
	</div>

	[$apiHead|[: LALRState dup() const :]$]
	<div class=\"api-def\">
		Returns a deep (not shallow) duplicate of this LALRState.
	</div>
</div>

[$apiSectionType| LALRAction | goldie.base | struct LALRAction $]
<div class=\"api-def\">
	[$apiHead|[: enum Type :]$]
	<div class=\"api-def\">
		The definition of [$ident|LALRAction.Type$] is:
[$code|highlight|
[:enum Type
{
    Shift  = 1, // target: LALR State Index
    Reduce = 2, // target: Rule Index
    Goto   = 3, // target: LALR State Index
    Accept = 4  // target: unused
}
:]$]
	</div>

	[$apiHead|[: int symbolId :]$]
	<div class=\"api-def\">
	<p>
		The symbol expected in order for the [$typeName|Parser$] to take
		this branch of the LALR graph.
	</p>
	<p>
		This is an index into [$typeName|Language$][$ident|.symbolTable$].
	</p>
	<p>
		For more information, see the definition of enum [$ident|Type$] above,
		as well as GOLD's documentation on
		[$link| http://goldparser.org/articles/lalr.htm | LALR Parsing $]
		and the
		[$link| http://goldparser.org/doc/cgt/index.htm | CGT file format $].
	</p>
	</div>

	[$apiHead|[: Type type :]$]
	<div class=\"api-def\">
	<p>
		The type of this state.
	</p>
	<p>
		For more information, see the definition of enum [$ident|Type$] above,
		as well as GOLD's documentation on
		[$link| http://goldparser.org/articles/lalr.htm | LALR Parsing $]
		and the
		[$link| http://goldparser.org/doc/cgt/index.htm | CGT file format $].
	</p>
	</div>

	[$apiHead|[: int target :]$]
	<div class=\"api-def\">
	<p>
		Extra information associated with this LALR state.
		The exact meaning of this depends on the value of [$ident|type$].
	</p>
	<p>
		For more information, see the definition of enum [$ident|Type$] above,
		as well as GOLD's documentation on
		[$link| http://goldparser.org/articles/lalr.htm | LALR Parsing $]
		and the
		[$link| http://goldparser.org/doc/cgt/index.htm | CGT file format $].
	</p>
	</div>

	[$apiHead|[: string toString() :]$]
	<div class=\"api-def\">
		The result of this is valid D code representing a struct literal.
		For example:
[$code|highlight|
[:auto lalrAction = LALRAction(7, LALRAction.Type.Shift, 10);
assert(lalrAction.toString() == `LALRAction(7,LALRAction.Type.Shift,10)`);
:]$]
	</div>

	[$apiHead|[: static string typeToString(Type type) :]$]
	<div class=\"api-def\">
		Example:
[$code|highlight|
[:string str = LALRAction.typeToString(LALRAction.Type.Reduce);
assert(str == \"Reduce\");
:]$]
	</div>

	[$apiHead|[: static string fullTypeToString(Type type) :]$]
	<div class=\"api-def\">
		Example:
[$code|highlight|
[:string str = LALRAction.fullTypeToString(LALRAction.Type.Reduce);
assert(str == \"LALRAction.Type.Reduce\");
:]$]
	</div>
</div>

[$apiSection| Module | goldie.base | Module-Level Members $]
<div class=\"api-def\">
	[$apiHead|[: T[] goldieBaseDup(T)(const(T[]) arr) :]$]
	<div class=\"api-def\">
	<p>
		Duplicates the given array, calling [$code|inline|xxxx.dup()$]
		on each member.
	</p>
	<p>
		Intended specifically for arrays of the types defined in
		this [$code|inline|goldie.base$] module.
	</p>
	</div>
</div>
", 
		"0: name": {
			"srcIndexStart": "0", 
			"data": "Base", 
			"srcLength": "13", 
			"0: data": {
				"srcIndexStart": "7", 
				"data": "Base", 
				"srcLength": "4"
			}
		}, 
		"1: data": {
			"srcIndexStart": "13", 
			"data": "
", 
			"srcLength": "1"
		}, 
		"2: title": {
			"srcIndexStart": "14", 
			"data": "Base", 
			"srcLength": "14", 
			"0: data": {
				"srcIndexStart": "22", 
				"data": "Base", 
				"srcLength": "4"
			}
		}, 
		"3: data": {
			"srcIndexStart": "28", 
			"data": "
", 
			"srcLength": "1"
		}, 
		"4: frame": {
			"srcIndexStart": "29", 
			"data": "HTMLPage.tmpl", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "37", 
				"data": "HTMLPage.tmpl", 
				"srcLength": "13"
			}
		}, 
		"5: data": {
			"srcIndexStart": "52", 
			"data": "

<ul>
<li>", 
			"srcLength": "11"
		}, 
		"6: typeLink": {
			"srcIndexStart": "63", 
			"param 0": "CharPair", 
			"data": "struct CharPair", 
			"srcLength": "50", 
			"0: data": {
				"srcIndexStart": "89", 
				"data": "struct CharPair", 
				"srcLength": "22"
			}
		}, 
		"7: data": {
			"srcIndexStart": "113", 
			"data": "</li>
<li>", 
			"srcLength": "10"
		}, 
		"8: typeLink": {
			"srcIndexStart": "123", 
			"param 0": "CharSet", 
			"data": "struct CharSet", 
			"srcLength": "50", 
			"0: data": {
				"srcIndexStart": "149", 
				"data": "struct CharSet", 
				"srcLength": "22"
			}
		}, 
		"9: data": {
			"srcIndexStart": "173", 
			"data": "</li>
<li>", 
			"srcLength": "10"
		}, 
		"10: pageLink": {
			"srcIndexStart": "183", 
			"param 0": "#Symbol", 
			"data": "struct Symbol", 
			"srcLength": "50", 
			"0: data": {
				"srcIndexStart": "209", 
				"data": "struct Symbol", 
				"srcLength": "22"
			}
		}, 
		"11: data": {
			"srcIndexStart": "233", 
			"data": "</li>
<li>", 
			"srcLength": "10"
		}, 
		"12: typeLink": {
			"srcIndexStart": "243", 
			"param 0": "Rule", 
			"data": "struct Rule", 
			"srcLength": "50", 
			"0: data": {
				"srcIndexStart": "269", 
				"data": "struct Rule", 
				"srcLength": "22"
			}
		}, 
		"13: data": {
			"srcIndexStart": "293", 
			"data": "</li>
<li>", 
			"srcLength": "10"
		}, 
		"14: typeLink": {
			"srcIndexStart": "303", 
			"param 0": "DFAState", 
			"data": "struct DFAState", 
			"srcLength": "50", 
			"0: data": {
				"srcIndexStart": "329", 
				"data": "struct DFAState", 
				"srcLength": "22"
			}
		}, 
		"15: data": {
			"srcIndexStart": "353", 
			"data": "</li>
<li>", 
			"srcLength": "10"
		}, 
		"16: typeLink": {
			"srcIndexStart": "363", 
			"param 0": "DFAStateEdge", 
			"data": "struct DFAStateEdge", 
			"srcLength": "50", 
			"0: data": {
				"srcIndexStart": "389", 
				"data": "struct DFAStateEdge", 
				"srcLength": "22"
			}
		}, 
		"17: data": {
			"srcIndexStart": "413", 
			"data": "</li>
<li>", 
			"srcLength": "10"
		}, 
		"18: typeLink": {
			"srcIndexStart": "423", 
			"param 0": "LALRState", 
			"data": "struct LALRState", 
			"srcLength": "50", 
			"0: data": {
				"srcIndexStart": "449", 
				"data": "struct LALRState", 
				"srcLength": "22"
			}
		}, 
		"19: data": {
			"srcIndexStart": "473", 
			"data": "</li>
<li>", 
			"srcLength": "10"
		}, 
		"20: typeLink": {
			"srcIndexStart": "483", 
			"param 0": "LALRAction", 
			"data": "struct LALRAction", 
			"srcLength": "50", 
			"0: data": {
				"srcIndexStart": "509", 
				"data": "struct LALRAction", 
				"srcLength": "22"
			}
		}, 
		"21: data": {
			"srcIndexStart": "533", 
			"data": "</li>
<li>", 
			"srcLength": "10"
		}, 
		"22: pageLink": {
			"srcIndexStart": "543", 
			"param 0": "#Module", 
			"data": "Module-Level Members", 
			"srcLength": "50", 
			"0: data": {
				"srcIndexStart": "569", 
				"data": "Module-Level Members", 
				"srcLength": "22"
			}
		}, 
		"23: data": {
			"srcIndexStart": "593", 
			"data": "</li>
</ul>

<p>
These types store the information contained in a
", 
			"srcLength": "66"
		}, 
		"24: pageLink": {
			"srcIndexStart": "659", 
			"param 0": "CGT", 
			"data": "CGT file", 
			"srcLength": "29", 
			"0: data": {
				"srcIndexStart": "676", 
				"data": "CGT file", 
				"srcLength": "10"
			}
		}, 
		"25: data": {
			"srcIndexStart": "688", 
			"data": ".
For more information on what these actually mean, see GOLD's documentation on
", 
			"srcLength": "80"
		}, 
		"26: link": {
			"srcIndexStart": "768", 
			"param 0": "http://goldparser.org/articles/dfa.htm", 
			"data": "DFA Lexing", 
			"srcLength": "62", 
			"0: data": {
				"srcIndexStart": "816", 
				"data": "DFA Lexing", 
				"srcLength": "12"
			}
		}, 
		"27: data": {
			"srcIndexStart": "830", 
			"data": ",
", 
			"srcLength": "2"
		}, 
		"28: link": {
			"srcIndexStart": "832", 
			"param 0": "http://goldparser.org/articles/lalr.htm", 
			"data": "LALR(1) Parsing", 
			"srcLength": "68", 
			"0: data": {
				"srcIndexStart": "881", 
				"data": "LALR(1) Parsing", 
				"srcLength": "17"
			}
		}, 
		"29: data": {
			"srcIndexStart": "900", 
			"data": ",
and the
", 
			"srcLength": "10"
		}, 
		"30: link": {
			"srcIndexStart": "910", 
			"param 0": "http://goldparser.org/doc/cgt/index.htm", 
			"data": "CGT file format", 
			"srcLength": "68", 
			"0: data": {
				"srcIndexStart": "959", 
				"data": "CGT file format", 
				"srcLength": "17"
			}
		}, 
		"31: data": {
			"srcIndexStart": "978", 
			"data": ".
</p>
<p>
Most users of GoldieLib will only need to deal directly with ", 
			"srcLength": "72"
		}, 
		"32: typeName": {
			"srcIndexStart": "1050", 
			"data": "Symbol", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "1061", 
				"data": "Symbol", 
				"srcLength": "6"
			}
		}, 
		"33: data": {
			"srcIndexStart": "1069", 
			"data": ".
</p>

", 
			"srcLength": "8"
		}, 
		"34: apiSectionType": {
			"srcIndexStart": "1077", 
			"param 0": "CharPair", 
			"param 1": "goldie.base", 
			"data": "struct CharPair", 
			"srcLength": "61", 
			"0: data": {
				"srcIndexStart": "1119", 
				"data": "struct CharPair", 
				"srcLength": "17"
			}
		}, 
		"35: data": {
			"srcIndexStart": "1138", 
			"data": "
<div class=\"api-def\">
	", 
			"srcLength": "24"
		}, 
		"36: apiHead": {
			"srcIndexStart": "1162", 
			"data": "
		dchar start 
		dchar end
	", 
			"srcLength": "45", 
			"0: data": {
				"srcIndexStart": "1172", 
				"data": "
		dchar start 
		dchar end
	", 
				"srcLength": "33"
			}
		}, 
		"37: data": {
			"srcIndexStart": "1207", 
			"data": "
	<div class=\"api-def\">
		The start and end points of a range of UTF-32 code points.
		Both ", 
			"srcLength": "92"
		}, 
		"38: ident": {
			"srcIndexStart": "1299", 
			"data": "start", 
			"srcLength": "15", 
			"0: data": {
				"srcIndexStart": "1307", 
				"data": "start", 
				"srcLength": "5"
			}
		}, 
		"39: data": {
			"srcIndexStart": "1314", 
			"data": " and ", 
			"srcLength": "5"
		}, 
		"40: ident": {
			"srcIndexStart": "1319", 
			"data": "end", 
			"srcLength": "13", 
			"0: data": {
				"srcIndexStart": "1327", 
				"data": "end", 
				"srcLength": "3"
			}
		}, 
		"41: data": {
			"srcIndexStart": "1332", 
			"data": " are inclusive.
	</div>

	", 
			"srcLength": "26"
		}, 
		"42: apiHead": {
			"srcIndexStart": "1358", 
			"data": " const bool opEquals(ref const CharPair s) ", 
			"srcLength": "59", 
			"0: data": {
				"srcIndexStart": "1368", 
				"data": " const bool opEquals(ref const CharPair s) ", 
				"srcLength": "47"
			}
		}, 
		"43: data": {
			"srcIndexStart": "1417", 
			"data": "
	<div class=\"api-def\">
		Comparison operator.
	</div>
	
	", 
			"srcLength": "58"
		}, 
		"44: apiHead": {
			"srcIndexStart": "1475", 
			"data": " string toString() ", 
			"srcLength": "35", 
			"0: data": {
				"srcIndexStart": "1485", 
				"data": " string toString() ", 
				"srcLength": "23"
			}
		}, 
		"45: data": {
			"srcIndexStart": "1510", 
			"data": "
	<div class=\"api-def\">
		The result of this is valid D code representing a struct literal.
		For example:
", 
			"srcLength": "107"
		}, 
		"46: code": {
			"srcIndexStart": "1617", 
			"param 0": "highlight", 
			"data": "auto charPair = CharPair('A', 'Z');
assert(charPair.toString() == `CharPair('\\U00000041','\\U0000005A')`);", 
			"srcLength": "130", 
			"0: data": {
				"srcIndexStart": "1634", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "1635", 
				"data": "auto charPair = CharPair('A', 'Z');
assert(charPair.toString() == `CharPair('\\U00000041','\\U0000005A')`);", 
				"srcLength": "109"
			}, 
			"2: data": {
				"srcIndexStart": "1744", 
				"data": "", 
				"srcLength": "1"
			}
		}, 
		"47: data": {
			"srcIndexStart": "1747", 
			"data": "
	</div>
</div>

", 
			"srcLength": "17"
		}, 
		"48: apiSectionType": {
			"srcIndexStart": "1764", 
			"param 0": "CharSet", 
			"param 1": "goldie.base", 
			"data": "struct CharSet", 
			"srcLength": "59", 
			"0: data": {
				"srcIndexStart": "1805", 
				"data": "struct CharSet", 
				"srcLength": "16"
			}
		}, 
		"49: data": {
			"srcIndexStart": "1823", 
			"data": "
<div class=\"api-def\">
	", 
			"srcLength": "24"
		}, 
		"50: apiHead": {
			"srcIndexStart": "1847", 
			"data": " CharPair[] pairs ", 
			"srcLength": "34", 
			"0: data": {
				"srcIndexStart": "1857", 
				"data": " CharPair[] pairs ", 
				"srcLength": "22"
			}
		}, 
		"51: data": {
			"srcIndexStart": "1881", 
			"data": "
	<div class=\"api-def\">
		This array defines all the UTF-32 code points
		contained in this character set.
	</div>

	", 
			"srcLength": "117"
		}, 
		"52: apiHead": {
			"srcIndexStart": "1998", 
			"data": " this(dstring str) ", 
			"srcLength": "35", 
			"0: data": {
				"srcIndexStart": "2008", 
				"data": " this(dstring str) ", 
				"srcLength": "23"
			}
		}, 
		"53: data": {
			"srcIndexStart": "2033", 
			"data": "
	<div class=\"api-def\">
	<p>
		Constructor.
	</p>
	<p>
		Automatically converts an unsorted array of UTF-32 code points
		(with possible duplicates) to the internal, sorted and canonical,
		", 
			"srcLength": "190"
		}, 
		"54: code": {
			"srcIndexStart": "2223", 
			"param 0": "inline", 
			"data": "CharPair[]", 
			"srcLength": "30", 
			"0: data": {
				"srcIndexStart": "2237", 
				"data": "CharPair[]", 
				"srcLength": "14"
			}
		}, 
		"55: data": {
			"srcIndexStart": "2253", 
			"data": " representation.
	</p>
	</div>
	
	", 
			"srcLength": "34"
		}, 
		"56: apiHead": {
			"srcIndexStart": "2287", 
			"data": " this(CharPair[] pairs) ", 
			"srcLength": "40", 
			"0: data": {
				"srcIndexStart": "2297", 
				"data": " this(CharPair[] pairs) ", 
				"srcLength": "28"
			}
		}, 
		"57: data": {
			"srcIndexStart": "2327", 
			"data": "
	<div class=\"api-def\">
	<p>
		Constructor.
	</p>
	<p>
		This <em>should</em> be sorted and canonical. For instance,
		a set containing \"ABC123\" <em>should</em> be laid out exactly
		like this:
	</p>
", 
			"srcLength": "200"
		}, 
		"58: code": {
			"srcIndexStart": "2527", 
			"param 0": "highlight", 
			"data": "CharSet([ CharPair('1','3'), CharPair('A','C') ]);", 
			"srcLength": "74", 
			"0: data": {
				"srcIndexStart": "2544", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "2545", 
				"data": "CharSet([ CharPair('1','3'), CharPair('A','C') ]);", 
				"srcLength": "54"
			}
		}, 
		"59: data": {
			"srcIndexStart": "2601", 
			"data": "
	<p>
		Any other equivalent set <em>might not</em> be properly handled by
		when comparing with another CharSet. See ", 
			"srcLength": "118"
		}, 
		"60: ident": {
			"srcIndexStart": "2719", 
			"data": "opEquals", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "2727", 
				"data": "opEquals", 
				"srcLength": "8"
			}
		}, 
		"61: data": {
			"srcIndexStart": "2737", 
			"data": " below
		for specifics.
	</p>
	<p>
		If you're not passing the CharSet into Goldie, and you don't need
		comparisons to be properly set-based, then this isn't required to be
		sorted or canonical.
	</p>
	</div>

	", 
			"srcLength": "213"
		}, 
		"62: apiHead": {
			"srcIndexStart": "2950", 
			"data": " const bool opEquals(ref const CharSet s) ", 
			"srcLength": "58", 
			"0: data": {
				"srcIndexStart": "2960", 
				"data": " const bool opEquals(ref const CharSet s) ", 
				"srcLength": "46"
			}
		}, 
		"63: data": {
			"srcIndexStart": "3008", 
			"data": "
	<div class=\"api-def\">
	<p>
		Comparison operator.
	</p>
	<p>
		Only checks that the ", 
			"srcLength": "86"
		}, 
		"64: ident": {
			"srcIndexStart": "3094", 
			"data": "pairs", 
			"srcLength": "15", 
			"0: data": {
				"srcIndexStart": "3102", 
				"data": "pairs", 
				"srcLength": "5"
			}
		}, 
		"65: data": {
			"srcIndexStart": "3109", 
			"data": " arrays are equal.
		Doesn't check for set equivalence:
	</p>
", 
			"srcLength": "62"
		}, 
		"66: code": {
			"srcIndexStart": "3171", 
			"param 0": "highlight", 
			"data": "auto a = CharSet([ CharPair('A','D') ]);
auto b = CharSet([ CharPair('A','B'), CharPair('C','D') ]);
auto c = CharSet([ CharPair('C','D'), CharPair('A','B') ]);
auto d = CharSet([ CharPair('A','C'), CharPair('B','D') ]);
assert(a == b); <span class=\"code-comment\">// Fails!</span>
assert(a == c); <span class=\"code-comment\">// Fails!</span>
assert(a == d); <span class=\"code-comment\">// Fails!</span>
assert(b == c); <span class=\"code-comment\">// Fails!</span>
assert(b == d); <span class=\"code-comment\">// Fails!</span>
assert(c == d); <span class=\"code-comment\">// Fails!</span>
", 
			"srcLength": "401", 
			"0: data": {
				"srcIndexStart": "3188", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "3189", 
				"data": "auto a = CharSet([ CharPair('A','D') ]);
auto b = CharSet([ CharPair('A','B'), CharPair('C','D') ]);
auto c = CharSet([ CharPair('C','D'), CharPair('A','B') ]);
auto d = CharSet([ CharPair('A','C'), CharPair('B','D') ]);
assert(a == b); // Fails!
assert(a == c); // Fails!
assert(a == d); // Fails!
assert(b == c); // Fails!
assert(b == d); // Fails!
assert(c == d); // Fails!
", 
				"srcLength": "381"
			}
		}, 
		"67: data": {
			"srcIndexStart": "3572", 
			"data": "
	</div>
	
	", 
			"srcLength": "12"
		}, 
		"68: apiHead": {
			"srcIndexStart": "3584", 
			"data": " string toString() ", 
			"srcLength": "35", 
			"0: data": {
				"srcIndexStart": "3594", 
				"data": " string toString() ", 
				"srcLength": "23"
			}
		}, 
		"69: data": {
			"srcIndexStart": "3619", 
			"data": "
	<div class=\"api-def\">
		The result of this is valid D code representing a struct literal.
		For example:
", 
			"srcLength": "107"
		}, 
		"70: code": {
			"srcIndexStart": "3726", 
			"param 0": "highlight", 
			"data": "auto charSet = CharSet(\"123ABC\"d);
assert(
    charSet.toString() ==
    `CharSet(CharPair('\\U00000031','\\U00000033'),CharPair('\\U00000041','\\U00000043'))`
);
", 
			"srcLength": "177", 
			"0: data": {
				"srcIndexStart": "3743", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "3744", 
				"data": "auto charSet = CharSet(\"123ABC\"d);
assert(
	charSet.toString() ==
	`CharSet(CharPair('\\U00000031','\\U00000033'),CharPair('\\U00000041','\\U00000043'))`
);
", 
				"srcLength": "157"
			}
		}, 
		"71: data": {
			"srcIndexStart": "3903", 
			"data": "
	</div>

	", 
			"srcLength": "11"
		}, 
		"72: apiHead": {
			"srcIndexStart": "3914", 
			"data": " dstring toRawChars() ", 
			"srcLength": "38", 
			"0: data": {
				"srcIndexStart": "3924", 
				"data": " dstring toRawChars() ", 
				"srcLength": "26"
			}
		}, 
		"73: data": {
			"srcIndexStart": "3952", 
			"data": "
	<div class=\"api-def\">
	<p>
		Returns an array of all the UTF-32 code points in this set.
	</p>
	<p>
		Not guaranteed to be sorted or to lack duplicates unless the
		internal ", 
			"srcLength": "176"
		}, 
		"74: ident": {
			"srcIndexStart": "4128", 
			"data": "pairs", 
			"srcLength": "15", 
			"0: data": {
				"srcIndexStart": "4136", 
				"data": "pairs", 
				"srcLength": "5"
			}
		}, 
		"75: data": {
			"srcIndexStart": "4143", 
			"data": " array is sorted and canonical.
	</p>
	</div>

	", 
			"srcLength": "48"
		}, 
		"76: apiHead": {
			"srcIndexStart": "4191", 
			"data": " CharSet dup() const ", 
			"srcLength": "37", 
			"0: data": {
				"srcIndexStart": "4201", 
				"data": " CharSet dup() const ", 
				"srcLength": "25"
			}
		}, 
		"77: data": {
			"srcIndexStart": "4228", 
			"data": "
	<div class=\"api-def\">
		Returns a deep (not shallow) duplicate of this CharSet.
	</div>

	", 
			"srcLength": "92"
		}, 
		"78: apiHead": {
			"srcIndexStart": "4320", 
			"data": " bool matches(dchar ch) ", 
			"srcLength": "40", 
			"0: data": {
				"srcIndexStart": "4330", 
				"data": " bool matches(dchar ch) ", 
				"srcLength": "28"
			}
		}, 
		"79: data": {
			"srcIndexStart": "4360", 
			"data": "
	<div class=\"api-def\">
		Checks whether a UTF-32 code point is included in this set.
", 
			"srcLength": "86"
		}, 
		"80: code": {
			"srcIndexStart": "4446", 
			"param 0": "highlight", 
			"data": "auto charSet = CharSet([ CharPair('1','3'), CharPair('A','C') ]);
assert(charSet.matches('B'));", 
			"srcLength": "119", 
			"0: data": {
				"srcIndexStart": "4463", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "4464", 
				"data": "auto charSet = CharSet([ CharPair('1','3'), CharPair('A','C') ]);
assert(charSet.matches('B'));", 
				"srcLength": "99"
			}
		}, 
		"81: data": {
			"srcIndexStart": "4565", 
			"data": "
	</div>
</div>

", 
			"srcLength": "17"
		}, 
		"82: apiSection": {
			"srcIndexStart": "4582", 
			"param 0": "Symbol", 
			"param 1": "goldie.base", 
			"data": "struct Symbol", 
			"srcLength": "53", 
			"0: data": {
				"srcIndexStart": "4618", 
				"data": "struct Symbol", 
				"srcLength": "15"
			}
		}, 
		"83: data": {
			"srcIndexStart": "4635", 
			"data": "
<div class=\"api-def\">
	See the ", 
			"srcLength": "32"
		}, 
		"84: pageTitle": {
			"srcIndexStart": "4667", 
			"data": "Symbol", 
			"srcLength": "20", 
			"0: data": {
				"srcIndexStart": "4679", 
				"data": "Symbol", 
				"srcLength": "6"
			}
		}, 
		"85: data": {
			"srcIndexStart": "4687", 
			"data": " page.
</div>

", 
			"srcLength": "15"
		}, 
		"86: apiSectionType": {
			"srcIndexStart": "4702", 
			"param 0": "Rule", 
			"param 1": "goldie.base", 
			"data": "struct Rule", 
			"srcLength": "53", 
			"0: data": {
				"srcIndexStart": "4740", 
				"data": "struct Rule", 
				"srcLength": "13"
			}
		}, 
		"87: data": {
			"srcIndexStart": "4755", 
			"data": "
<div class=\"api-def\">
	", 
			"srcLength": "24"
		}, 
		"88: apiHead": {
			"srcIndexStart": "4779", 
			"data": " int symbolIndex ", 
			"srcLength": "33", 
			"0: data": {
				"srcIndexStart": "4789", 
				"data": " int symbolIndex ", 
				"srcLength": "21"
			}
		}, 
		"89: data": {
			"srcIndexStart": "4812", 
			"data": "
	<div class=\"api-def\">
	<p>
		The nonterminal symbol this rule reduces to.
	</p>
	<p>
		This is an index into ", 
			"srcLength": "111"
		}, 
		"90: typeName": {
			"srcIndexStart": "4923", 
			"data": "Language", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "4934", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"91: ident": {
			"srcIndexStart": "4944", 
			"data": ".symbolTable", 
			"srcLength": "22", 
			"0: data": {
				"srcIndexStart": "4952", 
				"data": ".symbolTable", 
				"srcLength": "12"
			}
		}, 
		"92: data": {
			"srcIndexStart": "4966", 
			"data": ".
	</p>
	</div>

	", 
			"srcLength": "18"
		}, 
		"93: apiHead": {
			"srcIndexStart": "4984", 
			"data": " int[] subSymbolIndicies ", 
			"srcLength": "41", 
			"0: data": {
				"srcIndexStart": "4994", 
				"data": " int[] subSymbolIndicies ", 
				"srcLength": "29"
			}
		}, 
		"94: data": {
			"srcIndexStart": "5025", 
			"data": "
	<div class=\"api-def\">
	<p>
		The symbols that get reduced by this rule.
	</p>
	<p>
		These are indicies into ", 
			"srcLength": "111"
		}, 
		"95: typeName": {
			"srcIndexStart": "5136", 
			"data": "Language", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "5147", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"96: ident": {
			"srcIndexStart": "5157", 
			"data": ".symbolTable", 
			"srcLength": "22", 
			"0: data": {
				"srcIndexStart": "5165", 
				"data": ".symbolTable", 
				"srcLength": "12"
			}
		}, 
		"97: data": {
			"srcIndexStart": "5179", 
			"data": ".
	</p>
	</div>

	", 
			"srcLength": "18"
		}, 
		"98: apiHead": {
			"srcIndexStart": "5197", 
			"data": " string toString() ", 
			"srcLength": "35", 
			"0: data": {
				"srcIndexStart": "5207", 
				"data": " string toString() ", 
				"srcLength": "23"
			}
		}, 
		"99: data": {
			"srcIndexStart": "5232", 
			"data": "
	<div class=\"api-def\">
		The result of this is valid D code representing a struct literal.
		For example:
", 
			"srcLength": "107"
		}, 
		"100: code": {
			"srcIndexStart": "5339", 
			"param 0": "highlight", 
			"data": "auto rule = Rule(10, [2, 3, 4]);
assert(rule.toString() == `Rule( 10, [2, 3, 4] )`);
", 
			"srcLength": "109", 
			"0: data": {
				"srcIndexStart": "5356", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "5357", 
				"data": "auto rule = Rule(10, [2, 3, 4]);
assert(rule.toString() == `Rule( 10, [2, 3, 4] )`);
", 
				"srcLength": "89"
			}
		}, 
		"101: data": {
			"srcIndexStart": "5448", 
			"data": "
	</div>

	", 
			"srcLength": "11"
		}, 
		"102: apiHead": {
			"srcIndexStart": "5459", 
			"data": " Rule dup() const ", 
			"srcLength": "34", 
			"0: data": {
				"srcIndexStart": "5469", 
				"data": " Rule dup() const ", 
				"srcLength": "22"
			}
		}, 
		"103: data": {
			"srcIndexStart": "5493", 
			"data": "
	<div class=\"api-def\">
		Returns a deep (not shallow) duplicate of this Rule.
	</div>
</div>

", 
			"srcLength": "95"
		}, 
		"104: apiSectionType": {
			"srcIndexStart": "5588", 
			"param 0": "DFAState", 
			"param 1": "goldie.base", 
			"data": "struct DFAState", 
			"srcLength": "61", 
			"0: data": {
				"srcIndexStart": "5630", 
				"data": "struct DFAState", 
				"srcLength": "17"
			}
		}, 
		"105: data": {
			"srcIndexStart": "5649", 
			"data": "
<div class=\"api-def\">
	", 
			"srcLength": "24"
		}, 
		"106: apiHead": {
			"srcIndexStart": "5673", 
			"data": " bool accept ", 
			"srcLength": "29", 
			"0: data": {
				"srcIndexStart": "5683", 
				"data": " bool accept ", 
				"srcLength": "17"
			}
		}, 
		"107: data": {
			"srcIndexStart": "5702", 
			"data": "
	<div class=\"api-def\">
		Is this an \"accept\" state?
	</div>

	", 
			"srcLength": "63"
		}, 
		"108: apiHead": {
			"srcIndexStart": "5765", 
			"data": " int acceptSymbolIndex ", 
			"srcLength": "39", 
			"0: data": {
				"srcIndexStart": "5775", 
				"data": " int acceptSymbolIndex ", 
				"srcLength": "27"
			}
		}, 
		"109: data": {
			"srcIndexStart": "5804", 
			"data": "
	<div class=\"api-def\">
	<p>
		If this is an accept state, ", 
			"srcLength": "59"
		}, 
		"110: ident": {
			"srcIndexStart": "5863", 
			"data": "acceptSymbolIndex", 
			"srcLength": "27", 
			"0: data": {
				"srcIndexStart": "5871", 
				"data": "acceptSymbolIndex", 
				"srcLength": "17"
			}
		}, 
		"111: data": {
			"srcIndexStart": "5890", 
			"data": " refers to
		the symbol that has been found.
	</p>
	<p>
		This is an index into ", 
			"srcLength": "80"
		}, 
		"112: typeName": {
			"srcIndexStart": "5970", 
			"data": "Language", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "5981", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"113: ident": {
			"srcIndexStart": "5991", 
			"data": ".symbolTable", 
			"srcLength": "22", 
			"0: data": {
				"srcIndexStart": "5999", 
				"data": ".symbolTable", 
				"srcLength": "12"
			}
		}, 
		"114: data": {
			"srcIndexStart": "6013", 
			"data": ".
	</p>
	</div>

	", 
			"srcLength": "18"
		}, 
		"115: apiHead": {
			"srcIndexStart": "6031", 
			"data": " DFAStateEdge[] edges ", 
			"srcLength": "38", 
			"0: data": {
				"srcIndexStart": "6041", 
				"data": " DFAStateEdge[] edges ", 
				"srcLength": "26"
			}
		}, 
		"116: data": {
			"srcIndexStart": "6069", 
			"data": "
	<div class=\"api-def\">
	<p>
		The DFA edges leading away from this state.
	</p>
	<p>
		For more information,
		see ", 
			"srcLength": "116"
		}, 
		"117: typeName": {
			"srcIndexStart": "6185", 
			"data": "DFAStateEdge", 
			"srcLength": "25", 
			"0: data": {
				"srcIndexStart": "6196", 
				"data": "DFAStateEdge", 
				"srcLength": "12"
			}
		}, 
		"118: data": {
			"srcIndexStart": "6210", 
			"data": " and GOLD's documentation on both
		", 
			"srcLength": "36"
		}, 
		"119: link": {
			"srcIndexStart": "6246", 
			"param 0": "http://goldparser.org/articles/dfa.htm", 
			"data": "DFA Lexing", 
			"srcLength": "62", 
			"0: data": {
				"srcIndexStart": "6294", 
				"data": "DFA Lexing", 
				"srcLength": "12"
			}
		}, 
		"120: data": {
			"srcIndexStart": "6308", 
			"data": "
		and the
		", 
			"srcLength": "13"
		}, 
		"121: link": {
			"srcIndexStart": "6321", 
			"param 0": "http://goldparser.org/doc/cgt/index.htm", 
			"data": "CGT file format", 
			"srcLength": "68", 
			"0: data": {
				"srcIndexStart": "6370", 
				"data": "CGT file format", 
				"srcLength": "17"
			}
		}, 
		"122: data": {
			"srcIndexStart": "6389", 
			"data": ".
	</p>
	</div>

	", 
			"srcLength": "18"
		}, 
		"123: apiHead": {
			"srcIndexStart": "6407", 
			"data": " string toString() ", 
			"srcLength": "35", 
			"0: data": {
				"srcIndexStart": "6417", 
				"data": " string toString() ", 
				"srcLength": "23"
			}
		}, 
		"124: data": {
			"srcIndexStart": "6442", 
			"data": "
	<div class=\"api-def\">
		The result of this is valid D code representing a struct literal.
		For example:
", 
			"srcLength": "107"
		}, 
		"125: code": {
			"srcIndexStart": "6549", 
			"param 0": "highlight", 
			"data": "auto dfaState = DFAState(true, 5, [ DFAStateEdge(3, 8) ]);
assert(dfaState.toString() == `DFAState( true, 5, [DFAStateEdge(3,8)] )`);
", 
			"srcLength": "158", 
			"0: data": {
				"srcIndexStart": "6566", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "6567", 
				"data": "auto dfaState = DFAState(true, 5, [ DFAStateEdge(3, 8) ]);
assert(dfaState.toString() == `DFAState( true, 5, [DFAStateEdge(3,8)] )`);
", 
				"srcLength": "138"
			}
		}, 
		"126: data": {
			"srcIndexStart": "6707", 
			"data": "
	</div>

	", 
			"srcLength": "11"
		}, 
		"127: apiHead": {
			"srcIndexStart": "6718", 
			"data": " DFAState dup() const ", 
			"srcLength": "38", 
			"0: data": {
				"srcIndexStart": "6728", 
				"data": " DFAState dup() const ", 
				"srcLength": "26"
			}
		}, 
		"128: data": {
			"srcIndexStart": "6756", 
			"data": "
	<div class=\"api-def\">
		Returns a deep (not shallow) duplicate of this DFAState.
	</div>
</div>

", 
			"srcLength": "99"
		}, 
		"129: apiSectionType": {
			"srcIndexStart": "6855", 
			"param 0": "DFAStateEdge", 
			"param 1": "goldie.base", 
			"data": "struct DFAStateEdge", 
			"srcLength": "69", 
			"0: data": {
				"srcIndexStart": "6901", 
				"data": "struct DFAStateEdge", 
				"srcLength": "21"
			}
		}, 
		"130: data": {
			"srcIndexStart": "6924", 
			"data": "
<div class=\"api-def\">
	<p>
		If the current character being scanned by the ", 
			"srcLength": "76"
		}, 
		"131: typeName": {
			"srcIndexStart": "7000", 
			"data": "Lexer", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "7011", 
				"data": "Lexer", 
				"srcLength": "5"
			}
		}, 
		"132: data": {
			"srcIndexStart": "7018", 
			"data": "
		is in the character set referred to by ", 
			"srcLength": "42"
		}, 
		"133: ident": {
			"srcIndexStart": "7060", 
			"data": "charSetIndex", 
			"srcLength": "22", 
			"0: data": {
				"srcIndexStart": "7068", 
				"data": "charSetIndex", 
				"srcLength": "12"
			}
		}, 
		"134: data": {
			"srcIndexStart": "7082", 
			"data": ",
		then the ", 
			"srcLength": "13"
		}, 
		"135: typeName": {
			"srcIndexStart": "7095", 
			"data": "Lexer", 
			"srcLength": "18", 
			"0: data": {
				"srcIndexStart": "7106", 
				"data": "Lexer", 
				"srcLength": "5"
			}
		}, 
		"136: data": {
			"srcIndexStart": "7113", 
			"data": " moves to the DFA state referred to by
		", 
			"srcLength": "41"
		}, 
		"137: ident": {
			"srcIndexStart": "7154", 
			"data": "targetDFAStateIndex", 
			"srcLength": "29", 
			"0: data": {
				"srcIndexStart": "7162", 
				"data": "targetDFAStateIndex", 
				"srcLength": "19"
			}
		}, 
		"138: data": {
			"srcIndexStart": "7183", 
			"data": ".
	</p>
	<p>
		For more information, see GOLD's documentation on
		", 
			"srcLength": "67"
		}, 
		"139: link": {
			"srcIndexStart": "7250", 
			"param 0": "http://goldparser.org/articles/dfa.htm", 
			"data": "DFA Lexing", 
			"srcLength": "62", 
			"0: data": {
				"srcIndexStart": "7298", 
				"data": "DFA Lexing", 
				"srcLength": "12"
			}
		}, 
		"140: data": {
			"srcIndexStart": "7312", 
			"data": "
		and the
		", 
			"srcLength": "13"
		}, 
		"141: link": {
			"srcIndexStart": "7325", 
			"param 0": "http://goldparser.org/doc/cgt/index.htm", 
			"data": "CGT file format", 
			"srcLength": "68", 
			"0: data": {
				"srcIndexStart": "7374", 
				"data": "CGT file format", 
				"srcLength": "17"
			}
		}, 
		"142: data": {
			"srcIndexStart": "7393", 
			"data": ".
	</p>
	", 
			"srcLength": "9"
		}, 
		"143: apiHead": {
			"srcIndexStart": "7402", 
			"data": " int charSetIndex ", 
			"srcLength": "34", 
			"0: data": {
				"srcIndexStart": "7412", 
				"data": " int charSetIndex ", 
				"srcLength": "22"
			}
		}, 
		"144: data": {
			"srcIndexStart": "7436", 
			"data": "
	<div class=\"api-def\">
		This is an index into ", 
			"srcLength": "48"
		}, 
		"145: typeName": {
			"srcIndexStart": "7484", 
			"data": "Language", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "7495", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"146: ident": {
			"srcIndexStart": "7505", 
			"data": ".charSetTable", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "7513", 
				"data": ".charSetTable", 
				"srcLength": "13"
			}
		}, 
		"147: data": {
			"srcIndexStart": "7528", 
			"data": ".
	</div>

	", 
			"srcLength": "12"
		}, 
		"148: apiHead": {
			"srcIndexStart": "7540", 
			"data": " int targetDFAStateIndex ", 
			"srcLength": "41", 
			"0: data": {
				"srcIndexStart": "7550", 
				"data": " int targetDFAStateIndex ", 
				"srcLength": "29"
			}
		}, 
		"149: data": {
			"srcIndexStart": "7581", 
			"data": "
	<div class=\"api-def\">
		This is an index into ", 
			"srcLength": "48"
		}, 
		"150: typeName": {
			"srcIndexStart": "7629", 
			"data": "Language", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "7640", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"151: ident": {
			"srcIndexStart": "7650", 
			"data": ".dfaTable", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "7658", 
				"data": ".dfaTable", 
				"srcLength": "9"
			}
		}, 
		"152: data": {
			"srcIndexStart": "7669", 
			"data": ".
	</div>

	", 
			"srcLength": "12"
		}, 
		"153: apiHead": {
			"srcIndexStart": "7681", 
			"data": " string toString() ", 
			"srcLength": "35", 
			"0: data": {
				"srcIndexStart": "7691", 
				"data": " string toString() ", 
				"srcLength": "23"
			}
		}, 
		"154: data": {
			"srcIndexStart": "7716", 
			"data": "
	<div class=\"api-def\">
		The result of this is valid D code representing a struct literal.
		For example:
", 
			"srcLength": "107"
		}, 
		"155: code": {
			"srcIndexStart": "7823", 
			"param 0": "highlight", 
			"data": "auto dfaEdge = DFAStateEdge(3, 8);
assert(dfaEdge.toString() == `DFAStateEdge(3,8)`);
", 
			"srcLength": "110", 
			"0: data": {
				"srcIndexStart": "7840", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "7841", 
				"data": "auto dfaEdge = DFAStateEdge(3, 8);
assert(dfaEdge.toString() == `DFAStateEdge(3,8)`);
", 
				"srcLength": "90"
			}
		}, 
		"156: data": {
			"srcIndexStart": "7933", 
			"data": "
	</div>
</div>

", 
			"srcLength": "17"
		}, 
		"157: apiSectionType": {
			"srcIndexStart": "7950", 
			"param 0": "LALRState", 
			"param 1": "goldie.base", 
			"data": "struct LALRState", 
			"srcLength": "63", 
			"0: data": {
				"srcIndexStart": "7993", 
				"data": "struct LALRState", 
				"srcLength": "18"
			}
		}, 
		"158: data": {
			"srcIndexStart": "8013", 
			"data": "
<div class=\"api-def\">
	", 
			"srcLength": "24"
		}, 
		"159: apiHead": {
			"srcIndexStart": "8037", 
			"data": " LALRAction[] actions ", 
			"srcLength": "38", 
			"0: data": {
				"srcIndexStart": "8047", 
				"data": " LALRAction[] actions ", 
				"srcLength": "26"
			}
		}, 
		"160: data": {
			"srcIndexStart": "8075", 
			"data": "
	<div class=\"api-def\">
	<p>
		The possible LALR actions associated with this state.
	</p>
	<p>
		For more information, see GOLD's documentation on
		", 
			"srcLength": "150"
		}, 
		"161: link": {
			"srcIndexStart": "8225", 
			"param 0": "http://goldparser.org/articles/lalr.htm", 
			"data": "LALR Parsing", 
			"srcLength": "65", 
			"0: data": {
				"srcIndexStart": "8274", 
				"data": "LALR Parsing", 
				"srcLength": "14"
			}
		}, 
		"162: data": {
			"srcIndexStart": "8290", 
			"data": "
		and the
		", 
			"srcLength": "13"
		}, 
		"163: link": {
			"srcIndexStart": "8303", 
			"param 0": "http://goldparser.org/doc/cgt/index.htm", 
			"data": "CGT file format", 
			"srcLength": "68", 
			"0: data": {
				"srcIndexStart": "8352", 
				"data": "CGT file format", 
				"srcLength": "17"
			}
		}, 
		"164: data": {
			"srcIndexStart": "8371", 
			"data": ".
	</p>
	</div>

	", 
			"srcLength": "18"
		}, 
		"165: apiHead": {
			"srcIndexStart": "8389", 
			"data": " string toString() ", 
			"srcLength": "35", 
			"0: data": {
				"srcIndexStart": "8399", 
				"data": " string toString() ", 
				"srcLength": "23"
			}
		}, 
		"166: data": {
			"srcIndexStart": "8424", 
			"data": "
	<div class=\"api-def\">
		The result of this is valid D code representing a struct literal.
		For example:
", 
			"srcLength": "107"
		}, 
		"167: code": {
			"srcIndexStart": "8531", 
			"param 0": "highlight", 
			"data": "auto lalrState = LALRState([ LALRAction(7, LALRAction.Type.Shift, 10) ]);
assert(lalrState.toString() == `LALRState( [LALRAction(7,LALRAction.Type.Shift,10)] )`);
", 
			"srcLength": "187", 
			"0: data": {
				"srcIndexStart": "8548", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "8549", 
				"data": "auto lalrState = LALRState([ LALRAction(7, LALRAction.Type.Shift, 10) ]);
assert(lalrState.toString() == `LALRState( [LALRAction(7,LALRAction.Type.Shift,10)] )`);
", 
				"srcLength": "167"
			}
		}, 
		"168: data": {
			"srcIndexStart": "8718", 
			"data": "
	</div>

	", 
			"srcLength": "11"
		}, 
		"169: apiHead": {
			"srcIndexStart": "8729", 
			"data": " LALRState dup() const ", 
			"srcLength": "39", 
			"0: data": {
				"srcIndexStart": "8739", 
				"data": " LALRState dup() const ", 
				"srcLength": "27"
			}
		}, 
		"170: data": {
			"srcIndexStart": "8768", 
			"data": "
	<div class=\"api-def\">
		Returns a deep (not shallow) duplicate of this LALRState.
	</div>
</div>

", 
			"srcLength": "100"
		}, 
		"171: apiSectionType": {
			"srcIndexStart": "8868", 
			"param 0": "LALRAction", 
			"param 1": "goldie.base", 
			"data": "struct LALRAction", 
			"srcLength": "65", 
			"0: data": {
				"srcIndexStart": "8912", 
				"data": "struct LALRAction", 
				"srcLength": "19"
			}
		}, 
		"172: data": {
			"srcIndexStart": "8933", 
			"data": "
<div class=\"api-def\">
	", 
			"srcLength": "24"
		}, 
		"173: apiHead": {
			"srcIndexStart": "8957", 
			"data": " enum Type ", 
			"srcLength": "27", 
			"0: data": {
				"srcIndexStart": "8967", 
				"data": " enum Type ", 
				"srcLength": "15"
			}
		}, 
		"174: data": {
			"srcIndexStart": "8984", 
			"data": "
	<div class=\"api-def\">
		The definition of ", 
			"srcLength": "44"
		}, 
		"175: ident": {
			"srcIndexStart": "9028", 
			"data": "LALRAction.Type", 
			"srcLength": "25", 
			"0: data": {
				"srcIndexStart": "9036", 
				"data": "LALRAction.Type", 
				"srcLength": "15"
			}
		}, 
		"176: data": {
			"srcIndexStart": "9053", 
			"data": " is:
", 
			"srcLength": "5"
		}, 
		"177: code": {
			"srcIndexStart": "9058", 
			"param 0": "highlight", 
			"data": "enum Type
{
    Shift  = 1, <span class=\"code-comment\">// target: LALR State Index</span>
    Reduce = 2, <span class=\"code-comment\">// target: Rule Index</span>
    Goto   = 3, <span class=\"code-comment\">// target: LALR State Index</span>
    Accept = 4  <span class=\"code-comment\">// target: unused</span>
}
", 
			"srcLength": "198", 
			"0: data": {
				"srcIndexStart": "9075", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "9076", 
				"data": "enum Type
{
    Shift  = 1, // target: LALR State Index
    Reduce = 2, // target: Rule Index
    Goto   = 3, // target: LALR State Index
    Accept = 4  // target: unused
}
", 
				"srcLength": "178"
			}
		}, 
		"178: data": {
			"srcIndexStart": "9256", 
			"data": "
	</div>

	", 
			"srcLength": "11"
		}, 
		"179: apiHead": {
			"srcIndexStart": "9267", 
			"data": " int symbolId ", 
			"srcLength": "30", 
			"0: data": {
				"srcIndexStart": "9277", 
				"data": " int symbolId ", 
				"srcLength": "18"
			}
		}, 
		"180: data": {
			"srcIndexStart": "9297", 
			"data": "
	<div class=\"api-def\">
	<p>
		The symbol expected in order for the ", 
			"srcLength": "68"
		}, 
		"181: typeName": {
			"srcIndexStart": "9365", 
			"data": "Parser", 
			"srcLength": "19", 
			"0: data": {
				"srcIndexStart": "9376", 
				"data": "Parser", 
				"srcLength": "6"
			}
		}, 
		"182: data": {
			"srcIndexStart": "9384", 
			"data": " to take
		this branch of the LALR graph.
	</p>
	<p>
		This is an index into ", 
			"srcLength": "77"
		}, 
		"183: typeName": {
			"srcIndexStart": "9461", 
			"data": "Language", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "9472", 
				"data": "Language", 
				"srcLength": "8"
			}
		}, 
		"184: ident": {
			"srcIndexStart": "9482", 
			"data": ".symbolTable", 
			"srcLength": "22", 
			"0: data": {
				"srcIndexStart": "9490", 
				"data": ".symbolTable", 
				"srcLength": "12"
			}
		}, 
		"185: data": {
			"srcIndexStart": "9504", 
			"data": ".
	</p>
	<p>
		For more information, see the definition of enum ", 
			"srcLength": "64"
		}, 
		"186: ident": {
			"srcIndexStart": "9568", 
			"data": "Type", 
			"srcLength": "14", 
			"0: data": {
				"srcIndexStart": "9576", 
				"data": "Type", 
				"srcLength": "4"
			}
		}, 
		"187: data": {
			"srcIndexStart": "9582", 
			"data": " above,
		as well as GOLD's documentation on
		", 
			"srcLength": "47"
		}, 
		"188: link": {
			"srcIndexStart": "9629", 
			"param 0": "http://goldparser.org/articles/lalr.htm", 
			"data": "LALR Parsing", 
			"srcLength": "65", 
			"0: data": {
				"srcIndexStart": "9678", 
				"data": "LALR Parsing", 
				"srcLength": "14"
			}
		}, 
		"189: data": {
			"srcIndexStart": "9694", 
			"data": "
		and the
		", 
			"srcLength": "13"
		}, 
		"190: link": {
			"srcIndexStart": "9707", 
			"param 0": "http://goldparser.org/doc/cgt/index.htm", 
			"data": "CGT file format", 
			"srcLength": "68", 
			"0: data": {
				"srcIndexStart": "9756", 
				"data": "CGT file format", 
				"srcLength": "17"
			}
		}, 
		"191: data": {
			"srcIndexStart": "9775", 
			"data": ".
	</p>
	</div>

	", 
			"srcLength": "18"
		}, 
		"192: apiHead": {
			"srcIndexStart": "9793", 
			"data": " Type type ", 
			"srcLength": "27", 
			"0: data": {
				"srcIndexStart": "9803", 
				"data": " Type type ", 
				"srcLength": "15"
			}
		}, 
		"193: data": {
			"srcIndexStart": "9820", 
			"data": "
	<div class=\"api-def\">
	<p>
		The type of this state.
	</p>
	<p>
		For more information, see the definition of enum ", 
			"srcLength": "117"
		}, 
		"194: ident": {
			"srcIndexStart": "9937", 
			"data": "Type", 
			"srcLength": "14", 
			"0: data": {
				"srcIndexStart": "9945", 
				"data": "Type", 
				"srcLength": "4"
			}
		}, 
		"195: data": {
			"srcIndexStart": "9951", 
			"data": " above,
		as well as GOLD's documentation on
		", 
			"srcLength": "47"
		}, 
		"196: link": {
			"srcIndexStart": "9998", 
			"param 0": "http://goldparser.org/articles/lalr.htm", 
			"data": "LALR Parsing", 
			"srcLength": "65", 
			"0: data": {
				"srcIndexStart": "10047", 
				"data": "LALR Parsing", 
				"srcLength": "14"
			}
		}, 
		"197: data": {
			"srcIndexStart": "10063", 
			"data": "
		and the
		", 
			"srcLength": "13"
		}, 
		"198: link": {
			"srcIndexStart": "10076", 
			"param 0": "http://goldparser.org/doc/cgt/index.htm", 
			"data": "CGT file format", 
			"srcLength": "68", 
			"0: data": {
				"srcIndexStart": "10125", 
				"data": "CGT file format", 
				"srcLength": "17"
			}
		}, 
		"199: data": {
			"srcIndexStart": "10144", 
			"data": ".
	</p>
	</div>

	", 
			"srcLength": "18"
		}, 
		"200: apiHead": {
			"srcIndexStart": "10162", 
			"data": " int target ", 
			"srcLength": "28", 
			"0: data": {
				"srcIndexStart": "10172", 
				"data": " int target ", 
				"srcLength": "16"
			}
		}, 
		"201: data": {
			"srcIndexStart": "10190", 
			"data": "
	<div class=\"api-def\">
	<p>
		Extra information associated with this LALR state.
		The exact meaning of this depends on the value of ", 
			"srcLength": "134"
		}, 
		"202: ident": {
			"srcIndexStart": "10324", 
			"data": "type", 
			"srcLength": "14", 
			"0: data": {
				"srcIndexStart": "10332", 
				"data": "type", 
				"srcLength": "4"
			}
		}, 
		"203: data": {
			"srcIndexStart": "10338", 
			"data": ".
	</p>
	<p>
		For more information, see the definition of enum ", 
			"srcLength": "64"
		}, 
		"204: ident": {
			"srcIndexStart": "10402", 
			"data": "Type", 
			"srcLength": "14", 
			"0: data": {
				"srcIndexStart": "10410", 
				"data": "Type", 
				"srcLength": "4"
			}
		}, 
		"205: data": {
			"srcIndexStart": "10416", 
			"data": " above,
		as well as GOLD's documentation on
		", 
			"srcLength": "47"
		}, 
		"206: link": {
			"srcIndexStart": "10463", 
			"param 0": "http://goldparser.org/articles/lalr.htm", 
			"data": "LALR Parsing", 
			"srcLength": "65", 
			"0: data": {
				"srcIndexStart": "10512", 
				"data": "LALR Parsing", 
				"srcLength": "14"
			}
		}, 
		"207: data": {
			"srcIndexStart": "10528", 
			"data": "
		and the
		", 
			"srcLength": "13"
		}, 
		"208: link": {
			"srcIndexStart": "10541", 
			"param 0": "http://goldparser.org/doc/cgt/index.htm", 
			"data": "CGT file format", 
			"srcLength": "68", 
			"0: data": {
				"srcIndexStart": "10590", 
				"data": "CGT file format", 
				"srcLength": "17"
			}
		}, 
		"209: data": {
			"srcIndexStart": "10609", 
			"data": ".
	</p>
	</div>

	", 
			"srcLength": "18"
		}, 
		"210: apiHead": {
			"srcIndexStart": "10627", 
			"data": " string toString() ", 
			"srcLength": "35", 
			"0: data": {
				"srcIndexStart": "10637", 
				"data": " string toString() ", 
				"srcLength": "23"
			}
		}, 
		"211: data": {
			"srcIndexStart": "10662", 
			"data": "
	<div class=\"api-def\">
		The result of this is valid D code representing a struct literal.
		For example:
", 
			"srcLength": "107"
		}, 
		"212: code": {
			"srcIndexStart": "10769", 
			"param 0": "highlight", 
			"data": "auto lalrAction = LALRAction(7, LALRAction.Type.Shift, 10);
assert(lalrAction.toString() == `LALRAction(7,LALRAction.Type.Shift,10)`);
", 
			"srcLength": "159", 
			"0: data": {
				"srcIndexStart": "10786", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "10787", 
				"data": "auto lalrAction = LALRAction(7, LALRAction.Type.Shift, 10);
assert(lalrAction.toString() == `LALRAction(7,LALRAction.Type.Shift,10)`);
", 
				"srcLength": "139"
			}
		}, 
		"213: data": {
			"srcIndexStart": "10928", 
			"data": "
	</div>

	", 
			"srcLength": "11"
		}, 
		"214: apiHead": {
			"srcIndexStart": "10939", 
			"data": " static string typeToString(Type type) ", 
			"srcLength": "55", 
			"0: data": {
				"srcIndexStart": "10949", 
				"data": " static string typeToString(Type type) ", 
				"srcLength": "43"
			}
		}, 
		"215: data": {
			"srcIndexStart": "10994", 
			"data": "
	<div class=\"api-def\">
		Example:
", 
			"srcLength": "35"
		}, 
		"216: code": {
			"srcIndexStart": "11029", 
			"param 0": "highlight", 
			"data": "string str = LALRAction.typeToString(LALRAction.Type.Reduce);
assert(str == \"Reduce\");
", 
			"srcLength": "111", 
			"0: data": {
				"srcIndexStart": "11046", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "11047", 
				"data": "string str = LALRAction.typeToString(LALRAction.Type.Reduce);
assert(str == \"Reduce\");
", 
				"srcLength": "91"
			}
		}, 
		"217: data": {
			"srcIndexStart": "11140", 
			"data": "
	</div>

	", 
			"srcLength": "11"
		}, 
		"218: apiHead": {
			"srcIndexStart": "11151", 
			"data": " static string fullTypeToString(Type type) ", 
			"srcLength": "59", 
			"0: data": {
				"srcIndexStart": "11161", 
				"data": " static string fullTypeToString(Type type) ", 
				"srcLength": "47"
			}
		}, 
		"219: data": {
			"srcIndexStart": "11210", 
			"data": "
	<div class=\"api-def\">
		Example:
", 
			"srcLength": "35"
		}, 
		"220: code": {
			"srcIndexStart": "11245", 
			"param 0": "highlight", 
			"data": "string str = LALRAction.fullTypeToString(LALRAction.Type.Reduce);
assert(str == \"LALRAction.Type.Reduce\");
", 
			"srcLength": "131", 
			"0: data": {
				"srcIndexStart": "11262", 
				"data": "", 
				"srcLength": "1"
			}, 
			"1: data": {
				"srcIndexStart": "11263", 
				"data": "string str = LALRAction.fullTypeToString(LALRAction.Type.Reduce);
assert(str == \"LALRAction.Type.Reduce\");
", 
				"srcLength": "111"
			}
		}, 
		"221: data": {
			"srcIndexStart": "11376", 
			"data": "
	</div>
</div>

", 
			"srcLength": "17"
		}, 
		"222: apiSection": {
			"srcIndexStart": "11393", 
			"param 0": "Module", 
			"param 1": "goldie.base", 
			"data": "Module-Level Members", 
			"srcLength": "60", 
			"0: data": {
				"srcIndexStart": "11429", 
				"data": "Module-Level Members", 
				"srcLength": "22"
			}
		}, 
		"223: data": {
			"srcIndexStart": "11453", 
			"data": "
<div class=\"api-def\">
	", 
			"srcLength": "24"
		}, 
		"224: apiHead": {
			"srcIndexStart": "11477", 
			"data": " T[] goldieBaseDup(T)(const(T[]) arr) ", 
			"srcLength": "54", 
			"0: data": {
				"srcIndexStart": "11487", 
				"data": " T[] goldieBaseDup(T)(const(T[]) arr) ", 
				"srcLength": "42"
			}
		}, 
		"225: data": {
			"srcIndexStart": "11531", 
			"data": "
	<div class=\"api-def\">
	<p>
		Duplicates the given array, calling ", 
			"srcLength": "67"
		}, 
		"226: code": {
			"srcIndexStart": "11598", 
			"param 0": "inline", 
			"data": "xxxx.dup()", 
			"srcLength": "26", 
			"0: data": {
				"srcIndexStart": "11612", 
				"data": "xxxx.dup()", 
				"srcLength": "10"
			}
		}, 
		"227: data": {
			"srcIndexStart": "11624", 
			"data": "
		on each member.
	</p>
	<p>
		Intended specifically for arrays of the types defined in
		this ", 
			"srcLength": "96"
		}, 
		"228: code": {
			"srcIndexStart": "11720", 
			"param 0": "inline", 
			"data": "goldie.base", 
			"srcLength": "27", 
			"0: data": {
				"srcIndexStart": "11734", 
				"data": "goldie.base", 
				"srcLength": "11"
			}
		}, 
		"229: data": {
			"srcIndexStart": "11747", 
			"data": " module.
	</p>
	</div>
</div>", 
			"srcLength": "30"
		}
	}
}