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; }
