public void TestSuite3()
{
var symbols = new Dictionary <string, int>
{
{ "Val1", 0x11 },
{ "Val2", 0x22 },
{ "Val3", 0xff },
{ "Loc1", 0xd020 },
{ "Loc2", 0xd021 },
{ "Loc3", 0xd022 }
};
var symbolFile = new SymbolFile(symbols);
var tree = GetContext("GrammarTests/test-3.txt");
var walker = new ParseTreeWalker();
var sbl = new SimBaseListener {
Symbols = symbolFile
};
walker.Walk(sbl, tree);
Assert.AreEqual(0x11, sbl.Proc.ReadMemoryValueWithoutCycle(0xd020));
Assert.AreEqual(0x22, sbl.Proc.ReadMemoryValueWithoutCycle(0xd021));
Assert.AreEqual(0xff, sbl.Proc.ReadMemoryValueWithoutCycle(0xd022));
}
protected void ResolveReferences(DeclarationFinder finder, QualifiedModuleName module, IParseTree tree, CancellationToken token)
{
token.ThrowIfCancellationRequested();
Logger.Debug("Resolving identifier references in '{0}'... (thread {1})", module.Name, Thread.CurrentThread.ManagedThreadId);
var resolver = new IdentifierReferenceResolver(module, finder);
var listener = new IdentifierReferenceListener(resolver);
if (!string.IsNullOrWhiteSpace(tree.GetText().Trim()))
{
var walker = new ParseTreeWalker();
try
{
var watch = Stopwatch.StartNew();
walker.Walk(listener, tree);
watch.Stop();
Logger.Debug("Binding resolution done for component '{0}' in {1}ms (thread {2})", module.Name,
watch.ElapsedMilliseconds, Thread.CurrentThread.ManagedThreadId);
//Evaluation of the overall status has to be defered to allow processing of undeclared variables before setting the ready state.
_parserStateManager.SetModuleState(module, ParserState.Ready, token, false);
}
catch (OperationCanceledException)
{
throw; //We do not want to set an error state if the exception was just caused by some cancellation.
}
catch (Exception exception)
{
Logger.Error(exception, "Exception thrown resolving '{0}' (thread {1}).", module.Name, Thread.CurrentThread.ManagedThreadId);
_parserStateManager.SetModuleState(module, ParserState.ResolverError, token);
}
}
}
public UpgradeResult Upgrade(UpgradeJob upgradeJob)
{
var outputFiles = new List <UpgradeResult.OutputFile>();
foreach (var file in upgradeJob.Files)
{
var replacements = new List <TextReplacement>();
ICharStream input = CharStreams.fromstring(file.Source);
YarnSpinnerV1Lexer lexer = new YarnSpinnerV1Lexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
YarnSpinnerV1Parser parser = new YarnSpinnerV1Parser(tokens);
var tree = parser.dialogue();
var walker = new ParseTreeWalker();
var formatFunctionListener = new FormatFunctionListener(file.Source, parser, (replacement) => replacements.Add(replacement));
walker.Walk(formatFunctionListener, tree);
outputFiles.Add(new UpgradeResult.OutputFile(file.FileName, replacements, file.Source));
}
return(new UpgradeResult
{
Files = outputFiles,
});
}
public override void EnterBinaryComparasionPredicate([NotNull] MySqlParser.BinaryComparasionPredicateContext context)
{//обернуть в два листенера
if (_depth == _tmpDepth)
{
if (!context.GetChild(2).GetChild(0).GetType().ToString().Contains("SubqueryExpessionAtom"))
{
if (context.Stop.Type != 968)
{
ExprColumnNames.Add(context.left.GetText());
WhereList.Add(new WhereStructure(context.GetText(), context.left.GetText()));
}
else
{
if (context.Stop.Type == 968)
{
JoinListener tmpJoinListener = new JoinListener();
ParseTreeWalker wlk = new ParseTreeWalker();
wlk.Walk(tmpJoinListener, context);
JoinStructures.Add(new JoinStructure(context.Start.Text, context.Stop.Text,
tmpJoinListener.Output));
}
}
}
}
}
internal static ScriptFile ParseFile(IAddonManager addonManager, string content)
{
if (addonManager == null)
{
addonManager = AddonManager.Create();
addonManager.AddAssembly(typeof(Math).Assembly, false);
addonManager.AddAssembly(typeof(Enumerable).Assembly, false);
}
addonManager.AddAssembly(AddonManager.StepBroCoreAssembly, true); // Add StepBro.Core always.
ITokenSource lexer = new Grammar.StepBroLexer(new AntlrInputStream(content));
ITokenStream tokens = new CommonTokenStream(lexer);
var parser = new SBP(tokens);
var file = new ScriptFile();
parser.RemoveErrorListeners();
parser.AddErrorListener(file.Errors as ErrorCollector);
parser.BuildParseTree = true;
var listener = new StepBroListener(file.Errors as ErrorCollector, addonManager, file);
var context = parser.compilationUnit();
var walker = new ParseTreeWalker();
walker.Walk(listener, context);
if (file.Errors.ErrorCount > 0)
{
throw new Exception("PARSING ERRORS: " + file.Errors[0].ToString());
}
//file?.InitializeFileVariables();
return(file);
}
public void CollectInfo(CodeSource grammarSource, ANTLRv4Parser.GrammarSpecContext context)
{
GrammarSource = grammarSource;
var walker = new ParseTreeWalker();
walker.Walk(this, context);
}
internal static SBExpressionData ParsePrimary(string content, ScriptFile file = null)
{
ITokenSource lexer = new Grammar.StepBroLexer(new AntlrInputStream(content));
ITokenStream tokens = new CommonTokenStream(lexer);
var parser = new SBP(tokens);
ErrorCollector errors = (file != null) ? file.Errors as ErrorCollector : new ErrorCollector(null, false);
parser.AddErrorListener(errors);
parser.BuildParseTree = true;
StepBroListener listener = new StepBroListener(errors, null, file ?? new ScriptFile());
listener.PrepareForExpressionParsing("StepBroFileBuilder.ParsePrimary");
var context = parser.primary();
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(listener, context);
if (errors.ErrorCount > 0)
{
throw new Exception("PARSING ERRORS");
}
return(listener.GetExpressionResult());
}
public Expressions(Interval ruleInterval, ParserRuleContext context, string text) : base(ruleInterval, context, text)
{
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(_listener, context);
Rules = _listener.Rules;
}
internal static Tuple <Stack <SBExpressionData>, IErrorCollector> ParseSimpleArguments(string expression)
{
var addons = AddonManager.Create();
addons.AddAssembly(AddonManager.StepBroCoreAssembly, true);
addons.AddAssembly(typeof(System.Math).Assembly, false);
addons.AddAssembly(typeof(System.Linq.Enumerable).Assembly, false);
//if (module != null) addons.AddAssembly(module, false);
var file = new ScriptFile();
file.AddNamespaceUsing(-1, addons.Lookup(null, "System"));
file.AddNamespaceUsing(-1, addons.Lookup(null, "System.Linq"));
//foreach (var u in usings)
//{
// file.AddNamespaceUsing(addons.Lookup(null, u.FullName));
//}
var builder = new FileBuilder(new AntlrInputStream(expression), addons, file);
builder.Listener.PrepareForExpressionParsing("StepBroFileBuilder.ParseExpression");
var context = builder.Parser.arguments();
var walker = new ParseTreeWalker();
walker.Walk(builder.Listener, context);
return(new Tuple <Stack <SBExpressionData>, IErrorCollector>(builder.Listener.GetArguments(), builder.Errors));
}
object Process(ExpectedValueEnum expectedValueType)
{
object val = null;
AntlrInputStream input = new AntlrInputStream(paramExprContent);
ParamExprGrammarLexer lexer = new ParamExprGrammarLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
ParamExprGrammarParser parser = new ParamExprGrammarParser(tokens);
parser.RemoveErrorListeners();
ParamExprLogger.resetStream();
parser.AddErrorListener(new ParamExprErrorListener());
IParseTree tree = parser.param_expr();
ParseTreeWalker walker = new ParseTreeWalker();
ParamExprListener eval = new ParamExprListener(tokens);
eval.RevitElement = _element;
eval.RevitParameterName = _paramName;
try
{
walker.Walk(eval, tree);
if (eval.HasValue)
{
val = eval.Value;
}
}
catch
{
}
return(val);
}
/// <summary>
/// Locates all declared symbols (identifiers) in the project.
/// </summary>
/// <remarks>
/// This method walks the entire parse tree for each module.
/// </remarks>
private void IdentifySymbols()
{
foreach (var componentParseResult in _parseResults.Where(r => r.Component != null))
{
try
{
var listener = new DeclarationSymbolsListener(componentParseResult);
var walker = new ParseTreeWalker();
walker.Walk(listener, componentParseResult.ParseTree);
if (!_declarations.Items.Any())
{
var projectIdentifier = componentParseResult.QualifiedName.Project.Name;
var memberName = componentParseResult.QualifiedName.QualifyMemberName(projectIdentifier);
var projectDeclaration = new Declaration(memberName, "VBE", projectIdentifier, false, false, Accessibility.Global, DeclarationType.Project, false);
_declarations.Add(projectDeclaration);
}
foreach (var declaration in listener.Declarations.Items)
{
_declarations.Add(declaration);
}
}
catch (COMException)
{
// something happened, couldn't access VBComponent for some reason
}
}
}
public static OrderedDictionary Shred(byte[] content, string template)
{
Stream inputStream = new MemoryStream(Encoding.ASCII.GetBytes(template));
AntlrInputStream input = new AntlrInputStream(inputStream);
BinShredLexer lexer = new BinShredLexer(input);
lexer.RemoveErrorListeners();
lexer.AddErrorListener(new BinShredErrorListener <int>());
CommonTokenStream tokens = new CommonTokenStream(lexer);
BinShredParser parser = new BinShredParser(tokens);
parser.RemoveErrorListeners();
parser.AddErrorListener(new BinShredErrorListener <IToken>());
BinShredParser.TemplateContext context = parser.template();
ParseTreeWalker walker = new ParseTreeWalker();
BinShredAnalyzer contentAnalyzer = new BinShredAnalyzer(content);
walker.Walk(contentAnalyzer, context);
contentAnalyzer.Run();
return(contentAnalyzer.Result);
}
internal static FileBuilder ParseProcedure(
IAddonManager addonManager,
string[] usings,
Type usingType,
params string[] content)
{
if (addonManager == null)
{
addonManager = AddonManager.Create();
addonManager.AddAssembly(typeof(Math).Assembly, false);
addonManager.AddAssembly(typeof(Enumerable).Assembly, false);
}
addonManager.AddAssembly(AddonManager.StepBroCoreAssembly, true); // Add StepBro.Core always.
if (usingType != null)
{
addonManager.AddAssembly(usingType.Assembly, false);
}
var contentBuilder = new StringBuilder();
foreach (var s in content)
{
contentBuilder.AppendLine(s);
}
var file = new ScriptFile();
file.AddNamespaceUsing(-1, addonManager.Lookup(null, "System"));
file.AddNamespaceUsing(-1, addonManager.Lookup(null, "System.Linq"));
file.AddNamespaceUsing(-1, addonManager.Lookup(null, typeof(StepBro.Core.DataReport).Namespace));
if (usings != null)
{
foreach (var u in usings)
{
file.AddNamespaceUsing(-1, addonManager.Lookup(null, u));
}
}
if (usingType != null)
{
file.AddNamespaceUsing(-1, addonManager.Lookup(null, usingType.Namespace));
}
var builder = new FileBuilder(new AntlrInputStream(contentBuilder.ToString()), addonManager, file);
builder.Listener.PrepareForExpressionParsing("StepBroFileBuilder.ParseExpression");
var context = builder.Parser.procedureDeclaration();
var walker = new ParseTreeWalker();
walker.Walk(builder.Listener, context);
if (file.Errors.ErrorCount > 0)
{
throw new Exception("PARSING ERRORS");
}
return(builder);
}
static void Main(string[] args)
{
ParseOptions(args);
if (showHelp)
{
return;
}
var generators = new List <Tuple <ILanguageGenerator, IFunctionsGenerator> >();
if (language == "csharp")
{
generators.Add(new Tuple <ILanguageGenerator, IFunctionsGenerator>(
new CsharpLanguageGenerator(), new CsharpFunctionsGenerator()));
}
else if (language == "proto")
{
generators.Add(new Tuple <ILanguageGenerator, IFunctionsGenerator>(new ProtobufGenerator(), null));
}
else if (language == "ts")
{
generators.Add(new Tuple <ILanguageGenerator, IFunctionsGenerator>(new TypescriptGenerator(),
new TypescriptFunctionsGenerator()));
}
using (FileStream fs = new FileStream(expressPath, FileMode.Open))
{
var input = new AntlrInputStream(fs);
var lexer = new Express.ExpressLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new Express.ExpressParser(tokens);
parser.BuildParseTree = true;
var tree = parser.schemaDecl();
var walker = new ParseTreeWalker();
var testSb = new StringBuilder();
foreach (var generator in generators)
{
var listener = new Express.ExpressListener(generator.Item1);
walker.Walk(listener, tree);
Generate(listener, outDir, generator.Item1, generator.Item2);
}
if (!outputTokens)
{
return;
}
var tokenStr = new StringBuilder();
foreach (var t in tokens.GetTokens())
{
tokenStr.AppendLine(t.ToString());
}
Console.WriteLine(tokenStr);
}
}
public ComparisonOperator(Interval ruleInterval, ParserRuleContext context, string text) : base(ruleInterval, context, text)
{
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(_listener, context);
Rules = _listener.Rules;
this.DivideSym = "";
}
public AtomTableItem(Interval ruleInterval, ParserRuleContext context, string text) : base(ruleInterval, context, text)
{
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(_listener, context);
Rules = _listener.Rules;
_text = text;
}
//private bool _isRealised = false;
public FullColumnName(Interval ruleInterval, ParserRuleContext context, string text) : base(ruleInterval, context, text)
{
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(_listener, context);
Rules = _listener.Rules;
_text = text;
}
public SelectElements(Interval ruleInterval, MySqlParser.SelectElementsContext context, string text) : base(ruleInterval, context, text)
{
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(_listener, context);
Rules = _listener.Rules;
_text = text;
}
public AggregateWindowedFunction(Interval ruleInterval, ParserRuleContext context, string text) : base(ruleInterval, context, text)
{
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(_listener, context);
Rules = _listener.Rules;
_text = text;
}
public static IEnumerable <TContext> FindChildren <TContext>(this ParserRuleContext context) where TContext : ParserRuleContext
{
var walker = new ParseTreeWalker();
var listener = new ChildNodeListener <TContext>();
walker.Walk(listener, context);
return(listener.Matches);
}
public ExtractFunctionCall(Interval ruleInterval, ParserRuleContext context, string text) : base(ruleInterval, context, text)
{
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(_listener, context);
Rules = _listener.Rules;
_text = text;
}
/// <summary>
/// Create a Model given a STEP file.
/// </summary>
/// <param name="STEPfilePath">The path to the STEP file.</param>
/// <param name="errors">A list of errors generated during creation of the Document.</param>
/// <returns>A Model.</returns>
/// <exception cref="FileNotFoundException">The specified file path does not exist.</exception>
public Model(string STEPfilePath, IDictionary <Guid, BaseIfc> storage, out IList <STEPError> errors)
{
if (!File.Exists(STEPfilePath))
{
throw new FileNotFoundException($"The specified IFC STEP file does not exist: {STEPfilePath}.");
}
this.storage = storage;
using (FileStream fs = new FileStream(STEPfilePath, FileMode.Open))
{
var sw = new Stopwatch();
sw.Start();
var input = new AntlrInputStream(fs);
var lexer = new STEP.STEPLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new STEP.STEPParser(tokens);
parser.BuildParseTree = true;
var tree = parser.file();
var walker = new ParseTreeWalker();
var listener = new STEP.STEPListener();
walker.Walk(listener, tree);
sw.Stop();
Console.WriteLine($"{sw.Elapsed} for parsing STEP file {STEPfilePath}.");
sw.Reset();
sw.Start();
var err = new List <STEPError>();
foreach (var data in listener.InstanceData)
{
if (listener.InstanceData[data.Key].ConstructedInstance != null)
{
// Instance may have been previously constructed as the result
// of another construction.
continue;
}
ConstructAndStoreInstance(data.Value, listener.InstanceData, data.Key, err, 0);
}
// Transfer the constructed instances to storage.
foreach (var data in listener.InstanceData)
{
var inst = (BaseIfc)data.Value.ConstructedInstance;
storage.Add(inst.Id, inst);
}
sw.Stop();
Console.WriteLine($"{sw.Elapsed} for creating instances.");
errors = err;
}
}
public static void ParseProgramOrClass(TextSourceInfo textSourceInfo, ISearchableReadOnlyList <CodeElementsLine> codeElementsLines, TypeCobolOptions compilerOptions, SymbolTable customSymbols, out Program newProgram, out Class newClass, out IList <ParserDiagnostic> diagnostics)
{
// Create an Antlr compatible token source on top a the token iterator
CodeElementsLinesTokenSource tokenSource = new CodeElementsLinesTokenSource(
textSourceInfo.Name,
codeElementsLines);
// Init parser
ITokenStream tokenStream = new TokensLinesTokenStream(tokenSource, Token.CHANNEL_SourceTokens);
ProgramClassParser cobolParser = new ProgramClassParser(tokenStream);
// -> activate full ambiguities detection
//parser.Interpreter.PredictionMode = PredictionMode.LlExactAmbigDetection;
// Register all parse errors in a list in memory
ParserDiagnosticErrorListener errorListener = new ParserDiagnosticErrorListener();
cobolParser.RemoveErrorListeners();
cobolParser.AddErrorListener(errorListener);
// Try to parse a Cobol program or class
ProgramClassParser.CobolCompilationUnitContext programClassParseTree = cobolParser.cobolCompilationUnit();
// Visit the parse tree to build a first class object representing a Cobol program or class
ParseTreeWalker walker = new ParseTreeWalker();
CobolNodeBuilder programClassBuilder = new CobolNodeBuilder();
programClassBuilder.CustomSymbols = customSymbols;
programClassBuilder.Dispatcher = new NodeDispatcher();
programClassBuilder.Dispatcher.CreateListeners();
ParserDiagnostic programClassBuilderError = null;
try { walker.Walk(programClassBuilder, programClassParseTree); }
catch (Exception ex)
{
var code = Diagnostics.MessageCode.ImplementationError;
programClassBuilderError = new ParserDiagnostic(ex.ToString(), null, null, code);
}
//Complete some information on Node and run checker that need a full AST
if (programClassBuilder.Program != null)
{
programClassBuilder.Program.SyntaxTree.Root.AcceptASTVisitor(new Cobol85CompleteASTChecker());
}
// Register compiler results
newProgram = programClassBuilder.Program;
newClass = programClassBuilder.Class;
diagnostics = programClassBuilder.GetDiagnostics(programClassParseTree);
if (programClassBuilderError != null)
{
if (diagnostics == null)
{
diagnostics = new List <ParserDiagnostic>();
}
diagnostics.Add(programClassBuilderError);
}
}
static void Main(string[] args)
{
string filename = "code.txt";
using (StreamReader file = new StreamReader(filename))
{
AntlrInputStream inputStream = new AntlrInputStream(file.ReadToEnd());
ClojureObrLexer lexer = new ClojureObrLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(lexer);
ClojureObrParser parser = new ClojureObrParser(commonTokenStream);
ObrErrorListener errorListener = new ObrErrorListener();
parser.AddErrorListener(errorListener);
ClojureObrParser.FileContext tree = parser.file();
if (parser.NumberOfSyntaxErrors != 0)
{
Console.WriteLine($"Syntax is bad :( ");
foreach (var error in errorListener.Errors)
{
Console.WriteLine(error);
}
Console.ReadKey();
return;
}
if (R)
{
ParseTreeWalker walker = new ParseTreeWalker();
ObrListener semantic = new ObrListener();
try
{
walker.Walk(semantic, tree);
}
catch (Exception e)
{
Console.WriteLine($" :( Error: {e.ToString()}");
Console.ReadKey();
return;
}
var typedRoot = semantic.typedRoot;
var options = new JsonSerializerSettings
{
Formatting = Formatting.Indented,
NullValueHandling = NullValueHandling.Ignore
};
string typedTree = JsonConvert.SerializeObject(typedRoot, options);
File.WriteAllText("typedTree.json", typedTree);
GraphProcessor.BuildGraph(semantic.root, "tree");
}
}
Console.WriteLine("Syntax not so bad :| ");
Console.ReadKey();
}
public IExpression parse_expression()
{
IParseTree tree = expression();
EPromptoBuilder builder = new EPromptoBuilder(this);
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(builder, tree);
return(builder.GetNodeValue <IExpression>(tree));
}
public IStatement parse_statement()
{
IParseTree tree = statement();
EPromptoBuilder builder = new EPromptoBuilder(this);
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(builder, tree);
return(builder.GetNodeValue <IStatement>(tree));
}
public NativeCall parse_native_statement()
{
IParseTree tree = native_statement();
EPromptoBuilder builder = new EPromptoBuilder(this);
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(builder, tree);
return(builder.GetNodeValue <NativeCall>(tree));
}
public AssignInstanceStatement parse_assign_instance_statement()
{
IParseTree tree = assign_instance_statement();
EPromptoBuilder builder = new EPromptoBuilder(this);
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(builder, tree);
return(builder.GetNodeValue <AssignInstanceStatement>(tree));
}
public ConcreteMethodDeclaration parse_concrete_method_declaration()
{
IParseTree tree = concrete_method_declaration();
EPromptoBuilder builder = new EPromptoBuilder(this);
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(builder, tree);
return(builder.GetNodeValue <ConcreteMethodDeclaration>(tree));
}
public UnresolvedCall parse_method_call()
{
IParseTree tree = method_call_statement();
EPromptoBuilder builder = new EPromptoBuilder(this);
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(builder, tree);
return(builder.GetNodeValue <UnresolvedCall>(tree));
}
