public int Count()
{
if (Expression == "")
{
var ex = new Exception();
ex.Data.Add("Type", "reference to empty cell");
throw ex;
}
if (IsReevaluated)
{
return((int)Value);
}
try
{
var inputStream = new AntlrInputStream(Expression);
var lexer = new GrammarLexer(inputStream);
var commonTokenStream = new CommonTokenStream(lexer);
var parser = new GrammarParser(commonTokenStream);
parser.RemoveErrorListeners();
parser.AddErrorListener(new ParsingErrorListener());
var expr = parser.rule();
int val = (new ParsingVisitor(this)).Visit(expr);
IsReevaluated = true;
return(val);
}
catch
{
throw;
}
}
public static IEnumerable <string> GenerateFile(string file)
{
var name = Path.GetFileNameWithoutExtension(file);
var directory = Path.GetDirectoryName(file);
File representation;
using (var stream = System.IO.File.OpenRead(file))
{
var lexer = new GrammarLexer(new AntlrInputStream(stream));
var tokenStream = new CommonTokenStream(lexer);
var context = new GrammarParser(tokenStream).program();
var dsl = new Dsl(name);
dsl.Visit(context);
representation = dsl.File;
}
var outputs = representation.GenerateSource();
if (outputs.HasMessageContent)
{
if (outputs.HasMarkers)
{
var path = Path.Combine(directory, $"{representation.Name}MarkerInterfaces.cs");
System.IO.File.WriteAllText(path, outputs.Markers);
yield return(path);
}
if (outputs.HasMessages)
{
var path = Path.Combine(directory, $"{representation.Name}Messages.cs");
System.IO.File.WriteAllText(path, outputs.Messages);
yield return(path);
}
if (outputs.HasEnumerations)
{
var path = Path.Combine(directory, $"{representation.Name}Enums.cs");
System.IO.File.WriteAllText(path, outputs.Enumerations);
yield return(path);
}
}
if (outputs.HasStateDefinitions)
{
var path = Path.Combine(directory, $"{representation.Name}StateSubscriptions.cs");
System.IO.File.WriteAllText(path, outputs.StateDefinitions);
yield return(path);
}
if (outputs.HasEntities)
{
var path = Path.Combine(directory, $"{representation.Name}Entities.cs");
System.IO.File.WriteAllText(path, outputs.Entities);
yield return(path);
}
}
static void Main(string[] args)
{
//Adding translating tools for bools
var charStream = CharStreams.fromPath("firstProgram.txt");
var lexer = new GrammarLexer(charStream);
var tokenStream = new CommonTokenStream(lexer);
var parser = new GrammarParser(tokenStream)
{
BuildParseTree = true
};
var tree = parser.program();
var listener = new ScopeListener();
var ParseTreeWalker = new ParseTreeWalker();
ParseTreeWalker.Walk(listener, tree);
MainScopeClass.Scopes = listener.Scopes;
var visitor = new PrintVisitor();
visitor.VisitProgram(tree);
Console.WriteLine("Basic visitor done!");
var typeVisitor = new TypeCheckerVisitor();
typeVisitor.VisitProgram(tree);
Console.WriteLine("Typechecker visitor done!");
Console.WriteLine("Checking scopes:");
foreach (var Scope in listener.Scopes)
{
Console.WriteLine("Scope start:");
foreach (var element in Scope.SymbolTable)
{
Console.WriteLine(element);
}
}
Console.ReadLine();
}
public FileParseResult ParseProtoFile(string content)
{
var lexer = new GrammarLexer(new AntlrInputStream(content));
lexer.RemoveErrorListeners();
var tokens = new CommonTokenStream(lexer);
var parser = new GrammarParser(tokens);
var tree = parser.instructions();
var result = _mainVisitor.Visit(tree);
return((FileParseResult)result);
}
private GrammarParseResult Parse(string text)
{
AntlrInputStream inputStream = new AntlrInputStream(text);
GrammarLexer grammarLexer = new GrammarLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(grammarLexer);
GrammarParser grammarParser = new GrammarParser(commonTokenStream);
GrammarParser.StatementsContext context = grammarParser.statements();
StatementsVisitor visitor = new StatementsVisitor(new TestRuleSet());
GrammarParseResult result = visitor.Visit(context);
return(result);
}
private string Generate(string file)
{
var f = GetTestFile(file);
using (var stream = File.OpenRead(f))
{
var lexer = new GrammarLexer(new AntlrInputStream(stream));
var parser = new GrammarParser(new CommonTokenStream(lexer));
var visitor = new TarsGrammarVisitor(f);
AdhocWorkspace cw = new AdhocWorkspace();
var formattedNode = Formatter.Format(visitor.Visit(parser.tarsDefinition()), cw);
return(formattedNode.ToFullString());
}
}
public void Generate(string[] files, string dest)
{
foreach (var file in files)
{
using (var stream = File.OpenRead(file))
{
var lexer = new GrammarLexer(new AntlrInputStream(stream));
var parser = new GrammarParser(new CommonTokenStream(lexer));
var visitor = new TarsGrammarVisitor(file);
var syntax = Formatter.Format(visitor.Visit(parser.tarsDefinition()), workspace);
File.WriteAllText(Path.Combine(dest, Path.GetFileNameWithoutExtension(file) + ".cs"), syntax.ToFullString());
}
}
}
public AST Run(string input, bool print)
{
GrammarLexer lexer = new GrammarLexer(input);
GrammarParser parser = new GrammarParser(lexer);
// Executes the parsing
ParseResult result = parser.Parse();
CheckErrors(result);
// Prints the produced syntax tree
if (print)
{
Print(result.Root, new bool[] { });
}
return(_astBuilder.GetAST(result.Root));
}
private void Highlighting(object sender, TextChangedEventArgs e)
{
try
{ //ANTLRReaderStream input = new ANTLRReaderStream(Code.Document)
string text = new TextRange(Code.Document.ContentStart, Code.Document.ContentEnd).Text;
//ANTLRInputStream reader = new ANTLRInputStream(text);
ANTLRStringStream input = new ANTLRStringStream(text);
GrammarLexer lexer = new GrammarLexer((Antlr4.Runtime.ICharStream)input);
ITokenStream tokens = new CommonTokenStream((Antlr.Runtime.ITokenSource)lexer);
GrammarParser parser = new GrammarParser((Antlr4.Runtime.ITokenStream)tokens);
parser.prog();
}
catch (Exception ex)
{ }
}
public Generator(string text)
{
AntlrInputStream inputStream = new AntlrInputStream(text);
var lexer = new GrammarLexer(inputStream);
var tokenStream = new CommonTokenStream(lexer);
var parser = new GrammarParser(tokenStream);
var context = parser.file();
if (context.header() != null)
{
header = context.header().CODE().GetText();
header = header.Substring(1, header.Length - 2);
}
else
{
header = "";
}
name = context.LexerName().GetText();
Console.WriteLine($"Generate grammar \"{name}\"");
var rules = context.line();
foreach (var rule in rules)
{
if (rule?.ret is LexerRule lexerRule)
{
lexers.Add(lexerRule?.Name, lexerRule);
}
else
{
this.rules.Add(rule?.ret?.Name, rule?.ret);
}
}
foreach (var rule in this.rules.Values)
{
foreach (var pr in rule.Productions.Data)
{
foreach (var name in pr.Productions)
{
if (lexers.ContainsKey(name.name) || this.rules.ContainsKey(name.name))
{
continue;
}
throw new Exception($"Unknown name {name}");
}
}
}
}
public static GrammarParseResult Evaluate(string text, IRuleSet ruleSet)
{
if (String.IsNullOrEmpty(text?.Trim()))
{
return(GrammarParseResult.Unsuccessful(text));
}
AntlrInputStream inputStream = new AntlrInputStream(text);
GrammarLexer grammarLexer = new GrammarLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(grammarLexer);
GrammarParser grammarParser = new GrammarParser(commonTokenStream);
GrammarParser.StatementsContext context = grammarParser.statements();
StatementsVisitor visitor = new StatementsVisitor(ruleSet);
GrammarParseResult result = visitor.Visit(context);
return(result);
}
public void TestGrammarError(String path, ErrorCode expectedError)
{
StreamReader pom = new System.IO.StreamReader(path);
ErrorHandler handler = new ErrorHandler();
AntlrInputStream inputStream = new AntlrInputStream(pom);
GrammarLexer lexer = new GrammarLexer(inputStream);
lexer.RemoveErrorListeners();
lexer.AddErrorListener(new GrammarErrorListener(handler));
CommonTokenStream c = new CommonTokenStream(lexer);
GrammarParser helloParser = new GrammarParser(c);
helloParser.RemoveErrorListeners();
helloParser.AddErrorListener(new GrammarErrorListener(handler));
try
{
IParseTree tree = helloParser.start();
pom.Close();
if (handler.errorsOccured())
{
List <Error> grammarErrors = handler.GrammarErrors;
Assert.AreEqual(1, grammarErrors.Count, "More errors occured than expected");
Assert.AreEqual(ErrorCode.grammarError, grammarErrors[0].ErrorCode, "Invalid error type.");
}
else
{
Assert.Fail("No grammar error occured");
}
}
catch (ArgumentException e)
{
Console.WriteLine(e.Message);
}
}
void CalculateCellExpression(ElectronicTableCell cell)
{
try
{
var inputStream = new AntlrInputStream(cell.Expression);
var lexer = new GrammarLexer(inputStream);
var commonTokenStream = new CommonTokenStream(lexer);
var parser = new GrammarParser(commonTokenStream);
parser.RemoveErrorListeners();
parser.AddErrorListener(new ParsingErrorListener());
var expr = parser.rule();
cell.Value = (new ParsingVisitor(cell)).Visit(expr);
}
catch
{
throw;
}
cell.IsReevaluated = true;
foreach (var dep in cell.Depended)
{
CalculateCellExpression(dep);
}
}
// Public methods
public FeatureSelection Execute(CustomRule targetCustomRule)
{
// Get the expression
string expr = targetCustomRule.Expression; // OBS: an example for syntax: ">root.TotalScore=SumOf(>root.>descendants.ScoreValue)";
if (expr == null || expr == "")
{
return(null);
}
// Parse the expression
AntlrInputStream inputToParse = new AntlrInputStream(expr);
GrammarLexer lexer = new GrammarLexer(inputToParse);
CommonTokenStream tokens = new CommonTokenStream(lexer);
GrammarParser grammarParser = new GrammarParser(tokens);
IParseTree tree = grammarParser.prog();
Visitor visitor = new Visitor(configInstance);
// Execute it and return the parent FeatureSelection of the modified AttributeValue (left side of the expression)
var result = visitor.Visit(tree);
return(result as FeatureSelection);
}
public void Run(Options options)
{
GlobalScope globalScope = new GlobalScope();
Loader ld = new Loader(globalScope, options);
ld.Load(options.References);
Types.RegisterType("Boolean", (IType)globalScope.GetSymbol("System.Boolean"));
Types.RegisterType("Char", (IType)globalScope.GetSymbol("System.Char"));
Types.RegisterType("SByte", (IType)globalScope.GetSymbol("System.SByte"));
Types.RegisterType("Byte", (IType)globalScope.GetSymbol("System.Byte"));
Types.RegisterType("Int16", (IType)globalScope.GetSymbol("System.Int16"));
Types.RegisterType("UInt16", (IType)globalScope.GetSymbol("System.UInt16"));
Types.RegisterType("Int32", (IType)globalScope.GetSymbol("System.Int32"));
Types.RegisterType("UInt32", (IType)globalScope.GetSymbol("System.UInt32"));
Types.RegisterType("Int64", (IType)globalScope.GetSymbol("System.Int64"));
Types.RegisterType("UInt64", (IType)globalScope.GetSymbol("System.UInt64"));
Types.RegisterType("IntPtr", (IType)globalScope.GetSymbol("System.IntPtr"));
Types.RegisterType("UIntPtr", (IType)globalScope.GetSymbol("System.UIntPtr"));
Types.RegisterType("Single", (IType)globalScope.GetSymbol("System.Single"));
Types.RegisterType("Double", (IType)globalScope.GetSymbol("System.Double"));
Types.RegisterType("String", (IType)globalScope.GetSymbol("System.String"));
Types.RegisterType("Object", (IType)globalScope.GetSymbol("System.Object"));
Types.RegisterType("ValueType", (IType)globalScope.GetSymbol("System.ValueType"));
Types.RegisterType("Enum", (IType)globalScope.GetSymbol("System.Enum"));
Types.RegisterType("Void", (IType)globalScope.GetSymbol("System.Void"));
Types.RegisterType("Array", (IType)globalScope.GetSymbol("System.Array"));
Types.RegisterType("Exception", (IType)globalScope.GetSymbol("System.Exception"));
Types.RegisterType("Type", (IType)globalScope.GetSymbol("System.Type"));
Types.RegisterType("MulticastDelegate", (IType)globalScope.GetSymbol("System.MulticastDelegate"));
Types.RegisterType("IAsyncResult", (IType)globalScope.GetSymbol("System.IAsyncResult"));
Types.RegisterType("AsyncCallback", (IType)globalScope.GetSymbol("System.AsyncCallback"));
TypesHelper th = new TypesHelper();
th.Prepare();
Types.ResultTable = th.ResultTable;
Types.PromotionTable = th.PromotionTable;
int files_number = options.FilesNumber;
if (files_number == 0)
{
Report.Error.NoFilesToCompile();
}
List <FileNamespace> file_namespace = new List <FileNamespace>();
List <CompilationUnit> compilation_units = new List <CompilationUnit>();
foreach (string source in options.Files)
{
try
{
FileStream file = new FileStream(source, FileMode.Open, FileAccess.Read);
ANTLRInputStream input = new ANTLRInputStream(file);
GrammarLexer lexer = new GrammarLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
GrammarParser parser = new GrammarParser(tokens);
compilation_units.Add(parser.program());
file_namespace.Add(new FileNamespace(globalScope));
}
catch (FileNotFoundException)
{
Report.Error.SourceFileNotFound(source);
}
catch (DirectoryNotFoundException)
{
Report.Error.SourceFileNotFound(source);
}
catch (IOException)
{
Report.Error.IOError(source);
}
}
CodeGen codegen = new CodeGen(options);
for (int i = 0; i < files_number; ++i)
{
compilation_units[i].DefineSymbols(new Context(file_namespace[i]));
}
for (int i = 0; i < files_number; ++i)
{
compilation_units[i].ResolveSymbols(new Context(file_namespace[i]));
}
codegen.BuildAssembly(compilation_units);
}
public void TestOutputFromFile(String path, String output)
{
StreamReader pom = new System.IO.StreamReader(path);
ErrorHandler handler = new ErrorHandler();
AntlrInputStream inputStream = new AntlrInputStream(pom);
GrammarLexer lexer = new GrammarLexer(inputStream);
lexer.RemoveErrorListeners();
lexer.AddErrorListener(new GrammarErrorListener(handler));
CommonTokenStream c = new CommonTokenStream(lexer);
GrammarParser helloParser = new GrammarParser(c);
helloParser.RemoveErrorListeners();
helloParser.AddErrorListener(new GrammarErrorListener(handler));
String path_file_ins = "insc1.txt";
try
{
IParseTree tree = helloParser.start();
pom.Close();
if (handler.errorsOccured())
{
Assert.Fail("Errors detected during lexical or syntactic analysis.");
}
Visitor visitor = new Visitor(handler);
visitor.PrepareLibraryFunctions();
visitor.DoInitialJmp();
int t = visitor.Visit(tree);
if (handler.errorsOccured())
{
Assert.Fail("Errors detected during semantic analysis.");
}
visitor.numberInstructions();
Program.WriteInstructions(visitor.GetInstructions(), path_file_ins);
}
catch (ArgumentException e)
{
Console.WriteLine(e.Message);
}
Process interpreter = new Process();
interpreter.StartInfo.FileName = "../../../refint_pl0_ext.exe";
interpreter.StartInfo.Arguments = path_file_ins + " -s -l";
interpreter.StartInfo.UseShellExecute = false;
interpreter.StartInfo.RedirectStandardOutput = true;
interpreter.Start();
StreamReader reader = new StreamReader(interpreter.StandardOutput.BaseStream);
if (!interpreter.WaitForExit(15000))
{
Assert.IsFalse(true, "Process might got stuck in infinite loop");
interpreter.Kill();
}
String output_from_interpret = reader.ReadToEnd();
Assert.AreEqual("START PL/0\r\n" + output + " END PL/0\r\n", output_from_interpret);
}
