package antlr;
import antlr.collections.impl.BitSet;
import antlr.collections.impl.Vector;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;
import java.util.Hashtable;
public class DocBookCodeGenerator extends CodeGenerator
{
protected int syntacticPredLevel = 0;
protected boolean doingLexRules = false;
protected boolean firstElementInAlt;
protected AlternativeElement prevAltElem = null;
public DocBookCodeGenerator()
{
this.charFormatter = new JavaCharFormatter();
}
static String HTMLEncode(String paramString)
{
StringBuffer localStringBuffer = new StringBuffer();
int i = 0;
int j = paramString.length();
while (i < j)
{
char c = paramString.charAt(i);
if (c == '&')
localStringBuffer.append("&");
else if (c == '"')
localStringBuffer.append(""");
else if (c == '\'')
localStringBuffer.append("'");
else if (c == '<')
localStringBuffer.append("<");
else if (c == '>')
localStringBuffer.append(">");
else
localStringBuffer.append(c);
i++;
}
return localStringBuffer.toString();
}
static String QuoteForId(String paramString)
{
StringBuffer localStringBuffer = new StringBuffer();
int i = 0;
int j = paramString.length();
while (i < j)
{
char c = paramString.charAt(i);
if (c == '_')
localStringBuffer.append(".");
else
localStringBuffer.append(c);
i++;
}
return localStringBuffer.toString();
}
public void gen()
{
try
{
Enumeration localEnumeration = this.behavior.grammars.elements();
while (localEnumeration.hasMoreElements())
{
Grammar localGrammar = (Grammar)localEnumeration.nextElement();
localGrammar.setCodeGenerator(this);
localGrammar.generate();
if (!this.antlrTool.hasError())
continue;
this.antlrTool.fatalError("Exiting due to errors.");
}
}
catch (IOException localIOException)
{
this.antlrTool.reportException(localIOException, null);
}
}
public void gen(ActionElement paramActionElement)
{
}
public void gen(AlternativeBlock paramAlternativeBlock)
{
genGenericBlock(paramAlternativeBlock, "");
}
public void gen(BlockEndElement paramBlockEndElement)
{
}
public void gen(CharLiteralElement paramCharLiteralElement)
{
if (paramCharLiteralElement.not)
_print("~");
_print(HTMLEncode(paramCharLiteralElement.atomText) + " ");
}
public void gen(CharRangeElement paramCharRangeElement)
{
print(paramCharRangeElement.beginText + ".." + paramCharRangeElement.endText + " ");
}
public void gen(LexerGrammar paramLexerGrammar)
throws IOException
{
setGrammar(paramLexerGrammar);
this.antlrTool.reportProgress("Generating " + this.grammar.getClassName() + ".sgml");
this.currentOutput = this.antlrTool.openOutputFile(this.grammar.getClassName() + ".sgml");
this.tabs = 0;
this.doingLexRules = true;
genHeader();
println("");
if (this.grammar.comment != null)
_println(HTMLEncode(this.grammar.comment));
println("<para>Definition of lexer " + this.grammar.getClassName() + ", which is a subclass of " + this.grammar.getSuperClass() + ".</para>");
genNextToken();
Enumeration localEnumeration = this.grammar.rules.elements();
while (localEnumeration.hasMoreElements())
{
RuleSymbol localRuleSymbol = (RuleSymbol)localEnumeration.nextElement();
if (localRuleSymbol.id.equals("mnextToken"))
continue;
genRule(localRuleSymbol);
}
this.currentOutput.close();
this.currentOutput = null;
this.doingLexRules = false;
}
public void gen(OneOrMoreBlock paramOneOrMoreBlock)
{
genGenericBlock(paramOneOrMoreBlock, "+");
}
public void gen(ParserGrammar paramParserGrammar)
throws IOException
{
setGrammar(paramParserGrammar);
this.antlrTool.reportProgress("Generating " + this.grammar.getClassName() + ".sgml");
this.currentOutput = this.antlrTool.openOutputFile(this.grammar.getClassName() + ".sgml");
this.tabs = 0;
genHeader();
println("");
if (this.grammar.comment != null)
_println(HTMLEncode(this.grammar.comment));
println("<para>Definition of parser " + this.grammar.getClassName() + ", which is a subclass of " + this.grammar.getSuperClass() + ".</para>");
Enumeration localEnumeration = this.grammar.rules.elements();
while (localEnumeration.hasMoreElements())
{
println("");
GrammarSymbol localGrammarSymbol = (GrammarSymbol)localEnumeration.nextElement();
if (!(localGrammarSymbol instanceof RuleSymbol))
continue;
genRule((RuleSymbol)localGrammarSymbol);
}
this.tabs -= 1;
println("");
genTail();
this.currentOutput.close();
this.currentOutput = null;
}
public void gen(RuleRefElement paramRuleRefElement)
{
RuleSymbol localRuleSymbol = (RuleSymbol)this.grammar.getSymbol(paramRuleRefElement.targetRule);
_print("<link linkend=\"" + QuoteForId(paramRuleRefElement.targetRule) + "\">");
_print(paramRuleRefElement.targetRule);
_print("</link>");
_print(" ");
}
public void gen(StringLiteralElement paramStringLiteralElement)
{
if (paramStringLiteralElement.not)
_print("~");
_print(HTMLEncode(paramStringLiteralElement.atomText));
_print(" ");
}
public void gen(TokenRangeElement paramTokenRangeElement)
{
print(paramTokenRangeElement.beginText + ".." + paramTokenRangeElement.endText + " ");
}
public void gen(TokenRefElement paramTokenRefElement)
{
if (paramTokenRefElement.not)
_print("~");
_print(paramTokenRefElement.atomText);
_print(" ");
}
public void gen(TreeElement paramTreeElement)
{
print(paramTreeElement + " ");
}
public void gen(TreeWalkerGrammar paramTreeWalkerGrammar)
throws IOException
{
setGrammar(paramTreeWalkerGrammar);
this.antlrTool.reportProgress("Generating " + this.grammar.getClassName() + ".sgml");
this.currentOutput = this.antlrTool.openOutputFile(this.grammar.getClassName() + ".sgml");
this.tabs = 0;
genHeader();
println("");
println("");
if (this.grammar.comment != null)
_println(HTMLEncode(this.grammar.comment));
println("<para>Definition of tree parser " + this.grammar.getClassName() + ", which is a subclass of " + this.grammar.getSuperClass() + ".</para>");
println("");
this.tabs += 1;
Enumeration localEnumeration = this.grammar.rules.elements();
while (localEnumeration.hasMoreElements())
{
println("");
GrammarSymbol localGrammarSymbol = (GrammarSymbol)localEnumeration.nextElement();
if (!(localGrammarSymbol instanceof RuleSymbol))
continue;
genRule((RuleSymbol)localGrammarSymbol);
}
this.tabs -= 1;
println("");
this.currentOutput.close();
this.currentOutput = null;
}
public void gen(WildcardElement paramWildcardElement)
{
_print(". ");
}
public void gen(ZeroOrMoreBlock paramZeroOrMoreBlock)
{
genGenericBlock(paramZeroOrMoreBlock, "*");
}
protected void genAlt(Alternative paramAlternative)
{
if (paramAlternative.getTreeSpecifier() != null)
_print(paramAlternative.getTreeSpecifier().getText());
this.prevAltElem = null;
for (AlternativeElement localAlternativeElement = paramAlternative.head; !(localAlternativeElement instanceof BlockEndElement); localAlternativeElement = localAlternativeElement.next)
{
localAlternativeElement.generate();
this.firstElementInAlt = false;
this.prevAltElem = localAlternativeElement;
}
}
public void genCommonBlock(AlternativeBlock paramAlternativeBlock)
{
if (paramAlternativeBlock.alternatives.size() > 1)
println("<itemizedlist mark=\"none\">");
for (int i = 0; i < paramAlternativeBlock.alternatives.size(); i++)
{
Alternative localAlternative = paramAlternativeBlock.getAlternativeAt(i);
AlternativeElement localAlternativeElement = localAlternative.head;
if (paramAlternativeBlock.alternatives.size() > 1)
print("<listitem><para>");
if ((i > 0) && (paramAlternativeBlock.alternatives.size() > 1))
_print("| ");
boolean bool = this.firstElementInAlt;
this.firstElementInAlt = true;
this.tabs += 1;
genAlt(localAlternative);
this.tabs -= 1;
this.firstElementInAlt = bool;
if (paramAlternativeBlock.alternatives.size() <= 1)
continue;
_println("</para></listitem>");
}
if (paramAlternativeBlock.alternatives.size() > 1)
println("</itemizedlist>");
}
public void genFollowSetForRuleBlock(RuleBlock paramRuleBlock)
{
Lookahead localLookahead = this.grammar.theLLkAnalyzer.FOLLOW(1, paramRuleBlock.endNode);
printSet(this.grammar.maxk, 1, localLookahead);
}
protected void genGenericBlock(AlternativeBlock paramAlternativeBlock, String paramString)
{
if (paramAlternativeBlock.alternatives.size() > 1)
{
_println("");
if (!this.firstElementInAlt)
_println("(");
else
_print("(");
}
else
{
_print("( ");
}
genCommonBlock(paramAlternativeBlock);
if (paramAlternativeBlock.alternatives.size() > 1)
{
_println("");
print(")" + paramString + " ");
if (!(paramAlternativeBlock.next instanceof BlockEndElement))
{
_println("");
print("");
}
}
else
{
_print(")" + paramString + " ");
}
}
protected void genHeader()
{
println("<?xml version=\"1.0\" standalone=\"no\"?>");
println("<!DOCTYPE book PUBLIC \"-//OASIS//DTD DocBook V3.1//EN\">");
println("<book lang=\"en\">");
println("<bookinfo>");
println("<title>Grammar " + this.grammar.getClassName() + "</title>");
println(" <author>");
println(" <firstname></firstname>");
println(" <othername></othername>");
println(" <surname></surname>");
println(" <affiliation>");
println(" <address>");
println(" <email></email>");
println(" </address>");
println(" </affiliation>");
println(" </author>");
println(" <othercredit>");
println(" <contrib>");
println(" Generated by <ulink url=\"http://www.ANTLR.org/\">ANTLR</ulink>" + Tool.version);
println(" from " + this.antlrTool.grammarFile);
println(" </contrib>");
println(" </othercredit>");
println(" <pubdate></pubdate>");
println(" <abstract>");
println(" <para>");
println(" </para>");
println(" </abstract>");
println("</bookinfo>");
println("<chapter>");
println("<title></title>");
}
protected void genLookaheadSetForAlt(Alternative paramAlternative)
{
if ((this.doingLexRules) && (paramAlternative.cache[1].containsEpsilon()))
{
println("MATCHES ALL");
return;
}
int i = paramAlternative.lookaheadDepth;
if (i == 2147483647)
i = this.grammar.maxk;
for (int j = 1; j <= i; j++)
{
Lookahead localLookahead = paramAlternative.cache[j];
printSet(i, j, localLookahead);
}
}
public void genLookaheadSetForBlock(AlternativeBlock paramAlternativeBlock)
{
int i = 0;
Object localObject;
for (int j = 0; j < paramAlternativeBlock.alternatives.size(); j++)
{
localObject = paramAlternativeBlock.getAlternativeAt(j);
if (((Alternative)localObject).lookaheadDepth == 2147483647)
{
i = this.grammar.maxk;
break;
}
if (i >= ((Alternative)localObject).lookaheadDepth)
continue;
i = ((Alternative)localObject).lookaheadDepth;
}
for (j = 1; j <= i; j++)
{
localObject = this.grammar.theLLkAnalyzer.look(j, paramAlternativeBlock);
printSet(i, j, (Lookahead)localObject);
}
}
public void genNextToken()
{
println("");
println("/** Lexer nextToken rule:");
println(" * The lexer nextToken rule is synthesized from all of the user-defined");
println(" * lexer rules. It logically consists of one big alternative block with");
println(" * each user-defined rule being an alternative.");
println(" */");
RuleBlock localRuleBlock = MakeGrammar.createNextTokenRule(this.grammar, this.grammar.rules, "nextToken");
RuleSymbol localRuleSymbol = new RuleSymbol("mnextToken");
localRuleSymbol.setDefined();
localRuleSymbol.setBlock(localRuleBlock);
localRuleSymbol.access = "private";
this.grammar.define(localRuleSymbol);
genCommonBlock(localRuleBlock);
}
public void genRule(RuleSymbol paramRuleSymbol)
{
if ((paramRuleSymbol == null) || (!paramRuleSymbol.isDefined()))
return;
println("");
if ((paramRuleSymbol.access.length() != 0) && (!paramRuleSymbol.access.equals("public")))
_print("<para>" + paramRuleSymbol.access + " </para>");
println("<section id=\"" + QuoteForId(paramRuleSymbol.getId()) + "\">");
println("<title>" + paramRuleSymbol.getId() + "</title>");
if (paramRuleSymbol.comment != null)
_println("<para>" + HTMLEncode(paramRuleSymbol.comment) + "</para>");
println("<para>");
RuleBlock localRuleBlock = paramRuleSymbol.getBlock();
_println("");
print(paramRuleSymbol.getId() + ":\t");
this.tabs += 1;
genCommonBlock(localRuleBlock);
_println("");
this.tabs -= 1;
_println("</para>");
_println("</section><!-- section \"" + paramRuleSymbol.getId() + "\" -->");
}
protected void genSynPred(SynPredBlock paramSynPredBlock)
{
}
public void genTail()
{
println("</chapter>");
println("</book>");
}
protected void genTokenTypes(TokenManager paramTokenManager)
throws IOException
{
this.antlrTool.reportProgress("Generating " + paramTokenManager.getName() + TokenTypesFileSuffix + TokenTypesFileExt);
this.currentOutput = this.antlrTool.openOutputFile(paramTokenManager.getName() + TokenTypesFileSuffix + TokenTypesFileExt);
this.tabs = 0;
genHeader();
println("");
println("*** Tokens used by the parser");
println("This is a list of the token numeric values and the corresponding");
println("token identifiers. Some tokens are literals, and because of that");
println("they have no identifiers. Literals are double-quoted.");
this.tabs += 1;
Vector localVector = paramTokenManager.getVocabulary();
for (int i = 4; i < localVector.size(); i++)
{
String str = (String)localVector.elementAt(i);
if (str == null)
continue;
println(str + " = " + i);
}
this.tabs -= 1;
println("*** End of tokens used by the parser");
this.currentOutput.close();
this.currentOutput = null;
}
protected String processActionForSpecialSymbols(String paramString, int paramInt, RuleBlock paramRuleBlock, ActionTransInfo paramActionTransInfo)
{
return paramString;
}
public String getASTCreateString(Vector paramVector)
{
return null;
}
public String getASTCreateString(GrammarAtom paramGrammarAtom, String paramString)
{
return null;
}
public String mapTreeId(String paramString, ActionTransInfo paramActionTransInfo)
{
return paramString;
}
public void printSet(int paramInt1, int paramInt2, Lookahead paramLookahead)
{
int i = 5;
int[] arrayOfInt = paramLookahead.fset.toArray();
if (paramInt1 != 1)
print("k==" + paramInt2 + ": {");
else
print("{ ");
if (arrayOfInt.length > i)
{
_println("");
this.tabs += 1;
print("");
}
int j = 0;
for (int k = 0; k < arrayOfInt.length; k++)
{
j++;
if (j > i)
{
_println("");
print("");
j = 0;
}
if (this.doingLexRules)
_print(this.charFormatter.literalChar(arrayOfInt[k]));
else
_print((String)this.grammar.tokenManager.getVocabulary().elementAt(arrayOfInt[k]));
if (k == arrayOfInt.length - 1)
continue;
_print(", ");
}
if (arrayOfInt.length > i)
{
_println("");
this.tabs -= 1;
print("");
}
_println(" }");
}
}
/* Location: /home/mnovotny/projects/EMBEDDED_JBOSS_BETA3_COMMUNITY/embedded/output/lib/embedded-jboss/lib/thirdparty-all.jar
* Qualified Name: antlr.DocBookCodeGenerator
* JD-Core Version: 0.6.0
*/