public static int Count(EXPR pExpr) { int c = 0; for (ExpressionIterator it = new ExpressionIterator(pExpr); !it.AtEnd(); it.MoveNext()) { ++c; } return c; }
//------------------------------------------------------------ // FUNCBREC.BindNubGetValOrDef // /// <summary> /// Create an expr for exprSrc.GetValueOrDefault() /// where exprSrc->type is a NUBSYM. /// </summary> /// <param name="treeNode"></param> /// <param name="srcExpr"></param> /// <returns></returns> //------------------------------------------------------------ private EXPR BindNubGetValOrDef(BASENODE treeNode, EXPR srcExpr) { DebugUtil.Assert(srcExpr != null && srcExpr.TypeSym.IsNUBSYM); TYPESYM baseTypeSym = (srcExpr.TypeSym as NUBSYM).BaseTypeSym; // If srcExpr is null, just return the appropriate default value. if (srcExpr.GetConst() != null) { return(AddSideEffects(treeNode, NewExprZero(treeNode, baseTypeSym), srcExpr, true, true)); } // For new T?(x), the answer is x. if (IsNubCtor(srcExpr)) { DebugUtil.Assert( (srcExpr as EXPRCALL).ArgumentsExpr != null && (srcExpr as EXPRCALL).ArgumentsExpr.Kind != EXPRKIND.LIST); return((srcExpr as EXPRCALL).ArgumentsExpr); } AGGTYPESYM aggTypeSym = (srcExpr.TypeSym as NUBSYM).GetAggTypeSym(); if (aggTypeSym == null) { return(NewError(treeNode, baseTypeSym)); } Compiler.EnsureState(aggTypeSym, AggStateEnum.Prepared); METHSYM methSym = EnsureNubGetValOrDef(treeNode); if (methSym == null) { return(NewError(treeNode, baseTypeSym)); } CheckFieldUse(srcExpr, true); EXPRCALL resExpr = NewExpr(treeNode, EXPRKIND.CALL, baseTypeSym) as EXPRCALL; resExpr.MethodWithInst.Set(methSym, aggTypeSym, BSYMMGR.EmptyTypeArray); resExpr.ArgumentsExpr = null; resExpr.ObjectExpr = srcExpr; return(resExpr); }
private void Init(EXPR pExpr) { if (pExpr == null) { _pList = null; _pCurrent = null; } else if (pExpr.isLIST()) { _pList = pExpr.asLIST(); _pCurrent = _pList.GetOptionalElement(); } else { _pList = null; _pCurrent = pExpr; } }
private void Init(EXPR pExpr) { if (pExpr == null) { m_pList = null; m_pCurrent = null; } else if (pExpr.isLIST()) { m_pList = pExpr.asLIST(); m_pCurrent = m_pList.GetOptionalElement(); } else { m_pList = null; m_pCurrent = pExpr; } }
//-------------------------------------------------- // ExprUtil.CountArguments // /// <summary> /// (Utilities\ExprUtil.cs) /// </summary> /// <param name="argsExpr"></param> /// <returns></returns> //-------------------------------------------------- static internal int CountArguments(EXPR argsExpr) { int argCount = 0; for (EXPR list = argsExpr; list != null;) { ++argCount; if (list.Kind == EXPRKIND.LIST) { list = list.AsBIN.Operand2; } else { list = null; } } return(argCount); }
//------------------------------------------------------------ // FUNCBREC.BindNubOpRes (1) // /// <summary> /// <para>Combine the condition and value.</para> /// <para>(In sscli, warOnNull has the default value false.)</para> /// </summary> /// <param name="treeNode"></param> /// <param name="nubSym"></param> /// <param name="dstTypeSym"></param> /// <param name="valueExpr"></param> /// <param name="nubInfo"></param> /// <param name="warnOnNull"></param> /// <returns></returns> //------------------------------------------------------------ private EXPR BindNubOpRes( BASENODE treeNode, NUBSYM nubSym, TYPESYM dstTypeSym, EXPR valueExpr, ref NubInfo nubInfo, bool warnOnNull) // = false { if (nubInfo.FAlwaysNull() && warnOnNull) { Compiler.Error(treeNode, CSCERRID.WRN_AlwaysNull, new ErrArg(nubSym)); } return(BindNubOpRes( treeNode, dstTypeSym, valueExpr, NewExprZero(treeNode, dstTypeSym.IsNUBSYM ? dstTypeSym : nubSym), ref nubInfo)); }
//------------------------------------------------------------ // FUNCBREC.CreateAutoImplementedGetAccessor // /// <summary></summary> /// <param name="methodSym"></param> /// <returns></returns> //------------------------------------------------------------ internal EXPR CreateAutoImplementedGetAccessor(METHSYM methodSym) { CreateNewScope(); SCOPESYM scopeSym = this.currentScopeSym; this.currentScopeSym.ScopeFlags = SCOPEFLAGS.NONE; this.currentBlockExpr = NewExprBlock(treeNode); this.currentBlockExpr.ScopeSym = this.currentScopeSym; SymWithType symWithType = new SymWithType(); AGGTYPESYM parentAts = methodSym.ParentAggSym.GetThisType(); symWithType.Set( methodSym.PropertySym.BackFieldSym, parentAts); EXPR fieldExpr = BindToField( null, BindThisImplicit(null), FieldWithType.Convert(symWithType), BindFlagsEnum.RValueRequired); //TYPESYM retTypeSym = methodSym.ReturnTypeSym; EXPRRETURN returnExpr = NewExpr(null, EXPRKIND.RETURN, null) as EXPRRETURN; returnExpr.ObjectExpr = fieldExpr; this.currentBlockExpr.StatementsExpr = returnExpr; EXPRBLOCK blockExpr = this.currentBlockExpr; this.currentBlockExpr = blockExpr.OwingBlockExpr; CloseScope(); CorrectAnonMethScope(blockExpr.ScopeSym); return(blockExpr); }
//------------------------------------------------------------ // FUNCBREC.BindExtensionMethod // /// <summary></summary> /// <param name="callExpr"></param> /// <returns></returns> //------------------------------------------------------------ internal EXPR BindExtensionMethod(EXPRCALL instanceCallExpr) { DebugUtil.Assert( instanceCallExpr != null && instanceCallExpr.MethodWithInst != null && instanceCallExpr.MethodWithInst.MethSym != null); MethWithInst instanceMwi = instanceCallExpr.MethodWithInst; METHSYM instanceMethSym = instanceMwi.MethSym; METHSYM staticMethSym = instanceMethSym.StaticExtensionMethodSym; if (staticMethSym == null) { return(instanceCallExpr); } MethWithInst staticMwi = new MethWithInst( staticMethSym, staticMethSym.ParentAggSym.GetThisType(), // non-generic type. instanceMwi.TypeArguments); EXPR topArgExpr = instanceCallExpr.ObjectExpr; EXPR lastArgExpr = topArgExpr; if (instanceCallExpr.ArgumentsExpr != null) { NewList(instanceCallExpr.ArgumentsExpr, ref topArgExpr, ref lastArgExpr); } EXPRCALL staticCallExpr = NewExpr( treeNode, EXPRKIND.CALL, instanceCallExpr.TypeSym) as EXPRCALL; staticCallExpr.MethodWithInst = staticMwi; staticCallExpr.ArgumentsExpr = topArgExpr; staticCallExpr.ObjectExpr = null; return(staticCallExpr); }
//------------------------------------------------------------ // FUNCBREC.BindNubAddTmps // /// <summary> /// Combines the pre and post expressions of the NubInfo with exprRes. /// The pre and post exprs are typically to store values to temps and free the temps. /// </summary> /// <param name="treeNode"></param> /// <param name="resExpr"></param> /// <param name="nubInfo"></param> /// <returns></returns> //------------------------------------------------------------ private EXPR BindNubAddTmps(BASENODE treeNode, EXPR resExpr, ref NubInfo nubInfo) { if (nubInfo.PostExpr[1] != null) { resExpr = NewExprBinop(treeNode, EXPRKIND.SEQREV, resExpr.TypeSym, resExpr, nubInfo.PostExpr[1]); } if (nubInfo.PostExpr[0] != null) { resExpr = NewExprBinop(treeNode, EXPRKIND.SEQREV, resExpr.TypeSym, resExpr, nubInfo.PostExpr[0]); } if (nubInfo.PreExpr[1] != null) { resExpr = NewExprBinop(treeNode, EXPRKIND.SEQUENCE, resExpr.TypeSym, nubInfo.PreExpr[1], resExpr); } if (nubInfo.PreExpr[0] != null) { resExpr = NewExprBinop(treeNode, EXPRKIND.SEQUENCE, resExpr.TypeSym, nubInfo.PreExpr[0], resExpr); } return(resExpr); }
//------------------------------------------------------------ // FUNCBREC.BindUnaryOperator // // EXPR * BindStdUnaOp(BASENODE * tree, OPERATOR op, EXPR * arg); // EXPR * BindIntUnaOp(BASENODE * tree, EXPRKIND ek, uint flags, EXPR * arg); // EXPR * BindRealUnaOp(BASENODE * tree, EXPRKIND ek, uint flags, EXPR * arg); // EXPR * BindDecUnaOp(BASENODE * tree, EXPRKIND ek, uint flags, EXPR * arg); // EXPR * BindBoolUnaOp(BASENODE * tree, EXPRKIND ek, uint flags, EXPR * arg); // EXPR * BindEnumUnaOp(BASENODE * tree, EXPRKIND ek, uint flags, EXPR * arg); //------------------------------------------------------------ internal EXPR BindUnaryOperator( BindUnaOpEnum op, BASENODE tree, EXPRKIND ek, EXPRFLAG flags, EXPR arg) { switch (op) { case BindUnaOpEnum.Integer: // Handles standard unary integer based operators. // EXPR * FUNCBREC::BindIntUnaOp(BASENODE * tree, EXPRKIND ek, uint flags, EXPR * arg) DebugUtil.Assert(arg.TypeSym.IsPredefined()); return(BindIntOp(tree, ek, flags, arg, null, arg.TypeSym.GetPredefType())); case BindUnaOpEnum.Real: // Handles standard unary floating point (float, double) based operators. // EXPR * FUNCBREC::BindRealUnaOp(BASENODE * tree, EXPRKIND ek, uint flags, EXPR * arg) DebugUtil.Assert(arg.TypeSym.IsPredefined()); return(BindFloatOp(tree, ek, flags, arg, null)); case BindUnaOpEnum.Decimal: return(BindDecUnaOp(tree, ek, flags, arg)); case BindUnaOpEnum.Bool: return(BindBoolUnaOp(tree, ek, flags, arg)); break; case BindUnaOpEnum.Enum: return(BindEnumUnaOp(tree, ek, flags, arg)); default: DebugUtil.Assert(false, "FUNCBREC.BindUnaryOperator"); break; } return(null); }
//------------------------------------------------------------ // FUNCBREC.BindQMark // /// <summary> /// <para>Constructs an expr for "exprCond ? exprLeft : exprRight". If fInvert is true, reverses /// exprLeft and exprRight.</para> /// <para>(In sscli, fInvert has the default value false.)</para> /// </summary> /// <remarks> /// REVIEW ShonK: Optimize BindQmark when the condition is a constant (with possible side effects). /// </remarks> /// <param name="tree"></param> /// <param name="condExpr"></param> /// <param name="leftExpr"></param> /// <param name="rightExpr"></param> /// <param name="fInvert"></param> /// <returns></returns> //------------------------------------------------------------ private EXPR BindQMark( BASENODE tree, EXPR condExpr, EXPR leftExpr, EXPR rightExpr, bool fInvert) // =false { DebugUtil.Assert(condExpr.TypeSym.IsPredefType(PREDEFTYPE.BOOL)); DebugUtil.Assert(leftExpr.TypeSym == rightExpr.TypeSym); EXPR colonExpr; if (fInvert) { colonExpr = NewExprBinop(tree, EXPRKIND.BINOP, null, rightExpr, leftExpr); } else { colonExpr = NewExprBinop(tree, EXPRKIND.BINOP, null, leftExpr, rightExpr); } return(NewExprBinop(tree, EXPRKIND.QMARK, leftExpr.TypeSym, condExpr, colonExpr)); }
//------------------------------------------------------------ // FUNCBREC.BindNubOpRes (2) // /// <summary> /// Combine the condition and value. /// </summary> /// <param name="treeNode"></param> /// <param name="dstTypeSym"></param> /// <param name="valueExpr"></param> /// <param name="nullExpr"></param> /// <param name="nubInfo"></param> /// <returns></returns> //------------------------------------------------------------ private EXPR BindNubOpRes( BASENODE treeNode, TYPESYM dstTypeSym, EXPR valueExpr, EXPR nullExpr, ref NubInfo nubInfo) { EXPR resExpr; nullExpr = MustConvert(nullExpr, dstTypeSym, 0); valueExpr = MustConvert(valueExpr, dstTypeSym, 0); if (nubInfo.FAlwaysNonNull()) { // Don't need nullExpr and there aren't any temps. resExpr = valueExpr; } else if (nubInfo.FAlwaysNull()) { // Don't need valueExpr but do need side effects. resExpr = BindNubAddTmps(treeNode, nullExpr, ref nubInfo); } else { DebugUtil.Assert(nubInfo.CombinedConditionExpr != null); resExpr = BindQMark( treeNode, nubInfo.CombinedConditionExpr, MustConvert(valueExpr, dstTypeSym, 0), nullExpr, false); resExpr = BindNubAddTmps(treeNode, resExpr, ref nubInfo); } return(resExpr); }
public void SetOperator(EXPR value) { Operator = value; }
public void SetOptionalLeftChild(EXPR value) { _OptionalLeftChild = value; }
public void SetOptionalUserDefinedCall(EXPR value) { _OptionalUserDefinedCall = value; }
public void SetOptionalArguments(EXPR value) { _OptionalArguments = value; }
int parse_regx(int term, int paren) { int c; char kcode = '\0'; bool once = false; int nest = 0; RegexOptions options = RegexOptions.None; int re_start = thread.line; RNode list = null; newtok(); while ((c = nextc()) != -1) { if (c == term && nest == 0) { c = -100; // goto regx_end } switch (c) { case '#': list = str_extend(list, term); if (list is RNEOF) goto unterminated; continue; case '\\': if (tokadd_escape() < 0) return 0; continue; case -1: goto unterminated; default: if (paren != 0) { if (c == paren) nest++; if (c == term) nest--; } break; case -100: regx_end: for (;;) { switch (c = nextc()) { case 'i': options |= RegexOptions.IgnoreCase; break; case 'x': options |= RegexOptions.IgnorePatternWhitespace; break; case 'p': /* /p is obsolete */ ruby.warn("/p option is obsolete; use /m\n\tnote: /m does not change ^, $ behavior"); break; case 'm': options |= RegexOptions.Multiline; break; case 'o': once = true; break; case 'n': kcode = '\x16'; break; case 'e': kcode = '\x32'; break; case 's': kcode = '\x48'; break; case 'u': kcode = '\x64'; break; default: pushback(c); goto end_options; } } end_options: lex_state = EXPR.END; if (list != null) { list.SetLine(re_start); if (toklen() > 0) { RNode.list_append(thread, list, new RNStr(thread, ruby, tok())); } if (once) list = new RNDRegxOnce(list); else list = new RNDRegx(list); list.cflag = (uint)options | (uint)kcode; yylval = list; return Token.tDREGEXP; } else { yylval = RRegexpClass.s_new(ruby.cRegexp, tok(), options); return Token.tREGEXP; } } tokadd(c); } unterminated: thread.line = re_start; thread.CompileError("unterminated regexp meets end of file"); return 0; }
public void SetTestExpression(EXPR value) { TestExpression = value; }
public void SetArgument(EXPR expr) { Argument = expr; }
public ExpressionIterator(EXPR pExpr) { Init(pExpr); }
public void SetRHS(EXPR value) { _RHS = value; }
int here_document(int term, int indent) { int c; string line = String.Empty; RNode list = null; int linesave = thread.line; newtok(); switch (term) { case '\'': goto case '`'; case '"': goto case '`'; case '`': while ((c = nextc()) != term) { tokadd(c); } if (term == '\'') term = '\0'; break; default: c = term; term = '"'; if (!is_identchar(c)) { ruby.warn("use of bare << to mean <<\"\" is deprecated"); break; } while (is_identchar(c)) { tokadd(c); c = nextc(); } pushback(c); break; } string lastline_save = lastline; int offset_save = pcur - pbeg; string eos = string.Copy(tok()); int len = eos.Length; string str = String.Empty; for (;;) { lastline = line = getline(); if (line == null) { thread.line = linesave; thread.CompileError("can't find string \"" + eos + "\" anywhere before EOF"); return 0; } thread.line++; string p = line; if (indent > 0) { while (p.Length > 0 && (p[0] == ' ' || p[0] == '\t')) { p = p.Substring(1); } } if (String.Compare(eos, 0, p, 0, len) == 0) { if (p[len] == '\n' || p[len] == '\r') break; if (len == line.Length) break; } pbeg = pcur = 0; pend = pcur + line.Length; retry: switch (parse_string(term, '\n', '\n')) { case Token.tSTRING: // fall down to the next case case Token.tXSTRING: { yylval = (string)yylval + "\n"; } if (list == null) { str += (string)yylval; } else { RNode.list_append(thread, list, new RNStr(thread, ruby, (string)yylval)); } break; case Token.tDSTRING: if (list == null) list = new RNDStr(thread, ruby, str); goto case Token.tDXSTRING; case Token.tDXSTRING: if (list == null) list = new RNDXStr(thread, ruby, str); RNode.list_append(thread, (RNode)yylval, new RNStr(thread, ruby, "\n")); RNStr val = new RNStr((RNStr)yylval); yylval = new RNArray(thread, val); ((RNode)yylval).next = ((RNode)yylval).head.next; RNode.list_concat(list, (RNode)yylval); break; case 0: thread.line = linesave; thread.CompileError("can't find string \"" + eos + "\" anywhere before EOF"); return 0; } if (pcur != pend) { goto retry; } } lastline = lastline_save; pbeg = 0; pend = lastline.Length; pcur = offset_save; lex_state = EXPR.END; heredoc_end = thread.line; thread.line = linesave; if (list != null) { list.SetLine(linesave+1); yylval = list; } switch (term) { case '\0': goto case '"'; case '\'': goto case '"'; case '"': if (list != null) return Token.tDSTRING; yylval = str; return Token.tSTRING; case '`': if (list != null) return Token.tDXSTRING; yylval = str; return Token.tXSTRING; } return 0; }
private int yylex() { bool space_seen = false; kwtable kw; retry: int c = nextc(); switch (c) { case '\0': /* NUL */ case '\x0004': /* ^D */ case '\x001a': /* ^Z */ case -1: /* end of script. */ return 0; /* white spaces */ case ' ': case '\t': case '\f': case '\r': case '\v': space_seen = true; goto retry; case '#': /* it's a comment */ while ((c = nextc()) != '\n') { if (c == -1) return 0; } /* fall through */ goto case '\n'; case '\n': switch (lex_state) { case EXPR.BEG: case EXPR.FNAME: case EXPR.DOT: goto retry; default: break; } lex_state = EXPR.BEG; return '\n'; case '*': if ((c = nextc()) == '*') { lex_state = EXPR.BEG; if (nextc() == '=') { yylval = Token.tPOW; return Token.tOP_ASGN; } pushback(c); return Token.tPOW; } if (c == '=') { yylval = (int)'*'; lex_state = EXPR.BEG; return Token.tOP_ASGN; } pushback(c); if (lex_state == EXPR.ARG && space_seen && Char.IsWhiteSpace((char)c) == false) { ruby.warning("`*' interpreted as argument prefix"); c = Token.tSTAR; } else if (lex_state == EXPR.BEG || lex_state == EXPR.MID) { c = Token.tSTAR; } else { c = '*'; } lex_state = EXPR.BEG; return c; case '!': lex_state = EXPR.BEG; if ((c = nextc()) == '=') { return Token.tNEQ; } if (c == '~') { return Token.tNMATCH; } pushback(c); return '!'; case '=': if (pcur == pbeg + 1) { /* skip embedded rd document */ if (String.Compare(lastline, pcur, "begin", 0, 5) == 0 && Char.IsWhiteSpace(lastline[pcur + 5])) { for (;;) { pcur = pend; c = nextc(); if (c == -1) { thread.CompileError("embedded document meets end of file"); return 0; } if (c != '=') continue; if (String.Compare(lastline, pcur, "end", 0, 3) == 0 && Char.IsWhiteSpace(lastline[pcur + 3])) { break; } } pcur = pend; goto retry; } } lex_state = EXPR.BEG; if ((c = nextc()) == '=') { if ((c = nextc()) == '=') { return Token.tEQQ; } pushback(c); return Token.tEQ; } if (c == '~') { return Token.tMATCH; } else if (c == '>') { return Token.tASSOC; } pushback(c); return '='; case '<': c = nextc(); if (c == '<' && lex_state != EXPR.END && lex_state != EXPR.CLASS && (lex_state != EXPR.ARG || space_seen)) { int c2 = nextc(); int indent = 0; if (c2 == '-') { indent = 1; c2 = nextc(); } if (Char.IsWhiteSpace((char)c2) && "\"'`".IndexOf((char)c2) > 0 || is_identchar(c2)) { return here_document(c2, indent); } pushback(c2); } lex_state = EXPR.BEG; if (c == '=') { if ((c = nextc()) == '>') { return Token.tCMP; } pushback(c); return Token.tLEQ; } if (c == '<') { if (nextc() == '=') { yylval = Token.tLSHFT; return Token.tOP_ASGN; } pushback(c); return Token.tLSHFT; } pushback(c); return '<'; case '>': lex_state = EXPR.BEG; if ((c = nextc()) == '=') { return Token.tGEQ; } if (c == '>') { if ((c = nextc()) == '=') { yylval = Token.tRSHFT; return Token.tOP_ASGN; } pushback(c); return Token.tRSHFT; } pushback(c); return '>'; case '"': return parse_string(c,c,c); case '`': if (lex_state == EXPR.FNAME) return c; if (lex_state == EXPR.DOT) return c; return parse_string(c,c,c); case '\'': return parse_qstring(c,0); case '?': if (lex_state == EXPR.END) { lex_state = EXPR.BEG; return '?'; } c = nextc(); if (c == -1) { thread.CompileError("incomplete character syntax"); return 0; } if (lex_state == EXPR.ARG && Char.IsWhiteSpace((char)c)) { pushback(c); lex_state = EXPR.BEG; return '?'; } if (c == '\\') { c = read_escape(); } c &= 0xff; yylval = c; //INT2FIX(c); lex_state = EXPR.END; return Token.tINTEGER; case '&': if ((c = nextc()) == '&') { lex_state = EXPR.BEG; if ((c = nextc()) == '=') { yylval = Token.tANDOP; return Token.tOP_ASGN; } pushback(c); return Token.tANDOP; } else if (c == '=') { yylval = (int)'&'; lex_state = EXPR.BEG; return Token.tOP_ASGN; } pushback(c); if (lex_state == EXPR.ARG && space_seen && Char.IsWhiteSpace((char)c) == false) { ruby.warning("`&' interpreted as argument prefix"); c = Token.tAMPER; } else if (lex_state == EXPR.BEG || lex_state == EXPR.MID) { c = Token.tAMPER; } else { c = '&'; } lex_state = EXPR.BEG; return c; case '|': lex_state = EXPR.BEG; if ((c = nextc()) == '|') { if ((c = nextc()) == '=') { yylval = Token.tOROP; return Token.tOP_ASGN; } pushback(c); return Token.tOROP; } else if (c == '=') { yylval = (int)'|'; return Token.tOP_ASGN; } pushback(c); return '|'; case '+': c = nextc(); if (lex_state == EXPR.FNAME || lex_state == EXPR.DOT) { if (c == '@') { return Token.tUPLUS; } pushback(c); return '+'; } if (c == '=') { lex_state = EXPR.BEG; yylval = (int)'+'; return Token.tOP_ASGN; } if (lex_state == EXPR.BEG || lex_state == EXPR.MID || (lex_state == EXPR.ARG && space_seen && Char.IsWhiteSpace((char)c) == false)) { if (lex_state == EXPR.ARG) arg_ambiguous(); lex_state = EXPR.BEG; pushback(c); if (Char.IsDigit((char)c)) { c = '+'; goto start_num; } return Token.tUPLUS; } lex_state = EXPR.BEG; pushback(c); return '+'; case '-': c = nextc(); if (lex_state == EXPR.FNAME || lex_state == EXPR.DOT) { if (c == '@') { return Token.tUMINUS; } pushback(c); return '-'; } if (c == '=') { lex_state = EXPR.BEG; yylval = (int)'-'; return Token.tOP_ASGN; } if (lex_state == EXPR.BEG || lex_state == EXPR.MID || (lex_state == EXPR.ARG && space_seen && Char.IsWhiteSpace((char)c) == false)) { if (lex_state == EXPR.ARG) arg_ambiguous(); lex_state = EXPR.BEG; pushback(c); if (Char.IsDigit((char)c)) { c = '-'; goto start_num; } return Token.tUMINUS; } lex_state = EXPR.BEG; pushback(c); return '-'; case '.': lex_state = EXPR.BEG; if ((c = nextc()) == '.') { if ((c = nextc()) == '.') { return Token.tDOT3; } pushback(c); return Token.tDOT2; } pushback(c); if (!Char.IsDigit((char)c)) { lex_state = EXPR.DOT; return '.'; } c = '.'; /* fall through */ start_num: goto case '9'; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': { bool is_float = false; bool seen_point = false; bool seen_e = false; bool seen_uc = false; lex_state = EXPR.END; newtok(); if (c == '-' || c == '+') { tokadd(c); c = nextc(); } if (c == '0') { c = nextc(); if (c == 'x' || c == 'X') { /* hexadecimal */ c = nextc(); do { if (c == '_') { seen_uc = true; continue; } if (!ISXDIGIT((char)c)) break; seen_uc = false; tokadd(c); } while ((c = nextc()) > 0); pushback(c); if (toklen() == 0) { parser.yyerror("hexadecimal number without hex-digits"); } else if (seen_uc) goto trailing_uc; yylval = RInteger.StringToInteger(ruby, tok(), 16); return Token.tINTEGER; } if (c == 'b' || c == 'B') { /* binary */ c = nextc(); do { if (c == '_') { seen_uc = true; continue; } if (c != '0'&& c != '1') break; seen_uc = false; tokadd(c); } while ((c = nextc()) > 0); pushback(c); if (toklen() == 0) { parser.yyerror("numeric literal without digits"); } else if (seen_uc) goto trailing_uc; yylval = RInteger.StringToInteger(ruby, tok(), 2); return Token.tINTEGER; } if (c >= '0' && c <= '7' || c == '_') { /* octal */ do { if (c == '_') { seen_uc = true; continue; } if (c < '0' || c > '7') break; seen_uc = false; tokadd(c); } while ((c = nextc()) > 0); pushback(c); if (seen_uc) goto trailing_uc; yylval = RInteger.StringToInteger(ruby, tok(), 8); return Token.tINTEGER; } if (c > '7' && c <= '9') { parser.yyerror("Illegal octal digit"); } else if (c == '.') { tokadd('0'); } else { pushback(c); yylval = 0; //INT2FIX(0); return Token.tINTEGER; } } for (;;) { switch (c) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': seen_uc = false; tokadd(c); break; case '.': if (seen_uc) goto trailing_uc; if (seen_point || seen_e) { goto decode_num; } else { int c0 = nextc(); if (!Char.IsDigit((char)c0)) { pushback(c0); goto decode_num; } c = c0; } tokadd('.'); tokadd(c); is_float = true; seen_point = true; seen_uc = false; break; case 'e': case 'E': if (seen_e) { goto decode_num; } tokadd(c); seen_e = true; is_float = true; while ((c = nextc()) == '_') seen_uc = true; if (c == '-' || c == '+') tokadd(c); else continue; break; case '_': /* `_' in number just ignored */ seen_uc = true; break; default: goto decode_num; } c = nextc(); } decode_num: pushback(c); trailing_uc: if (seen_uc) { parser.yyerror("trailing `_' in number"); } if (is_float) { double d = 0.0; try { d = Convert.ToDouble(tok()); } catch (OverflowException) { ruby.warn("Float {0} out of range", tok()); } yylval = d; return Token.tFLOAT; } yylval = RInteger.StringToInteger(ruby, tok(), 0); return Token.tINTEGER; } case ']': case '}': lex_state = EXPR.END; return c; case ')': if (cond_nest > 0) { cond_stack >>= 1; } lex_state = EXPR.END; return c; case ':': c = nextc(); if (c == ':') { if (lex_state == EXPR.BEG || lex_state == EXPR.MID || (lex_state == EXPR.ARG && space_seen)) { lex_state = EXPR.BEG; return Token.tCOLON3; } lex_state = EXPR.DOT; return Token.tCOLON2; } pushback(c); if (lex_state == EXPR.END || Char.IsWhiteSpace((char)c)) { lex_state = EXPR.BEG; return ':'; } lex_state = EXPR.FNAME; return Token.tSYMBEG; case '/': if (lex_state == EXPR.BEG || lex_state == EXPR.MID) { return parse_regx('/', '/'); } if ((c = nextc()) == '=') { lex_state = EXPR.BEG; yylval = (int)'/'; return Token.tOP_ASGN; } pushback(c); if (lex_state == EXPR.ARG && space_seen) { if (!Char.IsWhiteSpace((char)c)) { arg_ambiguous(); return parse_regx('/', '/'); } } lex_state = EXPR.BEG; return '/'; case '^': lex_state = EXPR.BEG; if ((c = nextc()) == '=') { yylval = (int)'^'; return Token.tOP_ASGN; } pushback(c); return '^'; case ',': case ';': lex_state = EXPR.BEG; return c; case '~': if (lex_state == EXPR.FNAME || lex_state == EXPR.DOT) { if ((c = nextc()) != '@') { pushback(c); } } lex_state = EXPR.BEG; return '~'; case '(': if (cond_nest > 0) { cond_stack = (cond_stack<<1)|0; } if (lex_state == EXPR.BEG || lex_state == EXPR.MID) { c = Token.tLPAREN; } else if (lex_state == EXPR.ARG && space_seen) { ruby.warning(tok() + " (...) interpreted as method call", tok()); } lex_state = EXPR.BEG; return c; case '[': if (lex_state == EXPR.FNAME || lex_state == EXPR.DOT) { if ((c = nextc()) == ']') { if ((c = nextc()) == '=') { return Token.tASET; } pushback(c); return Token.tAREF; } pushback(c); return '['; } else if (lex_state == EXPR.BEG || lex_state == EXPR.MID) { c = Token.tLBRACK; } else if (lex_state == EXPR.ARG && space_seen) { c = Token.tLBRACK; } lex_state = EXPR.BEG; return c; case '{': if (lex_state != EXPR.END && lex_state != EXPR.ARG) c = Token.tLBRACE; lex_state = EXPR.BEG; return c; case '\\': c = nextc(); if (c == '\n') { space_seen = true; goto retry; /* skip \\n */ } pushback(c); return '\\'; case '%': if (lex_state == EXPR.BEG || lex_state == EXPR.MID) { c = nextc(); return quotation(c); } if ((c = nextc()) == '=') { yylval = (int)'%'; return Token.tOP_ASGN; } if (lex_state == EXPR.ARG && space_seen && Char.IsWhiteSpace((char)c) == false) { return quotation(c); } lex_state = EXPR.BEG; pushback(c); return '%'; case '$': lex_state = EXPR.END; newtok(); c = nextc(); switch (c) { case '_': /* $_: last read line string */ c = nextc(); if (is_identchar(c)) { tokadd('$'); tokadd('_'); break; } pushback(c); c = '_'; goto case '~'; /* fall through */ case '~': /* $~: match-data */ thread.LocalCnt((uint)c); goto case '*'; /* fall through */ case '*': /* $*: argv */ case '$': /* $$: pid */ case '?': /* $?: last status */ case '!': /* $!: error string */ case '@': /* $@: error position */ case '/': /* $/: input record separator */ case '\\': /* $\: output record separator */ case ';': /* $;: field separator */ case ',': /* $,: output field separator */ case '.': /* $.: last read line number */ case '=': /* $=: ignorecase */ case ':': /* $:: load path */ case '<': /* $<: reading filename */ case '>': /* $>: default output handle */ case '\"': /* $": already loaded files */ tokadd('$'); tokadd(c); yylval = ruby.intern(tok()); return Token.tGVAR; case '-': tokadd('$'); tokadd(c); c = nextc(); tokadd(c); yylval = ruby.intern(tok()); /* xxx shouldn't check if valid option variable */ return Token.tGVAR; case '&': /* $&: last match */ case '`': /* $`: string before last match */ case '\'': /* $': string after last match */ case '+': /* $+: string matches last paren. */ yylval = new RNBackRef(thread, c); return Token.tBACK_REF; case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': tokadd('$'); while (Char.IsDigit((char)c)) { tokadd(c); c = nextc(); } if (is_identchar(c)) break; pushback(c); yylval = new RNNthRef(thread, Convert.ToInt32(tok().Substring(1))); return Token.tNTH_REF; default: if (!is_identchar(c)) { pushback(c); return '$'; } goto case '0'; case '0': tokadd('$'); break; } break; case '@': c = nextc(); newtok(); tokadd('@'); if (c == '@') { tokadd('@'); c = nextc(); } if (Char.IsDigit((char)c)) { thread.CompileError(String.Format("`@{0}' is not a valid instance variable name", c)); } if (!is_identchar(c)) { pushback(c); return '@'; } break; default: if (!is_identchar(c) || Char.IsDigit((char)c)) { thread.CompileError(String.Format("Invalid char `0x{0:x2}' in expression", c)); goto retry; } newtok(); break; } while (is_identchar(c)) { tokadd(c); #if NONE_UCS2 if (ismbchar(c)) { int i, len = mbclen(c)-1; for (i = 0; i < len; i++) { c = nextc(); tokadd(c); } } #endif c = nextc(); } if ((c == '!' || c == '?') && is_identchar(tok()[0]) && !peek('=')) { tokadd(c); } else { pushback(c); } { int result = 0; switch (tok()[0]) { case '$': lex_state = EXPR.END; result = Token.tGVAR; break; case '@': lex_state = EXPR.END; if (tok()[1] == '@') result = Token.tCVAR; else result = Token.tIVAR; break; default: if (lex_state != EXPR.DOT) { /* See if it is a reserved word. */ kw = reserved_word(tok(), toklen()); if (kw.name != null) { EXPR state = lex_state; lex_state = kw.state; if (state == EXPR.FNAME) { yylval = ruby.intern(kw.name); } if (kw[0] == Token.kDO) { if (COND_P()) return Token.kDO_COND; if (CMDARG_P()) return Token.kDO_BLOCK; return Token.kDO; } if (state == EXPR.BEG) return kw[0]; else { if (kw[0] != kw[1]) lex_state = EXPR.BEG; return kw[1]; } } } if (toklast() == '!' || toklast() == '?') { result = Token.tFID; } else { if (lex_state == EXPR.FNAME) { if ((c = nextc()) == '=' && !peek('~') && !peek('>') && (!peek('=') || pcur + 1 < pend && lastline[pcur + 1] == '>')) { result = Token.tIDENTIFIER; tokadd(c); } else { pushback(c); } } if (result == 0 && Char.IsUpper(tok()[0])) { result = Token.tCONSTANT; } else { result = Token.tIDENTIFIER; } } if (lex_state == EXPR.BEG || lex_state == EXPR.DOT || lex_state == EXPR.ARG) { lex_state = EXPR.ARG; } else { lex_state = EXPR.END; } break; } yylval = ruby.intern(tok()); return result; } }
int parse_quotedwords(int term, int paren) { RNode qwords = null; int strstart = thread.line; int c; int nest = 0; newtok(); for (c = nextc(); Char.IsWhiteSpace((char)c); c = nextc()) ; /* skip preceding spaces */ pushback(c); while ((c = nextc()) != term || nest > 0) { if (c == -1) { thread.line = strstart; thread.CompileError("unterminated string meets end of file"); return 0; } /* if (ismbchar(c)) { int i, len = mbclen(c)-1; for (i = 0; i < len; i++) { tokadd(c); c = nextc(); } } */ else if (c == '\\') { c = nextc(); switch (c) { case '\n': continue; case '\\': c = '\\'; break; default: if (c == term) { tokadd(c); continue; } if (!Char.IsWhiteSpace((char)c)) tokadd('\\'); break; } } else if (Char.IsWhiteSpace((char)c)) { RNode str = new RNStr(thread, ruby, tok()); newtok(); if (qwords == null) qwords = new RNArray(thread, str); else RNode.list_append(thread, qwords, str); for (c = nextc(); Char.IsWhiteSpace((char)c); c = nextc()) ; /* skip continuous spaces */ pushback(c); continue; } if (paren != 0) { if (c == paren) nest++; if (c == term && nest-- == 0) break; } tokadd(c); } if (toklen() > 0) { RNode str = new RNStr(thread, ruby, tok()); if (qwords == null) qwords = new RNArray(thread, str); else RNode.list_append(thread, qwords, str); } if (qwords == null) qwords = new RNZArray(thread); yylval = qwords; lex_state = EXPR.END; return Token.tDSTRING; }
int parse_qstring(int term, int paren) { int c; int nest = 0; int strstart = thread.line; newtok(); while ((c = nextc()) != term || nest > 0) { if (c == -1) { thread.line = strstart; thread.CompileError("unterminated string meets end of file"); return 0; } /* if (ismbchar(c)) { int i, len = mbclen(c)-1; for (i = 0; i < len; i++) { tokadd(c); c = nextc(); } } */ else if (c == '\\') { c = nextc(); switch (c) { case '\n': continue; case '\\': c = '\\'; break; case '\'': if (term == '\'') { c = '\''; break; } goto default; default: tokadd('\\'); break; } } if (paren != 0) { if (c == paren) nest++; if (c == term && nest-- == 0) break; } tokadd(c); } yylval = tok(); lex_state = EXPR.END; return Token.tSTRING; }
int parse_string(int func, int term, int paren) { int c; RNode list = null; int strstart; int nest = 0; if (func == '\'') { return parse_qstring(term, paren); } if (func == 0) { /* read 1 line for heredoc */ /* -1 for chomp */ yylval = lastline.Substring(pbeg, pend - pbeg - 1); pcur = pend; return Token.tSTRING; } strstart = thread.line; newtok(); while ((c = nextc()) != term || nest > 0) { if (c == -1) { thread.line = strstart; thread.CompileError("unterminated string meets end of file"); return 0; } /* if (ismbchar(c)) { int i, len = mbclen(c)-1; for (i = 0; i < len; i++) { tokadd(c); c = nextc(); } } */ else if (c == '#') { list = str_extend(list, term); if (list is RNEOF) { thread.line = strstart; thread.CompileError("unterminated string meets end of file"); return 0; } continue; } else if (c == '\\') { c = nextc(); if (c == '\n') continue; if (c == term) { tokadd(c); } else { pushback(c); if (func != '"') tokadd('\\'); tokadd(read_escape()); } continue; } if (paren != 0) { if (c == paren) nest++; if (c == term && nest-- == 0) break; } tokadd(c); } lex_state = EXPR.END; if (list != null) { list.SetLine(strstart); if (toklen() > 0) { RNode.list_append(thread, list, new RNStr(thread, ruby, tok())); } yylval = list; if (func == '`') { yylval = new RNDXStr(list); return Token.tDXSTRING; } else { return Token.tDSTRING; } } else { yylval = tok(); return (func == '`') ? Token.tXSTRING : Token.tSTRING; } }
public void SetLHS(EXPR value) { LHS = value; }
public void SetIndex(EXPR value) { _Index = value; }
public void SetSecondArgument(EXPR value) { SecondArgument = value; }
public void SetArray(EXPR value) { _Array = value; }
public void SetOptionalElement(EXPR value) { OptionalElement = value; }
public void SetSecondArgument(EXPR value) { SecondArgument = value; }
public void SetOptionalArgumentDimensions(EXPR value) { _OptionalArgumentDimensions = value; }
public void SetArray(EXPR value) { _Array = value; }
public void SetFirstArgument(EXPR value) { FirstArgument = value; }
internal kwtable(string s, int i0, int i1, EXPR st) { name = s; id0 = i0; id1 = i1; state = st; }
public void SetOptionalExpression(EXPR value) { OptionalExpression = value; }
public void SetOptionalLeftChild(EXPR value) { _OptionalLeftChild = value; }
public void SetIndex(EXPR value) { _Index = value; }
public void SetOptionalUserDefinedCall(EXPR value) { _OptionalUserDefinedCall = value; }
public void SetOptionalRightChild(EXPR value) { _OptionalRightChild = value; }
public void SetOptionalArgumentDimensions(EXPR value) { _OptionalArgumentDimensions = value; }
public void SetLeft(EXPR value) { Left = value; }
public void SetOptionalNextListNode(EXPR value) { OptionalNextListNode = value; }
//------------------------------------------------------------ // FUNCBREC.RecurseAndRewriteExprTree // /// <summary> /// Recursively walks the expr tree, making type substitutions and /// rewriting the tree using the provided call-back function pointer /// </summary> /// <param name="expr"></param> /// <param name="rwInfo"></param> //------------------------------------------------------------ internal void RecurseAndRewriteExprTree(ref EXPR firstExpr, RewriteInfo rwInfo) { DebugUtil.Assert(rwInfo != null); if (firstExpr == null) { return; } EXPR expr = firstExpr; EXPR prevExpr = null; //bool updateFirstExpr = false; EXPR tempExpr = null; LRepeat: EXPRSTMT nextStmtExpr = null; if (expr.Kind < EXPRKIND.StmtLim) { // Process each in isolation. nextStmtExpr = (expr as EXPRSTMT).NextStatement; (expr as EXPRSTMT).NextStatement = null; // An unreachable switch means that the switch expression is a constant, // so at least one of the switch labels is reachable. // Thus we need to process the switch. if (!(expr as EXPRSTMT).Reachable() && expr.Kind != EXPRKIND.SWITCH) { expr = nextStmtExpr; if (expr == null) { return; } goto LRepeat; } } //-------------------------------------------------------- // Call out to do 2 things: // * transform this expr if needed // * find out if we need to recurse into this expr (post-transform) //-------------------------------------------------------- if (rwInfo.RewriteFunc(this, ref expr)) { //---------------------------------------------------- // Substitue all the types // NOTE: the order of type substitution is based on // the declaration order, so expr->type is last //---------------------------------------------------- if (TypeArray.Size(classTypeVariablesForMethod) > 0) { switch (expr.Kind) { default: DebugUtil.Assert(expr.Kind > EXPRKIND.COUNT); DebugUtil.Assert((expr.Flags & EXPRFLAG.BINOP) != 0); goto WALK_TYPE_EXPRBINOP; WALK_BASE_TYPE_EXPRSTMT: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRSTMT: goto WALK_BASE_TYPE_EXPRSTMT; case EXPRKIND.BINOP: goto WALK_TYPE_EXPRBINOP; WALK_BASE_TYPE_EXPRBINOP: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRBINOP: goto WALK_BASE_TYPE_EXPRBINOP; case EXPRKIND.USERLOGOP: goto WALK_TYPE_EXPRUSERLOGOP; WALK_BASE_TYPE_EXPRUSERLOGOP: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRUSERLOGOP: goto WALK_BASE_TYPE_EXPRUSERLOGOP; case EXPRKIND.DBLQMARK: goto WALK_TYPE_EXPRDBLQMARK; WALK_BASE_TYPE_EXPRDBLQMARK: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRDBLQMARK: goto WALK_BASE_TYPE_EXPRDBLQMARK; case EXPRKIND.TYPEOF: goto WALK_TYPE_EXPRTYPEOF; WALK_BASE_TYPE_EXPRTYPEOF: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRTYPEOF: //(static_cast<EXPRTYPEOF*>(*expr)).sourceType = compiler().getBSymmgr().SubstType( // (static_cast<EXPRTYPEOF*>(*expr)).sourceType, // (TypeArray*)null, // taClsVarsForMethVars).PARENTSYM::asTYPESYM (); // PARENTSYM does not have its own asTYPESYM(), // so we have no occasion to call PARENTSYM::asTYPESYM () ? (expr as EXPRTYPEOF).SourceTypeSym = compiler.MainSymbolManager.SubstType( (expr as EXPRTYPEOF).SourceTypeSym, (TypeArray)null, this.classTypeVariablesForMethod, SubstTypeFlagsEnum.NormNone) as TYPESYM; goto WALK_BASE_TYPE_EXPRTYPEOF; case EXPRKIND.SIZEOF: goto WALK_TYPE_EXPRSIZEOF; WALK_BASE_TYPE_EXPRSIZEOF: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRSIZEOF: //(static_cast<EXPRSIZEOF*>(*expr)).sourceType = compiler().getBSymmgr().SubstType( // (static_cast<EXPRSIZEOF*>(*expr)).sourceType, // (TypeArray*)null, // taClsVarsForMethVars).PARENTSYM::asTYPESYM (); (expr as EXPRSIZEOF).SourceTypeSym = compiler.MainSymbolManager.SubstType( (expr as EXPRSIZEOF).SourceTypeSym, (TypeArray)null, this.classTypeVariablesForMethod, SubstTypeFlagsEnum.NormNone) as TYPESYM; goto WALK_BASE_TYPE_EXPRSIZEOF; case EXPRKIND.CAST: goto WALK_TYPE_EXPRCAST; WALK_BASE_TYPE_EXPRCAST: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRCAST: goto WALK_BASE_TYPE_EXPRCAST; case EXPRKIND.ZEROINIT: goto WALK_TYPE_EXPRZEROINIT; WALK_BASE_TYPE_EXPRZEROINIT: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRZEROINIT: goto WALK_BASE_TYPE_EXPRZEROINIT; case EXPRKIND.BLOCK: goto WALK_TYPE_EXPRBLOCK; WALK_BASE_TYPE_EXPRBLOCK: goto WALK_TYPE_EXPRSTMT; WALK_TYPE_EXPRBLOCK: goto WALK_BASE_TYPE_EXPRBLOCK; case EXPRKIND.STMTAS: goto WALK_TYPE_EXPRSTMTAS; WALK_BASE_TYPE_EXPRSTMTAS: goto WALK_TYPE_EXPRSTMT; WALK_TYPE_EXPRSTMTAS: goto WALK_BASE_TYPE_EXPRSTMTAS; case EXPRKIND.MEMGRP: goto WALK_TYPE_EXPRMEMGRP; WALK_BASE_TYPE_EXPRMEMGRP: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRMEMGRP: //(static_cast<EXPRMEMGRP*>(*expr)).typeArgs = compiler().getBSymmgr().SubstTypeArray( // (static_cast<EXPRMEMGRP*>(*expr)).typeArgs, // (TypeArray*)null, // taClsVarsForMethVars); //(static_cast<EXPRMEMGRP*>(*expr)).typePar = compiler().getBSymmgr().SubstType( // (static_cast<EXPRMEMGRP*>(*expr)).typePar, // (TypeArray*)null, // taClsVarsForMethVars).PARENTSYM::asTYPESYM (); //(static_cast<EXPRMEMGRP*>(*expr)).types = compiler().getBSymmgr().SubstTypeArray( // (static_cast<EXPRMEMGRP*>(*expr)).types, // (TypeArray*)null, // taClsVarsForMethVars); (expr as EXPRMEMGRP).TypeArguments = compiler.MainSymbolManager.SubstTypeArray( (expr as EXPRMEMGRP).TypeArguments, (TypeArray)null, this.classTypeVariablesForMethod, SubstTypeFlagsEnum.NormNone); (expr as EXPRMEMGRP).ParentTypeSym = compiler.MainSymbolManager.SubstType( (expr as EXPRMEMGRP).ParentTypeSym, (TypeArray)null, this.classTypeVariablesForMethod, SubstTypeFlagsEnum.NormNone) as TYPESYM; (expr as EXPRMEMGRP).ContainingTypeArray = compiler.MainSymbolManager.SubstTypeArray( (expr as EXPRMEMGRP).ContainingTypeArray, (TypeArray)null, this.classTypeVariablesForMethod, SubstTypeFlagsEnum.NormNone); goto WALK_BASE_TYPE_EXPRMEMGRP; case EXPRKIND.CALL: goto WALK_TYPE_EXPRCALL; WALK_BASE_TYPE_EXPRCALL: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRCALL: //(static_cast<EXPRCALL*>(*expr)).mwi.typeArgs = compiler().getBSymmgr().SubstTypeArray( // (static_cast<EXPRCALL*>(*expr)).mwi.typeArgs, // (TypeArray*)null, // taClsVarsForMethVars); //(static_cast<EXPRCALL*>(*expr)).mwi.ats = compiler().getBSymmgr().SubstType( // (static_cast<EXPRCALL*>(*expr)).mwi.ats, // (TypeArray*)null, // taClsVarsForMethVars).asAGGTYPESYM(); (expr as EXPRCALL).MethodWithInst.TypeArguments = compiler.MainSymbolManager.SubstTypeArray( (expr as EXPRCALL).MethodWithInst.TypeArguments, (TypeArray)null, this.classTypeVariablesForMethod, SubstTypeFlagsEnum.NormNone); (expr as EXPRCALL).MethodWithInst.AggTypeSym = compiler.MainSymbolManager.SubstType( (expr as EXPRCALL).MethodWithInst.AggTypeSym, (TypeArray)null, this.classTypeVariablesForMethod, SubstTypeFlagsEnum.NormNone) as AGGTYPESYM; goto WALK_BASE_TYPE_EXPRCALL; case EXPRKIND.PROP: goto WALK_TYPE_EXPRPROP; WALK_BASE_TYPE_EXPRPROP: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRPROP: //(static_cast<EXPRPROP*>(*expr)).pwtSlot.ats = compiler().getBSymmgr().SubstType( // (static_cast<EXPRPROP*>(*expr)).pwtSlot.ats, // (TypeArray*)null, // taClsVarsForMethVars).asAGGTYPESYM(); //(static_cast<EXPRPROP*>(*expr)).mwtGet.ats = compiler().getBSymmgr().SubstType( // (static_cast<EXPRPROP*>(*expr)).mwtGet.ats, // (TypeArray*)null, // taClsVarsForMethVars).asAGGTYPESYM(); //(static_cast<EXPRPROP*>(*expr)).mwtSet.ats = compiler().getBSymmgr().SubstType( // (static_cast<EXPRPROP*>(*expr)).mwtSet.ats, // (TypeArray*)null, // taClsVarsForMethVars).asAGGTYPESYM(); (expr as EXPRPROP).SlotPropWithType.AggTypeSym = compiler.MainSymbolManager.SubstType( (expr as EXPRPROP).SlotPropWithType.AggTypeSym, (TypeArray)null, this.classTypeVariablesForMethod, SubstTypeFlagsEnum.NormNone) as AGGTYPESYM; (expr as EXPRPROP).GetMethodWithType.AggTypeSym = compiler.MainSymbolManager.SubstType( (expr as EXPRPROP).GetMethodWithType.AggTypeSym, (TypeArray)null, this.classTypeVariablesForMethod, SubstTypeFlagsEnum.NormNone) as AGGTYPESYM; (expr as EXPRPROP).SetMethodWithType.AggTypeSym = compiler.MainSymbolManager.SubstType( (expr as EXPRPROP).SetMethodWithType.AggTypeSym, (TypeArray)null, this.classTypeVariablesForMethod, SubstTypeFlagsEnum.NormNone) as AGGTYPESYM; goto WALK_BASE_TYPE_EXPRPROP; case EXPRKIND.FIELD: goto WALK_TYPE_EXPRFIELD; WALK_BASE_TYPE_EXPRFIELD: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRFIELD: //(static_cast<EXPRFIELD*>(*expr)).fwt.ats = compiler().getBSymmgr().SubstType( // (static_cast<EXPRFIELD*>(*expr)).fwt.ats, // (TypeArray*)null, // taClsVarsForMethVars).asAGGTYPESYM(); (expr as EXPRFIELD).FieldWithType.AggTypeSym = compiler.MainSymbolManager.SubstType( (expr as EXPRFIELD).FieldWithType.AggTypeSym, (TypeArray)null, this.classTypeVariablesForMethod, SubstTypeFlagsEnum.NormNone) as AGGTYPESYM; goto WALK_BASE_TYPE_EXPRFIELD; case EXPRKIND.EVENT: goto WALK_TYPE_EXPREVENT; WALK_BASE_TYPE_EXPREVENT: goto WALK_TYPE_EXPR; WALK_TYPE_EXPREVENT: //(static_cast<EXPREVENT*>(*expr)).ewt.ats = compiler().getBSymmgr().SubstType( // (static_cast<EXPREVENT*>(*expr)).ewt.ats, // (TypeArray*)null, // taClsVarsForMethVars).asAGGTYPESYM(); (expr as EXPREVENT).EventWithType.AggTypeSym = compiler.MainSymbolManager.SubstType( (expr as EXPREVENT).EventWithType.AggTypeSym, (TypeArray)null, this.classTypeVariablesForMethod, SubstTypeFlagsEnum.NormNone) as AGGTYPESYM; goto WALK_BASE_TYPE_EXPREVENT; case EXPRKIND.DECL: goto WALK_TYPE_EXPRDECL; WALK_BASE_TYPE_EXPRDECL: goto WALK_TYPE_EXPRSTMT; WALK_TYPE_EXPRDECL: goto WALK_BASE_TYPE_EXPRDECL; case EXPRKIND.LOCAL: goto WALK_TYPE_EXPRLOCAL; WALK_BASE_TYPE_EXPRLOCAL: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRLOCAL: goto WALK_BASE_TYPE_EXPRLOCAL; case EXPRKIND.RETURN: goto WALK_TYPE_EXPRRETURN; WALK_BASE_TYPE_EXPRRETURN: goto WALK_TYPE_EXPRSTMT; WALK_TYPE_EXPRRETURN: goto WALK_BASE_TYPE_EXPRRETURN; case EXPRKIND.THROW: goto WALK_TYPE_EXPRTHROW; WALK_BASE_TYPE_EXPRTHROW: goto WALK_TYPE_EXPRSTMT; WALK_TYPE_EXPRTHROW: goto WALK_BASE_TYPE_EXPRTHROW; case EXPRKIND.CONSTANT: case EXPRKIND.SYSTEMTYPE: // CS3 case EXPRKIND.FIELDINFO: // CS3 case EXPRKIND.METHODINFO: // CS3 case EXPRKIND.CONSTRUCTORINFO: // CS3 goto WALK_TYPE_EXPRCONSTANT; WALK_BASE_TYPE_EXPRCONSTANT: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRCONSTANT: goto WALK_BASE_TYPE_EXPRCONSTANT; case EXPRKIND.CLASS: goto WALK_TYPE_EXPRCLASS; WALK_BASE_TYPE_EXPRCLASS: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRCLASS: goto WALK_BASE_TYPE_EXPRCLASS; case EXPRKIND.NSPACE: goto WALK_TYPE_EXPRNSPACE; WALK_BASE_TYPE_EXPRNSPACE: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRNSPACE: goto WALK_BASE_TYPE_EXPRNSPACE; case EXPRKIND.LABEL: goto WALK_TYPE_EXPRLABEL; WALK_BASE_TYPE_EXPRLABEL: goto WALK_TYPE_EXPRSTMT; WALK_TYPE_EXPRLABEL: goto WALK_BASE_TYPE_EXPRLABEL; case EXPRKIND.GOTO: goto WALK_TYPE_EXPRGOTO; WALK_BASE_TYPE_EXPRGOTO: goto WALK_TYPE_EXPRSTMT; WALK_TYPE_EXPRGOTO: goto WALK_BASE_TYPE_EXPRGOTO; case EXPRKIND.GOTOIF: goto WALK_TYPE_EXPRGOTOIF; WALK_BASE_TYPE_EXPRGOTOIF: goto WALK_TYPE_EXPRGOTO; WALK_TYPE_EXPRGOTOIF: goto WALK_BASE_TYPE_EXPRGOTOIF; case EXPRKIND.FUNCPTR: goto WALK_TYPE_EXPRFUNCPTR; WALK_BASE_TYPE_EXPRFUNCPTR: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRFUNCPTR: //(static_cast<EXPRFUNCPTR*>(*expr)).mwi.typeArgs = compiler().getBSymmgr().SubstTypeArray( // (static_cast<EXPRFUNCPTR*>(*expr)).mwi.typeArgs, // (TypeArray*)null, // taClsVarsForMethVars); //(static_cast<EXPRFUNCPTR*>(*expr)).mwi.ats = compiler().getBSymmgr().SubstType( // (static_cast<EXPRFUNCPTR*>(*expr)).mwi.ats, // (TypeArray*)null, // taClsVarsForMethVars).asAGGTYPESYM(); (expr as EXPRFUNCPTR).MethWithInst.TypeArguments = compiler.MainSymbolManager.SubstTypeArray( (expr as EXPRFUNCPTR).MethWithInst.TypeArguments, (TypeArray)null, this.classTypeVariablesForMethod, SubstTypeFlagsEnum.NormNone); (expr as EXPRFUNCPTR).MethWithInst.AggTypeSym = compiler.MainSymbolManager.SubstType( (expr as EXPRFUNCPTR).MethWithInst.AggTypeSym, (TypeArray)null, this.classTypeVariablesForMethod, SubstTypeFlagsEnum.NormNone) as AGGTYPESYM; goto WALK_BASE_TYPE_EXPRFUNCPTR; case EXPRKIND.SWITCH: goto WALK_TYPE_EXPRSWITCH; WALK_BASE_TYPE_EXPRSWITCH: goto WALK_TYPE_EXPRSTMT; WALK_TYPE_EXPRSWITCH: goto WALK_BASE_TYPE_EXPRSWITCH; case EXPRKIND.HANDLER: goto WALK_TYPE_EXPRHANDLER; WALK_BASE_TYPE_EXPRHANDLER: goto WALK_TYPE_EXPRSTMT; WALK_TYPE_EXPRHANDLER: goto WALK_BASE_TYPE_EXPRHANDLER; case EXPRKIND.TRY: goto WALK_TYPE_EXPRTRY; WALK_BASE_TYPE_EXPRTRY: goto WALK_TYPE_EXPRSTMT; WALK_TYPE_EXPRTRY: goto WALK_BASE_TYPE_EXPRTRY; case EXPRKIND.SWITCHLABEL: goto WALK_TYPE_EXPRSWITCHLABEL; WALK_BASE_TYPE_EXPRSWITCHLABEL: goto WALK_TYPE_EXPRLABEL; WALK_TYPE_EXPRSWITCHLABEL: goto WALK_BASE_TYPE_EXPRSWITCHLABEL; case EXPRKIND.MULTIGET: goto WALK_TYPE_EXPRMULTIGET; WALK_BASE_TYPE_EXPRMULTIGET: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRMULTIGET: goto WALK_BASE_TYPE_EXPRMULTIGET; case EXPRKIND.MULTI: goto WALK_TYPE_EXPRMULTI; WALK_BASE_TYPE_EXPRMULTI: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRMULTI: goto WALK_BASE_TYPE_EXPRMULTI; case EXPRKIND.STTMP: goto WALK_TYPE_EXPRSTTMP; WALK_BASE_TYPE_EXPRSTTMP: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRSTTMP: goto WALK_BASE_TYPE_EXPRSTTMP; case EXPRKIND.LDTMP: goto WALK_TYPE_EXPRLDTMP; WALK_BASE_TYPE_EXPRLDTMP: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRLDTMP: goto WALK_BASE_TYPE_EXPRLDTMP; case EXPRKIND.FREETMP: goto WALK_TYPE_EXPRFREETMP; WALK_BASE_TYPE_EXPRFREETMP: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRFREETMP: goto WALK_BASE_TYPE_EXPRFREETMP; case EXPRKIND.WRAP: goto WALK_TYPE_EXPRWRAP; WALK_BASE_TYPE_EXPRWRAP: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRWRAP: goto WALK_BASE_TYPE_EXPRWRAP; case EXPRKIND.CONCAT: goto WALK_TYPE_EXPRCONCAT; WALK_BASE_TYPE_EXPRCONCAT: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRCONCAT: goto WALK_BASE_TYPE_EXPRCONCAT; case EXPRKIND.ARRINIT: goto WALK_TYPE_EXPRARRINIT; WALK_BASE_TYPE_EXPRARRINIT: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRARRINIT: goto WALK_BASE_TYPE_EXPRARRINIT; case EXPRKIND.NOOP: goto WALK_TYPE_EXPRNOOP; WALK_BASE_TYPE_EXPRNOOP: goto WALK_TYPE_EXPRSTMT; WALK_TYPE_EXPRNOOP: goto WALK_BASE_TYPE_EXPRNOOP; case EXPRKIND.DEBUGNOOP: goto WALK_TYPE_EXPRDEBUGNOOP; WALK_BASE_TYPE_EXPRDEBUGNOOP: goto WALK_TYPE_EXPRSTMT; WALK_TYPE_EXPRDEBUGNOOP: goto WALK_BASE_TYPE_EXPRDEBUGNOOP; case EXPRKIND.ANONMETH: case EXPRKIND.LAMBDAEXPR: // CS3 goto WALK_TYPE_EXPRANONMETH; WALK_BASE_TYPE_EXPRANONMETH: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRANONMETH: goto WALK_BASE_TYPE_EXPRANONMETH; case EXPRKIND.DELIM: goto WALK_TYPE_EXPRDELIM; WALK_BASE_TYPE_EXPRDELIM: goto WALK_TYPE_EXPRSTMT; WALK_TYPE_EXPRDELIM: goto WALK_BASE_TYPE_EXPRDELIM; case EXPRKIND.ERROR: goto WALK_TYPE_EXPRERROR; WALK_BASE_TYPE_EXPRERROR: goto WALK_TYPE_EXPR; WALK_TYPE_EXPRERROR: goto WALK_BASE_TYPE_EXPRERROR; } // switch (expr.Kind) WALK_TYPE_EXPR: expr.TypeSym = compiler.MainSymbolManager.SubstType( expr.TypeSym, (TypeArray)null, this.classTypeVariablesForMethod, SubstTypeFlagsEnum.NormNone); } // if (TypeArray.Size(classTypeVariablesForMethod) > 0) //---------------------------------------------------- // Recursively rewrite all the nested expr trees // NOTE: the order of type is based on the declaration order, // not the semmantic order //---------------------------------------------------- switch (expr.Kind) { default: DebugUtil.Assert(expr.Kind > EXPRKIND.COUNT); DebugUtil.Assert((expr.Flags & EXPRFLAG.BINOP) != 0); goto WALK_EXPRBINOP; WALK_BASE_EXPRSTMT: goto WALK_EXPR; WALK_EXPRSTMT: goto WALK_BASE_EXPRSTMT; case EXPRKIND.BINOP: goto WALK_EXPRBINOP; WALK_BASE_EXPRBINOP: goto WALK_EXPR; WALK_EXPRBINOP: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRBINOP*>(*expr)).p1, rwInfo); //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRBINOP*>(*expr)).p2, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRBINOP).Operand1, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRBINOP).Operand2, rwInfo); goto WALK_BASE_EXPRBINOP; case EXPRKIND.USERLOGOP: goto WALK_EXPRUSERLOGOP; WALK_BASE_EXPRUSERLOGOP: goto WALK_EXPR; WALK_EXPRUSERLOGOP: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRUSERLOGOP*>(*expr)).opX, rwInfo); //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRUSERLOGOP*>(*expr)).callTF, rwInfo); //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRUSERLOGOP*>(*expr)).callOp, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRUSERLOGOP).CallOp, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRUSERLOGOP).CallTF, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRUSERLOGOP).CallOp, rwInfo); goto WALK_BASE_EXPRUSERLOGOP; case EXPRKIND.DBLQMARK: goto WALK_EXPRDBLQMARK; WALK_BASE_EXPRDBLQMARK: goto WALK_EXPR; WALK_EXPRDBLQMARK: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRDBLQMARK*>(*expr)).exprTest, rwInfo); //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRDBLQMARK*>(*expr)).exprConv, rwInfo); //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRDBLQMARK*>(*expr)).exprElse, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRDBLQMARK).TestExpr, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRDBLQMARK).ConvertExpr, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRDBLQMARK).ElseExpr, rwInfo); goto WALK_BASE_EXPRDBLQMARK; case EXPRKIND.TYPEOF: goto WALK_EXPRTYPEOF; WALK_BASE_EXPRTYPEOF: goto WALK_EXPR; WALK_EXPRTYPEOF: goto WALK_BASE_EXPRTYPEOF; case EXPRKIND.SIZEOF: goto WALK_EXPRSIZEOF; WALK_BASE_EXPRSIZEOF: goto WALK_EXPR; WALK_EXPRSIZEOF: goto WALK_BASE_EXPRSIZEOF; case EXPRKIND.CAST: goto WALK_EXPRCAST; WALK_BASE_EXPRCAST: goto WALK_EXPR; WALK_EXPRCAST: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRCAST*>(*expr)).p1, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRCAST).Operand, rwInfo); goto WALK_BASE_EXPRCAST; case EXPRKIND.ZEROINIT: goto WALK_EXPRZEROINIT; WALK_BASE_EXPRZEROINIT: goto WALK_EXPR; WALK_EXPRZEROINIT: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRZEROINIT*>(*expr)).p1, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRZEROINIT).Operand, rwInfo); goto WALK_BASE_EXPRZEROINIT; case EXPRKIND.BLOCK: goto WALK_EXPRBLOCK; WALK_BASE_EXPRBLOCK: goto WALK_EXPRSTMT; WALK_EXPRBLOCK: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRBLOCK*>(*expr)).statements, rwInfo); tempExpr = (expr as EXPRBLOCK).StatementsExpr; RecurseAndRewriteExprTree(ref tempExpr, rwInfo); (expr as EXPRBLOCK).StatementsExpr = tempExpr as EXPRSTMT; goto WALK_BASE_EXPRBLOCK; case EXPRKIND.STMTAS: goto WALK_EXPRSTMTAS; WALK_BASE_EXPRSTMTAS: goto WALK_EXPRSTMT; WALK_EXPRSTMTAS: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRSTMTAS*>(*expr)).expression, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRSTMTAS).Expr, rwInfo); goto WALK_BASE_EXPRSTMTAS; case EXPRKIND.MEMGRP: goto WALK_EXPRMEMGRP; WALK_BASE_EXPRMEMGRP: goto WALK_EXPR; WALK_EXPRMEMGRP: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRMEMGRP*>(*expr)).object, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRMEMGRP).ObjectExpr, rwInfo); goto WALK_BASE_EXPRMEMGRP; case EXPRKIND.CALL: goto WALK_EXPRCALL; WALK_BASE_EXPRCALL: goto WALK_EXPR; WALK_EXPRCALL: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRCALL*>(*expr)).object, rwInfo); //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRCALL*>(*expr)).args, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRCALL).ObjectExpr, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRCALL).ArgumentsExpr, rwInfo); goto WALK_BASE_EXPRCALL; case EXPRKIND.PROP: goto WALK_EXPRPROP; WALK_BASE_EXPRPROP: goto WALK_EXPR; WALK_EXPRPROP: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRPROP*>(*expr)).object, rwInfo); //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRPROP*>(*expr)).args, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRPROP).ObjectExpr, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRPROP).ArgumentsExpr, rwInfo); goto WALK_BASE_EXPRPROP; case EXPRKIND.FIELD: goto WALK_EXPRFIELD; WALK_BASE_EXPRFIELD: goto WALK_EXPR; WALK_EXPRFIELD: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRFIELD*>(*expr)).object, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRFIELD).ObjectExpr, rwInfo); goto WALK_BASE_EXPRFIELD; case EXPRKIND.EVENT: goto WALK_EXPREVENT; WALK_BASE_EXPREVENT: goto WALK_EXPR; WALK_EXPREVENT: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPREVENT*>(*expr)).object, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPREVENT).ObjectExpr, rwInfo); goto WALK_BASE_EXPREVENT; case EXPRKIND.DECL: goto WALK_EXPRDECL; WALK_BASE_EXPRDECL: goto WALK_EXPRSTMT; WALK_EXPRDECL: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRDECL*>(*expr)).init, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRDECL).InitialExpr, rwInfo); goto WALK_BASE_EXPRDECL; case EXPRKIND.LOCAL: goto WALK_EXPRLOCAL; WALK_BASE_EXPRLOCAL: goto WALK_EXPR; WALK_EXPRLOCAL: goto WALK_BASE_EXPRLOCAL; case EXPRKIND.RETURN: goto WALK_EXPRRETURN; WALK_BASE_EXPRRETURN: goto WALK_EXPRSTMT; WALK_EXPRRETURN: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRRETURN*>(*expr)).object, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRRETURN).ObjectExpr, rwInfo); goto WALK_BASE_EXPRRETURN; case EXPRKIND.THROW: goto WALK_EXPRTHROW; WALK_BASE_EXPRTHROW: goto WALK_EXPRSTMT; WALK_EXPRTHROW: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRTHROW*>(*expr)).object, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRTHROW).ObjectExpr, rwInfo); goto WALK_BASE_EXPRTHROW; case EXPRKIND.CONSTANT: case EXPRKIND.SYSTEMTYPE: // CS3 case EXPRKIND.FIELDINFO: // CS3 case EXPRKIND.METHODINFO: // CS3 case EXPRKIND.CONSTRUCTORINFO: // CS3 goto WALK_EXPRCONSTANT; WALK_BASE_EXPRCONSTANT: goto WALK_EXPR; WALK_EXPRCONSTANT: goto WALK_BASE_EXPRCONSTANT; case EXPRKIND.CLASS: goto WALK_EXPRCLASS; WALK_BASE_EXPRCLASS: goto WALK_EXPR; WALK_EXPRCLASS: goto WALK_BASE_EXPRCLASS; case EXPRKIND.NSPACE: goto WALK_EXPRNSPACE; WALK_BASE_EXPRNSPACE: goto WALK_EXPR; WALK_EXPRNSPACE: goto WALK_BASE_EXPRNSPACE; case EXPRKIND.LABEL: goto WALK_EXPRLABEL; WALK_BASE_EXPRLABEL: goto WALK_EXPRSTMT; WALK_EXPRLABEL: goto WALK_BASE_EXPRLABEL; case EXPRKIND.GOTO: goto WALK_EXPRGOTO; WALK_BASE_EXPRGOTO: goto WALK_EXPRSTMT; WALK_EXPRGOTO: goto WALK_BASE_EXPRGOTO; case EXPRKIND.GOTOIF: goto WALK_EXPRGOTOIF; WALK_BASE_EXPRGOTOIF: goto WALK_EXPRGOTO; WALK_EXPRGOTOIF: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRGOTOIF*>(*expr)).condition, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRGOTOIF).ConditionExpr, rwInfo); goto WALK_BASE_EXPRGOTOIF; case EXPRKIND.FUNCPTR: goto WALK_EXPRFUNCPTR; WALK_BASE_EXPRFUNCPTR: goto WALK_EXPR; WALK_EXPRFUNCPTR: goto WALK_BASE_EXPRFUNCPTR; case EXPRKIND.SWITCH: goto WALK_EXPRSWITCH; WALK_BASE_EXPRSWITCH: goto WALK_EXPRSTMT; WALK_EXPRSWITCH: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRSWITCH*>(*expr)).arg, rwInfo); //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRSWITCH*>(*expr)).bodies, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRSWITCH).ArgumentExpr, rwInfo); tempExpr = (expr as EXPRSWITCH).BodiesExpr; RecurseAndRewriteExprTree(ref tempExpr, rwInfo); (expr as EXPRSWITCH).BodiesExpr = tempExpr as EXPRSWITCHLABEL; goto WALK_BASE_EXPRSWITCH; case EXPRKIND.HANDLER: goto WALK_EXPRHANDLER; WALK_BASE_EXPRHANDLER: goto WALK_EXPRSTMT; WALK_EXPRHANDLER: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRHANDLER*>(*expr)).handlerBlock, rwInfo); tempExpr = (expr as EXPRHANDLER).HandlerBlock; RecurseAndRewriteExprTree(ref tempExpr, rwInfo); (expr as EXPRHANDLER).HandlerBlock = tempExpr as EXPRBLOCK; goto WALK_BASE_EXPRHANDLER; case EXPRKIND.TRY: goto WALK_EXPRTRY; WALK_BASE_EXPRTRY: goto WALK_EXPRSTMT; WALK_EXPRTRY: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRTRY*>(*expr)).tryblock, rwInfo); //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRTRY*>(*expr)).handlers, rwInfo); tempExpr = (expr as EXPRTRY).TryBlockExpr; RecurseAndRewriteExprTree(ref tempExpr, rwInfo); (expr as EXPRTRY).TryBlockExpr = tempExpr as EXPRBLOCK; tempExpr = (expr as EXPRTRY).HandlersExpr; RecurseAndRewriteExprTree(ref tempExpr, rwInfo); (expr as EXPRTRY).HandlersExpr = tempExpr as EXPRSTMT; goto WALK_BASE_EXPRTRY; case EXPRKIND.SWITCHLABEL: goto WALK_EXPRSWITCHLABEL; WALK_BASE_EXPRSWITCHLABEL: goto WALK_EXPRLABEL; WALK_EXPRSWITCHLABEL: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRSWITCHLABEL*>(*expr)).key, rwInfo); //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRSWITCHLABEL*>(*expr)).statements, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRSWITCHLABEL).KeyExpr, rwInfo); tempExpr = (expr as EXPRSWITCHLABEL).StatementsExpr; RecurseAndRewriteExprTree(ref tempExpr, rwInfo); (expr as EXPRSWITCHLABEL).StatementsExpr = tempExpr as EXPRSTMT; goto WALK_BASE_EXPRSWITCHLABEL; case EXPRKIND.MULTIGET: goto WALK_EXPRMULTIGET; WALK_BASE_EXPRMULTIGET: goto WALK_EXPR; WALK_EXPRMULTIGET: goto WALK_BASE_EXPRMULTIGET; case EXPRKIND.MULTI: goto WALK_EXPRMULTI; WALK_BASE_EXPRMULTI: goto WALK_EXPR; WALK_EXPRMULTI: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRMULTI*>(*expr)).left, rwInfo); //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRMULTI*>(*expr)).op, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRMULTI).LeftExpr, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRMULTI).OperandExpr, rwInfo); goto WALK_BASE_EXPRMULTI; case EXPRKIND.STTMP: goto WALK_EXPRSTTMP; WALK_BASE_EXPRSTTMP: goto WALK_EXPR; WALK_EXPRSTTMP: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRSTTMP*>(*expr)).src, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRSTTMP).SourceExpr, rwInfo); goto WALK_BASE_EXPRSTTMP; case EXPRKIND.LDTMP: goto WALK_EXPRLDTMP; WALK_BASE_EXPRLDTMP: goto WALK_EXPR; WALK_EXPRLDTMP: goto WALK_BASE_EXPRLDTMP; case EXPRKIND.FREETMP: goto WALK_EXPRFREETMP; WALK_BASE_EXPRFREETMP: goto WALK_EXPR; WALK_EXPRFREETMP: goto WALK_BASE_EXPRFREETMP; case EXPRKIND.WRAP: goto WALK_EXPRWRAP; WALK_BASE_EXPRWRAP: goto WALK_EXPR; WALK_EXPRWRAP: goto WALK_BASE_EXPRWRAP; case EXPRKIND.CONCAT: goto WALK_EXPRCONCAT; WALK_BASE_EXPRCONCAT: goto WALK_EXPR; WALK_EXPRCONCAT: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRCONCAT*>(*expr)).list, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRCONCAT).List, rwInfo); goto WALK_BASE_EXPRCONCAT; case EXPRKIND.ARRINIT: goto WALK_EXPRARRINIT; WALK_BASE_EXPRARRINIT: goto WALK_EXPR; WALK_EXPRARRINIT: //RecurseAndRewriteExprTree((EXPR **)&(static_cast<EXPRARRINIT*>(*expr)).args, rwInfo); RecurseAndRewriteExprTree(ref (expr as EXPRARRINIT).ArgumentsExpr, rwInfo); goto WALK_BASE_EXPRARRINIT; case EXPRKIND.NOOP: goto WALK_EXPRNOOP; WALK_BASE_EXPRNOOP: goto WALK_EXPRSTMT; WALK_EXPRNOOP: goto WALK_BASE_EXPRNOOP; case EXPRKIND.DEBUGNOOP: goto WALK_EXPRDEBUGNOOP; WALK_BASE_EXPRDEBUGNOOP: goto WALK_EXPRSTMT; WALK_EXPRDEBUGNOOP: goto WALK_BASE_EXPRDEBUGNOOP; case EXPRKIND.ANONMETH: case EXPRKIND.LAMBDAEXPR: // CS3 goto WALK_EXPRANONMETH; WALK_BASE_EXPRANONMETH: goto WALK_EXPR; WALK_EXPRANONMETH: goto WALK_BASE_EXPRANONMETH; case EXPRKIND.DELIM: goto WALK_EXPRDELIM; WALK_BASE_EXPRDELIM: goto WALK_EXPRSTMT; WALK_EXPRDELIM: goto WALK_BASE_EXPRDELIM; case EXPRKIND.ERROR: goto WALK_EXPRERROR; WALK_BASE_EXPRERROR: goto WALK_EXPR; WALK_EXPRERROR: goto WALK_BASE_EXPRERROR; } // switch (expr.Kind) WALK_EXPR: // no nested exprs in EXPR node ; } // if (rwInfo.RewriteFunc(this, ref expr)) //if (!updateFirstExpr) if (prevExpr == null) { firstExpr = expr; //updateFirstExpr = true; } else { EXPRSTMT stmt = prevExpr as EXPRSTMT; if (stmt != null) { stmt.NextStatement = expr as EXPRSTMT; } } if (nextStmtExpr != null) { //while (*pexpr) // pexpr = (EXPR**)&(*pexpr)->asSTMT()->stmtNext; //*pexpr = stmtNext; //goto LRepeat; while ((expr as EXPRSTMT).NextStatement != null) { expr = (expr as EXPRSTMT).NextStatement; } (expr as EXPRSTMT).NextStatement = nextStmtExpr; prevExpr = expr; expr = nextStmtExpr; goto LRepeat; } }
public void SetOptionalRightChild(EXPR value) { _OptionalRightChild = value; }
public void SetRHS(EXPR value) { RHS = value; }
public void SetOptionalObjectThrough(EXPR value) { OptionalObjectThrough = value; }
public void SetFirstArgument(EXPR value) { FirstArgument = value; }
public void SetLeft(EXPR value) { Left = value; }
public void SetOptionalNextListNode(EXPR value) { OptionalNextListNode = value; }
public void SetOperator(EXPR value) { Operator = value; }
public void SetOptionalArguments(EXPR value) { _OptionalArguments = value; }
public void SetLHS(EXPR value) { _LHS = value; }
public void SetOptionalElement(EXPR value) { OptionalElement = value; }
public void SetOptionalExpression(EXPR value) { OptionalExpression = value; }
public ExpressionIterator(EXPR pExpr) { Init(pExpr); }
public void SetOptionalObjectThrough(EXPR value) { OptionalObjectThrough = value; }
public void SetOptionalObject(EXPR value) { OptionalObject = value; }
public void SetOptionalObject(EXPR value) { OptionalObject = value; }