1127 lines
49 KiB
C#
1127 lines
49 KiB
C#
|
///////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// Microsoft Research Singularity
|
||
|
|
//
|
||
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||
|
|
//
|
||
|
|
///////////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
using System;
|
||
|
|
using System.Collections;
|
||
|
|
using System.Text;
|
||
|
|
using System.IO;
|
||
|
|
using System.Reflection;
|
||
|
|
using System.Text.RegularExpressions;
|
||
|
|
|
||
|
|
namespace Microsoft.Singularity.Applications
|
||
|
|
{
|
||
|
|
class Generator
|
||
|
|
{
|
||
|
|
private String specFile;
|
||
|
|
private String outputFile;
|
||
|
|
private String className;
|
||
|
|
private String targetNamespace;
|
||
|
|
private const String fieldsSectionHeader = "[fields]";
|
||
|
|
private String fieldsSectionCode;
|
||
|
|
private static bool compileRegex = false;
|
||
|
|
private const String initSection = "[init]";
|
||
|
|
private const String tokensSection = "[tokens]";
|
||
|
|
private const String grammarSection = "[grammar]";
|
||
|
|
|
||
|
|
private const String EPSILON = "epsilon";
|
||
|
|
private const int EPSILON_ID = 1;
|
||
|
|
private Terminal epsilonTerm;
|
||
|
|
|
||
|
|
private const String END_MARKER = "$";
|
||
|
|
private const int END_MARKER_ID = 2;
|
||
|
|
private Terminal endMarkerTerm;
|
||
|
|
|
||
|
|
private ArrayList terminalList;
|
||
|
|
private Hashtable productionStrings;
|
||
|
|
private Hashtable grammarStringTable;
|
||
|
|
private Hashtable precedenceTable;
|
||
|
|
|
||
|
|
private Symbol[] grammarTable;
|
||
|
|
private int numTerminals = 0;
|
||
|
|
public Generator(String specFile,
|
||
|
|
String targetNamespace,
|
||
|
|
String className,
|
||
|
|
String outputFile)
|
||
|
|
{
|
||
|
|
this.specFile = specFile;
|
||
|
|
this.targetNamespace = targetNamespace;
|
||
|
|
this.className = className;
|
||
|
|
this.outputFile = outputFile;
|
||
|
|
|
||
|
|
terminalList = new System.Collections.ArrayList();
|
||
|
|
productionStrings = new Hashtable();
|
||
|
|
grammarStringTable = new Hashtable();
|
||
|
|
precedenceTable = new Hashtable();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void Main(String[] args)
|
||
|
|
{
|
||
|
|
if (args.Length < 4)
|
||
|
|
{
|
||
|
|
Console.WriteLine("Usage: spg specfile targetNamespace targetClass outputFile");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//ScriptEngine.Run(fileString, new ScriptEngine.CommandLineRunner(nothing));
|
||
|
|
Generator gen = new Generator(args[0], args[1], args[2], args[3]);
|
||
|
|
gen.Generate();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static int nothing(String[] args, bool isBackground){ return 0; }
|
||
|
|
private static Regex comment = new Regex("#.*"); //will eat more than it should
|
||
|
|
|
||
|
|
public void Generate()
|
||
|
|
{
|
||
|
|
|
||
|
|
String actionTableCode, gotoTableCode, tokenTypeTableCode, lexerActionMethodsCode,
|
||
|
|
productionTable, productionActionMethods;
|
||
|
|
|
||
|
|
epsilonTerm = new Terminal(EPSILON, 1);
|
||
|
|
grammarStringTable[EPSILON] = epsilonTerm;
|
||
|
|
numTerminals++;
|
||
|
|
endMarkerTerm = new Terminal(END_MARKER, 2);
|
||
|
|
grammarStringTable[END_MARKER] = epsilonTerm;
|
||
|
|
numTerminals++;
|
||
|
|
|
||
|
|
ParseSpecification();
|
||
|
|
GenerateGrammarTable();
|
||
|
|
|
||
|
|
GenerateParseTables(out actionTableCode, out gotoTableCode, out tokenTypeTableCode, out lexerActionMethodsCode, out productionTable, out productionActionMethods);
|
||
|
|
DerivedParserClassTemplate template = GenerateParserClass(actionTableCode, gotoTableCode, tokenTypeTableCode, lexerActionMethodsCode, productionTable, productionActionMethods);
|
||
|
|
|
||
|
|
WriteClassFile(template);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void ParseSpecification()
|
||
|
|
{
|
||
|
|
FileStream file = new FileStream(specFile, FileMode.Open, FileAccess.Read);
|
||
|
|
StreamReader fr = new StreamReader(file);
|
||
|
|
String fileString = fr.ReadToEnd();
|
||
|
|
|
||
|
|
StringReader sr = new StringReader(fileString);
|
||
|
|
String line;
|
||
|
|
bool parsedTokens = false, parsedGrammar = false;
|
||
|
|
while ((line = sr.ReadLine()) != null) {
|
||
|
|
line = line.Trim();
|
||
|
|
if (line.Length == 0) continue;
|
||
|
|
if (line[0] == '#') continue; //skip comments
|
||
|
|
switch (line) {
|
||
|
|
case fieldsSectionHeader:
|
||
|
|
ParseFieldsSection(sr);
|
||
|
|
break;
|
||
|
|
case initSection:
|
||
|
|
ParseInitSection(sr);
|
||
|
|
break;
|
||
|
|
case tokensSection:
|
||
|
|
ParseTokenSection(sr);
|
||
|
|
parsedTokens = true;
|
||
|
|
break;
|
||
|
|
case grammarSection:
|
||
|
|
ParseGrammarSection(sr);
|
||
|
|
parsedGrammar = true;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
sr.Close();
|
||
|
|
file.Close();
|
||
|
|
if (!parsedTokens) {
|
||
|
|
throw new Exception("missing lexical spec");
|
||
|
|
} else if (!parsedGrammar) {
|
||
|
|
throw new Exception("missing grammar spec");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void GenerateGrammarTable()
|
||
|
|
{
|
||
|
|
grammarTable = new Symbol[Symbol.idCount];
|
||
|
|
grammarTable[1] = epsilonTerm;
|
||
|
|
grammarTable[2] = endMarkerTerm;
|
||
|
|
foreach (Terminal token in terminalList) {
|
||
|
|
grammarTable[token.id] = token;
|
||
|
|
}
|
||
|
|
foreach (System.Collections.DictionaryEntry entry in productionStrings) {
|
||
|
|
String name = entry.Key as String;
|
||
|
|
Nonterminal nonterm = grammarStringTable[name] as Nonterminal;
|
||
|
|
grammarTable[nonterm.id] = nonterm;
|
||
|
|
System.Collections.ArrayList prods = entry.Value as System.Collections.ArrayList;
|
||
|
|
int[][] rhss = new int[prods.Count][];
|
||
|
|
String[][] allBindings = new string[prods.Count][];
|
||
|
|
ProductionAction[] actions = new ProductionAction[prods.Count];
|
||
|
|
int i = 0;
|
||
|
|
foreach (ProductionString prod in prods) {
|
||
|
|
actions[i] = new ProductionAction(this, nonterm.id, i, prod.action);
|
||
|
|
ArrayList elems = new System.Collections.ArrayList();
|
||
|
|
ArrayList bindingsList = new ArrayList();
|
||
|
|
foreach (String elemAndBinding in prod.rhs.Split(new char[] { ' ' })) {
|
||
|
|
if(elemAndBinding == "") continue;
|
||
|
|
String[] split = elemAndBinding.Split(":".ToCharArray());
|
||
|
|
if (split[0] == EPSILON) continue;
|
||
|
|
Symbol sym = grammarStringTable[split[0]] as Symbol;
|
||
|
|
if (sym == null) throw new Exception("Undefined symbol: " + split[0]);
|
||
|
|
elems.Add(sym.id);
|
||
|
|
String binding = null;
|
||
|
|
if (split.Length > 1) {
|
||
|
|
binding = split[1];
|
||
|
|
}
|
||
|
|
bindingsList.Add(binding);
|
||
|
|
}
|
||
|
|
int[] rhs = new int[elems.Count];
|
||
|
|
for (int j = 0; j < rhs.Length; ++j) {
|
||
|
|
rhs[j] = (int)elems[j];
|
||
|
|
}
|
||
|
|
rhss[i] = rhs;
|
||
|
|
|
||
|
|
String[] bindings = new String[bindingsList.Count];
|
||
|
|
for (int j = 0; j < bindings.Length; ++j) {
|
||
|
|
bindings[j] = (String)bindingsList[j];
|
||
|
|
}
|
||
|
|
allBindings[i] = bindings;
|
||
|
|
|
||
|
|
++i;
|
||
|
|
}
|
||
|
|
nonterm.rhss = rhss;
|
||
|
|
nonterm.bindings = allBindings;
|
||
|
|
nonterm.actions = actions;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void WriteClassFile(DerivedParserClassTemplate template)
|
||
|
|
{
|
||
|
|
String classText = template.Dump();
|
||
|
|
FileStream file = new FileStream(outputFile, FileMode.Create, FileAccess.Write);
|
||
|
|
StreamWriter sw = new StreamWriter(file);
|
||
|
|
sw.Write(classText);
|
||
|
|
sw.Close();
|
||
|
|
file.Close();
|
||
|
|
}
|
||
|
|
|
||
|
|
private DerivedParserClassTemplate GenerateParserClass(String actionTableCode, String gotoTableCode, String tokenTypeTableCode, String lexerActionMethodsCode, String productionTable, String productionActionMethods)
|
||
|
|
{
|
||
|
|
DerivedParserClassTemplate template = new DerivedParserClassTemplate(targetNamespace, className);
|
||
|
|
template.AddUsingCode("using System;\r\nusing System.Collections;\r\nusing System.Text;\r\nusing System.IO;\r\nusing System.Text.RegularExpressions;\r\nusing Microsoft.Contracts;\r\n");
|
||
|
|
template.AddFieldCode(fieldsSectionCode);
|
||
|
|
template.AddConstructorCode(actionTableCode + gotoTableCode + tokenTypeTableCode + productionTable);
|
||
|
|
template.AddMethodCode(lexerActionMethodsCode + productionActionMethods);
|
||
|
|
template.AddDefaultMembers();
|
||
|
|
return template;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void GenerateParseTables(out String actionTableCode, out String gotoTableCode, out String tokenTypeTableCode, out String lexerActionMethodsCode, out String productionTable, out String productionActionMethods)
|
||
|
|
{
|
||
|
|
ISet setsOfItems = ComputeSetsOfItems();
|
||
|
|
computeFirst();
|
||
|
|
computeFollow();
|
||
|
|
String parserType = "Parser.";
|
||
|
|
ArrayList productions;
|
||
|
|
Parser.Action[][] actionTable = computeActionTable(setsOfItems, out productions);
|
||
|
|
actionTableCode = GetProductionActionTableCode(parserType, "actionTable", actionTable);
|
||
|
|
Parser.State[][] gotoTable = computeGotoTable(setsOfItems);
|
||
|
|
gotoTableCode = GetGotoTableCode(parserType, "gotoTable", gotoTable);
|
||
|
|
GetTokenTypeTableCode("tokenList", out tokenTypeTableCode, out lexerActionMethodsCode);
|
||
|
|
GetProductionListCode(parserType, productions, out productionTable, out productionActionMethods);
|
||
|
|
}
|
||
|
|
|
||
|
|
public class DerivedParserClassTemplate
|
||
|
|
{
|
||
|
|
private String nspace;
|
||
|
|
private String className;
|
||
|
|
StringBuilder usings;
|
||
|
|
StringBuilder derivations;
|
||
|
|
StringBuilder fields;
|
||
|
|
StringBuilder constructor;
|
||
|
|
StringBuilder methods;
|
||
|
|
|
||
|
|
public DerivedParserClassTemplate(String nspace, String className)
|
||
|
|
{
|
||
|
|
this.nspace = nspace; this.className = className;
|
||
|
|
usings = new StringBuilder();
|
||
|
|
derivations = new StringBuilder(",");
|
||
|
|
fields = new StringBuilder();
|
||
|
|
constructor = new StringBuilder();
|
||
|
|
methods = new StringBuilder();
|
||
|
|
}
|
||
|
|
public void AddDefaultMembers() {
|
||
|
|
fields.Append(" private Action[,]! actionTable;\n");
|
||
|
|
fields.Append(" private State[,]! gotoTable;\n");
|
||
|
|
fields.Append(" private Production[]! productionTable;\n");
|
||
|
|
fields.Append(" private TokenType[]! tokenList;\n");
|
||
|
|
methods.Append(" protected override Action[,]! ActionTable { get { return this.actionTable; } }\n");
|
||
|
|
methods.Append(" protected override State[,]! GotoTable { get { return this.gotoTable; } }\n");
|
||
|
|
methods.Append(" protected override Production[]! ProductionTable { get { return this.productionTable; } }\n");
|
||
|
|
methods.Append(" protected override TokenType[]! TokenList { get { return this.tokenList; } }\n");
|
||
|
|
|
||
|
|
}
|
||
|
|
public void AddDerivationCode(String code)
|
||
|
|
{
|
||
|
|
derivations.Append(code);
|
||
|
|
}
|
||
|
|
public void AddMethodCode(String code){
|
||
|
|
methods.Append(code);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void AddFieldCode(String code)
|
||
|
|
{
|
||
|
|
fields.Append(code);
|
||
|
|
}
|
||
|
|
public void AddConstructorCode(String code)
|
||
|
|
{
|
||
|
|
constructor.Append(code);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void AddUsingCode(String code)
|
||
|
|
{
|
||
|
|
usings.Append(code);
|
||
|
|
}
|
||
|
|
|
||
|
|
public String Dump()
|
||
|
|
{
|
||
|
|
StringBuilder dump = new StringBuilder();
|
||
|
|
dump.Append("//This file is automatically generated\r\n" + usings + "\r\n" +
|
||
|
|
"namespace " + nspace + "{\r\n"
|
||
|
|
+ "\r\n class " + className + " : Parser" + "\r\n" +
|
||
|
|
"{\r\n" +
|
||
|
|
fields +
|
||
|
|
// "[NotDelayed]\r\n" +
|
||
|
|
"public " + className + "(){\r\n " + constructor +
|
||
|
|
";\r\n" +
|
||
|
|
//"base();\r\n" +
|
||
|
|
"}\r\n" +
|
||
|
|
methods +
|
||
|
|
"\t}\r\n" +
|
||
|
|
"}");
|
||
|
|
|
||
|
|
return dump.ToString();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void GetProductionListCode(String parserTypeString, ArrayList productions, out String productionTable, out String productionActionMethods)
|
||
|
|
{
|
||
|
|
parserTypeString = "";
|
||
|
|
StringBuilder array = new StringBuilder();
|
||
|
|
StringBuilder methods = new StringBuilder();
|
||
|
|
int i = 0;
|
||
|
|
array.Append(parserTypeString + "productionTable = new[Delayed] Production[]{");
|
||
|
|
foreach (ProductionAction action in productions) {
|
||
|
|
String methodName = "production_action_" + i;
|
||
|
|
StringBuilder method = new StringBuilder();
|
||
|
|
method.Append("private Object " + methodName + "(Stack! stack) {\r\n");
|
||
|
|
method.Append("\tObject value = null;\r\n");
|
||
|
|
String[] bindings = (grammarTable[action.nonterm] as Nonterminal).bindings[action.production];
|
||
|
|
for (int j = bindings.Length - 1; j >= 0; --j) {
|
||
|
|
if(bindings[j] != null){
|
||
|
|
method.Append("\tObject " + bindings[j] + " = ( (StackElement!) stack.Pop()).value;");
|
||
|
|
|
||
|
|
}else{
|
||
|
|
method.Append("\tstack.Pop(); //pop non binding element");
|
||
|
|
}
|
||
|
|
method.Append(j != 0 ? "\r\n\tstack.Pop(); //pop state\r\n" : "");
|
||
|
|
}
|
||
|
|
method.Append("\r\n\t\t//user code:\r\n" + action.action);
|
||
|
|
method.Append("\r\n\treturn value;");
|
||
|
|
method.Append("\r\n}\r\n");
|
||
|
|
methods.Append(method);
|
||
|
|
array.Append("new " + parserTypeString + "Production( " + action.nonterm + ", new " + parserTypeString + "Reducer(this." + methodName + ")),");
|
||
|
|
++i;
|
||
|
|
}
|
||
|
|
array.Remove(array.Length - 1, 1);
|
||
|
|
array.Append("};\r\n");
|
||
|
|
productionTable = array.ToString();
|
||
|
|
productionActionMethods = methods.ToString();
|
||
|
|
|
||
|
|
}
|
||
|
|
private String lexActionMethodPrefix = "LexActionMethod_";
|
||
|
|
private void GetTokenTypeTableCode(String tableName, out String tokenTableCode, out String lexerMethodsCode)
|
||
|
|
{
|
||
|
|
StringBuilder sb = new StringBuilder();
|
||
|
|
StringBuilder methods = new StringBuilder();
|
||
|
|
sb.Append(tableName + " = new[Delayed] TokenType[] \r\n\t\t{");
|
||
|
|
int i = 0;
|
||
|
|
int regExId = 0;
|
||
|
|
RegexCompilationInfo[] regexCompInfo = new RegexCompilationInfo[terminalList.Count];
|
||
|
|
foreach (Terminal term in terminalList) {
|
||
|
|
String methodName = lexActionMethodPrefix + i;
|
||
|
|
String id = term.id.ToString();
|
||
|
|
if(compileRegex)
|
||
|
|
{
|
||
|
|
regexCompInfo[regExId] = new RegexCompilationInfo(term.regex, RegexOptions.None, "LexRegex" + regExId, targetNamespace, true);
|
||
|
|
}
|
||
|
|
String regex = compileRegex ? "(new LexRegex" + regExId++ + "())" : "new Regex(@" + term.regex + ")" ;
|
||
|
|
|
||
|
|
String lexer;
|
||
|
|
if (term.action != null && term.action != "") {
|
||
|
|
String method =
|
||
|
|
"\tprivate void " + methodName + "(Token! tok) { \r\n" + term.action + "\r\n\t}\r\n";
|
||
|
|
methods.Append(method);
|
||
|
|
lexer = "new Lexer(this." + methodName + ")";
|
||
|
|
++i;
|
||
|
|
} else {
|
||
|
|
lexer = "null";
|
||
|
|
}
|
||
|
|
sb.Append("new TokenType(" + id + "," + regex + "," + lexer + " ),");
|
||
|
|
}
|
||
|
|
if (terminalList.Count != 0)
|
||
|
|
sb.Remove(sb.Length - 1, 1);
|
||
|
|
sb.Append("}\r\n;");
|
||
|
|
if(compileRegex)
|
||
|
|
{
|
||
|
|
AssemblyName assembly = new AssemblyName();
|
||
|
|
assembly.Name = "LexerRegex";
|
||
|
|
Regex.CompileToAssembly(regexCompInfo, assembly);
|
||
|
|
}
|
||
|
|
tokenTableCode = sb.ToString();
|
||
|
|
lexerMethodsCode = methods.ToString();
|
||
|
|
|
||
|
|
}
|
||
|
|
private String GetGotoTableCode(String parserTypeString, String tableName, Parser.State[][] gotoTable)
|
||
|
|
{
|
||
|
|
StringBuilder sb = new StringBuilder();
|
||
|
|
|
||
|
|
sb.Append(tableName + " = new State[,]\r\n\t{\r\n");
|
||
|
|
foreach (Parser.State[] row in gotoTable) {
|
||
|
|
sb.Append("\r\n\t\t{");
|
||
|
|
foreach (Parser.State state in row) {
|
||
|
|
if (state == null) {
|
||
|
|
sb.Append("null,");
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
sb.Append("new " + parserTypeString + "State(" + state.id.ToString() + "),");
|
||
|
|
}
|
||
|
|
if (row.Length != 0)
|
||
|
|
sb.Remove(sb.Length - 1, 1);
|
||
|
|
sb.Append("},");
|
||
|
|
}
|
||
|
|
if (gotoTable.Length != 0)
|
||
|
|
sb.Remove(sb.Length - 1, 1);
|
||
|
|
sb.Append("\r\n\t};\r\n");
|
||
|
|
|
||
|
|
return sb.ToString();
|
||
|
|
}
|
||
|
|
|
||
|
|
private Parser.State[][] computeGotoTable(ISet setsOfItems)
|
||
|
|
{
|
||
|
|
Parser.State[][] gotoTable = new Parser.State[setsOfItems.Count][];
|
||
|
|
Hashtable/*ISet -> int*/ stateTable = new Hashtable();
|
||
|
|
int i = 0;
|
||
|
|
foreach (ISet set in setsOfItems) {
|
||
|
|
gotoTable[i] = new Parser.State[Symbol.idCount];
|
||
|
|
stateTable[set] = i++;
|
||
|
|
}
|
||
|
|
|
||
|
|
foreach (ISet items in setsOfItems) {
|
||
|
|
foreach (Symbol symbol in grammarTable) {
|
||
|
|
|
||
|
|
if (symbol is Terminal) {
|
||
|
|
gotoTable[(int)stateTable[items]][symbol.id] = null;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
ISet gotoSet = computeGoto(items, symbol);
|
||
|
|
if (gotoSet.Count == 0) continue;
|
||
|
|
Object gotoState = stateTable[gotoSet];
|
||
|
|
if (gotoState == null) throw new Exception("missing state"); ;
|
||
|
|
gotoTable[(int)stateTable[items]][symbol.id] = new Parser.State((int)gotoState);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return gotoTable;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
private String GetProductionActionTableCode(String parserTypeString, String tableName, Parser.Action[][] actionTable)
|
||
|
|
{
|
||
|
|
StringBuilder sb = new StringBuilder();
|
||
|
|
sb.Append(tableName);
|
||
|
|
sb.Append(" = new Parser.Action[,]\r\n\t{\r\n");
|
||
|
|
foreach (Parser.Action[] row in actionTable) {
|
||
|
|
sb.Append("\r\n\t\t{");
|
||
|
|
foreach (Parser.Action action in row) {
|
||
|
|
if (action == null) {
|
||
|
|
sb.Append("null,");
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
sb.Append("new " + parserTypeString + "Action(");
|
||
|
|
String actionType = "";
|
||
|
|
switch (action.type) {
|
||
|
|
case Parser.ActionType.ACCEPT:
|
||
|
|
actionType = parserTypeString + "ActionType.ACCEPT";
|
||
|
|
break;
|
||
|
|
case Parser.ActionType.REDUCE:
|
||
|
|
actionType = parserTypeString + "ActionType.REDUCE";
|
||
|
|
break;
|
||
|
|
case Parser.ActionType.SHIFT:
|
||
|
|
actionType = parserTypeString + "ActionType.SHIFT";
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
throw new Exception("missed action type");
|
||
|
|
}
|
||
|
|
sb.Append(actionType + "," + action.stateOrProduction.ToString() + "),");
|
||
|
|
}
|
||
|
|
if (row.Length != 0)
|
||
|
|
sb.Remove(sb.Length - 1, 1);
|
||
|
|
sb.Append("},");
|
||
|
|
}
|
||
|
|
if (actionTable.Length != 0)
|
||
|
|
sb.Remove(sb.Length - 1, 1);
|
||
|
|
sb.Append("\r\n\t};\r\n");
|
||
|
|
|
||
|
|
return sb.ToString();
|
||
|
|
}
|
||
|
|
private Parser.Action[][] computeActionTable(ISet setsOfItems, out ArrayList productions)
|
||
|
|
{
|
||
|
|
//TODO: could be reduced since we only consult on terminals
|
||
|
|
productions = new ArrayList();
|
||
|
|
Parser.Action[][] actionTable = new Parser.Action[setsOfItems.Count][];
|
||
|
|
Hashtable/*ISet -> int*/ stateTable = new Hashtable();
|
||
|
|
Object[][] productionCacheTable = new Object[ Symbol.idCount][];
|
||
|
|
|
||
|
|
int i = 0;
|
||
|
|
foreach (ISet set in setsOfItems) {
|
||
|
|
actionTable[i] = new Parser.Action[Symbol.idCount];
|
||
|
|
stateTable[set] = i++;
|
||
|
|
}
|
||
|
|
foreach (ISet items in setsOfItems) {
|
||
|
|
foreach (Item item in items) {
|
||
|
|
Nonterminal nonterm = grammarTable[item.nonterm] as Nonterminal;
|
||
|
|
int[] production = nonterm.rhss[item.production];
|
||
|
|
if (item.position == production.Length) {
|
||
|
|
if (item.nonterm == 0) {
|
||
|
|
Object obj = stateTable[items];
|
||
|
|
if (obj == null) throw new Exception("Missing state:" + items);
|
||
|
|
if (actionTable[(int)obj][END_MARKER_ID] != null) throw new Exception("not slr");
|
||
|
|
actionTable[(int)obj][END_MARKER_ID] = new Parser.Action(Parser.ActionType.ACCEPT, 0);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
Object[] nontermProds = productionCacheTable[item.nonterm];
|
||
|
|
if (nontermProds == null) {
|
||
|
|
productionCacheTable[item.nonterm] = nontermProds = new Object[nonterm.rhss.Length];
|
||
|
|
}
|
||
|
|
Object prodIndexObject = nontermProds[item.production];
|
||
|
|
foreach (int followSym in followTable[item.nonterm] as HashSet) {
|
||
|
|
if (prodIndexObject == null) {
|
||
|
|
nontermProds[item.production] = prodIndexObject = productions.Add(nonterm.actions[item.production]);
|
||
|
|
}
|
||
|
|
int prodIndex = (int) prodIndexObject;
|
||
|
|
Object obj = stateTable[items];
|
||
|
|
if (obj == null) throw new Exception("Missing state:" + items);
|
||
|
|
Parser.Action newAction = new Parser.Action(Parser.ActionType.REDUCE, prodIndex);
|
||
|
|
Parser.Action currentAction = actionTable[(Int32)obj][followSym];
|
||
|
|
if (currentAction != null && !currentAction.Equals(newAction)) {
|
||
|
|
newAction = ResolveAction(currentAction, newAction, (Terminal) grammarTable[followSym], items, productions);
|
||
|
|
}
|
||
|
|
actionTable[(Int32)obj][followSym] = newAction;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
foreach (Symbol symbol in grammarTable) {
|
||
|
|
if (symbol is Nonterminal) continue;
|
||
|
|
ISet gotoSet = computeGoto(items, symbol);
|
||
|
|
Object nextState = (Object)stateTable[gotoSet];
|
||
|
|
if (nextState == null) continue;
|
||
|
|
Parser.Action newAction = new Parser.Action(Parser.ActionType.SHIFT, (Int32)nextState);
|
||
|
|
Parser.Action currentAction = actionTable[(Int32)stateTable[items]][symbol.id];
|
||
|
|
if (currentAction != null && !currentAction.Equals(newAction)) {
|
||
|
|
newAction = ResolveAction(currentAction, newAction, (Terminal) symbol ,items, productions);
|
||
|
|
}
|
||
|
|
actionTable[(Int32)stateTable[items]][symbol.id] = newAction;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return actionTable;
|
||
|
|
}
|
||
|
|
private Parser.Action ResolveAction(Parser.Action a1, Parser.Action a2, Terminal symbol, ISet items, ArrayList productions)
|
||
|
|
{
|
||
|
|
Parser.Action reducer;
|
||
|
|
Parser.Action shifter;
|
||
|
|
if (a1.type == Parser.ActionType.REDUCE) {
|
||
|
|
reducer = a1; shifter = a2;
|
||
|
|
} else {
|
||
|
|
reducer = a2; shifter = a1;
|
||
|
|
}
|
||
|
|
ProductionAction reduction = productions[reducer.stateOrProduction] as ProductionAction;
|
||
|
|
int[] reductionSymbols = (grammarTable[reduction.nonterm] as Nonterminal).rhss[reduction.production];
|
||
|
|
int j;
|
||
|
|
for (j = reductionSymbols.Length - 1; j >= 0; --j) {
|
||
|
|
if (grammarTable[reductionSymbols[j]] is Terminal) break;
|
||
|
|
}
|
||
|
|
if (j == -1) throw new Exception("non terminal in reduction");
|
||
|
|
int reductionTerminal = reductionSymbols[j];
|
||
|
|
int precedence;
|
||
|
|
PrecedenceRelation precedenceRelation = precedenceTable[new HashSet(new int[] { symbol.id, reductionTerminal })] as PrecedenceRelation;
|
||
|
|
if (precedenceRelation == null) {
|
||
|
|
//Console.Write("no precedence relation between " + grammarTable[symbol.id].name + " and " + grammarTable[reductionTerminal].name);
|
||
|
|
//Console.WriteLine(" defaulting to equivalent precedence");
|
||
|
|
precedence = PrecedenceRelation.EQUAL;
|
||
|
|
} else {
|
||
|
|
precedence = precedenceRelation.Precedence(symbol.id);
|
||
|
|
}
|
||
|
|
|
||
|
|
Parser.Action action;
|
||
|
|
switch (precedence) {
|
||
|
|
case PrecedenceRelation.EQUAL:
|
||
|
|
action = reducer; //left associative by default?
|
||
|
|
break;
|
||
|
|
case PrecedenceRelation.GREATER:
|
||
|
|
action = shifter;
|
||
|
|
break;
|
||
|
|
case PrecedenceRelation.LESS:
|
||
|
|
action = reducer;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
throw new Exception("missing precedence type");
|
||
|
|
}
|
||
|
|
return action;
|
||
|
|
}
|
||
|
|
private Parser.Action PromptAction(Parser.Action a1, Parser.Action a2, Terminal symbol, ISet items, ArrayList productions)
|
||
|
|
{
|
||
|
|
Console.WriteLine("In State: ");
|
||
|
|
foreach (Item item in items) {
|
||
|
|
Console.WriteLine(item.ToString());
|
||
|
|
}
|
||
|
|
Console.WriteLine("On symbol: " + symbol.name);
|
||
|
|
Console.WriteLine("1) " + ActionString(a1, productions));
|
||
|
|
Console.WriteLine("2) " + ActionString(a2, productions));
|
||
|
|
Console.Write("Selection: ");
|
||
|
|
|
||
|
|
int selection;
|
||
|
|
do {
|
||
|
|
selection = Convert.ToInt32(Console.ReadLine());
|
||
|
|
} while (selection != 1 && selection != 2);
|
||
|
|
|
||
|
|
return selection == 1 ? a1 : a2;
|
||
|
|
}
|
||
|
|
|
||
|
|
private string ActionString(Parser.Action action, ArrayList productions)
|
||
|
|
{
|
||
|
|
switch (action.type) {
|
||
|
|
case Parser.ActionType.ACCEPT:
|
||
|
|
return "ACCEPT";
|
||
|
|
case Parser.ActionType.REDUCE:
|
||
|
|
return "REDUCE by " + productions[action.stateOrProduction];
|
||
|
|
case Parser.ActionType.SHIFT:
|
||
|
|
|
||
|
|
return "SHIFT";
|
||
|
|
default:
|
||
|
|
throw new Exception("missing action type");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private class Item
|
||
|
|
{
|
||
|
|
public int nonterm;
|
||
|
|
public int production;
|
||
|
|
public int position;
|
||
|
|
public Generator gen;
|
||
|
|
public Item(Generator gen, int nonterm, int production, int position)
|
||
|
|
{
|
||
|
|
this.gen = gen; this.nonterm = nonterm; this.production = production; this.position = position;
|
||
|
|
}
|
||
|
|
public override int GetHashCode()
|
||
|
|
{
|
||
|
|
return nonterm.GetHashCode() ^ production.GetHashCode() ^ position.GetHashCode();
|
||
|
|
}
|
||
|
|
|
||
|
|
public override bool Equals(object obj)
|
||
|
|
{
|
||
|
|
if (!(obj is Item)) return false;
|
||
|
|
Item that = obj as Item;
|
||
|
|
return this.nonterm == that.nonterm && this.production == that.production && this.position == that.position;
|
||
|
|
}
|
||
|
|
|
||
|
|
public override String ToString()
|
||
|
|
{
|
||
|
|
StringBuilder sb = new StringBuilder();
|
||
|
|
Nonterminal nonterm = gen.grammarTable[this.nonterm] as Nonterminal;
|
||
|
|
for (int i = 0; i < nonterm.rhss[production].Length; ++i) {
|
||
|
|
String spacer = i == this.position ? " . " : " ";
|
||
|
|
sb.Append(spacer + gen.grammarTable[nonterm.rhss[production][i]].ToString());
|
||
|
|
}
|
||
|
|
if (this.position == nonterm.rhss[production].Length) sb.Append(" . ");
|
||
|
|
return gen.grammarTable[this.nonterm] + "=>" + sb.ToString();
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
private ISet doClosure(ISet items)
|
||
|
|
{
|
||
|
|
Queue toProcess = new Queue(items);
|
||
|
|
ISet newItems = new HashSet(items);
|
||
|
|
while (toProcess.Count != 0) {
|
||
|
|
Item item = toProcess.Dequeue() as Item;
|
||
|
|
Nonterminal nonterm = grammarTable[item.nonterm] as Nonterminal;
|
||
|
|
if (item.position == nonterm.rhss[item.production].Length) continue;
|
||
|
|
Symbol nextSymbol = grammarTable[nonterm.rhss[item.production][item.position]];
|
||
|
|
if (nextSymbol is Nonterminal) {
|
||
|
|
for (int j = 0; j < ((Nonterminal)nextSymbol).rhss.Length; ++j) {
|
||
|
|
Item newItem = new Item(this, nextSymbol.id, j, 0);
|
||
|
|
if (!newItems.Contains(newItem)) {
|
||
|
|
toProcess.Enqueue(newItem);
|
||
|
|
newItems.Add(newItem);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return newItems;
|
||
|
|
}
|
||
|
|
|
||
|
|
private ISet computeGoto(ISet items, Symbol symbol)
|
||
|
|
{
|
||
|
|
ISet gotoSet = new HashSet();
|
||
|
|
foreach (Item item in items) {
|
||
|
|
Nonterminal nonterm = grammarTable[item.nonterm] as Nonterminal;
|
||
|
|
if (item.position == nonterm.rhss[item.production].Length) continue;
|
||
|
|
if (nonterm.rhss[item.production][item.position] != symbol.id) continue;
|
||
|
|
Item nextItem = new Item(this, item.nonterm, item.production, item.position + 1);
|
||
|
|
gotoSet.Add(nextItem);
|
||
|
|
}
|
||
|
|
|
||
|
|
gotoSet = doClosure(gotoSet);
|
||
|
|
return gotoSet;
|
||
|
|
}
|
||
|
|
/* these need to be ordered by creation so set 0 is the initial state*/
|
||
|
|
private ISet ComputeSetsOfItems()
|
||
|
|
{
|
||
|
|
ISet sets = new HashSet();
|
||
|
|
ISet rootSet = new HashSet();
|
||
|
|
rootSet.Add(new Item(this, 0, 0, 0));
|
||
|
|
rootSet = doClosure(rootSet);
|
||
|
|
sets.Add(rootSet);
|
||
|
|
Queue toProcess = new Queue(sets);
|
||
|
|
while (toProcess.Count != 0) {
|
||
|
|
ISet set = toProcess.Dequeue() as ISet;
|
||
|
|
foreach (Symbol symbol in grammarTable) {
|
||
|
|
ISet gotoSet = computeGoto(set, symbol);
|
||
|
|
if (gotoSet.Count == 0)
|
||
|
|
continue;
|
||
|
|
if (sets.Contains(gotoSet)) continue;
|
||
|
|
toProcess.Enqueue(gotoSet);
|
||
|
|
sets.Add(gotoSet);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return sets;
|
||
|
|
}
|
||
|
|
ISet[] firstTable;
|
||
|
|
public void computeFirst()
|
||
|
|
{
|
||
|
|
firstTable = new ISet[Symbol.idCount];
|
||
|
|
bool changed = true;
|
||
|
|
while (changed) {
|
||
|
|
changed = false;
|
||
|
|
foreach (Symbol symbol in grammarTable) {
|
||
|
|
if (symbol is Terminal) {
|
||
|
|
ISet first = firstTable[symbol.id];
|
||
|
|
if (first == null) {
|
||
|
|
first = new HashSet();
|
||
|
|
changed = true;
|
||
|
|
}
|
||
|
|
first.Add(symbol.id);
|
||
|
|
|
||
|
|
firstTable[symbol.id] = first;
|
||
|
|
|
||
|
|
} else if (symbol is Nonterminal) {
|
||
|
|
Nonterminal nonterm = symbol as Nonterminal;
|
||
|
|
foreach (int[] rhs in nonterm.rhss) {
|
||
|
|
ISet newFirst = firstTable[nonterm.id];
|
||
|
|
|
||
|
|
if (newFirst == null) {
|
||
|
|
firstTable[nonterm.id] = newFirst = new HashSet();
|
||
|
|
}
|
||
|
|
HashSet oldFirst = new HashSet(newFirst);
|
||
|
|
if (rhs.Length == 0) { /* epsilon production*/
|
||
|
|
newFirst.Add(EPSILON_ID);
|
||
|
|
} else {
|
||
|
|
bool epsilonPrior = true;
|
||
|
|
for (int i = 0; i < rhs.Length && epsilonPrior; ++i) {
|
||
|
|
Symbol sym = grammarTable[rhs[i]];
|
||
|
|
if (sym is Terminal) {
|
||
|
|
newFirst.Add(rhs[i]);
|
||
|
|
if (sym.id != EPSILON_ID)
|
||
|
|
epsilonPrior = false;
|
||
|
|
} else if (sym is Nonterminal) {
|
||
|
|
ISet moreFirst = firstTable[sym.id];
|
||
|
|
if (moreFirst == null) {
|
||
|
|
moreFirst = new HashSet();
|
||
|
|
firstTable[sym.id] = moreFirst;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
newFirst.AddAll(moreFirst);
|
||
|
|
if (!moreFirst.Contains(EPSILON_ID))
|
||
|
|
epsilonPrior = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
changed |= !oldFirst.Equals(newFirst);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
private ISet[] followTable;
|
||
|
|
public void computeFollow()
|
||
|
|
{
|
||
|
|
followTable = new ISet[Symbol.idCount];
|
||
|
|
followTable[0] = new HashSet();
|
||
|
|
followTable[0].Add(END_MARKER_ID);
|
||
|
|
bool changed = false;
|
||
|
|
do {
|
||
|
|
changed = false;
|
||
|
|
foreach (Symbol symbol in grammarTable) {
|
||
|
|
if (!(symbol is Nonterminal)) continue;
|
||
|
|
Nonterminal nonterm = symbol as Nonterminal;
|
||
|
|
changed |= ComputeFollowForNonterminal(changed, nonterm);
|
||
|
|
}
|
||
|
|
} while (changed);
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool ComputeFollowForNonterminal(bool changed, Nonterminal nonterm)
|
||
|
|
{
|
||
|
|
foreach (int[] rhs in nonterm.rhss) {
|
||
|
|
changed |= ComputeFollowForProduction(changed, nonterm, rhs);
|
||
|
|
}
|
||
|
|
return changed;
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool ComputeFollowForProduction(bool changed, Nonterminal nonterm, int[] rhs)
|
||
|
|
{
|
||
|
|
ISet endFirst = new HashSet();
|
||
|
|
for (int i = rhs.Length - 1; i >= 0; --i) {
|
||
|
|
Symbol sym = grammarTable[rhs[i]];
|
||
|
|
if (sym is Nonterminal) {
|
||
|
|
ISet follow = followTable[sym.id];
|
||
|
|
if (follow == null) {
|
||
|
|
followTable[sym.id] = follow = new HashSet();
|
||
|
|
}
|
||
|
|
ISet oldFollow = new HashSet(follow);
|
||
|
|
follow.AddAll(endFirst);
|
||
|
|
follow.Remove(EPSILON_ID);
|
||
|
|
if (i == rhs.Length - 1 || endFirst.Contains(EPSILON_ID)) {
|
||
|
|
ISet prodFollow = followTable[nonterm.id];
|
||
|
|
if (prodFollow == null) {
|
||
|
|
followTable[nonterm.id] = prodFollow = new HashSet();
|
||
|
|
}
|
||
|
|
follow.AddAll(prodFollow);
|
||
|
|
}
|
||
|
|
if (!oldFollow.Equals(follow)) changed = true;
|
||
|
|
if (!firstTable[sym.id].Contains(EPSILON_ID))
|
||
|
|
endFirst = new HashSet();
|
||
|
|
endFirst.AddAll(firstTable[sym.id]);
|
||
|
|
} else {
|
||
|
|
endFirst = new HashSet();
|
||
|
|
endFirst.Add(sym.id);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return changed;
|
||
|
|
}
|
||
|
|
|
||
|
|
public void ParseFieldsSection(TextReader sr)
|
||
|
|
{
|
||
|
|
fieldsSectionCode = ParseSection(sr);
|
||
|
|
}
|
||
|
|
|
||
|
|
public String ParseInitSection(TextReader sr)
|
||
|
|
{
|
||
|
|
return ParseSection(sr);
|
||
|
|
}
|
||
|
|
private const String tokenAssign = ":=";
|
||
|
|
|
||
|
|
class TokenSpec
|
||
|
|
{
|
||
|
|
|
||
|
|
public Terminal token;
|
||
|
|
public Regex regex;
|
||
|
|
public TokenSpec(Terminal token, Regex regex)
|
||
|
|
{
|
||
|
|
this.token = token; this.regex = regex;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private class PrecedenceRelation
|
||
|
|
{
|
||
|
|
public const int LESS = -1, EQUAL = 0, GREATER = 1;
|
||
|
|
public int type;
|
||
|
|
public int leftTerminal;
|
||
|
|
public int rightTerminal;
|
||
|
|
public PrecedenceRelation(int type, int leftTerminal, int rightTerminal)
|
||
|
|
{
|
||
|
|
this.type = type; this.leftTerminal = leftTerminal; this.rightTerminal = rightTerminal;
|
||
|
|
}
|
||
|
|
|
||
|
|
public override int GetHashCode()
|
||
|
|
{
|
||
|
|
return type.GetHashCode() ^ leftTerminal.GetHashCode() ^ rightTerminal.GetHashCode();
|
||
|
|
}
|
||
|
|
|
||
|
|
public override bool Equals(object obj)
|
||
|
|
{
|
||
|
|
if (!(obj is PrecedenceRelation)) return false;
|
||
|
|
PrecedenceRelation that = obj as PrecedenceRelation;
|
||
|
|
return this.type == that.type && this.leftTerminal == that.leftTerminal && this.rightTerminal == that.rightTerminal;
|
||
|
|
}
|
||
|
|
//assumes that you that right side of the caller and this instance match
|
||
|
|
public int Precedence(int leftSide)
|
||
|
|
{
|
||
|
|
if (this.leftTerminal == leftSide) return this.type;
|
||
|
|
else {
|
||
|
|
switch (this.type) {
|
||
|
|
case LESS:
|
||
|
|
return GREATER;
|
||
|
|
case EQUAL:
|
||
|
|
return EQUAL;
|
||
|
|
case GREATER:
|
||
|
|
return LESS;
|
||
|
|
default:
|
||
|
|
throw new Exception("missed type");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
public void ParseTokenSection(TextReader sr)
|
||
|
|
{
|
||
|
|
String line = sr.ReadLine();
|
||
|
|
if (line == null || line.Trim() != "{") throw new Exception("missing left brace");
|
||
|
|
while ((line = sr.ReadLine()) != null) {
|
||
|
|
line = line.Trim();
|
||
|
|
if (line == "") continue;
|
||
|
|
if (line == "}") {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
int index = line.IndexOf(tokenAssign);
|
||
|
|
if (index == -1) {
|
||
|
|
int precedence = PrecedenceRelation.GREATER;
|
||
|
|
index = line.IndexOf(">");
|
||
|
|
if (index == -1) {
|
||
|
|
precedence = PrecedenceRelation.LESS;
|
||
|
|
index = line.IndexOf("<");
|
||
|
|
if (index == -1) {
|
||
|
|
precedence = PrecedenceRelation.EQUAL;
|
||
|
|
index = line.IndexOf("=");
|
||
|
|
if (index == -1) throw new Exception("invalid token line");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
String[] leftTerminalNames = whitespace.Split(line.Substring(0, index));
|
||
|
|
String[] rightTerminalNames = whitespace.Split(line.Substring(index + 1));
|
||
|
|
Symbol[] rightTerminalSymbols = new Symbol[rightTerminalNames.Length];
|
||
|
|
for (int i = 0; i < rightTerminalSymbols.Length; ++i) {
|
||
|
|
if (rightTerminalNames[i] == "") continue;
|
||
|
|
Symbol rightSymbol = grammarStringTable[rightTerminalNames[i]] as Terminal;
|
||
|
|
if (rightSymbol == null || !(rightSymbol is Terminal))
|
||
|
|
throw new Exception("Symbol is either not defined for non a terminal:" + rightTerminalNames[i]);
|
||
|
|
rightTerminalSymbols[i] = rightSymbol;
|
||
|
|
}
|
||
|
|
foreach (String leftTerminalName in leftTerminalNames) {
|
||
|
|
if (leftTerminalName == "") continue;
|
||
|
|
Symbol leftSymbol = grammarStringTable[leftTerminalName] as Symbol;
|
||
|
|
if (leftSymbol == null || !(leftSymbol is Terminal))
|
||
|
|
throw new Exception("Symbol is either not defined for non a terminal:" + leftTerminalName);
|
||
|
|
foreach (Symbol rightSymbol in rightTerminalSymbols) {
|
||
|
|
if (rightSymbol == null) continue;
|
||
|
|
precedenceTable[new HashSet(new int[] { leftSymbol.id, rightSymbol.id })] = new PrecedenceRelation(precedence, leftSymbol.id, rightSymbol.id);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
String regex = line.Substring(index + tokenAssign.Length).Trim();
|
||
|
|
String action = ParseSection(sr);
|
||
|
|
Terminal token = new Terminal(line.Substring(0, index).Trim(), regex, action);
|
||
|
|
grammarStringTable[token.name] = token;
|
||
|
|
numTerminals++;
|
||
|
|
terminalList.Add(token);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
private const String startSymbol = "S";
|
||
|
|
private const String productionSym = "=>";
|
||
|
|
public void ParseGrammarSection(TextReader sr)
|
||
|
|
{
|
||
|
|
String line = sr.ReadLine();
|
||
|
|
if (line == null || line.Trim() != "{") throw new Exception("missing left brace");
|
||
|
|
bool foundStart = false;
|
||
|
|
while ((line = sr.ReadLine()) != null) {
|
||
|
|
line = line.Trim();
|
||
|
|
if (line == "") continue;
|
||
|
|
if (line == "}") {
|
||
|
|
if (!foundStart) {
|
||
|
|
throw new Exception("No start symbol S");
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
int index = line.IndexOf(productionSym);
|
||
|
|
if (index == -1) throw new Exception("bad grammar format");
|
||
|
|
String name = line.Substring(0, index).Trim();
|
||
|
|
if (!foundStart && name == startSymbol) {
|
||
|
|
Nonterminal augment = new Nonterminal(startSymbol + "'", 0);
|
||
|
|
grammarStringTable[augment.name] = augment;
|
||
|
|
System.Collections.ArrayList augProdList = new System.Collections.ArrayList();
|
||
|
|
productionStrings[augment.name] = augProdList;
|
||
|
|
augProdList.Add(new ProductionString(augment, startSymbol, ""));
|
||
|
|
foundStart = true;
|
||
|
|
}
|
||
|
|
String rhs = line.Substring(index + productionSym.Length).Trim();
|
||
|
|
String action = ParseSection(sr);
|
||
|
|
|
||
|
|
System.Collections.ArrayList prodList = productionStrings[name] as System.Collections.ArrayList;
|
||
|
|
if (prodList == null) {
|
||
|
|
productionStrings[name] = prodList = new System.Collections.ArrayList();
|
||
|
|
}
|
||
|
|
|
||
|
|
Nonterminal nonterm = grammarStringTable[name] as Nonterminal;
|
||
|
|
if (nonterm == null) {
|
||
|
|
grammarStringTable[name] = nonterm = new Nonterminal(name);
|
||
|
|
}
|
||
|
|
prodList.Add(new ProductionString(nonterm, rhs, action));
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
throw new Exception("missing right brace");
|
||
|
|
}
|
||
|
|
private static Regex whitespace = new Regex("\\s");
|
||
|
|
|
||
|
|
public static String ParseSection(TextReader sr)
|
||
|
|
{
|
||
|
|
StringBuilder section = new StringBuilder();
|
||
|
|
while (true) {
|
||
|
|
int peek = sr.Peek();
|
||
|
|
if (peek == -1) return null;
|
||
|
|
char cpeek = (char)peek;
|
||
|
|
if (whitespace.IsMatch(((char)peek).ToString())) {
|
||
|
|
sr.Read();
|
||
|
|
} else if (peek != '{') {
|
||
|
|
return null;
|
||
|
|
} else
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
sr.Read();
|
||
|
|
/*if(line == null || line.Trim() != "{") throw new Exception();*/
|
||
|
|
int numBrackets = 1;
|
||
|
|
int last = -1;
|
||
|
|
bool inString = false;
|
||
|
|
bool inQuotes = false;
|
||
|
|
int curr;
|
||
|
|
while ((curr = sr.Read()) != -1) {
|
||
|
|
switch (curr) {
|
||
|
|
case '{':
|
||
|
|
if (!inString && !inQuotes && last != '\\') numBrackets++;
|
||
|
|
break;
|
||
|
|
case '}':
|
||
|
|
if (!inString && !inQuotes && last != '\\') numBrackets--;
|
||
|
|
break;
|
||
|
|
case '"':
|
||
|
|
if (!inString && last != '\\') {
|
||
|
|
inQuotes = !inQuotes;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case '\'':
|
||
|
|
if (!inQuotes && last != '\\')
|
||
|
|
inString = !inString;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (numBrackets == 0) break;
|
||
|
|
section.Append((char)curr);
|
||
|
|
last = curr;
|
||
|
|
}
|
||
|
|
if (numBrackets > 0) throw new Exception("missing bracket");
|
||
|
|
return section.ToString();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
private class Symbol
|
||
|
|
{
|
||
|
|
public static int idCount = 3;
|
||
|
|
public int id;
|
||
|
|
public String name;
|
||
|
|
protected Symbol(String name)
|
||
|
|
{
|
||
|
|
id = idCount++;
|
||
|
|
this.name = name;
|
||
|
|
}
|
||
|
|
protected Symbol(String name, int id)
|
||
|
|
{
|
||
|
|
this.name = name;
|
||
|
|
this.id = id;
|
||
|
|
}
|
||
|
|
|
||
|
|
public override int GetHashCode()
|
||
|
|
{
|
||
|
|
return name.GetHashCode();
|
||
|
|
}
|
||
|
|
|
||
|
|
public override bool Equals(object obj)
|
||
|
|
{
|
||
|
|
if (!(obj is Symbol)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return name.Equals(((Symbol)obj).name);
|
||
|
|
}
|
||
|
|
|
||
|
|
public override string ToString()
|
||
|
|
{
|
||
|
|
return name + ":" + id;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private class Nonterminal : Symbol
|
||
|
|
{
|
||
|
|
public int[][] rhss;
|
||
|
|
public String[][] bindings;
|
||
|
|
public ProductionAction[] actions;
|
||
|
|
public Nonterminal(String name) : base(name) { }
|
||
|
|
public Nonterminal(String name, int id) : base(name, id) { }
|
||
|
|
}
|
||
|
|
|
||
|
|
private class Terminal : Symbol
|
||
|
|
{
|
||
|
|
public String regex;
|
||
|
|
public String action;
|
||
|
|
public Terminal(String name, String regex, String action) : base(name) { this.regex = regex; this.action = action; }
|
||
|
|
public Terminal(String name, int id) : base(name, id) { }
|
||
|
|
}
|
||
|
|
|
||
|
|
private class ProductionAction
|
||
|
|
{
|
||
|
|
public String action;
|
||
|
|
public int nonterm;
|
||
|
|
public int production;
|
||
|
|
public Generator gen;
|
||
|
|
public ProductionAction(Generator gen, int nonterm, int production, String action)
|
||
|
|
{
|
||
|
|
this.gen = gen;
|
||
|
|
this.nonterm = nonterm;
|
||
|
|
this.production = production;
|
||
|
|
this.action = action;
|
||
|
|
}
|
||
|
|
|
||
|
|
public override String ToString()
|
||
|
|
{
|
||
|
|
StringBuilder sb = new StringBuilder(gen.grammarTable[nonterm].name + " => ");
|
||
|
|
foreach (int sym in (gen.grammarTable[nonterm] as Nonterminal).rhss[production]) {
|
||
|
|
sb.Append(gen.grammarTable[sym].name + " ");
|
||
|
|
}
|
||
|
|
return sb.ToString();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
private class ProductionString
|
||
|
|
{
|
||
|
|
Nonterminal nonterm;
|
||
|
|
public String rhs;
|
||
|
|
public String action;
|
||
|
|
public ProductionString(Nonterminal nonterm, String rhs, String action)
|
||
|
|
{
|
||
|
|
this.nonterm = nonterm;
|
||
|
|
this.rhs = rhs;
|
||
|
|
this.action = action;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|