public override object Visit(CallExpression that, object value) { that.Callee.Visit(this); _writer.Write('('); foreach (Expression argument in that.Arguments) { if (argument != that.Arguments[0]) _writer.Write(", "); argument.Visit(this); } _writer.Write(')'); return null; }
public override object Visit(CallExpression that, object value) { var result = new System.Text.StringBuilder(256); // Output the signature of Braceless v0.x encoded/mangled names. result.Append(marker + "b0" + marker); that.Callee.Visit(this, (object) result); result.Append(marker); /** \note Don't encode the return type as we do like C++ and C#: Overloads cannot differ only in return type. */ // Encode number of parameters. result.Append(that.Arguments.Length.ToString()); result.Append(marker); foreach (Expression argument in that.Arguments) { argument.Visit(this, (object) result); result.Append(marker); } that.Encoded = result.ToString(); return null; }
public override object Visit(CallExpression that, object value = null) { PrintPrologue(that); PrintNodeId("Callee", that.Callee); PrintSequence("Arguments", that.Arguments); _writer.WriteLine("Encoded = {0}", (that.Encoded != null) ? that.Encoded : "(none)"); PrintNodeId("Target", that.Target); PrintEpilogue(that); that.Callee.Visit(this); foreach (Expression argument in that.Arguments) argument.Visit(this); return null; }
public override object Visit(CallExpression that, object value) { Storage index = (Storage) value; if (index == null) index = new TemporaryStorage(CreateTemporary()); _writer.Write("call "); _writer.Write(index.ToString()); #if FINISHED that.Callee.Type.Visit(this); #endif _writer.Write(" @"); _writer.Write(EncodeEncoded(that.Encoded)); _writer.Write('('); foreach (Expression argument in that.Arguments) { argument.Visit(this); if (argument != that.Arguments[that.Arguments.Length - 1]) _writer.Write(", "); } _writer.Write(')'); return (object) index; }
public override object Visit(CallExpression that, object value = null) { /** \note Don't visit the \c Callee yet as this is done in \c ResolveRoutinesWalker. */ foreach (Expression argument in that.Arguments) argument.Visit(this); return null; }
/** Parses an expression. */ private Expression ParseExpression() { Expression result; /** Parse the expression prefix. */ switch (_matcher.This.Kind) { #if DONE case TokenKind.Keyword_Base: result = (Expression) ParseParentReference(); break; #endif case TokenKind.Dot: result = (Expression) ParseMemberReference(); break; case TokenKind.Exclamation: result = (Expression) ParseGlobalReference(); break; #if DONE case TokenKind.Keyword_False: case TokenKind.Keyword_True: result = (Expression) ParseBooleanLiteral(); break; #endif case TokenKind.Name: result = (Expression) ParseSymbolReference(); break; case TokenKind.Literal_Cardinal: result = (Expression) ParseCardinalLiteral(); break; #if DONE case TokenKind.Literal_Character: result = (Expression) ParseCharacterLiteral(); break; #endif case TokenKind.Literal_Text: result = (Expression) ParseTextLiteral(); break; #if DONE case TokenKind.Keyword_New: result = (Expression) ParseNewExpression(); break; case TokenKind.Keyword_None: result = (Expression) ParseNoneExpression(); break; case TokenKind.Keyword_This: { _matcher.Match(TokenKind.Keyword_This); result = (Expression) ParseMemberReference(); break; } case TokenKind.BracketBegin: result = (Expression) ParseBracketExpression(); break; #endif default: /** \todo The \c ToString() invokation does not call our \c ToString() - why? */ throw new ParserError(_matcher.This.Cursor, "Expression expected, found " + _matcher.This.Kind.ToString()); } bool done = false; while (!done) { switch (_matcher.This.Kind) { case TokenKind.Dot: { Token start = _matcher.Match(TokenKind.Dot); Token label = _matcher.Match(TokenKind.Name); result = new PrefixReference(start.Cursor, result, label.Text); break; } #if DONE case TokenKind.BracketBegin: { Token start = _matcher.Match(TokenKind.BracketBegin); Expression other = ParseExpression(); _matcher.Match(TokenKind.BracketClose); result = new ArrayExpression(start.Cursor, result, other); break; } #endif case TokenKind.ParenthesisBegin: { Token start = _matcher.This; Expression[] arguments = ParseArguments(); result = new CallExpression(start.Cursor, result, arguments); break; } default: done = true; break; } } return result; }