public override void EnterNamespace_(XSharpParser.Namespace_Context context) { String newNamespaceName = context.Name.GetText(); // We already have something in Stack // so we are nesting Namespaces, get the previous name prefix if (this.NamespaceStack.Count > 0) { newNamespaceName = this.CurrentNamespace.Name + "." + newNamespaceName; } CodeNamespace newNamespace = new CodeNamespace(newNamespaceName); // this.NamespaceStack.Push(this.CurrentNamespace); // if (String.IsNullOrEmpty(this.CurrentNamespace.Name)) { // We could just have the empty fake Namespace here, but // if we have some Usings inside we must copy them if ((this.CurrentNamespace.Types.Count == 0) && (this.CurrentNamespace.Imports.Count > 0)) { // No Types means no Classes // Ok, copy foreach (CodeNamespaceImport import in this.CurrentNamespace.Imports) newNamespace.Imports.Add(import); } } // this.CurrentNamespace = newNamespace; }
XSharpParserRuleContext buildTree(XSharpParser parser) { XSharpParserRuleContext tree; if (_isScript) { if (_isMacroScript) { tree = parser.macroScript(); } else { tree = parser.script(); } } else if (_options.Dialect == XSharpDialect.FoxPro) { tree = parser.foxsource(); } else { tree = parser.source(); } return(tree); }
public XSharpTreeTransformationXPP(XSharpParser parser, CSharpParseOptions options, SyntaxListPool pool, ContextAwareSyntax syntaxFactory, string fileName) : base(parser, options, pool, syntaxFactory, fileName) { _classes = new List <XppClassInfo>(); _classstack = new Stack <IList <XppClassInfo> >(); _currentClass = null; _entryPoint = "Main"; }
public XSharpTreeTransformationVO(XSharpParser parser, CSharpParseOptions options, SyntaxListPool pool, ContextAwareSyntax syntaxFactory, string fileName) : base(parser, options, pool, syntaxFactory, fileName) { if (options.XSharpRuntime) { _winBoolType = XSharpQualifiedTypeNames.WinBool; } else { _winBoolType = VulcanQualifiedTypeNames.WinBool; } }
static int AnalyzeCode(string code, bool showErrors) { var stream = new AntlrInputStream(code.ToString()); var lexer = new XSharpLexer(stream); lexer.Options = new CSharpParseOptions(); var tokens = new CommonTokenStream(lexer); var parser = new XSharpParser(tokens); parser.Options = lexer.Options; var errorListener = new XSharpErrorListener(showErrors); parser.AddErrorListener(errorListener); var tree = parser.source(); //Console.WriteLine(tree.ToStringTree()); return(errorListener.TotalErrors); }
List <MethodInfo> GetMethodInfos() { var lexer = XSharpLexer.Create(SourceCodeFile.SourceCode, SourceCodeFile.FileName); lexer.RemoveErrorListeners(); var tokenStream = new CommonTokenStream(lexer, 0); var parser = new XSharpParser(tokenStream); parser.Options = new XSharpParseOptions(); parser.Options.SetXSharpSpecificOptions(XSharpSpecificCompilationOptions.Default); parser.RemoveErrorListeners(); var source = parser.source(); var listener = new MethodListener(); new ParseTreeWalker().Walk(listener, source); return(listener.MethodList); }
internal static XSharpTreeTransformationCore CreateTransform(XSharpParser parser, CSharpParseOptions options, SyntaxListPool pool, ContextAwareSyntax syntaxFactory, string fileName) { switch (options.Dialect) { case XSharpDialect.Core: return(new XSharpTreeTransformationCore(parser, options, pool, syntaxFactory, fileName)); case XSharpDialect.VO: case XSharpDialect.Vulcan: return(new XSharpTreeTransformationVO(parser, options, pool, syntaxFactory, fileName)); case XSharpDialect.FoxPro: return(new XSharpTreeTransformationFox(parser, options, pool, syntaxFactory, fileName)); case XSharpDialect.XPP: return(new XSharpTreeTransformationXPP(parser, options, pool, syntaxFactory, fileName)); case XSharpDialect.Harbour: default: return(new XSharpTreeTransformationRT(parser, options, pool, syntaxFactory, fileName)); } }
private CodeTypeReference BuildName(XSharpParser.NameContext context) { CodeTypeReference expr = null; // if (context is XSharpParser.QualifiedNameContext) { XSharpParser.QualifiedNameContext qual = (XSharpParser.QualifiedNameContext)context; expr = BuildName(qual.Left); expr = new CodeTypeReference(expr.BaseType + "." + BuildSimpleName(qual.Right).BaseType); } else if (context is XSharpParser.SimpleOrAliasedNameContext) { XSharpParser.SimpleOrAliasedNameContext alias = (XSharpParser.SimpleOrAliasedNameContext)context; // if (alias.Name is XSharpParser.AliasQualifiedNameContext) { XSharpParser.AliasQualifiedNameContext al = (XSharpParser.AliasQualifiedNameContext)alias.Name; expr = BuildSimpleName(al.Right); expr = new CodeTypeReference(al.Alias.GetText() + "::" + expr.BaseType); } else if (alias.Name is XSharpParser.GlobalQualifiedNameContext) { XSharpParser.GlobalQualifiedNameContext gbl = (XSharpParser.GlobalQualifiedNameContext)alias.Name; expr = BuildSimpleName(gbl.Right); expr = new CodeTypeReference("GLOBAL::" + expr.BaseType); } else if (alias.Name is XSharpParser.IdentifierOrGenericNameContext) { XSharpParser.IdentifierOrGenericNameContext id = (XSharpParser.IdentifierOrGenericNameContext)alias.Name; expr = BuildSimpleName(id.Name); } } // return expr; }
private CodeVariableDeclarationStatement BuildLocalVar(XSharpParser.LocalvarContext context, CodeTypeReference localType) { CodeVariableDeclarationStatement local = new CodeVariableDeclarationStatement(); local.Name = context.Id.GetText(); local.Type = localType; if (context.Expression != null) { if (context.Expression is XSharpParser.PrimaryExpressionContext) { XSharpParser.PrimaryContext ctx = ((XSharpParser.PrimaryExpressionContext)context.Expression).Expr; if (ctx is XSharpParser.LiteralExpressionContext) { XSharpParser.LiteralExpressionContext lit = (XSharpParser.LiteralExpressionContext)ctx; local.InitExpression = BuildLiteralValue(lit.Literal); } } else { local.InitExpression = new CodeSnippetExpression(context.Expression.GetText()); } } return local; }
/// <summary> /// Get a LiteralValueContext containing a BIN_CONST, INT_CONST, HEX_CONST, or a REAL_CONST /// as a String, and convert it to the "real" value, with the corresponding Type. /// </summary> /// <param name="context"></param> /// <returns>An Object of the needed Type, with the value</returns> private object GetNumericValue(XSharpParser.LiteralValueContext context) { Object ret = null; String value = context.GetText(); // if (context.BIN_CONST() != null || context.INT_CONST() != null || context.HEX_CONST() != null) { bool isUnsigned = (value.Substring(0, 1).ToLower().CompareTo("u") == 0); // -1 for Unsigned; -2 for 0x or 0b int len = value.Length - (isUnsigned ? 1 : 0) - (context.BIN_CONST() != null || context.HEX_CONST() != null ? 2 : 0); // if (context.BIN_CONST() != null) { if (len > 64) { ret = Double.NaN; } else { // Don't forget to remove the prefix !!! value = value.Substring(2); // BIN are always unsigned (??) UInt64 bin64; try { bin64 = Convert.ToUInt64(value, 2); // Maybe 32 bits is enough ? if (bin64 <= UInt32.MaxValue) { UInt32 bin32 = Convert.ToUInt32(bin64); ret = bin32; } else { ret = bin64; } } catch { ret = Double.NaN; } } } else if (context.HEX_CONST() != null) { if (len > 16) { ret = Double.NaN; } else { // Don't forget to remove the prefix !!! value = value.Substring(2); // HEX are always unsigned (??) UInt64 hex64; try { hex64 = Convert.ToUInt64(value, 16); // Maybe 32 bits is enough ? if (hex64 <= UInt32.MaxValue) { UInt32 hex32 = Convert.ToUInt32(hex64); ret = hex32; } else { ret = hex64; } } catch { ret = Double.NaN; } } } else { // context.INT_CONST() != null if (len > 64) { ret = Double.NaN; } else if (isUnsigned) { UInt64 myUInt64; try { myUInt64 = Convert.ToUInt64(value, 10); // Maybe 32 bits is enough ? if (myUInt64 <= UInt32.MaxValue) { UInt32 myUInt32 = Convert.ToUInt32(myUInt64); ret = myUInt32; } else { ret = myUInt64; } } catch { ret = Double.NaN; } } else { Int64 myInt64; try { myInt64 = Convert.ToInt64(value, 10); // Maybe 32 bits is enough ? if ((myInt64 >= UInt32.MinValue) && (myInt64 <= UInt32.MaxValue)) { Int32 myInt32 = Convert.ToInt32(myInt64); ret = myInt32; } else { ret = myInt64; } } catch { ret = Double.NaN; } } } } else { double d; // Should be REAL_CONST if (!double.TryParse(value, out d)) { d = double.NaN; } ret = d; } return ret; }
private MemberAttributes ContextToEventModifiers(XSharpParser.EventModifiersContext modifiers) { return decodeMemberAttributes(modifiers._Tokens); }
private CodeExpression BuildExpression(XSharpParser.PrimaryExpressionContext expression) { CodeExpression expr = null; XSharpParser.PrimaryContext ctx = expression.Expr; // if (ctx is XSharpParser.SelfExpressionContext) // Self { expr = new CodeThisReferenceExpression(); } else if (ctx is XSharpParser.SuperExpressionContext) // Super { expr = new CodeBaseReferenceExpression(); } else if (ctx is XSharpParser.LiteralExpressionContext) { XSharpParser.LiteralExpressionContext lit = (XSharpParser.LiteralExpressionContext)ctx; expr = BuildLiteralValue(lit.Literal); } else if (ctx is XSharpParser.LiteralArrayExpressionContext) // { expr [, expr] } { XSharpParser.LiteralArrayContext arr = ((XSharpParser.LiteralArrayExpressionContext)ctx).LiteralArray; // Typed Array ? if (arr.Type != null) { List<CodeExpression> exprlist = new List<CodeExpression>(); foreach (var Element in arr._Elements) { exprlist.Add(BuildExpression(Element.Expr,true)); } expr = new CodeArrayCreateExpression(BuildDataType(arr.Type), exprlist.ToArray()); } else { expr = new CodeSnippetExpression(arr.GetText()); } } else if (ctx is XSharpParser.DelegateCtorCallContext) { XSharpParser.DelegateCtorCallContext delg = (XSharpParser.DelegateCtorCallContext)ctx; // CodeTypeReference ctr = BuildDataType(delg.Type); CodeExpression ce = BuildExpression(delg.Obj,false); // expr = new CodeDelegateCreateExpression(BuildDataType(delg.Type), BuildExpression(delg.Obj,false), delg.Func.GetText()); } else if (ctx is XSharpParser.CtorCallContext) { XSharpParser.CtorCallContext ctor = (XSharpParser.CtorCallContext)ctx; CodeTypeReference ctr = BuildDataType(ctor.Type); List<CodeExpression> exprlist = new List<CodeExpression>(); if (ctor.ArgList != null) { foreach (var arg in ctor.ArgList._Args) { // We should handle arg.Name if arg.ASSIGN_OP is not null... exprlist.Add(BuildExpression(arg.Expr,false)); } } expr = new CodeObjectCreateExpression(ctr.BaseType, exprlist.ToArray()); } else if (ctx is XSharpParser.TypeOfExpressionContext) { CodeTypeReference ctr = BuildDataType(((XSharpParser.TypeOfExpressionContext)ctx).Type); expr = new CodeTypeOfExpression(ctr); } else if (ctx is XSharpParser.NameExpressionContext) { String name = ((XSharpParser.NameExpressionContext)ctx).Name.Id.GetText(); // Sometimes, we will need to do it that way.... if (name.ToLower() == "self") { expr = new CodeThisReferenceExpression(); } else if (name.ToLower() == "super") { expr = new CodeBaseReferenceExpression(); } else { CodeTypeReference ctr = BuildSimpleName(((XSharpParser.NameExpressionContext)ctx).Name); expr = new CodeVariableReferenceExpression(name); } } else { expr = new CodeSnippetExpression(ctx.GetText()); } return expr; }
public XSharpParseErrorAnalysis(XSharpParser parser, IList <ParseErrorData> parseErrors, CSharpParseOptions options) { _parser = parser; _parseErrors = parseErrors; _options = options; }
protected override XSharpTreeTransformationCore CreateWalker(XSharpParser parser) { return(new XSharpTreeTransformationVO(parser, _options, _pool, _syntaxFactory, _fileName)); }
public XSharpTreeTransformationFox(XSharpParser parser, CSharpParseOptions options, SyntaxListPool pool, ContextAwareSyntax syntaxFactory, string fileName) : base(parser, options, pool, syntaxFactory, fileName) { }
private TypeAttributes ContextToClassModifiers(XSharpParser.ClassModifiersContext modifiers) { TypeAttributes retValue = TypeAttributes.Public; ITerminalNode[] visibility; // visibility = modifiers.INTERNAL(); if (visibility.Length > 0) retValue = TypeAttributes.NestedAssembly; // visibility = modifiers.HIDDEN(); if (visibility.Length > 0) retValue = TypeAttributes.NestedPrivate; // visibility = modifiers.PRIVATE(); if (visibility.Length > 0) retValue = TypeAttributes.NestedPrivate; // visibility = modifiers.PROTECTED(); if (visibility.Length > 0) { visibility = modifiers.INTERNAL(); if (visibility.Length > 0) retValue = TypeAttributes.NestedFamORAssem; else retValue = TypeAttributes.NestedFamily; } // visibility = modifiers.EXPORT(); if (visibility.Length > 0) retValue = TypeAttributes.Public; // return retValue; }
private MemberAttributes ContextToConstructorModifiers(XSharpParser.ConstructorModifiersContext modifiers) { return decodeMemberAttributes(modifiers._Tokens); }
public override void EnterClass_(XSharpParser.Class_Context context) { CodeTypeDeclaration newClass = new CodeTypeDeclaration(context.Id.GetText()); // Set as Current working Class CurrentClass = newClass; // and push into the Namespace CurrentNamespace.Types.Add(newClass); // That's a Class newClass.IsClass = true; // if (context.Modifiers == null) { newClass.TypeAttributes = System.Reflection.TypeAttributes.Public; } else { // PARTIAL ? if (context.Modifiers.PARTIAL().Length > 0) newClass.IsPartial = true; // if (context.Modifiers.SEALED().Length > 0) newClass.Attributes |= MemberAttributes.Final; if (context.Modifiers.ABSTRACT().Length > 0) newClass.Attributes |= MemberAttributes.Abstract; if (context.Modifiers.INTERNAL().Length > 0) newClass.Attributes |= MemberAttributes.Private; // What Visibility ? newClass.TypeAttributes = ContextToClassModifiers(context.Modifiers); } // INHERIT from ? if (context.BaseType != null) { newClass.BaseTypes.Add(new CodeTypeReference(context.BaseType.GetText())); } // IMPLEMENTS ? if ((context._Implements != null) && (context._Implements.Count > 0)) { foreach (var interfaces in context._Implements) { newClass.BaseTypes.Add(new CodeTypeReference(interfaces.GetText())); } } // }
private CodeParameterDeclarationExpressionCollection GetParametersList(XSharpParser.ParameterListContext paramList) { CodeParameterDeclarationExpressionCollection pList = new CodeParameterDeclarationExpressionCollection(); // foreach (var param in paramList._Params) { CodeParameterDeclarationExpression pm = new CodeParameterDeclarationExpression(); pm.Name = param.Id.GetText(); pm.Type = BuildDataType(param.Type); // new CodeTypeReference(param.Type.GetText()); pm.Direction = FieldDirection.In; if (param.Modifiers != null) { if (param.Modifiers.REF() != null) { pm.Direction = FieldDirection.Ref; } else if (param.Modifiers.OUT() != null) { pm.Direction = FieldDirection.Out; } } // pList.Add(pm); } // return pList; }
private CodeTypeReference BuildNativeType(XSharpParser.NativeTypeContext nativeType) { CodeTypeReference expr = null; // if ((nativeType.BYTE() != null) || (nativeType.CHAR() != null) || (nativeType.DWORD() != null) || (nativeType.DYNAMIC() != null) || (nativeType.INT() != null) || (nativeType.INT64() != null) || (nativeType.LOGIC() != null) || (nativeType.LONGINT() != null) || (nativeType.OBJECT() != null) || (nativeType.PTR() != null) || (nativeType.REAL4() != null) || (nativeType.REAL8() != null) || (nativeType.SHORTINT() != null) || (nativeType.STRING() != null) || (nativeType.UINT64() != null) || (nativeType.VOID() != null) || (nativeType.WORD() != null)) { expr = BuildNativeType(nativeType.GetText()); } // return expr; }
private CodeTypeReference BuildXBaseType(XSharpParser.XbaseTypeContext xbaseType) { CodeTypeReference expr = null; // if ((xbaseType.ARRAY() != null) || (xbaseType.CODEBLOCK() != null) || (xbaseType.DATE() != null) || (xbaseType.FLOAT() != null) || (xbaseType.PSZ() != null) || (xbaseType.SYMBOL() != null) || (xbaseType.USUAL() != null)) { expr = new CodeTypeReference(xbaseType.GetText()); } // return expr; }
private CodeTypeReference BuildSimpleName(XSharpParser.SimpleNameContext simpleName) { CodeTypeReference expr = null; // String name = simpleName.Id.GetText(); String gen = ""; if (simpleName.GenericArgList != null) { string argList = ""; int i = 0; foreach (var generic in simpleName.GenericArgList._GenericArgs) { if (i > 0) argList += ","; CodeTypeReference tmp = BuildDataType(generic); argList += tmp.BaseType; i++; } // gen = "`" + i.ToString() + "[" + argList + "]"; } expr = new CodeTypeReference(name + gen); // return expr; }
private CodeExpression BuildExpression(XSharpParser.ExpressionContext expression, bool right ) { CodeExpression expr = null; // if (expression is XSharpParser.PrimaryExpressionContext) // xyz.SimpleName { expr = BuildExpression((XSharpParser.PrimaryExpressionContext)expression); } else if (expression is XSharpParser.AccessMemberContext) // xyz.SimpleName { XSharpParser.AccessMemberContext member = (XSharpParser.AccessMemberContext)expression; //what is the left hand side ? // Self -> check if Right is in the member of CurrentClass --> FieldReference // else --> always Property bool isMember = false; CodeExpression left = BuildExpression(member.Expr,false); if (left is CodeThisReferenceExpression) { string fieldCandidate = member.Name.GetText(); foreach (CodeTypeMember cm in this.CurrentClass.Members) { if (cm is CodeMemberField) { if (String.Compare(fieldCandidate, cm.Name, true) == 0) { isMember = true; break; } } } } // It seems to be a member... if (isMember) { expr = new CodeFieldReferenceExpression(BuildExpression(member.Expr,false), member.Name.GetText()); } else { // Let's guess that on the Left member, we should have a Property if it is not a Field if (!right) { expr = new CodePropertyReferenceExpression(BuildExpression(member.Expr, false), member.Name.GetText()); } else { // We are processing the Right member of an Assignment... // Most likely Enum Value, which is a typereference expression followed by a DOT and a field if (member.DOT() != null) { var typeexpr = new CodeTypeReferenceExpression(member.Expr.GetText()); expr = new CodeFieldReferenceExpression(typeexpr, member.Name.GetText()); } else { expr = new CodeSnippetExpression(member.GetText()); } } } } else if (expression is XSharpParser.MethodCallContext) { XSharpParser.MethodCallContext meth = (XSharpParser.MethodCallContext)expression; CodeExpression target = BuildExpression(meth.Expr,false); List<CodeExpression> exprlist = new List<CodeExpression>(); if (meth.ArgList != null) { foreach (var arg in meth.ArgList._Args) { exprlist.Add(BuildExpression(arg.Expr,false)); } } if (target is CodeFieldReferenceExpression) { // expr = new CodeMethodInvokeExpression(((CodeFieldReferenceExpression)target).TargetObject, ((CodeFieldReferenceExpression)target).FieldName, exprlist.ToArray()); } else if (target is CodePropertyReferenceExpression) { // expr = new CodeMethodInvokeExpression(((CodePropertyReferenceExpression)target).TargetObject, ((CodePropertyReferenceExpression)target).PropertyName, exprlist.ToArray()); } else expr = new CodeMethodInvokeExpression(null, meth.Expr.GetText(), exprlist.ToArray()); } else { expr = new CodeSnippetExpression(expression.GetText()); } // return expr; }
private CodeExpression BuildLiteralValue(XSharpParser.LiteralValueContext context) { CodeExpression expr = null; ITerminalNode node; // node = context.BIN_CONST(); if (node != null) { expr = new CodePrimitiveExpression(GetNumericValue(context)); } node = context.INT_CONST(); if (node != null) { expr = new CodePrimitiveExpression(GetNumericValue(context)); } // node = context.HEX_CONST(); if (node != null) { expr = new CodePrimitiveExpression(GetNumericValue(context)); } // node = context.REAL_CONST(); if (node != null) { expr = new CodePrimitiveExpression(GetNumericValue(context)); } // node = context.TRUE_CONST(); if (node != null) { expr = new CodePrimitiveExpression(true); } // node = context.FALSE_CONST(); if (node != null) { expr = new CodePrimitiveExpression(false); } // node = context.STRING_CONST(); if (node != null) { // Remove the quotes String value = context.GetText(); value = value.Substring(1, value.Length - 2); expr = new CodePrimitiveExpression(value); } // node = context.ESCAPED_STRING_CONST(); if (node != null) { // Remove the e in front of quotes, AND the Quotes String value = context.GetText(); value = value.Substring(1); value = value.Substring(1, value.Length - 2); expr = new CodePrimitiveExpression(BuildUnEscapedString(value)); } // node = context.CHAR_CONST(); if (node != null) { // Remove the quotes String value = context.GetText(); value = value.Substring(1, value.Length - 2); if (value.Length >= 1) expr = new CodePrimitiveExpression(value[0]); } // node = context.NIL(); if (node != null) { expr = new CodeSnippetExpression("NIL"); } // node = context.NULL(); if (node != null) { expr = new CodePrimitiveExpression(null); } // node = context.NULL_ARRAY(); if (node != null) { expr = new CodeSnippetExpression("NULL_ARRAY"); } // node = context.NULL_CODEBLOCK(); if (node != null) { expr = new CodeSnippetExpression("NULL_CODEBLOCK"); } // node = context.NULL_DATE(); if (node != null) { expr = new CodeSnippetExpression("NULL_DATE"); } // node = context.NULL_OBJECT(); if (node != null) { expr = new CodeSnippetExpression("NULL_OBJECT"); } // node = context.NULL_PSZ(); if (node != null) { expr = new CodeSnippetExpression("NULL_PSZ"); } // node = context.NULL_PTR(); if (node != null) { expr = new CodeSnippetExpression("NULL_PTR"); } // node = context.NULL_STRING(); if (node != null) { expr = new CodeSnippetExpression("NULL_STRING"); } // node = context.NULL_SYMBOL(); if (node != null) { expr = new CodeSnippetExpression("NULL_SYMBOL"); } // node = context.SYMBOL_CONST(); if (node != null) { expr = new CodeSnippetExpression(context.GetText().ToUpper()); } // node = context.DATE_CONST(); if (node != null) { expr = new CodeSnippetExpression(context.GetText()); } // if ( expr == null ) { expr = new CodeSnippetExpression(context.GetText()); } return expr; }
internal CompilationUnitSyntax ParseCompilationUnitCore() { #if DEBUG && DUMP_TIMES DateTime t = DateTime.Now; #endif if (_options.ShowIncludes) { _options.ConsoleOutput.WriteLine("Compiling {0}", _fileName); } var sourceText = _text.ToString(); XSharpLexer lexer = null; XSharpPreprocessor pp = null; XSharpParserRuleContext tree = new XSharpParserRuleContext(); XSharpParser parser = null; var parseErrors = ParseErrorData.NewBag(); try { lexer = XSharpLexer.Create(sourceText, _fileName, _options); lexer.Options = _options; _lexerTokenStream = lexer.GetTokenStream(); } catch (Exception e) { // Exception during Lexing parseErrors.Add(new ParseErrorData(_fileName, ErrorCode.ERR_Internal, e.Message, e.StackTrace)); // create empty token stream so we can continue the rest of the code _lexerTokenStream = new BufferedTokenStream(new XSharpListTokenSource(lexer, new List <IToken>())); } #if DEBUG && DUMP_TIMES { var ts = DateTime.Now - t; t += ts; Debug.WriteLine("Lexing completed in {0}", ts); } #endif // do not pre-process when there were lexer exceptions if (lexer != null && parseErrors.Count == 0) { foreach (var e in lexer.LexErrors) { parseErrors.Add(e); } BufferedTokenStream ppStream = null; try { // Check for #pragma in the lexerTokenStream _lexerTokenStream.Fill(); if (!_options.MacroScript) { pp = new XSharpPreprocessor(lexer, _lexerTokenStream, _options, _fileName, _text.Encoding, _text.ChecksumAlgorithm, parseErrors); } var mustPreprocess = !_options.MacroScript && (lexer.HasPreprocessorTokens || !_options.NoStdDef); if (mustPreprocess) { var ppTokens = pp.PreProcess(); ppStream = new CommonTokenStream(new XSharpListTokenSource(lexer, ppTokens)); } else { // No Standard Defs and no preprocessor tokens in the lexer // so we bypass the preprocessor and use the lexer tokenstream // but if a .ppo is required we must use the preprocessor to // write the source text to the .ppo file if (_options.PreprocessorOutput && pp != null) { pp.writeToPPO(sourceText, false); } BufferedTokenStream ts = (BufferedTokenStream)_lexerTokenStream; var tokens = ts.GetTokens(); // commontokenstream filters on tokens on the default channel. All other tokens are ignored ppStream = new CommonTokenStream(new XSharpListTokenSource(lexer, tokens)); } ppStream.Fill(); _preprocessorTokenStream = ppStream; } catch (Exception e) { // Exception during Preprocessing parseErrors.Add(new ParseErrorData(_fileName, ErrorCode.ERR_Internal, e.Message, e.StackTrace)); // create empty token stream so we can continue the rest of the code _preprocessorTokenStream = new BufferedTokenStream(new XSharpListTokenSource(lexer, new List <IToken>())); } } #if DEBUG && DUMP_TIMES { var ts = DateTime.Now - t; t += ts; Debug.WriteLine("Preprocessing completed in {0}", ts); } #endif parser = new XSharpParser(_preprocessorTokenStream) { Options = _options }; tree = new XSharpParserRuleContext(); if (_options.ParseLevel != ParseLevel.Lex) { // When parsing in Sll mode we do not record any parser errors. // When this fails, then we try again with LL mode and then we record errors parser.RemoveErrorListeners(); parser.Interpreter.PredictionMode = PredictionMode.Sll; // some options to have FAST parsing parser.Interpreter.tail_call_preserves_sll = false; parser.Interpreter.treat_sllk1_conflict_as_ambiguity = true; parser.ErrorHandler = new BailErrorStrategy(); try { tree = buildTree(parser); } catch (ParseCanceledException e) { if (_options.Verbose) { string msg = _GetInnerExceptionMessage(e); _options.ConsoleOutput.WriteLine("Antlr: SLL parsing failed with failure: " + msg + ". Trying again in LL mode."); } var errorListener = new XSharpErrorListener(_fileName, parseErrors); parser.AddErrorListener(errorListener); parser.ErrorHandler = new XSharpErrorStrategy(); // we need to set force_global_context to get proper error messages. This makes parsing slower // but gives better messages parser.Interpreter.treat_sllk1_conflict_as_ambiguity = false; parser.Interpreter.force_global_context = true; parser.Interpreter.enable_global_context_dfa = true; parser.Interpreter.PredictionMode = PredictionMode.Ll; _preprocessorTokenStream.Reset(); if (_options.Verbose && pp != null) { pp.DumpStats(); } if (pp != null) { pp.Close(); } parser.Reset(); try { tree = buildTree(parser); } catch (Exception e1) { // Cannot parse again. Must be a syntax error. if (_options.Verbose) { string msg = _GetInnerExceptionMessage(e1); _options.ConsoleOutput.WriteLine("Antlr: LL parsing also failed with failure: " + msg); } } } }// _options.ParseLevel < Complete #if DEBUG && DUMP_TIMES { var ts = DateTime.Now - t; t += ts; Debug.WriteLine("Parsing completed in {0}", ts); } #endif if (_options.DumpAST && tree != null) { string strTree = tree.ToStringTree(); string file = System.IO.Path.ChangeExtension(_fileName, "ast"); strTree = strTree.Replace(@"\r\n)))))", @"\r\n*)))))" + "\r\n"); strTree = strTree.Replace(@"\r\n))))", @"\r\n*)))" + "\r\n"); strTree = strTree.Replace(@"\r\n)))", @"\r\n*)))" + "\r\n"); strTree = strTree.Replace(@"\r\n))", @"\r\n*))" + "\r\n"); strTree = strTree.Replace(@"\r\n)", @"\r\n*)" + "\r\n"); strTree = strTree.Replace(@"\r\n*)", @"\r\n)"); System.IO.File.WriteAllText(file, strTree); } var walker = new ParseTreeWalker(); if (_options.ParseLevel == ParseLevel.Complete) { // check for parser errors, such as missing tokens // This adds items to the parseErrors list for missing // tokens and missing keywords try { var errchecker = new XSharpParseErrorAnalysis(parser, parseErrors, _options); walker.Walk(errchecker, tree); } catch (Exception e) { parseErrors.Add(new ParseErrorData(_fileName, ErrorCode.ERR_Internal, e.Message, e.StackTrace)); } } var treeTransform = CreateTransform(parser, _options, _pool, _syntaxFactory, _fileName); bool hasErrors = false; SyntaxToken eof = null; try { if (_options.ParseLevel < ParseLevel.Complete || parser.NumberOfSyntaxErrors != 0 || (parseErrors.Count != 0 && parseErrors.Contains(p => !ErrorFacts.IsWarning(p.Code)))) { eof = SyntaxFactory.Token(SyntaxKind.EndOfFileToken); eof = AddLeadingSkippedSyntax(eof, ParserErrorsAsTrivia(parseErrors, pp.IncludedFiles)); if (tree != null) { eof.XNode = new XTerminalNodeImpl(tree.Stop); } else { eof.XNode = new XTerminalNodeImpl(_lexerTokenStream.Get(_lexerTokenStream.Size - 1)); } hasErrors = true; } if (!hasErrors) { try { walker.Walk(treeTransform, tree); } catch (Exception e) { parseErrors.Add(new ParseErrorData(_fileName, ErrorCode.ERR_Internal, e.Message, e.StackTrace)); } eof = SyntaxFactory.Token(SyntaxKind.EndOfFileToken); if (!parseErrors.IsEmpty()) { eof = AddLeadingSkippedSyntax(eof, ParserErrorsAsTrivia(parseErrors, pp.IncludedFiles)); } } var result = _syntaxFactory.CompilationUnit( treeTransform.GlobalEntities.Externs, treeTransform.GlobalEntities.Usings, treeTransform.GlobalEntities.Attributes, treeTransform.GlobalEntities.Members, eof); result.XNode = tree; tree.CsNode = result; result.XTokens = _lexerTokenStream; result.XPPTokens = _preprocessorTokenStream; result.HasDocComments = lexer.HasDocComments; if (!_options.MacroScript && !hasErrors) { result.InitProcedures = treeTransform.GlobalEntities.InitProcedures; result.Globals = treeTransform.GlobalEntities.Globals; result.PragmaWarnings = treeTransform.GlobalEntities.PragmaWarnings; result.PragmaOptions = treeTransform.GlobalEntities.PragmaOptions; result.IncludedFiles = pp?.IncludedFiles; result.FileWidePublics = treeTransform.GlobalEntities.FileWidePublics; result.HasPCall = treeTransform.GlobalEntities.HasPCall; result.NeedsProcessing = treeTransform.GlobalEntities.NeedsProcessing; if (_options.HasRuntime) { result.LiteralSymbols = ((XSharpTreeTransformationRT)treeTransform).LiteralSymbols; result.LiteralPSZs = ((XSharpTreeTransformationRT)treeTransform).LiteralPSZs; } } return(result); } finally { #if DEBUG && DUMP_TIMES { var ts = DateTime.Now - t; t += ts; Debug.WriteLine("Tree transform completed in {0}", ts); } #endif treeTransform.Free(); if (pp != null) { pp.Close(); } } }
private CodeTypeReference BuildDataType(XSharpParser.DatatypeContext context) { CodeTypeReference expr = null; // if (context is XSharpParser.PtrDatatypeContext) { XSharpParser.PtrDatatypeContext ptrData = (XSharpParser.PtrDatatypeContext)context; if (ptrData.TypeName.NativeType != null) expr = BuildNativeType(ptrData.TypeName.NativeType); else if (ptrData.TypeName.XType != null) expr = BuildXBaseType(ptrData.TypeName.XType); else if (ptrData.TypeName.Name != null) expr = BuildName(ptrData.TypeName.Name); } else if (context is XSharpParser.ArrayDatatypeContext) { } else if (context is XSharpParser.SimpleDatatypeContext) { XSharpParser.SimpleDatatypeContext sdt = (XSharpParser.SimpleDatatypeContext)context; if (sdt.TypeName.Name != null) expr = BuildName(sdt.TypeName.Name); else expr = BuildNativeType(sdt.TypeName.GetText()); } else if (context is XSharpParser.NullableDatatypeContext) { } // return expr; }
private static void Parse(string fileName) { ITokenStream stream; IList <ParseErrorData> parseErrors = ParseErrorData.NewBag(); var filestream = new AntlrFileStream(fileName); var lexer = new XSharpLexer(filestream); lexer.TokenFactory = XSharpTokenFactory.Default; stream = new CommonTokenStream(lexer, Lexer.DefaultTokenChannel); var parser = new XSharpParser(stream); parser.IsScript = false; parser.AllowFunctionInsideClass = false; parser.AllowNamedArgs = false; parser.AllowXBaseVariables = false; parser.RemoveErrorListeners(); parser.Interpreter.PredictionMode = PredictionMode.Sll; parser.Interpreter.reportAmbiguities = true; parser.Interpreter.enable_global_context_dfa = true; // default false parser.Interpreter.optimize_tail_calls = true; parser.Interpreter.tail_call_preserves_sll = true; //parser.Interpreter.userWantsCtxSensitive = true; // default true parser.ErrorHandler = new XSharpErrorStrategy(); parser.AddErrorListener(new XSharpErrorListener(fileName, parseErrors, true)); XSharpParserRuleContext tree; try { tree = parser.source(); } catch (ParseCanceledException) { Console.WriteLine("Parse error, Errors from SLL mode"); showErrors(parseErrors); parseErrors.Clear(); parser.ErrorHandler = new XSharpErrorStrategy(); parser.AddErrorListener(new XSharpErrorListener(fileName, parseErrors, true)); parser.Interpreter.PredictionMode = PredictionMode.Ll; parser.Interpreter.force_global_context = true; parser.Interpreter.optimize_ll1 = false; parser.Interpreter.reportAmbiguities = true; parser.Reset(); try { tree = parser.source(); } catch (Exception e) { tree = null; Console.WriteLine(e.Message); } } // find parser errors (missing tokens etc) foreach (var e in lexer.LexErrors) { parseErrors.Add(e); } var walker = new ParseTreeWalker(); var errchecker = new XSharpParseErrorAnalysis(parser, parseErrors); if (tree != null) { walker.Walk(errchecker, tree); } Console.WriteLine("Parse error, Errors:"); showErrors(parseErrors); }
public static bool Parse(string sourceText, string fileName, CSharpParseOptions options, IErrorListener listener, out ITokenStream tokens, out XSharpParser.SourceContext tree) { tree = null; tokens = null; var parseErrors = ParseErrorData.NewBag(); try { var lexer = XSharpLexer.Create(sourceText, fileName, options); lexer.Options = options; BufferedTokenStream tokenStream = lexer.GetTokenStream(); tokenStream.Fill(); tokens = (ITokenStream)tokenStream; GetLexerErrors(lexer, tokenStream, parseErrors); // do we need to preprocess #region Determine if we really need the preprocessor bool mustPreprocess = true; if (lexer.HasPreprocessorTokens || !options.NoStdDef) { // no need to pre process in partial compilation // if lexer does not contain UDCs, Messages or Includes mustPreprocess = lexer.MustBeProcessed; } else { mustPreprocess = false; } #endregion XSharpPreprocessor pp = null; BufferedTokenStream ppStream = null; pp = new XSharpPreprocessor(lexer, tokenStream, options, fileName, Encoding.Unicode, SourceHashAlgorithm.None, parseErrors); if (mustPreprocess) { var ppTokens = pp.PreProcess(); ppStream = new CommonTokenStream(new XSharpListTokenSource(lexer, ppTokens)); } else { // No Standard Defs and no preprocessor tokens in the lexer // so we bypass the preprocessor and use the lexer token stream ppStream = new CommonTokenStream(new XSharpListTokenSource(lexer, tokenStream.GetTokens())); } ppStream.Fill(); var parser = new XSharpParser(ppStream); parser.Interpreter.tail_call_preserves_sll = false; // default = true Setting to FALSE will reduce memory used by parser parser.Options = options; tree = null; parser.RemoveErrorListeners(); parser.Interpreter.PredictionMode = PredictionMode.Sll; parser.ErrorHandler = new BailErrorStrategy(); try { tree = parser.source(); } catch (Exception) { var errorListener = new XSharpErrorListener(fileName, parseErrors); parser.AddErrorListener(errorListener); parser.ErrorHandler = new XSharpErrorStrategy(); parser.Interpreter.PredictionMode = PredictionMode.Ll; ppStream.Reset(); parser.Reset(); try { tree = parser.source(); } catch (Exception) { tree = null; } } } catch (Exception) { tree = null; } ReportErrors(parseErrors, listener); return(tree != null); }