private CFlatType TypeCheckIncrementDecrement(ASTExpression expr, string operatorName, LexLocation loc) { //totally cheating here. the grammar should not even allow this to happen. if (expr is ASTIdentifier) { ASTIdentifier identifier = (ASTIdentifier)expr; //need to set a flag so that the code generator can store back the result identifier.IsLeftHandSide = true; CFlatType t = CheckSubTree(identifier); if (t.IsNumeric) { return(t); } else { ReportError(loc, "The {0} operator requires an instance of a numeric datatype", operatorName); } } else { ReportError(loc, "The {0} operator requires an instance of a numeric datatype", operatorName); } /* note: the ReportError method will always throw, so this part of the code should not be reached, * unless of course we change the ReportError method to not throw or try to implement some error recovery * strategy... * */ throw new InternalCompilerException("This part of the code should not be reachable."); }
private static ASTExpression ParseExpression() { ASTExpression lhs = ParsePrimary(); if (lhs == null) { return(null); } return(ParseRHSBinaryOperator(0, lhs)); }
private void ApplyIncrementDecrement(ASTExpression exp, OpCode op) { exp.Visit(this); //visit the identifier again, as the right hand side of an assignment so we emit the OpCodes for loading onto the stack new ASTIdentifier(null, _lastWalkedIdentifier).Visit(this); _gen.Emit(OpCodes.Ldc_I4_1); _gen.Emit(op); //store this back to the location ApplyAssignmentCallback(); }
private static ASTFunction ParseTopLevelExpression() { ASTExpression e = ParseExpression(); if (e == null) { return(null); } // create an anonymous prototype to evaluate the expression ASTPrototype proto = new ASTPrototype("__proto", new List <string>()); return(new ASTFunction(proto, e)); }
private static ASTExpression ParseParenExpression() { NextToken(); // eat first '(' ASTExpression exp = ParseExpression(); if (exp == null) { return(null); } if (CurrentToken.StringValue != ")") { return(LogError("Expected ')'")); } NextToken(); // eat ')' return(exp); }
/* apply optimizations to the AST. returns False if it runs out of memory. */ private static void OptimizeAST(ref ASTExpression Expr) { bool DidSomething = true; while (DidSomething) { bool OneDidSomething; DidSomething = false; ASTExpression exprReplacement; Expr.FoldConst(out OneDidSomething, out exprReplacement); if (exprReplacement != null) { Expr = exprReplacement; } DidSomething = DidSomething || OneDidSomething; } }
private static ASTFunction ParseDefinition() { NextToken(); // eat the 'def' keyword ASTPrototype proto = ParsePrototype(); // parse the definition if (proto == null) { return(null); } ASTExpression body = ParseExpression(); // and the body if (body != null) { return(new ASTFunction(proto, body)); } return(null); }
private static ASTExpression ParseRHSBinaryOperator(int prec, ASTExpression lhs) { while (true) { int tokPrec = Grammar.GetPrecedence(CurrentToken.StringValue); // If this is a binop that binds at least as tightly as the current binop, // consume it, otherwise we are done. if (tokPrec < prec) { return(lhs); } // we now know this is a binary operator string binop = CurrentToken.StringValue; NextToken(); // consume op // parse primary expr after the operator ASTExpression rhs = ParsePrimary(); if (rhs == null) { return(null); } // If the binop binds less tightly with RHS than the operator after RHS, let // the pending operator take RHS as its LHS. Basically look-ahead int nextPrec = Grammar.GetPrecedence(CurrentToken.StringValue); if (tokPrec < nextPrec) { rhs = ParseRHSBinaryOperator(prec + 1, rhs); if (rhs == null) { return(null); } } // merge lhs and rhs lhs = new ASTExpressionBinary(binop, lhs, rhs); } // end of while loop }
ASTExpression ParseExpression() { ASTExpression firstExpr = ParseExpressionImpl(); if (lexer.IsReading) { if (lexer.PeekNext() == TokenType.Operator) // Operators { Token opToken = lexer.NextToken(); ASTExpression rightSide = ParseExpression(); ASTOperator opNode = new ASTOperator(opToken.Source, firstExpr, rightSide); return(opNode); } else if (lexer.PeekNext() == TokenType.SquareBraceOpen) // Array access { ASTIndexer upper = null; while (lexer.PeekNext() == TokenType.SquareBraceOpen) { MatchNext(TokenType.SquareBraceOpen); ASTExpression index = ParseExpression(); upper = new ASTIndexer(firstExpr, index); firstExpr = upper; MatchNext(TokenType.SquareBraceClose); } return(upper); } } return(firstExpr); }
/* compile a special function. a special function has no function header, but is */ /* simply some code to be executed. the parameters the code is expecting are provided */ /* in the FuncArray[] and NumParams. the first parameter is deepest beneath the */ /* top of stack. the TextData is NOT altered. if an error occurrs, *FunctionOut */ /* will NOT contain a valid object */ public static CompileErrors CompileSpecialFunction( CodeCenterRec CodeCenter, FunctionParamRec[] FuncArray, out int ErrorLineNumber, out DataTypes ReturnTypeOut, string TextData, bool suppressCILEmission, out PcodeRec FunctionOut, out ASTExpression ASTOut) { CompileErrors Error; ErrorLineNumber = -1; ASTOut = null; FunctionOut = null; ReturnTypeOut = DataTypes.eInvalidDataType; ScannerRec <KeywordsType> TheScanner = new ScannerRec <KeywordsType>(TextData, KeywordTable); SymbolTableRec TheSymbolTable = new SymbolTableRec(); // reconstitute function prototypes for (int i = 0; i < CodeCenter.RetainedFunctionSignatures.Length; i++) { SymbolRec functionSignature = ArgListTypesToSymbol( CodeCenter.RetainedFunctionSignatures[i].Key, CodeCenter.RetainedFunctionSignatures[i].Value.ArgsTypes, CodeCenter.RetainedFunctionSignatures[i].Value.ReturnType); bool f = TheSymbolTable.Add(functionSignature); Debug.Assert(f); // should never fail (due to duplicate) since CodeCenter.RetainedFunctionSignatures is unique-keyed } /* build parameters into symbol table */ int StackDepth = 0; int MaxStackDepth = 0; int ReturnAddressIndex = StackDepth; for (int i = 0; i < FuncArray.Length; i += 1) { SymbolRec TheParameter = new SymbolRec(FuncArray[i].ParameterName); TheParameter.SymbolBecomeVariable(FuncArray[i].ParameterType); /* allocate stack slot */ StackDepth++; MaxStackDepth = Math.Max(MaxStackDepth, StackDepth); TheParameter.SymbolVariableStackLocation = StackDepth; if (!TheSymbolTable.Add(TheParameter)) // our own code should never pass in a formal arg list with duplicates { Debug.Assert(false); throw new InvalidOperationException(); } } /* fence them off */ TheSymbolTable.IncrementSymbolTableLevel(); /* reserve spot for fake return address (so we have uniform calling convention everywhere) */ StackDepth++; MaxStackDepth = Math.Max(MaxStackDepth, StackDepth); if (StackDepth != FuncArray.Length + 1) { // stack depth error before evaluating function Debug.Assert(false); throw new InvalidOperationException(); } ASTExpressionList ListOfExpressions; Error = ParseExprList( out ListOfExpressions, new ParserContext( TheScanner, TheSymbolTable), out ErrorLineNumber); /* compile the thing */ if (Error != CompileErrors.eCompileNoError) { return(Error); } ASTExpression TheExpressionThang = new ASTExpression( ListOfExpressions, TheScanner.GetCurrentLineNumber()); /* make sure there is nothing after it */ TokenRec <KeywordsType> Token = TheScanner.GetNextToken(); if (Token.GetTokenType() != TokenTypes.eTokenEndOfInput) { ErrorLineNumber = TheScanner.GetCurrentLineNumber(); return(CompileErrors.eCompileInputBeyondEndOfFunction); } DataTypes ResultingType; Error = TheExpressionThang.TypeCheck(out ResultingType, out ErrorLineNumber); if (Error != CompileErrors.eCompileNoError) { return(Error); } OptimizeAST(ref TheExpressionThang); PcodeRec TheFunctionCode = new PcodeRec(); TheExpressionThang.PcodeGen( TheFunctionCode, ref StackDepth, ref MaxStackDepth); Debug.Assert(StackDepth <= MaxStackDepth); ReturnTypeOut = TheExpressionThang.ResultType; /* 2 extra words for retaddr, resultofexpr */ if (StackDepth != FuncArray.Length + 1 /*retaddr*/ + 1 /*result*/) { // stack depth error after evaluating function Debug.Assert(false); throw new InvalidOperationException(); } /* now put the return instruction */ int unused; TheFunctionCode.AddPcodeInstruction(Pcodes.epReturnFromSubroutine, out unused, TheScanner.GetCurrentLineNumber()); // special function returns without popping args -- so that args can be have in/out behavior TheFunctionCode.AddPcodeOperandInteger(0); StackDepth -= 1; /* pop retaddr */ Debug.Assert(StackDepth <= MaxStackDepth); if (StackDepth != 1 + FuncArray.Length) { // stack depth is wrong at end of function Debug.Assert(false); throw new InvalidOperationException(); } TheFunctionCode.MaxStackDepth = MaxStackDepth; /* optimize stupid things away */ TheFunctionCode.OptimizePcode(); if (CILObject.EnableCIL && !suppressCILEmission) { DataTypes[] argsTypes = new DataTypes[FuncArray.Length]; string[] argsNames = new string[FuncArray.Length]; for (int i = 0; i < argsTypes.Length; i++) { argsTypes[i] = FuncArray[i].ParameterType; argsNames[i] = FuncArray[i].ParameterName; } CILAssembly cilAssembly = new CILAssembly(); CILObject cilObject = new CILObject( CodeCenter.ManagedFunctionLinker, argsTypes, argsNames, TheExpressionThang.ResultType, TheExpressionThang, cilAssembly, true /*argsByRef*/); // args by ref true for special functions to permit multiple return values TheFunctionCode.cilObject = cilObject; cilAssembly.Finish(); } /* it worked, so return the dang thing */ FunctionOut = TheFunctionCode; ASTOut = TheExpressionThang; return(CompileErrors.eCompileNoError); }
ASTExpression ParseExpressionImpl() { Token first = lexer.NextToken(); switch (first.Type) { case TokenType.True: return(new ASTLiteral(true)); case TokenType.False: return(new ASTLiteral(false)); case TokenType.Number: if (first.Source.Contains(".")) { return(new ASTLiteral(float.Parse(first.Source))); } try { int i = int.Parse(first.Source); } catch (System.Exception e) { Debug.LogError("Integer Invalid: " + first.Source + " len: " + first.Source.Length); } return(new ASTLiteral(int.Parse(first.Source))); case TokenType.String: return(new ASTLiteral(first.Source)); case TokenType.Identifier: { if (lexer.PeekNext() == TokenType.BracketOpen) { ASTFuncCall funcCall = new ASTFuncCall(first.Source); lexer.NextToken(); // Eat open bracket while (true) { if (lexer.PeekNext() == TokenType.BracketClose) { lexer.NextToken(); break; } ASTExpression arg = ParseExpression(); funcCall.AddArg(arg); if (lexer.PeekNext() == TokenType.BracketClose) { lexer.NextToken(); break; } MatchNext(TokenType.Comma); } return(funcCall); } return(new ASTVariable(first.Source)); } default: throw new Exception("Unexpected token " + first); } }
public override object Visit(ASTExpression node, object data) { return(this.ShowNode(node, data)); }
public virtual Object Visit(ASTExpression node, Object data) { data = node.ChildrenAccept(this, data); return(data); }
ASTStatement ParseStatement() { if (lexer.PeekNext() == TokenType.Identifier) // Function call { ASTFuncCall funcCall = ParseExpression() as ASTFuncCall; return(new ASTInlineCall(funcCall)); } Token first = lexer.NextToken(); switch (first.Type) { case TokenType.Set: { Token varNameToken = MatchNext(TokenType.Identifier); List <ASTExpression> indexers = new List <ASTExpression>(); while (lexer.PeekNext() == TokenType.SquareBraceOpen) { MatchNext(TokenType.SquareBraceOpen); indexers.Add(ParseExpression()); MatchNext(TokenType.SquareBraceClose); } MatchNext(TokenType.To); ASTExpression expression = ParseExpression(); return(new ASTSet(varNameToken.Source, expression, indexers)); } case TokenType.If: { ASTExpression check = ParseExpression(); ASTStatements statements = new ASTStatements(); ASTIf ifStmnt = new ASTIf(check, statements); MatchNext(TokenType.Do); while (lexer.PeekNext() != TokenType.End) { if (lexer.PeekNext() == TokenType.Else) { lexer.NextToken(); statements = new ASTStatements(); ifStmnt.SetElse(statements); MatchNext(TokenType.Do); } else if (lexer.PeekNext() == TokenType.Elif) { lexer.NextToken(); statements = new ASTStatements(); ASTIf elseifStmnt = new ASTIf(ParseExpression(), statements); ifStmnt.SetElseIf(elseifStmnt); MatchNext(TokenType.Do); } statements.AddStatement(ParseStatement()); } lexer.NextToken(); return(ifStmnt); } case TokenType.While: { ASTExpression check = ParseExpression(); ASTStatements statements = new ASTStatements(); ASTWhile whileStmnt = new ASTWhile(check, statements); MatchNext(TokenType.Do); while (lexer.PeekNext() != TokenType.End) { statements.AddStatement(ParseStatement()); } lexer.NextToken(); return(whileStmnt); } case TokenType.Return: { return(new ASTReturn(ParseExpression())); } default: throw new Exception("Unexpected token " + first); } return(null); }
public ASTUnaryExpression(ASTToken op, ASTExpression expr) : base("UnaryExpression") { Expression = expr; Operator = op; }
public ASTFunctionCall(ASTExpression name, List <ASTNode> args) : base("FunctionCall") { FunctionName = name; ArgList = args; }
public ASTArrayAccess(ASTExpression arrayname, List <ASTExpression> elements) : base("ArrayAccess") { ArrayName = arrayname; Elements = elements; }
// Compile multiple modules. (eliminates the need to do prototyping or function signature inference.) // CodeCenter is cleared, and if compilation succeeds, the functions are added to CodeCenter. public static CompileErrors CompileWholeProgram( out int ErrorLineNumber, out int ErrorModuleIndex, string[] TextDatas, object[] Signatures, CodeCenterRec CodeCenter, string[] Filenames) { Debug.Assert(TextDatas.Length == Signatures.Length); Debug.Assert(TextDatas.Length == Filenames.Length); ErrorLineNumber = -1; ErrorModuleIndex = -1; CodeCenter.FlushAllCompiledFunctions(); CodeCenter.RetainedFunctionSignatures = new KeyValuePair <string, FunctionSignature> [0]; // parse List <SymbolRec> SymbolTableEntriesForForm = new List <SymbolRec>(); List <ASTExpression> FunctionBodyRecords = new List <ASTExpression>(); List <int> ModuleIndices = new List <int>(); Dictionary <string, List <ParserContext.FunctionSymbolRefInfo> > FunctionRefSymbolList = new Dictionary <string, List <ParserContext.FunctionSymbolRefInfo> >(); List <int> InitialLineNumbersOfForm = new List <int>(); for (int module = 0; module < TextDatas.Length; module++) { string TextData = TextDatas[module]; ErrorModuleIndex = module; ScannerRec <KeywordsType> TheScanner = new ScannerRec <KeywordsType>(TextData, KeywordTable); SymbolTableRec TheSymbolTable = new SymbolTableRec(); /* loop until there are no more things to parse */ while (true) { TokenRec <KeywordsType> Token = TheScanner.GetNextToken(); int InitialLineNumberOfForm = TheScanner.GetCurrentLineNumber(); if (Token.GetTokenType() == TokenTypes.eTokenEndOfInput) { /* no more functions to parse, so stop */ break; } SymbolRec SymbolTableEntryForForm; ASTExpression FunctionBodyRecord; /* parse the function */ TheScanner.UngetToken(Token); CompileErrors Error = ParseForm( out SymbolTableEntryForForm, out FunctionBodyRecord, new ParserContext( TheScanner, TheSymbolTable, FunctionRefSymbolList), out ErrorLineNumber); if (Error != CompileErrors.eCompileNoError) { return(Error); } Debug.Assert(FunctionBodyRecord != null); ModuleIndices.Add(module); SymbolTableEntriesForForm.Add(SymbolTableEntryForForm); FunctionBodyRecords.Add(FunctionBodyRecord); InitialLineNumbersOfForm.Add(InitialLineNumberOfForm); } foreach (KeyValuePair <string, List <ParserContext.FunctionSymbolRefInfo> > name in FunctionRefSymbolList) { foreach (ParserContext.FunctionSymbolRefInfo funcRef in name.Value) { funcRef.module = module; } } } // push function type signatures into function call refs Dictionary <string, bool> functionNamesUsed = new Dictionary <string, bool>(); for (int i = 0; i < SymbolTableEntriesForForm.Count; i++) { ErrorModuleIndex = ModuleIndices[i]; SymbolRec FunctionDeclarationSymbol = SymbolTableEntriesForForm[i]; if (functionNamesUsed.ContainsKey(FunctionDeclarationSymbol.SymbolName)) { ErrorLineNumber = FunctionBodyRecords[i].LineNumber; return(CompileErrors.eCompileMultiplyDeclaredFunction); } functionNamesUsed.Add(FunctionDeclarationSymbol.SymbolName, false); List <ParserContext.FunctionSymbolRefInfo> symbols; if (FunctionRefSymbolList.TryGetValue(FunctionDeclarationSymbol.SymbolName, out symbols)) { foreach (ParserContext.FunctionSymbolRefInfo functionRef in symbols) { functionRef.symbol.SymbolBecomeFunction2( FunctionDeclarationSymbol.FunctionArgList, FunctionDeclarationSymbol.FunctionReturnType); } FunctionRefSymbolList.Remove(FunctionDeclarationSymbol.SymbolName); } } foreach (KeyValuePair <string, List <ParserContext.FunctionSymbolRefInfo> > name in FunctionRefSymbolList) { foreach (ParserContext.FunctionSymbolRefInfo funcRef in name.Value) { ErrorModuleIndex = funcRef.module; ErrorLineNumber = funcRef.lineNumber; return(CompileErrors.eCompileMultiplyDeclaredFunction); } } // type check and type inference for (int i = 0; i < FunctionBodyRecords.Count; i++) { int module = ModuleIndices[i]; SymbolRec SymbolTableEntryForForm = SymbolTableEntriesForForm[i]; ASTExpression FunctionBodyRecord = FunctionBodyRecords[i]; int InitialLineNumberOfForm = InitialLineNumbersOfForm[i]; ErrorModuleIndex = module; /* SymbolTableEntryForForm will be the symbol table entry that */ /* was added to the symbol table. FunctionBodyRecord is either */ /* an expression for a function or NIL if it was a prototype */ Debug.Assert(!CodeCenter.CodeCenterHaveThisFunction(SymbolTableEntryForForm.SymbolName)); /* step 1: do type checking */ DataTypes ResultingType; CompileErrors Error = FunctionBodyRecord.TypeCheck( out ResultingType, out ErrorLineNumber); if (Error != CompileErrors.eCompileNoError) { return(Error); } /* check to see that resulting type matches declared type */ if (!CanRightBeMadeToMatchLeft(SymbolTableEntryForForm.FunctionReturnType, ResultingType)) { ErrorLineNumber = InitialLineNumberOfForm; return(CompileErrors.eCompileTypeMismatch); } /* if it has to be promoted, then promote it */ if (MustRightBePromotedToLeft(SymbolTableEntryForForm.FunctionReturnType, ResultingType)) { /* insert promotion operator above expression */ ASTExpression ReplacementExpr = PromoteTheExpression( ResultingType, SymbolTableEntryForForm.FunctionReturnType, FunctionBodyRecord, InitialLineNumberOfForm); FunctionBodyRecord = ReplacementExpr; /* sanity check */ Error = FunctionBodyRecord.TypeCheck( out ResultingType, out ErrorLineNumber); if (Error != CompileErrors.eCompileNoError) { // type promotion caused failure Debug.Assert(false); throw new InvalidOperationException(); } if (ResultingType != SymbolTableEntryForForm.FunctionReturnType) { // after type promotion, types are no longer the same Debug.Assert(false); throw new InvalidOperationException(); } } } // code generation CILAssembly cilAssembly = null; if (CILObject.EnableCIL) { cilAssembly = new CILAssembly(); } FuncCodeRec[] TheWholeFunctionThings = new FuncCodeRec[FunctionBodyRecords.Count]; for (int i = 0; i < FunctionBodyRecords.Count; i++) { int module = ModuleIndices[i]; SymbolRec SymbolTableEntryForForm = SymbolTableEntriesForForm[i]; ASTExpression FunctionBodyRecord = FunctionBodyRecords[i]; int InitialLineNumberOfForm = InitialLineNumbersOfForm[i]; string Filename = Filenames[module]; object Signature = Signatures[module]; ErrorModuleIndex = module; Debug.Assert(!CodeCenter.CodeCenterHaveThisFunction(SymbolTableEntryForForm.SymbolName)); /* step 1.5: optimize the AST */ OptimizeAST(ref FunctionBodyRecord); /* step 2: do code generation */ /* calling conventions: */ /* - push the arguments */ /* - funccall pushes the return address */ /* thus, upon entry, Stack[0] will be the return address */ /* and Stack[-1] will be the rightmost argument */ /* on return, args and retaddr are popped and retval replaces them */ int StackDepth = 0; int MaxStackDepth = 0; int ReturnValueLocation = StackDepth; /* remember return value location */ int ArgumentIndex = 0; SymbolListRec FormalArgumentListScan = SymbolTableEntryForForm.FunctionArgList; while (FormalArgumentListScan != null) { SymbolRec TheFormalArg = FormalArgumentListScan.First; StackDepth++; /* allocate first */ MaxStackDepth = Math.Max(MaxStackDepth, StackDepth); TheFormalArg.SymbolVariableStackLocation = StackDepth; /* remember */ ArgumentIndex++; FormalArgumentListScan = FormalArgumentListScan.Rest; } /* reserve return address spot */ StackDepth++; MaxStackDepth = Math.Max(MaxStackDepth, StackDepth); /* allocate the function code */ PcodeRec TheFunctionCode = new PcodeRec(); FunctionBodyRecord.PcodeGen( TheFunctionCode, ref StackDepth, ref MaxStackDepth); Debug.Assert(StackDepth <= MaxStackDepth); /* 2 extra words for retaddr and resultofexpr */ if (StackDepth != ArgumentIndex + 1 + 1) { // stack depth error after evaluating function Debug.Assert(false); throw new InvalidOperationException(); } /* now put the return instruction (pops retaddr and args, leaving retval) */ int ignored; TheFunctionCode.AddPcodeInstruction(Pcodes.epReturnFromSubroutine, out ignored, InitialLineNumberOfForm); TheFunctionCode.AddPcodeOperandInteger(ArgumentIndex); StackDepth = StackDepth - (1 + ArgumentIndex); Debug.Assert(StackDepth <= MaxStackDepth); if (StackDepth != 1) { // stack depth is wrong at end of function Debug.Assert(false); throw new InvalidOperationException(); } TheFunctionCode.MaxStackDepth = MaxStackDepth; /* step 2.5: optimize the code */ TheFunctionCode.OptimizePcode(); /* step 3: create the function and save it away */ FuncCodeRec TheWholeFunctionThing = new FuncCodeRec( SymbolTableEntryForForm.SymbolName, SymbolTableEntryForForm.FunctionArgList, TheFunctionCode, SymbolTableEntryForForm.FunctionReturnType, Filename); TheWholeFunctionThings[i] = TheWholeFunctionThing; if (CILObject.EnableCIL) { DataTypes[] argsTypes; string[] argsNames; SymbolicArgListToType(SymbolTableEntryForForm, out argsTypes, out argsNames); CILObject cilObject = new CILObject( CodeCenter.ManagedFunctionLinker, argsTypes, argsNames, SymbolTableEntryForForm.FunctionReturnType, FunctionBodyRecord, cilAssembly, false /*argsByRef*/); TheWholeFunctionThing.CILObject = cilObject; } } // register after entire assembly is emitted if (CILObject.EnableCIL) { cilAssembly.Finish(); } for (int i = 0; i < TheWholeFunctionThings.Length; i++) { FuncCodeRec TheWholeFunctionThing = TheWholeFunctionThings[i]; object Signature = Signatures[ModuleIndices[i]]; CodeCenter.AddFunctionToCodeCenter(TheWholeFunctionThing, Signature); } // retain signatures for compilation of special functions CodeCenter.RetainedFunctionSignatures = new KeyValuePair <string, FunctionSignature> [SymbolTableEntriesForForm.Count]; for (int i = 0; i < CodeCenter.RetainedFunctionSignatures.Length; i++) { DataTypes[] argsTypes; string[] argsNames; SymbolicArgListToType(SymbolTableEntriesForForm[i], out argsTypes, out argsNames); CodeCenter.RetainedFunctionSignatures[i] = new KeyValuePair <string, FunctionSignature>( SymbolTableEntriesForForm[i].SymbolName, new FunctionSignature( argsTypes, SymbolTableEntriesForForm[i].FunctionReturnType)); } return(CompileErrors.eCompileNoError); }
public ASTExpressionBinary(string op, ASTExpression lhs, ASTExpression rhs) { Operator = op; LHS = lhs; RHS = rhs; }
public ASTFunction(ASTPrototype prototype, ASTExpression body) { Prototype = prototype; Body = body; }
public virtual System.Object visit(ASTExpression node, System.Object data) { data = node.childrenAccept(this, data); return(data); }
public ASTBinaryExpression(ASTToken op, ASTExpression e1, ASTExpression e2) : base("BinaryExpression") { Operator = op; Expr1 = e1; Expr2 = e2; }
public ASTOperator(string op, ASTExpression left, ASTExpression right) { this.op = op; this.left = left; this.right = right; }
public ASTPostfixExpression(ASTExpression expr, ASTToken op) : base("PostfixExpression") { Expression = expr; Operator = op; }
public void AddArg(ASTExpression expression) { expressions.Add(expression); }
public ASTArrayDeclarator(ASTDeclarator declarator, ASTExpression expressions) : base("ArrayDeclarator") { Declarator = declarator; Expression = expressions; }
public ASTIndexer(ASTExpression baseExpr, ASTExpression indexExpr) { this.baseExpr = baseExpr; this.indexExpr = indexExpr; }
/// <summary>Display an ASTExpression node /// </summary> public override Object Visit(ASTExpression node, Object data) { return(ShowNode(node, data)); }
/// <summary>Display an ASTExpression node /// </summary> public override System.Object visit(ASTExpression node, System.Object data) { return(showNode(node, data)); }
/* ----------------------------------------------------------------------- * * Expression Syntax * * ----------------------------------------------------------------------*/ public void Expression() { /*@bgen(jjtree) Expression */ ASTExpression jjtn000 = new ASTExpression(this, ParserTreeConstants.EXPRESSION); bool jjtc000 = true; nodeTree.OpenNodeScope(jjtn000); //UPGRADE_NOTE: Exception 'java.lang.Throwable' was converted to ' ' which has different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1100"' try { if (jj_2_10(2147483647)) { Assignment(); } else { switch(GetCurrentTokenKind()) { case ParserConstants.LBRACKET: case ParserConstants.LPAREN: case ParserConstants.WHITESPACE: case ParserConstants.STRING_LITERAL: case ParserConstants.TRUE: case ParserConstants.FALSE: case ParserConstants.LOGICAL_NOT: case ParserConstants.NUMBER_LITERAL: case ParserConstants.IDENTIFIER: case ParserConstants.LCURLY: ConditionalOrExpression(); break; default: jj_la1[36] = jj_gen; ConsumeToken(-1); throw new ParseException(); } } } catch(Exception exception) { nodeTree.ClearNodeScope(jjtn000); jjtc000 = false; if (exception is SystemException) { throw; } if (exception is ParseException) { throw; } throw (ApplicationException) exception; } finally { if (jjtc000) { nodeTree.CloseNodeScope(jjtn000, true); } } }
public ASTSet(string varName, ASTExpression expression, List <ASTExpression> indexers) { this.varName = varName; this.expression = expression; this.indexers = indexers; }