public static Pagination Parse(string raw)
{
var parser = new LLParser(":", raw);
var result = new Pagination();
result.TotalCount = int.Parse(parser.Next());
result.RangeIn = int.Parse(parser.Next());
result.RangeOut = int.Parse(parser.Next());
return(result);
}
public TablesForm(Syntactic syntactic, Semantic semantic)
{
_semantic = semantic;
_syntactic = syntactic;
_llanalyser = new LLParser(_semantic, _syntactic);
_lrParser = new LRParser(_semantic, _syntactic);
_slrParser = new SLRParser(_semantic, _syntactic);
_lalrParser = new LALRParser(_semantic, _syntactic);
InitializeComponent();
}
private void rbLL_CheckedChanged(object sender, EventArgs e)
{
if (rbLL.Checked)
{
//Gerar tabela LL(1)
_llanalyser = new LLParser(_semantic, _syntactic);
_llanalyser.GenerateTable(this.gridTables);
}
if (_llanalyser.Generated)
{
//TODO: remover preenchimento de dentro método global, criar um método apenas para preenchimento
}
}
public void Next_CallNumbers(string input, int expectedCallNumber)
{
var parser = new LLParser(".", input);
var calls = 0;
while (parser.Next() != null)
{
calls++;
}
Assert.AreEqual(expectedCallNumber, calls);
}
public static ExecutionResult Execute(TestCaseSourceFile[] files)
{
foreach (var scriptFile in files)
{
var tokens = Lexer.Tokenize(scriptFile);
var syntaxTree = LLParser.Parse(tokens);
Evaluator.Eval(syntaxTree);
}
return(new ExecutionResult());
}
static int Main(string[] args)
{
if (args.Length == 0)
{
Console.WriteLine("Please enter a minipl program path as argument");
return(1);
}
var fileAsString = File.ReadAllText(args[0]);
List <Token> tokens = null;
try {
tokens = new Scanner(fileAsString).Tokenize();
} catch {
Console.WriteLine("Scanner exited with status code 1");
return(1);
}
// foreach (var token in tokens)
// {
// Console.Write(token + " ");
// }
var program = new LLParser(tokens).Parse();
if (program == null)
{
Console.WriteLine("Parser exited with status code 1");
return(1);
}
var environment = new Analyzer(program).Analyze();
if (environment == null)
{
Console.WriteLine("Analyzer with status code 1");
return(1);
}
// Console.WriteLine();
try {
new Interpreter(program, environment).Interpret();
} catch (Exception e) {
Console.WriteLine("Interpreter exited with status code 1" + e);
return(1);
}
return(0);
}
public void Next_ValidResult(string input, params string[] expected)
{
var parser = new LLParser(".", input);
var result = new List <string>();
Span <char> next = null;
while ((next = parser.Next()) != null)
{
result.Add(next.ToString());
}
Assert.AreEqual(expected.Length, result.Count);
result.ToArray().Should().Equal(expected);
}
static void Main(string[] args)
{
var file = @"..\..\..\ebnf.ebnf";
var doc = EbnfDocument.ReadFrom(file);
doc.Prepare();
var cfg = doc.ToCfg();
cfg.PrepareLL1();
var lexer = doc.ToLexer(cfg);
string filestring;
using (var sr = File.OpenText(file))
filestring = sr.ReadToEnd();
LLParser parser = cfg.ToLL1Parser(lexer);
parser.Restart(ParseContext.Create(filestring));
Console.WriteLine(parser.ParseSubtree());
var sw = new Stopwatch();
sw.Restart();
for (var i = 0; i < 100; ++i)
{
parser.Restart(ParseContext.Create(filestring));
while (parser.Read())
{
;
}
}
sw.Stop();
Console.WriteLine("Runtime Parser: {0}", sw.Elapsed / 100);
parser = new EbnfParser();
sw.Restart();
for (var i = 0; i < 100; ++i)
{
parser.Restart(ParseContext.Create(filestring));
while (parser.Read())
{
;
}
}
sw.Stop();
Console.WriteLine("Generated Parser: {0}", sw.Elapsed / 100);
}
public static BlockGroup Parse(string raw)
{
var result = new BlockGroup();
var parser = new LLParser(".", raw);
while (true)
{
var idRaw = parser.Next();
if (idRaw == null)
{
break;
}
if (!int.TryParse(idRaw, out var id))
{
throw new Exception($"Can't parse group id in: {raw}");
}
result.Add(id);
}
return(result);
}
public IEnumerable <FXmlElement> Deserialize(Stream stream)
{
errors = null;
List <string> lines = new List <string>();
using (StreamReader reader = new StreamReader(stream))
{
while (!reader.EndOfStream)
{
lines.Add(reader.ReadLine());
}
}
Preprocessor preprocessor = new Preprocessor();
string code = preprocessor.FixString(lines);
TokenParser tokenParser = new TokenParser();
bool result = tokenParser.Parse(code);
if (!result)
{
errors = new List <Error>();
errors.Add(tokenParser.Error);
return(null);
}
LLParser llParser = new LLParser();
result = llParser.Parse(tokenParser.Tokens);
if (!result)
{
errors = new List <Error>();
errors.AddRange(llParser.Errors);
return(null);
}
return(llParser.FXmlElements);
}
public void SetUp()
{
parser = new LLParser(separator, string.Join(separator, Enumerable.Range(0, N).Select(x => "x")));
}
