public static void SetupNewProgram(ref TreeNode <string> root, ref Grammar grammar, List <TypeSpec> typeSpecs, Random random, int input_arg_limit, ref List <Parameter> parameters)
{
parameters = new List <Parameter>();
if (input_arg_limit == 2)
{
var inputParameter_1 = new Parameter()
{
index = 1,
parameterType = ParameterType.Input,
argType = ArgType.List,
obj = $"x1"
};
parameters.Add(inputParameter_1);
var inputParameter_2 = new Parameter()
{
index = 2,
parameterType = ParameterType.Input,
argType = ArgType.Int,
obj = $"x2"
};
parameters.Add(inputParameter_2);
}
else
{
for (int i = 1; i <= input_arg_limit; i++)
{
var inputParameter = new Parameter()
{
index = i,
parameterType = ParameterType.Input,
argType = random.EnumValue <ArgType>(),
obj = $"x{i}"
};
parameters.Add(inputParameter);
}
}
var outputParameter = new Parameter()
{
index = 0,
parameterType = ParameterType.Output,
argType = ArgType.List,
obj = $"y"
};
parameters.Add(outputParameter);
root = new TreeNode <string>();
grammar = GrammarBuilder.Build(Resources.path_grammarSpec, typeSpecs, random, parameters);
}
private static Tokenizer <TokenType> CreateParserForProcess()
{
var builder = new GrammarBuilder <TokenType>()
{
new Grammar <TokenType>(TokenType.Space, " "),
new Grammar <TokenType>(TokenType.Equal, "="),
new Grammar <TokenType>(TokenType.Process, "PROCESS"),
new Grammar <TokenType>(TokenType.Produce, "PRODUCE"),
new Grammar <TokenType>(TokenType.Comma, ","),
new Grammar <TokenType>(TokenType.Using, "USING"),
new Grammar <TokenType>(TokenType.SemiColon, ";"),
};
return(builder.Build());
}
public void preposition_first()
{
var tokens = new List <string>()
{
"on", "x"
};
var grammarBuilder = new GrammarBuilder(tokens);
var results = grammarBuilder.Build();
Assert.AreEqual(4, results.Count);
Assert.IsTrue(results.Contains("on <noun>"));
Assert.IsTrue(results.Contains("on <held>"));
Assert.IsTrue(results.Contains("on <multi>"));
Assert.IsTrue(results.Contains("on <multiheld>"));
}
private static Tokenizer <TokenType> CreateParserForReduce(StringComparison stringComparison = StringComparison.Ordinal)
{
var builder = new GrammarBuilder <TokenType>(stringComparison)
{
new Grammar <TokenType>(TokenType.Space, " "),
new Grammar <TokenType>(TokenType.Equal, "="),
new Grammar <TokenType>(TokenType.Reduce, "REDUCE"),
new Grammar <TokenType>(TokenType.Produce, "PRODUCE"),
new Grammar <TokenType>(TokenType.On, "ON"),
new Grammar <TokenType>(TokenType.Comma, ","),
new Grammar <TokenType>(TokenType.Using, "USING"),
new Grammar <TokenType>(TokenType.SemiColon, ";"),
};
return(builder.Build());
}
public void object_only()
{
var tokens = new List <string>()
{
"x"
};
var grammarBuilder = new GrammarBuilder(tokens);
var results = grammarBuilder.Build();
Assert.AreEqual(4, results.Count);
Assert.IsTrue(results.Contains("<noun>"));
Assert.IsTrue(results.Contains("<held>"));
Assert.IsTrue(results.Contains("<multi>"));
Assert.IsTrue(results.Contains("<multiheld>"));
}
public void with_indirect_object()
{
var tokens = new List <string>()
{
"x", "with", "y"
};
var grammarBuilder = new GrammarBuilder(tokens);
var results = grammarBuilder.Build();
Assert.AreEqual(8, results.Count);
Assert.IsTrue(results.Contains("<noun> with <noun>"));
Assert.IsTrue(results.Contains("<held> with <noun>"));
Assert.IsTrue(results.Contains("<multi> with <noun>"));
Assert.IsTrue(results.Contains("<multiheld> with <noun>"));
Assert.IsTrue(results.Contains("<noun> with <held>"));
Assert.IsTrue(results.Contains("<held> with <held>"));
Assert.IsTrue(results.Contains("<multi> with <held>"));
Assert.IsTrue(results.Contains("<multiheld> with <held>"));
}
public void Generate()
{
grammarBuilder.Build();
if (!Directory.Exists(outputPath))
{
Directory.CreateDirectory(outputPath);
}
//GenerateNodeInterface();
GenerateVocabulary();
GenerateTerminalNodes();
GenerateNonTerminalsNode();
table = new LALRTable(grammarBuilder);
table.Build();
GenereteParserFile();
InsertInProjectFile();
}
static void Main(string[] args)
{
var grammar = new GrammarBuilder();
grammar.DefineTerminal("tk_package", false, (int)TokenDefine.Token, "package");
grammar.DefineTerminal("tk_public", (int)TokenDefine.Token, "public");
grammar.DefineTerminal("tk_final", (int)TokenDefine.Token, "final");
grammar.DefineTerminal("tk_class", (int)TokenDefine.Token, "class");
grammar.DefineTerminal("tk_void", (int)TokenDefine.Token, "void");
grammar.DefineTerminal("tk_static", (int)TokenDefine.Token, "static");
grammar.DefineTerminal("tk_semicolon", false, (int)TokenDefine.Semicolon);
grammar.DefineTerminal("tk_dot", false, (int)TokenDefine.Dot);
grammar.DefineTerminal("tk_open_brace", false, (int)TokenDefine.OpenBrace);
grammar.DefineTerminal("tk_close_brace", false, (int)TokenDefine.CloseBrace);
grammar.DefineTerminal("identifier", (int)TokenDefine.Token, "[a-zA-Z]+[a-zA-Z0-9]*");
grammar.DefineRoot("class_definition");
grammar.DefineRoot("package_sentences", "class_definition");
grammar.ParseNonTerminal("package_sentences", true, "package_sentence*");
grammar.ParseNonTerminal("package_sentence", true, "tk_package identifier(tk_dot identifier)* tk_semicolon");
grammar.DefineNonTerminal("class_modifiers", true, "tk_public", "tk_final");
grammar.DefineNonTerminal("class_definition", "class_modifiers", "tk_class", "identifier", "tk_open_brace", "functions", "tk_close_brace");
grammar.ParseNonTerminal("functions", true, "function_definition*");
grammar.DefineNonTerminal("function_definition", "tk_public", "tk_static", "tk_void", "identifier", "tk_open_brace", "tk_close_brace");
var parser = grammar.Build();
var parse = new MyParser();
var tokens = parse.ParseFile(@"G:\workspace\SimpleParser\test.java");
parser.Parse(tokens, new ASTVisitor());
}
private void BuildCC0()
{
var projectDir = DirRef.ProjectDir();
var cc0 = projectDir.Dir("..").Dir("LinguCC0");
var genDir = cc0.Dir("Gen");
Environment.CurrentDirectory = genDir;
var grammarSource = FileRef.From($"./Lingu.Grammar");
var outs = FileRef.From("./Lingu").Add(".Out");
var raw = Parser.Parse(grammarSource);
if (raw != null)
{
var builder = new GrammarBuilder(raw);
var grammar = builder.Build();
new Dumper(grammar).Dump(outs);
var csharp = new CSharpWriter(grammar, grammarSource, genDir);
csharp.Write();
}
}
public InputResult Parse(string input)
{
var result = new InputResult();
var tokenizer = new InputTokenizer();
var tokens = tokenizer.Tokenize(input);
Action removeVerbToken = () => tokens.RemoveAt(0);
if (tokens.Count == 0)
{
result.Action = () =>
{
Context.Parser.Print(L.DoNotUnderstand);
return true;
};
return result;
}
// there can be more than one match for verbs like "switch"
// which has one class that handles "switch on" and another
// class that handles "switch off"
var possibleVerbs = VerbList.GetVerbsByName(tokens[0]);
if (possibleVerbs.Count == 0)
{
result.Verb = new NullVerb();
result.Action = ErrorAction(L.VerbNotRecognized);
return result;
}
if (possibleVerbs.Count == 1)
{
result.Verb = possibleVerbs.First();
}
//else { NOT sure what to do about multiple possible verbs here}
// remove verb token
removeVerbToken();
var grammarTokens = new List<string>();
bool hasPreposition = false;
foreach (string token in tokens)
{
bool hasObject = result.Objects.Count > 0;
var objects = Objects.WithName(token);
if (!hasObject)
{
var rooms = Rooms.WithName(token);
foreach (var room in rooms)
{
objects.Add(room);
}
}
if (objects.Count == 0)
{
bool isDirection = possibleVerbs.Count == 1 &&
Compass.Directions.Contains(token) &&
result.Objects.Count == 0;
bool isPreposition = Prepositions.Contains(token);
if (isDirection)
{
possibleVerbs.Clear();
possibleVerbs.Add(VerbList.GetVerbByName(token));
}
else if (isPreposition)
{
hasPreposition = true;
grammarTokens.Add(token);
result.Preposition = token;
}
else if (token == K.ALL)
{
// result.Objects.AddRange(L.ObjectsInScope());
grammarTokens.Add(token);
result.IsAll = true;
}
else if (token == K.EXCEPT)
{
if (!result.IsAll && !result.Objects.Any())
{
result.Action = ErrorAction(L.CantSeeObject);
return result;
}
result.IsExcept = true;
}
else
{
if (result.IsPartial)
{
string partial = String.Format("I only understood you as far as wanting to {0} the {1}.", possibleVerbs[0].Name, result.Objects[0].Name);
result.Action = ErrorAction(partial);
return result;
}
result.Action = ErrorAction(L.CantSeeObject);
return result;
}
}
else
{
// need to implement "Which do you mean, the red cape or the black cape?" type behavior here
Object obj;
var ofInterest = objects.Where(x => x.InScope).ToList();
if (ofInterest.Count > 1)
{
obj = ofInterest.FirstOrDefault(x => x.InInventory);
}
else
{
obj = ofInterest.FirstOrDefault();
}
//-------------------------------------------------------------------------------------
bool isIndirectObject = hasPreposition && hasObject;
if (obj == null)
{
result.Action = ErrorAction(L.CantSeeObject);
return result;
}
if (isIndirectObject)
{
grammarTokens.Add(K.INDIRECT_OBJECT_TOKEN);
result.IndirectObject = obj;
}
else if (result.IsExcept)
{
//result.Objects.Remove(obj);
result.Exceptions.Add(obj);
}
else
{
if (!grammarTokens.Contains(K.OBJECT_TOKEN))
grammarTokens.Add(K.OBJECT_TOKEN);
if (!result.Objects.Contains(obj))
result.Objects.Add(obj);
result.IsPartial = true;
}
}
}
result.Pregrammar = string.Join(" ", grammarTokens.ToArray());
var grammarBuilder = new GrammarBuilder(grammarTokens);
var grammars = grammarBuilder.Build();
FindVerb(result, possibleVerbs, grammars);
if (result.Grammar == null)
{
var incomplete = new IncompleteInput();
incomplete.Handle(result);
}
if (result.IsAll)
{
if (result.ObjectsMustBeHeld)
{
result.Objects = result.Objects.Where(x => x.InInventory).ToList();
}
else
{
result.Objects = L.ObjectsInScope();
}
}
if (result.IsExcept)
{
result.Exceptions.ForEach(x => result.Objects.Remove(x));
}
return result;
}
