public static List<Error> Translate(Source source)
{
var err = new List<Error>();
var prg = new Program();
try
{
var input = new ANTLRStringStream(source.GetSourceData());
var lexer = new PascalLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new PascalParser(tokens);
prg = parser.program();
prg.SetSourceIdentifier(source.GetSourceIdentifier());
}
catch (RecognitionException e)
{
err.Add(new Error(FormatRecognitionException(e, source.GetSourceIdentifier())));
}
if (err.Count != 0)
return err;
var val = new Validator();
err = val.Validate(prg);
Root = prg;
return err;
}
public static void Main(string[] args)
{
if (args.Length == 1)
{
string fullpath;
if ( Path.IsPathRooted(args[0]) )
fullpath = args[0];
else
fullpath = Path.Combine(Environment.CurrentDirectory, args[0]);
Console.Out.WriteLine("Processing file: {0}", fullpath);
ICharStream input = new ANTLRFileStream(fullpath);
SimpleCLexer lex = new SimpleCLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lex);
SimpleCParser parser = new SimpleCParser(tokens);
SimpleCParser.program_return r = parser.program();
Console.Out.WriteLine("tree="+((ITree)r.Tree).ToStringTree());
if ( parser.NumberOfSyntaxErrors > 0 ) {
// don't tree parse if has errors
return;
}
CommonTreeNodeStream nodes = new CommonTreeNodeStream((ITree)r.Tree);
nodes.TokenStream = tokens;
SimpleCWalker walker = new SimpleCWalker(nodes);
walker.program();
}
else
Console.Error.WriteLine("Usage: SimpleC <input-file>");
}
public void VisitLine(String line)
{
Core interp_visitor = new Core();
PrintVisitor print_visitor = new PrintVisitor(interp_visitor);
ANTLRStringStream string_stream = new ANTLRStringStream(line);
spinachLexer lexer = new spinachLexer(string_stream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
spinachParser parser = new Test_Core(tokens, "");
try
{
spinachParser.program_return program = parser.program(); //h= (l+j)*h*l+l-h;
if (strBuilder.ToString() == "")
{
List<Element> elements = program.ret;
///-- call core function. to pass list of element.
for (int i = 0; i < elements.Count; i++)
{
Element curr = elements[i];
curr.Accept(print_visitor);
curr.Accept(interp_visitor);//PlotReceiver
}
}
else
{
Onerror(101, strBuilder.ToString());
}
}
catch (RecognitionException e)
{
Onerror(102, e.Message);
}
}
public ASMParser GetParser(string script)
{
var input = new ANTLRStringStream(script);
var lexer = new ASMLexer(input);
var tokens = new CommonTokenStream(lexer);
return new ASMParser(tokens);
}
/// <summary>
/// Parses input stream to tokens and then according to CSS grammar.
/// </summary>
/// <param name="inp">file name of input stream.</param>
public void Parse(string inp)
{
string fullpath;
if (Path.IsPathRooted(inp))
fullpath = inp;
else
fullpath = Common.PathCombine(Environment.CurrentDirectory, inp);
ICharStream input = new ANTLRFileStream(fullpath, Encoding.UTF8);
csst3Lexer lex = new csst3Lexer(input);
CommonTokenStream tokens = new CommonTokenStream(lex);
csst3Parser parser = new csst3Parser(tokens);
// return results as parameters
try
{
Root = (CommonTree)parser.stylesheet().Tree;
Errors = parser.GetErrors();
}
catch (Exception)
{
Errors = parser.GetErrors();
throw;
}
}
public Boolean RunTest()
{
try
{
GlobalMemory.Clear();
var sStream = new ANTLRStringStream(input);
var lexer = new SGLLexer(sStream);
var tStream = new CommonTokenStream(lexer);
// Parsing
var parser = new SGLParser(tStream);
var t = (CommonTree) parser.main().Tree;
// Printing tree
Console.WriteLine("; " + t.ToStringTree());
// TreeWalking
var treeStream = new CommonTreeNodeStream(t);
var tw = new SGLTreeWalker(treeStream, true);
AbstractNode returned = tw.main();
returned.Evaluate();
if (debug)
{
realOutput = GlobalMemory.Instance.DebugString;
}
else
{
realOutput = GlobalMemory.Instance.StoryboardCode.ToString();
}
// comparison
realOutput = realOutput.Trim();
output.Trim();
if (output.Equals(realOutput))
{
return true;
}
else
{
return false;
}
}
catch (CompilerException ce)
{
Console.WriteLine(ce.GetExceptionAsString());
return false;
}
catch (Exception ex)
{
Console.WriteLine("Es ist ein Fehler aufgetreten.");
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
return false;
}
}
public static MAst Compile(AstHelper runtime, ICharStream stream)
{
var lexer = new TigerLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new TigerParser(tokens);
ProgramExpression programExpression = parser.parse();
if (parser.NumberOfSyntaxErrors > 0)
{
IEnumerable<string> errors = from e in parser.Errors
select e.ToString();
throw new SyntaxException(errors);
}
AstHelper helper = runtime.CreateChild(function: true, variables: true, types: true);
programExpression.CheckSemantics(helper);
if (helper.Errors.HasErrors)
{
throw new SemanticException(helper.Errors);
}
return programExpression.Transform();
}
public Expression Compile(String relinqScript)
{
var input = new ANTLRStringStream(relinqScript);
var lex = new EcmaScriptV3Lexer(input);
var tokens = new CommonTokenStream(lex);
var parser = new EcmaScriptV3Parser(tokens);
var es3Ast = parser.expression();
var rsAst = new RelinqScriptParser().Visit((CommonTree)es3Ast.Tree);
var compilerAst = new TypeInferenceAstBuilder().Visit(rsAst);
using (var engine = new TypeInferenceEngine(compilerAst))
{
#if DEBUG
try
{
var wtf = 0;
while(!engine.Run()) if (wtf++ == 10) break;
return new StronglyTypedAstBuilder().Visit(compilerAst);
}
catch (Exception)
{
engine.Dump();
throw;
}
#else
engine.Run();
return new StronglyTypedAstBuilder().Visit(tiAst);
#endif
}
}
public void Execute()
{
string input =
@"
Sart(0,0)
End(12,15)
";
ANTLRStringStream inStream = new ANTLRStringStream(input);
ConfLexer lexer = new ConfLexer(inStream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
ConfParser parser = new ConfParser(tokens);
ConfParser.prog_return returnParser = parser.prog();
var tree = returnParser.Tree as CommonTree;
foreach (CommonTree item in tree.Children)
{
if (item.Type == ConfLexer.ID)
Console.WriteLine("function=" + item.Text);
else if(item.Type == ConfLexer.INT)
Console.WriteLine("params:" + item.Text);
}
Console.ReadKey();
}
/// <summary>
/// Parse the fragment of the source code already given.
/// </summary>
/// <param name="parser"></param>
/// <param name="tokenStream"></param>
private static CstNode ParseFragment(TParser parser, CommonTokenStream tokenStream)
{
var builder = new CstBuilderForAntlr3WithMemorizingError(
tokenStream, parser.TokenNames);
parser.TreeAdaptor = builder;
tokenStream.Mark();
var methodInfos =
parser.GetType().GetMethods(BindingFlags.Public | BindingFlags.Instance);
foreach (var methodInfo in methodInfos)
{
if (methodInfo.ReturnType.IsSubclassOf(typeof(ParserRuleContext)) &&
methodInfo.GetParameters().Length == 0)
{
builder.Initialize();
parser.Reset();
var ret = methodInfo.Invoke(parser, new object[0]);
if (!builder.HasErrors)
{
return(builder.FinishParsing((CstNode)ret));
}
}
}
throw builder.LastException;
}
public static string Compile(string input)
{
input = input.Replace("\r", "");
ANTLRStringStream Input = new ANTLRStringStream(input);
SugarCppLexer lexer = new SugarCppLexer(Input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
SugarCppParser parser = new SugarCppParser(tokens);
AstParserRuleReturnScope<CommonTree, IToken> t = parser.root();
CommonTree ct = (CommonTree)t.Tree;
if (parser.errors.Count() > 0)
{
StringBuilder sb = new StringBuilder();
foreach (var error in parser.errors)
{
sb.Append(error);
sb.Append("\n");
}
throw new Exception(sb.ToString());
}
CommonTreeNodeStream nodes = new CommonTreeNodeStream(ct);
SugarWalker walker = new SugarWalker(nodes);
Root ast = walker.root();
TargetCpp target_cpp = new TargetCpp();
return ast.Accept(target_cpp).Render();
}
/// <summary>
/// Parses an expression in text form for later evaluation.
/// </summary>
/// <param name="pszCode">The expression to be parsed.</param>
/// <param name="dwFlags">A combination of flags from the PARSEFLAGS enumeration that controls parsing.</param>
/// <param name="nRadix">The radix to be used in parsing any numerical information in pszCode.</param>
/// <param name="ppExpr">Returns the IDebugExpression2 object that represents the parsed expression, which is ready for binding and evaluation.</param>
/// <param name="pbstrError">Returns the error message if the expression contains an error.</param>
/// <param name="pichError">Returns the character index of the error in pszCode if the expression contains an error.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code.</returns>
/// <remarks>
/// When this method is called, a debug engine (DE) should parse the expression and validate it for correctness.
/// The pbstrError and pichError parameters may be filled in if the expression is invalid.
///
/// Note that the expression is not evaluated, only parsed. A later call to the IDebugExpression2.EvaluateSync
/// or IDebugExpression2.EvaluateAsync methods evaluates the parsed expression.
/// </remarks>
public int ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr, out string pbstrError, out uint pichError)
{
if (pszCode == null)
throw new ArgumentNullException("pszCode");
if (pszCode.Length == 0)
throw new ArgumentException();
// dwFlags=0 in the Immediate window
if (dwFlags != enum_PARSEFLAGS.PARSE_EXPRESSION && dwFlags != 0)
throw new NotImplementedException();
try
{
var expressionInput = new ANTLRStringStream(pszCode);
var expressionUnicodeInput = new JavaUnicodeStream(expressionInput);
var expressionLexer = new Java2Lexer(expressionUnicodeInput);
var expressionTokens = new CommonTokenStream(expressionLexer);
var expressionParser = new Java2Parser(expressionTokens);
IAstRuleReturnScope<CommonTree> result = expressionParser.standaloneExpression();
ppExpr = new JavaDebugExpression(this, result.Tree, pszCode);
pbstrError = null;
pichError = 0;
return VSConstants.S_OK;
}
catch (RecognitionException e)
{
ppExpr = null;
pbstrError = e.Message;
pichError = (uint)Math.Max(0, e.Index);
return VSConstants.E_FAIL;
}
}
public void Compile(ICharStream input)
{
try
{
AssemblerLexer lex = new AssemblerLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lex);
AssemblerParser p = new AssemblerParser(tokens);
BytecodeGenerator gen = new BytecodeGenerator(Defaults.SystemMethods.Values);
p.SetGenerator(gen);
p.TraceDestination = _traceDestination;
p.program();
if (p.NumberOfSyntaxErrors > 0 && _listener != null)
{
_listener.Error(Convert.ToString(p.NumberOfSyntaxErrors) + " syntax error(s)");
return;
}
_result = gen.Result;
}
catch (GenerationException ex)
{
_listener.Error(ex.Message);
}
}
public static MySQL51Parser.program_return ParseSql(string sql, bool expectErrors, out StringBuilder sb, Version version )
{
// The grammar supports upper case only
MemoryStream ms = new MemoryStream(ASCIIEncoding.ASCII.GetBytes(sql/*.ToUpper() */));
CaseInsensitiveInputStream input = new CaseInsensitiveInputStream(ms);
//ANTLRInputStream input = new ANTLRInputStream(ms);
MySQLLexer lexer = new MySQLLexer(input);
lexer.MySqlVersion = version;
CommonTokenStream tokens = new CommonTokenStream(lexer);
MySQLParser parser = new MySQLParser(tokens);
parser.MySqlVersion = version;
sb = new StringBuilder();
TextWriter tw = new StringWriter(sb);
parser.TraceDestination = tw;
MySQL51Parser.program_return r = parser.program();
if (!expectErrors)
{
if (0 != parser.NumberOfSyntaxErrors)
Assert.AreEqual("", sb.ToString());
//Assert.AreEqual( 0, parser.NumberOfSyntaxErrors);
}
else
{
Assert.AreNotEqual(0, parser.NumberOfSyntaxErrors);
}
return r;
}
public static InOutStep<EvilLexer, Tuple<CommonTokenStream, CommonTree>> Parse()
{
return new InOutStep<EvilLexer, Tuple<CommonTokenStream, CommonTree>>((lexer) =>
{
CommonTokenStream tokens = new CommonTokenStream(lexer);
EvilParser parser = new EvilParser(tokens);
EvilParser.program_return ret = null;
parser.TraceDestination = Console.Out;
try
{
ret = parser.Program();
}
catch (RecognitionException e)
{
throw new EvilException(EvilSystem.Parsing, "Error parsing.", e);
}
if (parser.NumberOfSyntaxErrors != 0)
throw new EvilException(EvilSystem.Parsing, "Syntax errors.");
CommonTree t = (CommonTree)ret.Tree;
return new Tuple<CommonTokenStream, CommonTree>(tokens, t);
});
}
public Context From(string source)
{
var stream = new ANTLRStringStream(source);
var lexer = new MessageContractsLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new MessageContractsParser(tokens)
{
TreeAdaptor = new CommonTreeAdaptor()
};
var program = parser.GetProgram();
var commonTree = (CommonTree)program.Tree;
var node = commonTree as CommonErrorNode;
if (node != null)
{
throw new InvalidOperationException(node.ToString());
}
var ctx = new Context();
foreach (var child in commonTree.Children)
{
WalkDeclarations(child, ctx);
}
return ctx;
}
public BlaiseInstrumentTreeWalker(CommonTree tree, CommonTokenStream tokens, BlaiseImportOptions options, string agencyId, string mainLanguage)
{
this.tree = tree;
this.tokens = tokens;
this.options = options;
this.MainLanguage = mainLanguage;
this.AgencyId = agencyId;
Result = new XDocument();
DdiInstance = Ddi.Element(Ddi.DdiInstance);
Ddi.AddNamespaces(DdiInstance);
ResourcePackage = Ddi.Element(Ddi.ResourcePackage);
// Required in DDI 3.1
var purpose = Ddi.Element(Ddi.Purpose);
purpose.Add(Ddi.XmlLang(MainLanguage));
purpose.Add(new XElement(Ddi.Content, "Not Specified"));
ResourcePackage.Add(purpose);
Instrument = Ddi.Element(Ddi.Instrument);
ControlConstructScheme = Ddi.Element(Ddi.ControlConstructScheme);
XElement groupDataCollection = Ddi.Element(Ddi.GroupDataCollection, false);
XElement dataCollection = Ddi.Element(Ddi.DataCollection);
groupDataCollection.Add(dataCollection);
dataCollection.Add(Instrument);
ResourcePackage.Add(groupDataCollection);
ResourcePackage.Add(ControlConstructScheme);
DdiInstance.Add(ResourcePackage);
}
public static void Main(string[] args)
{
if (args.Length == 1)
{
string fullpath;
if ( Path.IsPathRooted(args[0]) )
fullpath = args[0];
else
fullpath = Path.Combine(Environment.CurrentDirectory, args[0]);
Console.Out.WriteLine("Processing file: {0}", fullpath);
ICharStream input = new ANTLRFileStream(fullpath);
LangLexer lex = new LangLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lex);
LangParser parser = new LangParser(tokens);
//LangParser.decl_return r = parser.decl();
LangParser.start_return r = parser.start();
Console.Out.WriteLine("tree: "+((ITree)r.Tree).ToStringTree());
CommonTree r0 = ((CommonTree)r.Tree);
CommonTreeNodeStream nodes = new CommonTreeNodeStream(r0);
nodes.TokenStream = tokens;
LangDumpDecl walker = new LangDumpDecl(nodes);
walker.decl();
}
else
Console.Error.WriteLine("Usage: TreeParser <input-file>");
}
public static LuaResult Compile(
StaticMetaTables staticTables,
string source,
dynamic globals = null,
string name = null)
{
var result = new LuaResult();
var stopwatch = new Stopwatch();
stopwatch.Start();
try
{
var stream = new ANTLRStringStream(source);
var lexer = new ChunkLexer(stream);
var tokenStream = new CommonTokenStream(lexer);
var parser = new ChunkParser(tokenStream);
var r = parser.chunk();
result.Errors.AddRange(parser.Errors);
Expression e;
var scope = Scope.NewTopLevelScop();
var chunk = new Chunk();
result.Errors.AddRange(chunk.Generate(staticTables, scope, r.Tree, out e));
var fnExp = Expression.Lambda<Func<Table, object>>(e, scope.Env.GlobalParameter);
result.Chunk = new CompiledChunk(fnExp.Compile(), globals ?? new Table(), name);
}
finally
{
stopwatch.Stop();
result.ElapsedTime = stopwatch.Elapsed;
result.Success = !result.Errors.ContainsError();
}
return result;
}
public Feature Parse(TextReader featureFileReader)
{
var fileContent = featureFileReader.ReadToEnd() + Environment.NewLine;
CultureInfo language = GetLanguage(fileContent);
var inputStream = new ANTLRReaderStream(new StringReader(fileContent));
var lexer = GetLexter(language, inputStream);
var tokenStream = new CommonTokenStream(lexer);
var parser = new Grammar.SpecFlowLangParser(tokenStream);
var featureTree = parser.feature().Tree as CommonTree;
if (featureTree == null || parser.ParserErrors.Count > 0 || lexer.LexerErrors.Count > 0)
{
throw new SpecFlowParserException("Invalid Gherkin file!", lexer.LexerErrors.Concat(parser.ParserErrors).ToArray());
}
var walker = new SpecFlowLangWalker(new CommonTreeNodeStream(featureTree));
Feature feature = walker.feature();
if (feature == null)
throw new SpecFlowParserException("Invalid Gherkin file!");
feature.Language = language.Name;
return feature;
}
public Boolean RunTest()
{
try
{
ANTLRStringStream sStream = new ANTLRStringStream(input);
SGLLexer lexer = new SGLLexer(sStream);
CommonTokenStream tStream = new CommonTokenStream(lexer);
// Parsing
SGLParser parser = new SGLParser(tStream);
CommonTree t = (CommonTree)parser.compilationUnit().Tree;
// Printing tree
Console.WriteLine("; " + t.ToStringTree());
// TreeWalking
CommonTreeNodeStream treeStream = new CommonTreeNodeStream(t);
SGLTreeWalker tw = new SGLTreeWalker(treeStream);
SGLNode returned = tw.compilationUnit();
returned.Evaluate();
realOutput = tw.GetStoryboardCode().ToString();
// comparison
realOutput = realOutput.Trim();
output.Trim();
if (output.Equals(realOutput))
{
return true;
}
else
{
return false;
}
}
catch (SGLCompilerException ce)
{
if (ce.ErrorType.Equals("Antlr.Parser"))
{
Console.WriteLine("Error (wrong syntax) on " + ce.Message);
}
else
{
Console.WriteLine("Error (" + ce.ErrorType + ") on line " + ce.Line + ": " + ce.Message);
}
return false;
}
catch (Exception ex)
{
Console.WriteLine("Es ist ein Fehler aufgetreten.");
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
return false;
}
}
private void compilacion(ICharStream input, string pathSalida)
{
compilacionOK = false;
//Plantillas
//TextReader groupFileR = new StreamReader("C:\\Proyectos\\ProyectosVS\\FKVM\\FKVM\\src\\antlr\\FkvmIL.stg");
TextReader groupFileR = new StreamReader(
System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("FKVM.src.antlr.FkvmIL.stg"));
StringTemplateGroup templates = new StringTemplateGroup(groupFileR);
groupFileR.Close();
//Análisis Léxico-Sintáctico
Console.WriteLine("Análisis léxico-sintáctico...");
//ANTLRFileStream input = new ANTLRFileStream(pathEntrada);
FKVMLexer lexer = new FKVMLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
FKVMParser parser = new FKVMParser(tokens);
parser.TreeAdaptor = adaptor;
parser.reportarError = re;
FKVMParser.programa_return result = parser.programa();
//Si no hay errores léxicos ni sintácticos ==> Análisis Semántico
if (lexer.numErrors + parser.numErrors == 0)
{
//Analisis Semántico
Console.WriteLine("Análisis semántico...");
CommonTree t = ((CommonTree)result.Tree);
//Console.WriteLine(t.ToStringTree() + "\n\n"); //
CommonTreeNodeStream nodes2 = new CommonTreeNodeStream(t);
nodes2.TokenStream = tokens;
FKVMSem walker2 = new FKVMSem(nodes2);
walker2.reportarError = re;
walker2.programa(parser.symtable);
//Si no hay errores en el análisis semántico ==> Generación de código
if (walker2.numErrors == 0)
{
//Generación de Código
Console.WriteLine("Generación de código...");
CommonTreeNodeStream nodes = new CommonTreeNodeStream(t);
nodes.TokenStream = tokens;
FKVMGen walker = new FKVMGen(nodes);
walker.TemplateLib = templates;
FKVMGen.programa_return r2 = walker.programa(parser.numVars);
//Presentación de resultados
StringTemplate output = (StringTemplate)r2.Template;
//Console.WriteLine(output.ToString());
StreamWriter pw = new StreamWriter(pathSalida);
pw.WriteLine(output.ToString());
pw.Flush();
pw.Close();
compilacionOK = true;
}
}
}
public static JsonParser jsonParserFromString(string input)
{
var inputStream = new ANTLRStringStream(input);
var lexer = new JsonLexer(inputStream);
var tokens = new CommonTokenStream(lexer);
var parser = new JsonParser(tokens);
return parser;
}
/// <summary>
/// Creates a CPL parser for the given code, using the given error tracker.
/// </summary>
/// <param name="p_strCode">The code be parsed.</param>
/// <param name="p_ertErrorTracker">The error tracker to use to log
/// parsing errors.</param>
/// <returns>A CPL parser for the given code.</returns>
public AntlrParserBase CreateParser(string p_strCode, ErrorTracker p_ertErrorTracker)
{
AntlrLexerBase lexLexer = CreateLexer(p_strCode, p_ertErrorTracker);
CommonTokenStream ctsTokens = new CommonTokenStream(lexLexer);
CPLParser prsParser = new CPLParser(ctsTokens);
prsParser.ErrorTracker = p_ertErrorTracker;
return prsParser;
}
public static Definitions Parse(TextReader source)
{
var lex = new ParserImpl.WebIDLLexer(new ANTLRReaderStream(source));
var tokens = new CommonTokenStream(lex);
var parser = new ParserImpl.WebIDLParser(tokens);
return parser.definitions();
}
private static AntlrCalcEngineParser CreateParser( string parseText )
{
var input = new ANTLRStringStream( parseText );
var lex = new AntlrCalcEngineLexer( input );
var tokens = new CommonTokenStream( lex );
return new AntlrCalcEngineParser( tokens );
}
private CommonTree ParseViaAntlrOnly(String relinqScriptCode)
{
var input = new ANTLRStringStream(relinqScriptCode);
var lex = new EcmaScriptV3Lexer(input);
var tokens = new CommonTokenStream(lex);
var parser = new EcmaScriptV3Parser(tokens);
return (CommonTree)parser.expression().Tree;
}
/// <summary>
/// Creates a CPL parser for the given code, using the given error tracker.
/// </summary>
/// <param name="p_strCode">The code be parsed.</param>
/// <param name="p_ertErrorTracker">The error tracker to use to log
/// parsing errors.</param>
/// <returns>A CPL parser for the given code.</returns>
public AntlrParserBase CreateParser(string p_strCode, ErrorTracker p_ertErrorTracker)
{
AntlrLexerBase lexLexer = CreateLexer(p_strCode, p_ertErrorTracker);
CommonTokenStream ctsTokens = new CommonTokenStream(lexLexer);
SkyrimCplParser prsParser = new SkyrimCplParser(ctsTokens, "");
prsParser.SetErrorTracker(p_ertErrorTracker);
return prsParser;
}
private static CommonTree GetAst(FileInfo file)
{
var v = new ANTLRFileStream(file.FullName);
var lex = new vguiLexer(v);
var cts = new CommonTokenStream(lex);
var prs = new vguiParser(cts) {TreeAdaptor = new CommonTreeAdaptor()};
return (CommonTree) prs.start().Tree;
}
protected override void ReParseImpl()
{
var outputWindow = OutputWindowService.TryGetPane(PredefinedOutputWindowPanes.TvlIntellisense);
try
{
Stopwatch stopwatch = Stopwatch.StartNew();
var snapshot = TextBuffer.CurrentSnapshot;
SnapshotCharStream input = new SnapshotCharStream(snapshot, new Span(0, snapshot.Length));
GoLexer lexer = new GoLexer(input);
GoSemicolonInsertionTokenSource tokenSource = new GoSemicolonInsertionTokenSource(lexer);
CommonTokenStream tokens = new CommonTokenStream(tokenSource);
GoParser parser = new GoParser(tokens);
List<ParseErrorEventArgs> errors = new List<ParseErrorEventArgs>();
parser.ParseError += (sender, e) =>
{
errors.Add(e);
string message = e.Message;
ITextDocument document;
if (TextBuffer.Properties.TryGetProperty(typeof(ITextDocument), out document) && document != null)
{
string fileName = document.FilePath;
var line = snapshot.GetLineFromPosition(e.Span.Start);
message = string.Format("{0}({1},{2}): {3}", fileName, line.LineNumber + 1, e.Span.Start - line.Start.Position + 1, message);
}
if (message.Length > 100)
message = message.Substring(0, 100) + " ...";
if (outputWindow != null)
outputWindow.WriteLine(message);
if (errors.Count > 100)
throw new OperationCanceledException();
};
var result = parser.compilationUnit();
OnParseComplete(new AntlrParseResultEventArgs(snapshot, errors, stopwatch.Elapsed, tokens.GetTokens(), result));
}
catch (Exception e)
{
if (ErrorHandler.IsCriticalException(e))
throw;
try
{
if (outputWindow != null)
outputWindow.WriteLine(e.Message);
}
catch (Exception ex2)
{
if (ErrorHandler.IsCriticalException(ex2))
throw;
}
}
}
public static void Main(string[] args)
{
Stream inputStream = Console.OpenStandardInput();
ANTLRInputStream input = new ANTLRInputStream(inputStream);
CalculatorLexer lexer = new CalculatorLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CalculatorParser parser = new CalculatorParser(tokens);
parser.stat();
}
static void Main(string[] args)
{
if (args.Length == 2)
{
Antlr.Runtime.ANTLRFileStream inStream = new Antlr.Runtime.ANTLRFileStream(args[0]);
testLexer lexer = new testLexer(inStream);
Emitter emitter = new Emitter();
Antlr.Runtime.CommonTokenStream tokenStream = new Antlr.Runtime.CommonTokenStream(lexer);
testParser parser = new testParser(tokenStream, emitter);
//вызываем разбор правил programm
parser.program();
emitter.SaveMSIL(args[1]);
}
else
{
Console.WriteLine("usege: <program> <inputfile> <outputfile>");
Console.ReadKey();
}
}