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

<ul>
<li>[$pageLink|#CreateCompiler| Q: How can I use Goldie to create a compiler? $]</li>
<li>[$pageLink|#TheName|        Q: Why the name \"Goldie\"? $]</li>
<li>[$pageLink|#EmptyRule|      Q: How do I refer to a rule that has no subtokens? $]</li>
<li>[$pageLink|#Ambiguous|      Q: I'm getting \"Ambiguous symbol\" errors! $]</li>
<li>[$pageLink|#VsGazelle|      Q: This project sounds very similar to Gazelle.
	What's the difference, and which one is better? $]</li>
<li>[$pageLink|#VsANTLR|        Q: What about Goldie vs. ANTLR? $]</li>
<li>[$pageLink|#ReallyFA|       Q: Are these questions really frequently-asked? $]</li>
</ul>

<a name=\"CreateCompiler\" />
<h2>Q: How can I use Goldie to create a compiler?</h2>
<p>
A: This is not an easy task no matter what parsing tool you use.
To get started, see the [$pageTitle|LearnParsing$] page which contains an
overview of everything involved in creating a full compiler.
</p>
<p>
In summary: 
Use Goldie to implement a lexer/parser (see [$pageTitle|Overview$] and
the [$pageTitle|Tutorial$]), and then,
just as with any other parsing tool, you'll have to do your own
semantic analysis on the resulting tree, and then implement a compiler backend.
</p>

<a name=\"TheName\" />
<h2>Q: Why the name \"Goldie\"?</h2>
<p>
A: \"[$pageLink|OtherTools#GOLD|GOLD$] for D\" -> \"GOLD D\" -> \"Goldie\"
</p>

<a name=\"EmptyRule\" />
<h2>Q: How do I refer to a rule that has no subtokens?</h2>
<p>
A: Use [$code|inline|null$] for the list of subtokens.
For details and examples, see
[$pageLink|APIOver#EmptyRule|Referring to a rule that has no subtokens$]
on the [$pageTitle|APIOver$] page.
</p>

<a name=\"Ambiguous\" />
<h2>Q: I'm getting \"Ambiguous symbol\" errors!</h2>
<p>
A: See [$pageTitle|AmbiguousSym$].
</p>

<a name=\"VsGazelle\" />
<h2>
	Q: This project sounds very similar to Gazelle.
	What's the difference, and which one is better?
</h2>
<p>
A: GOLD/Goldie and [$link|http://www.reverberate.org/gazelle/|Gazelle$] are
both members of a new class of generic parsers that focus on fully-reusable
grammars that aren't tied to any particular host language. They both
accomplish this by completely separating the grammar from the parsing engine.
</p>
<p>
Both systems have their pros and cons, and which one's better is up to you.
They're both evolving, so limitations on both sides are likely to change.
Here is a comparison (disclaimer: based on my admittedly limited knowledge of Gazelle)
so you can decide for yourself:
</p>
<table class=\"comparison-table\">
<tr style=\"font-size: 1.1em;\">
	<th style=\"width: auto;\">&nbsp;</th>
	<th style=\"width: 33%; text-align: center;\">Goldie</th>
	<th style=\"width: 33%; text-align: center;\">Gazelle</th>
</tr>
<tr>
	<th>Parser Type</th>
	<td>[$link| http://goldparser.org/articles/lalr.htm | LALR(1) $]</td>
	<td>LL(*)</td>
</tr>
<tr>
	<th>Grammars Compile To</th>
	<td>Tables</td>
	<td>Bytecode</td>
</tr>
<tr>
	<th>Written In</th>
	<td>[$link|http://www.d-programming-language.org/|D$]</td>
	<td>C</td>
</tr>
<tr>
	<th>Easily Used From Other Languages</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Event-Based Parsing</th>
	<td class=\"box-no\">No</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Creates a Parse Tree</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-no\">No</td>
</tr>
<tr>
	<th>Speed</th>
	<td class=\"box-no\">Medium focus so far</td>
	<td class=\"box-yes\">Strong focus so far</td>
</tr>
<tr>
	<th>Usability (Tools, API, Docs, etc...)</th>
	<td class=\"box-yes\">Strong focus so far</td>
	<td class=\"box-no\">Medium focus so far</td>
</tr>
<tr>
	<th>Existing Ecosystem</th>
	<td class=\"box-yes\">Fairly large, due to compatability with [$pageLink|OtherTools#GOLD|GOLD$]</td>
	<td class=\"box-no\">Currently limited to the main Gazelle project</td>
</tr>
<tr>
	<th>Grammar Definition Expressiveness</th>
	<td class=\"box-no\">Powerful, but room for improvement</td>
	<td class=\"box-yes\">Appears to be quite powerful</td>
</tr>
<tr>
	<th>Regular Expressions for Defining Terminals</th>
	<td>
	GOLD's [$link| http://goldparser.org/doc/grammars/index.htm | custom
	regex syntax $], designed to be easy to read
	</td>
	<td>
	Standard PCRE regex
	</td>
</tr>
<tr>
	<th>Various Tools Available</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Integrated Lexing and Parsing</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Library API for Compiling Grammars</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Strives for Flexibility</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Cross-Platform</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Commandline Compatible</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Open Source</th>
	<td class=\"box-yes\">Yes, [$link| https://bitbucket.org/Abscissa/goldie/src/v0.8/LICENSE.txt | zlib/libpng $]</td>
	<td class=\"box-yes\">Yes, [$link| https://github.com/haberman/gazelle/blob/master/LICENSE | 3-Clause BSD $]</td>
</tr>
</table>
<p>
(If anything in this comparison appears to be wrong or out-of-date,
I invite you to file a [$pageLink|Tickets| bug report $].)
</p>

<a name=\"VsANTLR\" />
<h2>Q: What about Goldie vs. ANTLR?</h2>
<p>
A: While Goldie and Gazelle are in roughly the same class,
[$link|http://www.antlr.org/|ANTLR$] is very different
in that grammars are not independent from the host language.
</p>
<table class=\"comparison-table\">
<tr style=\"font-size: 1.1em;\">
	<th style=\"width: auto;\">&nbsp;</th>
	<th style=\"width: 25%; text-align: center;\">Goldie</th>
	<th style=\"width: 25%; text-align: center;\">Gazelle</th>
	<th style=\"width: 25%; text-align: center;\">ANTLR</th>
</tr>
<tr>
	<th>Parser Type</th>
	<td>[$link| http://goldparser.org/articles/lalr.htm | LALR(1) $]</td>
	<td>LL(*)</td>
	<td>LL(k)</td>
</tr>
<tr>
	<th>Maturity</th>
	<td class=\"box-no\">Still young</td>
	<td class=\"box-no\">Still young</td>
	<td class=\"box-yes\">Very mature, with a large following</td>
</tr>
<tr>
	<th>Official Host Languages</th>
	<td>[$link|http://www.d-programming-language.org/|D$]</td>
	<td>C</td>
	<td>[$link|http://www.antlr.org/api/index.html|Java, C, C#, Python, ActionScript$]</td>
</tr>
<tr>
	<th>Other Host Languages Available</th>
	<td class=\"box-yes\">[$pageLink|OtherTools#EngineLinks|Yes$]</td>
	<td class=\"box-no\">No</td>
	<td class=\"box-yes\">[$link|http://www.antlr.org/wiki/display/ANTLR3/Code+Generation+Targets|Yes$]</td>
</tr>
<tr>
	<th>Easy to Support a New Host Language</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-no\">
		No. Typically, the entire ANTLR and
		[$link| http://www.stringtemplate.org/ | StringTemplate $]
		projects must be ported.
	</td>
</tr>
<tr>
	<th>Can Embed Source Code Into Grammar</th>
	<td class=\"box-no\">No</td>
	<td class=\"box-no\">No</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Reuse Grammars on Other Host Languages</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-no\">Typically, no. The embedded code must be ported.</td>
</tr>
<tr>
	<th>Extensive Tools, Including GUIs</th>
	<td class=\"box-yes\">[$pageLink|Tools|Yes$]</td>
	<td class=\"box-no\">No</td>
	<td class=\"box-yes\">[$link|http://www.antlr.org/works/index.html|Yes$]</td>
</tr>
<tr>
	<th>Open Source</th>
	<td class=\"box-yes\">Yes, [$link| https://bitbucket.org/Abscissa/goldie/src/v0.8/LICENSE.txt | zlib/libpng $]</td>
	<td class=\"box-yes\">Yes, [$link| https://github.com/haberman/gazelle/blob/master/LICENSE | 3-Clause BSD $]</td>
	<td class=\"box-yes\">Yes, [$link| http://www.antlr.org/license.html | 3-Clause BSD $]</td>
</tr>
<tr>
	<th>Nutty Creator</th>
	<td class=\"box-yes\">[$link| http://www.semitwist.com/download/img/shots/goldie-wtf.png | Yes $]</td>
	<td>Unknown</td>
	<td class=\"box-yes\">[$link| http://www.antlr.org/images/terence_antlr.jpg | Yes $]</td>
</tr>
</table>
<p>
(If anything in this comparison appears to be wrong or out-of-date,
I invite you to file a [$pageLink|Tickets| bug report $].)
</p>

<a name=\"ReallyFA\" />
<h2>Q: Are these questions really frequently-asked?</h2>
<p>
A: No, I'm just anticipating them. ;)
</p>
", 
		"0: name": {
			"srcIndexStart": "0", 
			"data": "FAQ", 
			"srcLength": "12", 
			"0: data": {
				"srcIndexStart": "7", 
				"data": "FAQ", 
				"srcLength": "3"
			}
		}, 
		"1: data": {
			"srcIndexStart": "12", 
			"data": "
", 
			"srcLength": "1"
		}, 
		"2: title": {
			"srcIndexStart": "13", 
			"data": "FAQ", 
			"srcLength": "13", 
			"0: data": {
				"srcIndexStart": "21", 
				"data": "FAQ", 
				"srcLength": "3"
			}
		}, 
		"3: data": {
			"srcIndexStart": "26", 
			"data": "
", 
			"srcLength": "1"
		}, 
		"4: frame": {
			"srcIndexStart": "27", 
			"data": "HTMLPage.tmpl", 
			"srcLength": "23", 
			"0: data": {
				"srcIndexStart": "35", 
				"data": "HTMLPage.tmpl", 
				"srcLength": "13"
			}
		}, 
		"5: data": {
			"srcIndexStart": "50", 
			"data": "

<ul>
<li>", 
			"srcLength": "11"
		}, 
		"6: pageLink": {
			"srcIndexStart": "61", 
			"param 0": "#CreateCompiler", 
			"data": "Q: How can I use Goldie to create a compiler?", 
			"srcLength": "76", 
			"0: data": {
				"srcIndexStart": "88", 
				"data": "Q: How can I use Goldie to create a compiler?", 
				"srcLength": "47"
			}
		}, 
		"7: data": {
			"srcIndexStart": "137", 
			"data": "</li>
<li>", 
			"srcLength": "10"
		}, 
		"8: pageLink": {
			"srcIndexStart": "147", 
			"param 0": "#TheName", 
			"data": "Q: Why the name \"Goldie\"?", 
			"srcLength": "56", 
			"0: data": {
				"srcIndexStart": "167", 
				"data": "Q: Why the name \"Goldie\"?", 
				"srcLength": "34"
			}
		}, 
		"9: data": {
			"srcIndexStart": "203", 
			"data": "</li>
<li>", 
			"srcLength": "10"
		}, 
		"10: pageLink": {
			"srcIndexStart": "213", 
			"param 0": "#EmptyRule", 
			"data": "Q: How do I refer to a rule that has no subtokens?", 
			"srcLength": "81", 
			"0: data": {
				"srcIndexStart": "235", 
				"data": "Q: How do I refer to a rule that has no subtokens?", 
				"srcLength": "57"
			}
		}, 
		"11: data": {
			"srcIndexStart": "294", 
			"data": "</li>
<li>", 
			"srcLength": "10"
		}, 
		"12: pageLink": {
			"srcIndexStart": "304", 
			"param 0": "#Ambiguous", 
			"data": "Q: I'm getting \"Ambiguous symbol\" errors!", 
			"srcLength": "72", 
			"0: data": {
				"srcIndexStart": "326", 
				"data": "Q: I'm getting \"Ambiguous symbol\" errors!", 
				"srcLength": "48"
			}
		}, 
		"13: data": {
			"srcIndexStart": "376", 
			"data": "</li>
<li>", 
			"srcLength": "10"
		}, 
		"14: pageLink": {
			"srcIndexStart": "386", 
			"param 0": "#VsGazelle", 
			"data": "Q: This project sounds very similar to Gazelle.
	What's the difference, and which one is better?", 
			"srcLength": "127", 
			"0: data": {
				"srcIndexStart": "408", 
				"data": "Q: This project sounds very similar to Gazelle.
	What's the difference, and which one is better?", 
				"srcLength": "103"
			}
		}, 
		"15: data": {
			"srcIndexStart": "513", 
			"data": "</li>
<li>", 
			"srcLength": "10"
		}, 
		"16: pageLink": {
			"srcIndexStart": "523", 
			"param 0": "#VsANTLR", 
			"data": "Q: What about Goldie vs. ANTLR?", 
			"srcLength": "62", 
			"0: data": {
				"srcIndexStart": "543", 
				"data": "Q: What about Goldie vs. ANTLR?", 
				"srcLength": "40"
			}
		}, 
		"17: data": {
			"srcIndexStart": "585", 
			"data": "</li>
<li>", 
			"srcLength": "10"
		}, 
		"18: pageLink": {
			"srcIndexStart": "595", 
			"param 0": "#ReallyFA", 
			"data": "Q: Are these questions really frequently-asked?", 
			"srcLength": "78", 
			"0: data": {
				"srcIndexStart": "616", 
				"data": "Q: Are these questions really frequently-asked?", 
				"srcLength": "55"
			}
		}, 
		"19: data": {
			"srcIndexStart": "673", 
			"data": "</li>
</ul>

<a name=\"CreateCompiler\" />
<h2>Q: How can I use Goldie to create a compiler?</h2>
<p>
A: This is not an easy task no matter what parsing tool you use.
To get started, see the ", 
			"srcLength": "189"
		}, 
		"20: pageTitle": {
			"srcIndexStart": "862", 
			"data": "LearnParsing", 
			"srcLength": "26", 
			"0: data": {
				"srcIndexStart": "874", 
				"data": "LearnParsing", 
				"srcLength": "12"
			}
		}, 
		"21: data": {
			"srcIndexStart": "888", 
			"data": " page which contains an
overview of everything involved in creating a full compiler.
</p>
<p>
In summary: 
Use Goldie to implement a lexer/parser (see ", 
			"srcLength": "151"
		}, 
		"22: pageTitle": {
			"srcIndexStart": "1039", 
			"data": "Overview", 
			"srcLength": "22", 
			"0: data": {
				"srcIndexStart": "1051", 
				"data": "Overview", 
				"srcLength": "8"
			}
		}, 
		"23: data": {
			"srcIndexStart": "1061", 
			"data": " and
the ", 
			"srcLength": "9"
		}, 
		"24: pageTitle": {
			"srcIndexStart": "1070", 
			"data": "Tutorial", 
			"srcLength": "22", 
			"0: data": {
				"srcIndexStart": "1082", 
				"data": "Tutorial", 
				"srcLength": "8"
			}
		}, 
		"25: data": {
			"srcIndexStart": "1092", 
			"data": "), and then,
just as with any other parsing tool, you'll have to do your own
semantic analysis on the resulting tree, and then implement a compiler backend.
</p>

<a name=\"TheName\" />
<h2>Q: Why the name \"Goldie\"?</h2>
<p>
A: \"", 
			"srcLength": "227"
		}, 
		"26: pageLink": {
			"srcIndexStart": "1319", 
			"param 0": "OtherTools#GOLD", 
			"data": "GOLD", 
			"srcLength": "33", 
			"0: data": {
				"srcIndexStart": "1346", 
				"data": "GOLD", 
				"srcLength": "4"
			}
		}, 
		"27: data": {
			"srcIndexStart": "1352", 
			"data": " for D\" -> \"GOLD D\" -> \"Goldie\"
</p>

<a name=\"EmptyRule\" />
<h2>Q: How do I refer to a rule that has no subtokens?</h2>
<p>
A: Use ", 
			"srcLength": "132"
		}, 
		"28: code": {
			"srcIndexStart": "1484", 
			"param 0": "inline", 
			"data": "null", 
			"srcLength": "20", 
			"0: data": {
				"srcIndexStart": "1498", 
				"data": "null", 
				"srcLength": "4"
			}
		}, 
		"29: data": {
			"srcIndexStart": "1504", 
			"data": " for the list of subtokens.
For details and examples, see
", 
			"srcLength": "58"
		}, 
		"30: pageLink": {
			"srcIndexStart": "1562", 
			"param 0": "APIOver#EmptyRule", 
			"data": "Referring to a rule that has no subtokens", 
			"srcLength": "72", 
			"0: data": {
				"srcIndexStart": "1591", 
				"data": "Referring to a rule that has no subtokens", 
				"srcLength": "41"
			}
		}, 
		"31: data": {
			"srcIndexStart": "1634", 
			"data": "
on the ", 
			"srcLength": "8"
		}, 
		"32: pageTitle": {
			"srcIndexStart": "1642", 
			"data": "APIOver", 
			"srcLength": "21", 
			"0: data": {
				"srcIndexStart": "1654", 
				"data": "APIOver", 
				"srcLength": "7"
			}
		}, 
		"33: data": {
			"srcIndexStart": "1663", 
			"data": " page.
</p>

<a name=\"Ambiguous\" />
<h2>Q: I'm getting \"Ambiguous symbol\" errors!</h2>
<p>
A: See ", 
			"srcLength": "98"
		}, 
		"34: pageTitle": {
			"srcIndexStart": "1761", 
			"data": "AmbiguousSym", 
			"srcLength": "26", 
			"0: data": {
				"srcIndexStart": "1773", 
				"data": "AmbiguousSym", 
				"srcLength": "12"
			}
		}, 
		"35: data": {
			"srcIndexStart": "1787", 
			"data": ".
</p>

<a name=\"VsGazelle\" />
<h2>
	Q: This project sounds very similar to Gazelle.
	What's the difference, and which one is better?
</h2>
<p>
A: GOLD/Goldie and ", 
			"srcLength": "163"
		}, 
		"36: link": {
			"srcIndexStart": "1950", 
			"param 0": "http://www.reverberate.org/gazelle/", 
			"data": "Gazelle", 
			"srcLength": "52", 
			"0: data": {
				"srcIndexStart": "1993", 
				"data": "Gazelle", 
				"srcLength": "7"
			}
		}, 
		"37: data": {
			"srcIndexStart": "2002", 
			"data": " are
both members of a new class of generic parsers that focus on fully-reusable
grammars that aren't tied to any particular host language. They both
accomplish this by completely separating the grammar from the parsing engine.
</p>
<p>
Both systems have their pros and cons, and which one's better is up to you.
They're both evolving, so limitations on both sides are likely to change.
Here is a comparison (disclaimer: based on my admittedly limited knowledge of Gazelle)
so you can decide for yourself:
</p>
<table class=\"comparison-table\">
<tr style=\"font-size: 1.1em;\">
	<th style=\"width: auto;\">&nbsp;</th>
	<th style=\"width: 33%; text-align: center;\">Goldie</th>
	<th style=\"width: 33%; text-align: center;\">Gazelle</th>
</tr>
<tr>
	<th>Parser Type</th>
	<td>", 
			"srcLength": "766"
		}, 
		"38: link": {
			"srcIndexStart": "2768", 
			"param 0": "http://goldparser.org/articles/lalr.htm", 
			"data": "LALR(1)", 
			"srcLength": "60", 
			"0: data": {
				"srcIndexStart": "2817", 
				"data": "LALR(1)", 
				"srcLength": "9"
			}
		}, 
		"39: data": {
			"srcIndexStart": "2828", 
			"data": "</td>
	<td>LL(*)</td>
</tr>
<tr>
	<th>Grammars Compile To</th>
	<td>Tables</td>
	<td>Bytecode</td>
</tr>
<tr>
	<th>Written In</th>
	<td>", 
			"srcLength": "136"
		}, 
		"40: link": {
			"srcIndexStart": "2964", 
			"param 0": "http://www.d-programming-language.org/", 
			"data": "D", 
			"srcLength": "49", 
			"0: data": {
				"srcIndexStart": "3010", 
				"data": "D", 
				"srcLength": "1"
			}
		}, 
		"41: data": {
			"srcIndexStart": "3013", 
			"data": "</td>
	<td>C</td>
</tr>
<tr>
	<th>Easily Used From Other Languages</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Event-Based Parsing</th>
	<td class=\"box-no\">No</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Creates a Parse Tree</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-no\">No</td>
</tr>
<tr>
	<th>Speed</th>
	<td class=\"box-no\">Medium focus so far</td>
	<td class=\"box-yes\">Strong focus so far</td>
</tr>
<tr>
	<th>Usability (Tools, API, Docs, etc...)</th>
	<td class=\"box-yes\">Strong focus so far</td>
	<td class=\"box-no\">Medium focus so far</td>
</tr>
<tr>
	<th>Existing Ecosystem</th>
	<td class=\"box-yes\">Fairly large, due to compatability with ", 
			"srcLength": "699"
		}, 
		"42: pageLink": {
			"srcIndexStart": "3712", 
			"param 0": "OtherTools#GOLD", 
			"data": "GOLD", 
			"srcLength": "33", 
			"0: data": {
				"srcIndexStart": "3739", 
				"data": "GOLD", 
				"srcLength": "4"
			}
		}, 
		"43: data": {
			"srcIndexStart": "3745", 
			"data": "</td>
	<td class=\"box-no\">Currently limited to the main Gazelle project</td>
</tr>
<tr>
	<th>Grammar Definition Expressiveness</th>
	<td class=\"box-no\">Powerful, but room for improvement</td>
	<td class=\"box-yes\">Appears to be quite powerful</td>
</tr>
<tr>
	<th>Regular Expressions for Defining Terminals</th>
	<td>
	GOLD's ", 
			"srcLength": "325"
		}, 
		"44: link": {
			"srcIndexStart": "4070", 
			"param 0": "http://goldparser.org/doc/grammars/index.htm", 
			"data": "custom
	regex syntax", 
			"srcLength": "78", 
			"0: data": {
				"srcIndexStart": "4124", 
				"data": "custom
	regex syntax", 
				"srcLength": "22"
			}
		}, 
		"45: data": {
			"srcIndexStart": "4148", 
			"data": ", designed to be easy to read
	</td>
	<td>
	Standard PCRE regex
	</td>
</tr>
<tr>
	<th>Various Tools Available</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Integrated Lexing and Parsing</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Library API for Compiling Grammars</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Strives for Flexibility</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Cross-Platform</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Commandline Compatible</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Open Source</th>
	<td class=\"box-yes\">Yes, ", 
			"srcLength": "767"
		}, 
		"46: link": {
			"srcIndexStart": "4915", 
			"param 0": "https://bitbucket.org/Abscissa/goldie/src/v0.8/LICENSE.txt", 
			"data": "zlib/libpng", 
			"srcLength": "83", 
			"0: data": {
				"srcIndexStart": "4983", 
				"data": "zlib/libpng", 
				"srcLength": "13"
			}
		}, 
		"47: data": {
			"srcIndexStart": "4998", 
			"data": "</td>
	<td class=\"box-yes\">Yes, ", 
			"srcLength": "32"
		}, 
		"48: link": {
			"srcIndexStart": "5030", 
			"param 0": "https://github.com/haberman/gazelle/blob/master/LICENSE", 
			"data": "3-Clause BSD", 
			"srcLength": "81", 
			"0: data": {
				"srcIndexStart": "5095", 
				"data": "3-Clause BSD", 
				"srcLength": "14"
			}
		}, 
		"49: data": {
			"srcIndexStart": "5111", 
			"data": "</td>
</tr>
</table>
<p>
(If anything in this comparison appears to be wrong or out-of-date,
I invite you to file a ", 
			"srcLength": "116"
		}, 
		"50: pageLink": {
			"srcIndexStart": "5227", 
			"param 0": "Tickets", 
			"data": "bug report", 
			"srcLength": "33", 
			"0: data": {
				"srcIndexStart": "5246", 
				"data": "bug report", 
				"srcLength": "12"
			}
		}, 
		"51: data": {
			"srcIndexStart": "5260", 
			"data": ".)
</p>

<a name=\"VsANTLR\" />
<h2>Q: What about Goldie vs. ANTLR?</h2>
<p>
A: While Goldie and Gazelle are in roughly the same class,
", 
			"srcLength": "134"
		}, 
		"52: link": {
			"srcIndexStart": "5394", 
			"param 0": "http://www.antlr.org/", 
			"data": "ANTLR", 
			"srcLength": "36", 
			"0: data": {
				"srcIndexStart": "5423", 
				"data": "ANTLR", 
				"srcLength": "5"
			}
		}, 
		"53: data": {
			"srcIndexStart": "5430", 
			"data": " is very different
in that grammars are not independent from the host language.
</p>
<table class=\"comparison-table\">
<tr style=\"font-size: 1.1em;\">
	<th style=\"width: auto;\">&nbsp;</th>
	<th style=\"width: 25%; text-align: center;\">Goldie</th>
	<th style=\"width: 25%; text-align: center;\">Gazelle</th>
	<th style=\"width: 25%; text-align: center;\">ANTLR</th>
</tr>
<tr>
	<th>Parser Type</th>
	<td>", 
			"srcLength": "396"
		}, 
		"54: link": {
			"srcIndexStart": "5826", 
			"param 0": "http://goldparser.org/articles/lalr.htm", 
			"data": "LALR(1)", 
			"srcLength": "60", 
			"0: data": {
				"srcIndexStart": "5875", 
				"data": "LALR(1)", 
				"srcLength": "9"
			}
		}, 
		"55: data": {
			"srcIndexStart": "5886", 
			"data": "</td>
	<td>LL(*)</td>
	<td>LL(k)</td>
</tr>
<tr>
	<th>Maturity</th>
	<td class=\"box-no\">Still young</td>
	<td class=\"box-no\">Still young</td>
	<td class=\"box-yes\">Very mature, with a large following</td>
</tr>
<tr>
	<th>Official Host Languages</th>
	<td>", 
			"srcLength": "254"
		}, 
		"56: link": {
			"srcIndexStart": "6140", 
			"param 0": "http://www.d-programming-language.org/", 
			"data": "D", 
			"srcLength": "49", 
			"0: data": {
				"srcIndexStart": "6186", 
				"data": "D", 
				"srcLength": "1"
			}
		}, 
		"57: data": {
			"srcIndexStart": "6189", 
			"data": "</td>
	<td>C</td>
	<td>", 
			"srcLength": "23"
		}, 
		"58: link": {
			"srcIndexStart": "6212", 
			"param 0": "http://www.antlr.org/api/index.html", 
			"data": "Java, C, C#, Python, ActionScript", 
			"srcLength": "78", 
			"0: data": {
				"srcIndexStart": "6255", 
				"data": "Java, C, C#, Python, ActionScript", 
				"srcLength": "33"
			}
		}, 
		"59: data": {
			"srcIndexStart": "6290", 
			"data": "</td>
</tr>
<tr>
	<th>Other Host Languages Available</th>
	<td class=\"box-yes\">", 
			"srcLength": "79"
		}, 
		"60: pageLink": {
			"srcIndexStart": "6369", 
			"param 0": "OtherTools#EngineLinks", 
			"data": "Yes", 
			"srcLength": "39", 
			"0: data": {
				"srcIndexStart": "6403", 
				"data": "Yes", 
				"srcLength": "3"
			}
		}, 
		"61: data": {
			"srcIndexStart": "6408", 
			"data": "</td>
	<td class=\"box-no\">No</td>
	<td class=\"box-yes\">", 
			"srcLength": "55"
		}, 
		"62: link": {
			"srcIndexStart": "6463", 
			"param 0": "http://www.antlr.org/wiki/display/ANTLR3/Code+Generation+Targets", 
			"data": "Yes", 
			"srcLength": "77", 
			"0: data": {
				"srcIndexStart": "6535", 
				"data": "Yes", 
				"srcLength": "3"
			}
		}, 
		"63: data": {
			"srcIndexStart": "6540", 
			"data": "</td>
</tr>
<tr>
	<th>Easy to Support a New Host Language</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-no\">
		No. Typically, the entire ANTLR and
		", 
			"srcLength": "184"
		}, 
		"64: link": {
			"srcIndexStart": "6724", 
			"param 0": "http://www.stringtemplate.org/", 
			"data": "StringTemplate", 
			"srcLength": "58", 
			"0: data": {
				"srcIndexStart": "6764", 
				"data": "StringTemplate", 
				"srcLength": "16"
			}
		}, 
		"65: data": {
			"srcIndexStart": "6782", 
			"data": "
		projects must be ported.
	</td>
</tr>
<tr>
	<th>Can Embed Source Code Into Grammar</th>
	<td class=\"box-no\">No</td>
	<td class=\"box-no\">No</td>
	<td class=\"box-yes\">Yes</td>
</tr>
<tr>
	<th>Reuse Grammars on Other Host Languages</th>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-yes\">Yes</td>
	<td class=\"box-no\">Typically, no. The embedded code must be ported.</td>
</tr>
<tr>
	<th>Extensive Tools, Including GUIs</th>
	<td class=\"box-yes\">", 
			"srcLength": "445"
		}, 
		"66: pageLink": {
			"srcIndexStart": "7227", 
			"param 0": "Tools", 
			"data": "Yes", 
			"srcLength": "22", 
			"0: data": {
				"srcIndexStart": "7244", 
				"data": "Yes", 
				"srcLength": "3"
			}
		}, 
		"67: data": {
			"srcIndexStart": "7249", 
			"data": "</td>
	<td class=\"box-no\">No</td>
	<td class=\"box-yes\">", 
			"srcLength": "55"
		}, 
		"68: link": {
			"srcIndexStart": "7304", 
			"param 0": "http://www.antlr.org/works/index.html", 
			"data": "Yes", 
			"srcLength": "50", 
			"0: data": {
				"srcIndexStart": "7349", 
				"data": "Yes", 
				"srcLength": "3"
			}
		}, 
		"69: data": {
			"srcIndexStart": "7354", 
			"data": "</td>
</tr>
<tr>
	<th>Open Source</th>
	<td class=\"box-yes\">Yes, ", 
			"srcLength": "65"
		}, 
		"70: link": {
			"srcIndexStart": "7419", 
			"param 0": "https://bitbucket.org/Abscissa/goldie/src/v0.8/LICENSE.txt", 
			"data": "zlib/libpng", 
			"srcLength": "83", 
			"0: data": {
				"srcIndexStart": "7487", 
				"data": "zlib/libpng", 
				"srcLength": "13"
			}
		}, 
		"71: data": {
			"srcIndexStart": "7502", 
			"data": "</td>
	<td class=\"box-yes\">Yes, ", 
			"srcLength": "32"
		}, 
		"72: link": {
			"srcIndexStart": "7534", 
			"param 0": "https://github.com/haberman/gazelle/blob/master/LICENSE", 
			"data": "3-Clause BSD", 
			"srcLength": "81", 
			"0: data": {
				"srcIndexStart": "7599", 
				"data": "3-Clause BSD", 
				"srcLength": "14"
			}
		}, 
		"73: data": {
			"srcIndexStart": "7615", 
			"data": "</td>
	<td class=\"box-yes\">Yes, ", 
			"srcLength": "32"
		}, 
		"74: link": {
			"srcIndexStart": "7647", 
			"param 0": "http://www.antlr.org/license.html", 
			"data": "3-Clause BSD", 
			"srcLength": "59", 
			"0: data": {
				"srcIndexStart": "7690", 
				"data": "3-Clause BSD", 
				"srcLength": "14"
			}
		}, 
		"75: data": {
			"srcIndexStart": "7706", 
			"data": "</td>
</tr>
<tr>
	<th>Nutty Creator</th>
	<td class=\"box-yes\">", 
			"srcLength": "62"
		}, 
		"76: link": {
			"srcIndexStart": "7768", 
			"param 0": "http://www.semitwist.com/download/img/shots/goldie-wtf.png", 
			"data": "Yes", 
			"srcLength": "75", 
			"0: data": {
				"srcIndexStart": "7836", 
				"data": "Yes", 
				"srcLength": "5"
			}
		}, 
		"77: data": {
			"srcIndexStart": "7843", 
			"data": "</td>
	<td>Unknown</td>
	<td class=\"box-yes\">", 
			"srcLength": "45"
		}, 
		"78: link": {
			"srcIndexStart": "7888", 
			"param 0": "http://www.antlr.org/images/terence_antlr.jpg", 
			"data": "Yes", 
			"srcLength": "62", 
			"0: data": {
				"srcIndexStart": "7943", 
				"data": "Yes", 
				"srcLength": "5"
			}
		}, 
		"79: data": {
			"srcIndexStart": "7950", 
			"data": "</td>
</tr>
</table>
<p>
(If anything in this comparison appears to be wrong or out-of-date,
I invite you to file a ", 
			"srcLength": "116"
		}, 
		"80: pageLink": {
			"srcIndexStart": "8066", 
			"param 0": "Tickets", 
			"data": "bug report", 
			"srcLength": "33", 
			"0: data": {
				"srcIndexStart": "8085", 
				"data": "bug report", 
				"srcLength": "12"
			}
		}, 
		"81: data": {
			"srcIndexStart": "8099", 
			"data": ".)
</p>

<a name=\"ReallyFA\" />
<h2>Q: Are these questions really frequently-asked?</h2>
<p>
A: No, I'm just anticipating them. ;)
</p>", 
			"srcLength": "135"
		}
	}
}