public override Expression Parse(Parser p, Expression left, Token t) { var exp = new CallExpr(); exp.CallTargetExpr = left; exp.Position = left.Position; if (p.Match(TokenType.RParen)) return exp; do { exp.ArgumentExprs.Add(p.ParseExpression()); } while (p.Match(TokenType.Comma)); p.Consume(TokenType.RParen); return exp; }
public static CallExpr __CreateInstance(CallExpr.__Internal native, bool skipVTables = false) { return new CallExpr(native, skipVTables); }
public override Null Visit(CallExpr node) { context = null; node.computedType = new ErrorType(); // Context is tricky. For overloaded functions, we want to handle // arguments first and use them to provide context for overload // resolution. For normal functions, we want to handle the function // first and use its type to provide context for the arguments. // The problem is that we can't know which one to visit without visiting // one of them first. To handle this, we temporarily disable logging and // check if the function type is OverloadedFuncType or not. log.disabled = true; node.func.Accept(this); log.disabled = false; bool isOverload = node.func.computedType is OverloadedFuncType; if (isOverload) { // Visit the arguments first to get context for resolving overloads VisitAll(node.args); // Visit the function last and provide the overload resolving context context = new Context { argTypes = node.args.ConvertAll(arg => arg.computedType) }; node.func.Accept(this); } else { // Visit the function again, this time with logging node.func.Accept(this); // Visit the arguments and provide context with the argument type FuncType funcType = node.func.computedType is FuncType ? (FuncType)node.func.computedType : null; for (int i = 0; i < node.args.Count; i++) { if (funcType != null && i < funcType.argTypes.Count) { context = new Context { targetType = funcType.argTypes[i] }; } node.args[i].Accept(this); } } // Cache information for checking List<Type> argTypes = node.args.ConvertAll(arg => arg.computedType); Type type = node.func.computedType; // Check for constructors if (type.IsInstantiatableType() && argTypes.Count == 0 && type.InstanceType() is ClassType) { node.computedType = type.InstanceType(); node.isCtor = true; return null; } // Call the function if there is one, inserting implicit casts as appropriate if (type is FuncType && argTypes.MatchesWithImplicitConversions(type.ArgTypes())) { FuncType funcType = (FuncType)type; for (int i = 0; i < funcType.argTypes.Count; i++) { if (!node.args[i].computedType.EqualsType(funcType.argTypes[i])) { node.args[i] = InsertCast(node.args[i], funcType.argTypes[i]); } } node.computedType = funcType.returnType; } else { log.ErrorCallNotFound(node.location, type, argTypes); } return null; }
protected CallExpr(CallExpr.Internal* native, bool skipVTables = false) : base((CppSharp.Parser.AST.Expression.Internal*) null) { __PointerAdjustment = 0; if (native == null) return; __Instance = new global::System.IntPtr(native); }
private static CallExpr.Internal* __CopyValue(CallExpr.Internal native) { var ret = Marshal.AllocHGlobal(64); CppSharp.Parser.AST.CallExpr.Internal.cctor_2(ret, new global::System.IntPtr(&native)); return (CallExpr.Internal*) ret; }
void DoExpr(Expression e, bool setVar = false, int setVarLhsCount = -1, bool onlyCheckConsts = false) { if (e is AnonymousFunctionExpr) // function() ... end { } else if (e is BinOpExpr) { BinOpExpr boe = e as BinOpExpr; switch (boe.GetOperator()) { case BinaryOperator.Add: binOp("ADD", boe.Lhs, boe.Rhs); return; case BinaryOperator.Subtract: binOp("SUB", boe.Lhs, boe.Rhs); return; case BinaryOperator.Multiply: binOp("MUL", boe.Lhs, boe.Rhs); return; case BinaryOperator.Divide: binOp("DIV", boe.Lhs, boe.Rhs); return; case BinaryOperator.Power: binOp("POW", boe.Lhs, boe.Rhs); return; case BinaryOperator.Modulus: binOp("MOD", boe.Lhs, boe.Rhs); return; case BinaryOperator.Concat: binOp("CONCAT", boe.Lhs, boe.Rhs); return; case BinaryOperator.And: break; case BinaryOperator.Or: break; case BinaryOperator.LessThan: break; case BinaryOperator.LessThanOrEqualTo: break; case BinaryOperator.GreaterThan: break; case BinaryOperator.GreaterThanOrEqualTo: break; case BinaryOperator.NotEqual: break; case BinaryOperator.ShiftRight: CallExpr ce = new CallExpr(); ce.Arguments.Add(boe.Lhs); ce.Arguments.Add(boe.Rhs); ce.Base = new MemberExpr() { Base = new VariableExpression() { Var = new Variable() { Name = "bit", IsGlobal = true } }, Ident = "rshift", Indexer = ".", }; DoExpr(ce); return; case BinaryOperator.ShiftLeft: ce = new CallExpr(); ce.Arguments.Add(boe.Lhs); ce.Arguments.Add(boe.Rhs); ce.Base = new MemberExpr() { Base = new VariableExpression() { Var = new Variable() { Name = "bit", IsGlobal = true } }, Ident = "lshift", Indexer = ".", }; DoExpr(ce); return; case BinaryOperator.Xor: ce = new CallExpr(); ce.Arguments.Add(boe.Lhs); ce.Arguments.Add(boe.Rhs); ce.Base = new MemberExpr() { Base = new VariableExpression() { Var = new Variable() { Name = "bit", IsGlobal = true } }, Ident = "bxor", Indexer = ".", }; DoExpr(ce); return; case BinaryOperator.BitAnd: ce = new CallExpr(); ce.Arguments.Add(boe.Lhs); ce.Arguments.Add(boe.Rhs); ce.Base = new MemberExpr() { Base = new VariableExpression() { Var = new Variable() { Name = "bit", IsGlobal = true } }, Ident = "band", Indexer = ".", }; DoExpr(ce); return; case BinaryOperator.BitOr: ce = new CallExpr(); ce.Arguments.Add(boe.Lhs); ce.Arguments.Add(boe.Rhs); ce.Base = new MemberExpr() { Base = new VariableExpression() { Var = new Variable() { Name = "bit", IsGlobal = true } }, Ident = "bor", Indexer = ".", }; DoExpr(ce); return; case BinaryOperator.BitNot: ce = new CallExpr(); ce.Arguments.Add(boe.Lhs); ce.Arguments.Add(boe.Rhs); ce.Base = new MemberExpr() { Base = new VariableExpression() { Var = new Variable() { Name = "bit", IsGlobal = true } }, Ident = "bnot", Indexer = ".", }; DoExpr(ce); return; case BinaryOperator.NONE: default: throw new Exception("Unknown binary operator '" + boe.Op + "'"); } } else if (e is BoolExpr) { bool v = ((BoolExpr)e).Value; Instruction i = new Instruction("LOADBOOL"); i.A = block.getreg(); i.B = v ? 1 : 0; i.C = 0; emit(i); return; } else if (e is CallExpr)//&& (!(e is StringCallExpr) && !(e is TableCallExpr))) { CallExpr ce = e as CallExpr; int breg = ++block.regnum; DoExpr(ce.Base); bool isZero = false; bool isMethod = false; Expression ex = ce.Base; while (ex != null) { if (ex is IndexExpr) { ex = ((IndexExpr)ex).Index; } else if (ex is MemberExpr) { MemberExpr me = ex as MemberExpr; if (me.Indexer == ":") { isMethod = true; break; } else { break; } //ex = me.Ident; } else { break; } } foreach (Expression e2 in ce.Arguments) { DoExpr(e2); if (e2 is CallExpr || block.Chunk.Instructions[block.Chunk.Instructions.Count - 1].Opcode == Instruction.LuaOpcode.CALL) { isZero = true; Instruction i_ = block.Chunk.Instructions[block.Chunk.Instructions.Count - 1]; Debug.Assert(i_.Opcode == Instruction.LuaOpcode.CALL); i_.C = 0; } } Instruction i = new Instruction("CALL"); i.A = breg; if (isMethod) { //i.B++; i.B = isZero ? 2 : (ce.Arguments.Count > 0 ? 2 + ce.Arguments.Count : 2); } else { i.B = isZero ? 0 : (ce.Arguments.Count > 0 ? 1 + ce.Arguments.Count : 1); } i.C = setVarLhsCount == 0 || setVarLhsCount == -1 ? 1 : //(isZero ? 0 : 1) : 1 + setVarLhsCount; // (isZero ? 0 : 1 + setVarLhsCount); //i.C = setVarLhsCount == 0 || setVarLhsCount == -1 ? 1 : 1 + setVarLhsCount; emit(i); return; } else if (e is StringCallExpr) { throw new Exception(); } else if (e is TableCallExpr) { throw new Exception(); } else if (e is IndexExpr) { IndexExpr ie = e as IndexExpr; int regnum = block.regnum; DoExpr(ie.Base); DoExpr(ie.Index); Instruction i = new Instruction("GETTABLE"); i.A = regnum; i.B = regnum; i.C = block.regnum - 1;// block.getreg(); emit(i); block.regnum = regnum + 1; return; } else if (e is InlineFunctionExpression) // |<args>| -> <exprs> { InlineFunctionExpression i = e as InlineFunctionExpression; AnonymousFunctionExpr af = new AnonymousFunctionExpr(); af.Arguments = i.Arguments; af.IsVararg = i.IsVararg; af.Body = new List <Statement>() { new ReturnStatement { Arguments = i.Expressions } }; DoExpr(af); } else if (e is MemberExpr) { MemberExpr me = e as MemberExpr; if (me.Indexer == ".") { int regnum = block.regnum; DoExpr(me.Base); DoExpr(new StringExpr(me.Ident), false, -1, true); Instruction i = new Instruction("GETTABLE"); i.A = regnum; i.B = regnum; i.C = 256 + block.K[me.Ident]; //i.C = block.regnum - 1;// block.getreg(); emit(i); block.regnum = regnum + 1; return; } else if (me.Indexer == ":") { int regnum = block.regnum; DoExpr(me.Base); DoExpr(new StringExpr(me.Ident), false, -1, true); Instruction i = new Instruction("SELF"); i.A = regnum; i.B = regnum; i.C = 256 + block.K[me.Ident]; //i.C = block.regnum - 1;// block.getreg(); emit(i); block.regnum = regnum + 1; return; } else { throw new Exception("Unknown member indexer '" + me.Indexer + "'"); } } else if (e is NilExpr) { Instruction i = new Instruction("LOADNIL"); i.A = block.getreg(); i.B = setVarLhsCount == -1 ? i.A : setVarLhsCount - 1; i.C = 0; emit(i); return; } else if (e is NumberExpr) { NumberExpr ne = e as NumberExpr; // TODO: this can optimized into a Dictionary to avoid re-parsing numbers each time double r; int x = Lua.luaO_str2d(ne.Value.Replace("_", ""), out r); if (x == 0) { throw new LuaSourceException(line, 0, "Invalid number"); } if (onlyCheckConsts == false) { Instruction i = new Instruction("loadk"); i.A = block.getreg(); i.Bx = block.K[r]; emit(i); } else { block.K.Check(r); } return; } else if (e is StringExpr) { StringExpr se = e as StringExpr; string s = se.Value; if (se.StringType != TokenType.LongString) { s = Unescaper.Unescape(s); } else { int i = 1; while (s[i] != '[') { i++; } i++; s = s.Substring(i, s.Length - i - 2); } if (onlyCheckConsts == false) { Instruction i2 = new Instruction("loadk"); i2.A = block.getreg(); i2.Bx = block.K[s]; emit(i2); } else { block.K.Check(s); } return; } else if (e is TableConstructorExpr) { Instruction i = new Instruction("NEWTABLE"); int tblA = block.regnum; i.A = block.getreg(); i.B = 0; i.C = 0; emit(i); TableConstructorExpr tce = e as TableConstructorExpr; if (tce.EntryList.Count == 0) { return; } int b = 0; bool wasLastCall = false; foreach (Expression e2 in tce.EntryList) { if (e2 is TableConstructorKeyExpr) { TableConstructorKeyExpr tcke = e2 as TableConstructorKeyExpr; DoExpr(tcke.Key); DoExpr(tcke.Value); } else if (e2 is TableConstructorNamedFunctionExpr) { TableConstructorNamedFunctionExpr tcnfe = e2 as TableConstructorNamedFunctionExpr; } else if (e2 is TableConstructorStringKeyExpr) { TableConstructorStringKeyExpr tcske = e2 as TableConstructorStringKeyExpr; DoExpr(new StringExpr(tcske.Key)); DoExpr(tcske.Value); } else if (e2 is TableConstructorValueExpr) { TableConstructorValueExpr tcve = e2 as TableConstructorValueExpr; DoExpr(tcve.Value); if (tcve.Value is VarargExpr || tcve.Value is CallExpr) { wasLastCall = true; } else { wasLastCall = false; } } b++; } i.B = b; i = new Instruction("SETLIST"); i.A = tblA; if (wasLastCall) { i.B = 0; } else { i.B = block.regnum - 1; } i.C = tblA + 1; emit(i); block.regnum = tblA; return; } else if (e is UnOpExpr) { UnOpExpr uoe = e as UnOpExpr; switch (uoe.GetOperator()) { case UnaryOperator.Not: unOp("NOT", uoe.Rhs); return; case UnaryOperator.Length: unOp("LEN", uoe.Rhs); return; case UnaryOperator.BitNot: CallExpr ce = new CallExpr(); ce.Arguments.Add(uoe.Rhs); ce.Base = new MemberExpr() { Base = new VariableExpression() { Var = new Variable() { Name = "bit", IsGlobal = true } }, Ident = "bnot", Indexer = ".", }; DoExpr(ce); return; case UnaryOperator.Negate: unOp("UNM", uoe.Rhs); return; case UnaryOperator.UnNegate: ce = new CallExpr(); ce.Arguments.Add(uoe.Rhs); ce.Base = new MemberExpr() { Base = new VariableExpression() { Var = new Variable() { Name = "math", IsGlobal = true } }, Ident = "abs", Indexer = ".", }; DoExpr(ce); return; case UnaryOperator.NONE: default: throw new Exception("Unknown unary operator '" + uoe.Op + "'"); } } else if (e is VarargExpr) { if (block.Chunk.Vararg == 0) { throw new LuaSourceException(0, 0, "Cannot use varargs (...) outside of a vararg function"); } Instruction i = new Instruction("VARARG"); i.A = block.getreg(); if (setVar) { i.B = setVarLhsCount == -1 ? 0 : 1 + setVarLhsCount; } else { i.B = 0; } emit(i); return; } else if (e is VariableExpression) { VariableExpression ve = e as VariableExpression; if (ve.Var.IsGlobal == false) { // local if (setVar) { //Instruction i = new Instruction("move"); //i.B = block.V[ve.Var.Name]; // moved into here //i.A = block.getreg(); // from here //emit(i); int _TMP_001_ = block.V[ve.Var.Name]; // Should probably just add a Check method in Var2Reg block.CheckLocalName(ve.Var.Name); } else { Instruction i = new Instruction("move"); i.B = block.V[ve.Var.Name]; // moved into here i.A = block.getreg(); // from here emit(i); } } else { // global Instruction i = null; if (setVar) { i = new Instruction("setglobal"); i.A = block.regnum - 1; // ret } else { i = new Instruction("getglobal"); i.A = block.getreg(); // ret } i.Bx = block.K[ve.Var.Name]; // const emit(i); } return; } throw new NotImplementedException(e.GetType().Name + " is not implemented"); }
public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result) { result = new CallExpr(this, binder.Name, args); return(true); }
Expression ParseSuffixedExpr(Scope scope, bool onlyDotColon = false) { // base primary expression Expression prim = ParsePrimaryExpr(scope); while (true) { if (reader.IsSymbol('.') || reader.IsSymbol(':')) { string symb = reader.Get().Data; // '.' or ':' // TODO: should we allow keywords? I vote no. if (!reader.Is(TokenType.Ident)) { error("<Ident> expected"); } Token id = reader.Get(); MemberExpr m = new MemberExpr(); m.Base = prim; m.Indexer = symb; m.Ident = id.Data; prim = m; } else if (!onlyDotColon && reader.ConsumeSymbol('[')) { int pass = 0; const int maxamount = 100; bool wasLastNumeric = false; bool first = true; bool hadComma = false; do { Token tok = reader.Peek(); int col = tok.Column; int line = tok.Line; Expression ex = ParseExpr(scope); //if (!reader.ConsumeSymbol(']')) //error("']' expected"); IndexExpr i = new IndexExpr(); i.Base = prim; i.Index = ex; prim = i; if ((first || wasLastNumeric) && ex is NumberExpr && hadComma == false) { tok = reader.Peek(); bool cma = reader.ConsumeSymbol(','); if (cma && hadComma == false && first == false) { error("Unexpected ',' in matrice indexing", tok.Line, tok.Column, tok); } //else if (cma == false && hadComma) // ; hadComma = cma; } else { tok = reader.Peek(); bool cma = reader.ConsumeSymbol(','); //if (cma == false) // break; if (cma && hadComma == false) { error("Unexpected ',' in matrice indexing", -1, -1, tok); } else if (cma == false && ex is NumberExpr == false && wasLastNumeric && hadComma == false) { error("Expected numeric constant in matrice indexing", line, col, tok); } else if (cma == false && hadComma) { if (tok.Type == TokenType.Symbol && tok.Data == "]") { ; } else { error("Expected ','", -1, -1, tok); } } else if (cma == false) { break; } else { hadComma = true; } hadComma = cma; } if (pass++ >= maxamount) { error("Maximum index depth reached"); } wasLastNumeric = ex is NumberExpr; first = false; } while (!(reader.Peek().Data == "]")); if (!reader.ConsumeSymbol(']')) { error("']' expected"); } } else if (!onlyDotColon && reader.ConsumeSymbol('(')) { List <Expression> args = new List <Expression>(); while (!reader.ConsumeSymbol(')')) { Expression ex = ParseExpr(scope); args.Add(ex); if (!reader.ConsumeSymbol(',')) { if (reader.ConsumeSymbol(')')) { break; } else { error("')' expected"); } break; } } CallExpr c = new CallExpr(); c.Base = prim; c.Arguments = args; prim = c; } else if (!onlyDotColon && (reader.Is(TokenType.SingleQuoteString) || reader.Is(TokenType.DoubleQuoteString) || reader.Is(TokenType.LongString))) { //string call StringCallExpr e = new StringCallExpr(); e.Base = prim; e.Arguments = new List <Expression> { new StringExpr(reader.Peek().Data) { StringType = reader.Peek().Type } }; reader.Get(); prim = e; } else if (!onlyDotColon && reader.IsSymbol('{')) { // table call // Fix for the issue with whole expr being parsed, not just table. // See LuaMinify issue #2 (https://github.com/stravant/LuaMinify/issues/2) //Expression ex = ParseExpr(scope); Expression ex = ParseSimpleExpr(scope); TableCallExpr t = new TableCallExpr(); t.Base = prim; t.Arguments = new List <Expression> { ex }; prim = t; } else { break; } } return(prim); }
string DoExpr(Expression e) { string ret = ""; if (e is AnonymousFunctionExpr) // function() ... end { AnonymousFunctionExpr f = e as AnonymousFunctionExpr; StringBuilder sb = new StringBuilder(); sb.Append("function("); for (int i = 0; i < f.Arguments.Count; i++) { sb.Append(f.Arguments[i].Name); if (i != f.Arguments.Count - 1 || f.IsVararg) { sb.Append(", "); } } if (f.IsVararg) { sb.Append("..."); } sb.Append(")"); if (f.Body.Count > 1) { sb.Append(EOL); indent++; sb.Append(DoChunk(f.Body)); sb.Append(nldedent()); sb.Append("end"); } else if (f.Body.Count == 0) { sb.Append(" end"); } else { sb.Append(" " + DoStatement(f.Body[0])); sb.Append(" end"); } ret = sb.ToString(); } else if (e is BinOpExpr) { BinOpExpr b = e as BinOpExpr; string left = DoExpr(b.Lhs); string op = b.Op; string right = DoExpr(b.Rhs); ret = string.Format("{0} {1} {2}", left, op, right); } else if (e is BoolExpr) { bool val = (e as BoolExpr).Value; ret = val ? "true" : "false"; } else if (e is CallExpr && (!(e is StringCallExpr) && !(e is TableCallExpr))) { CallExpr c = e as CallExpr; StringBuilder sb = new StringBuilder(); sb.Append(DoExpr(c.Base) + "("); for (int i = 0; i < c.Arguments.Count; i++) { sb.Append(DoExpr(c.Arguments[i])); if (i != c.Arguments.Count - 1) { sb.Append(", "); } } sb.Append(")"); ret = sb.ToString(); } else if (e is StringCallExpr) { StringCallExpr s = e as StringCallExpr; ret = string.Format("{0} {1}", DoExpr(s.Base), DoExpr(s.Arguments[0])); } else if (e is TableCallExpr) { TableCallExpr s = e as TableCallExpr; ret = string.Format("{0} {1}", DoExpr(s.Base), DoExpr(s.Arguments[0])); } else if (e is IndexExpr) { IndexExpr i = e as IndexExpr; ret = string.Format("{0}[{1}]", DoExpr(i.Base), DoExpr(i.Index)); } else if (e is InlineFunctionExpression) // |<args>| -> <exprs> { InlineFunctionExpression ife = e as InlineFunctionExpression; StringBuilder sb = new StringBuilder(); sb.Append("function("); for (int i = 0; i < ife.Arguments.Count; i++) { sb.Append(ife.Arguments[i].Name); if (i != ife.Arguments.Count - 1 || ife.IsVararg) { sb.Append(", "); } } if (ife.IsVararg) { sb.Append("..."); } sb.Append(") return "); for (int i2 = 0; i2 < ife.Expressions.Count; i2++) { sb.Append(DoExpr(ife.Expressions[i2])); if (i2 != ife.Expressions.Count - 1) { sb.Append(", "); } } sb.Append(" end"); ret = sb.ToString(); } else if (e is TableConstructorKeyExpr) { TableConstructorKeyExpr t = e as TableConstructorKeyExpr; ret = "[" + DoExpr(t.Key) + "] = " + DoExpr(t.Value); } else if (e is MemberExpr) { MemberExpr m = e as MemberExpr; ret = DoExpr(m.Base) + m.Indexer + m.Ident; } else if (e is NilExpr) { ret = "nil"; } else if (e is NumberExpr) { ret = (e as NumberExpr).Value; } else if (e is StringExpr) { StringExpr se = e as StringExpr; string delim = se.StringType == TokenType.SingleQuoteString ? "'" : se.StringType == TokenType.DoubleQuoteString ? "\"" : "["; if (delim == "[") { // Long strings keep their [=*[ ret = se.Value; } else { ret = delim + se.Value + delim; } } else if (e is TableConstructorStringKeyExpr) { TableConstructorStringKeyExpr tcske = e as TableConstructorStringKeyExpr; ret = tcske.Key + " = " + DoExpr(tcske.Value); } else if (e is TableConstructorExpr) { TableConstructorExpr t = e as TableConstructorExpr; StringBuilder sb = new StringBuilder(); sb.Append("{ "); for (int i = 0; i < t.EntryList.Count; i++) { sb.Append(DoExpr(t.EntryList[i])); if (i != t.EntryList.Count - 1) { sb.Append(", "); } } sb.Append("} "); ret = sb.ToString(); } else if (e is UnOpExpr) { string op = (e as UnOpExpr).Op; string s = op; if (s.Length != 1) { s += " "; } ret = s + DoExpr((e as UnOpExpr).Rhs); } else if (e is TableConstructorValueExpr) { ret = DoExpr((e as TableConstructorValueExpr).Value); } else if (e is VarargExpr) { ret = "..."; } else if (e is VariableExpression) { ret = (e as VariableExpression).Var.Name; } return(string.Format("{0}{1}{2}", oparens(e.ParenCount), ret, cparens(e.ParenCount))); throw new NotImplementedException(e.GetType().Name + " is not implemented"); }
public bool VisitCallExpr(CallExpr stmt) { throw new NotImplementedException(); }
internal string DoExpr(Expression e, Scope s) { int startP = index; index += e.ParenCount; string ret = null; if (e is AnonymousFunctionExpr) // function() ... end { AnonymousFunctionExpr f = e as AnonymousFunctionExpr; StringBuilder sb = new StringBuilder(); sb.Append(fromToken(tok[index++], s)); // 'function' sb.Append(fromToken(tok[index++], s)); // '(' for (int i2 = 0; i2 < f.Arguments.Count; i2++) { sb.Append(fromToken(tok[index++], s)); if (i2 != f.Arguments.Count - 1 || f.IsVararg) { sb.Append(fromToken(tok[index++], s) + " "); } } if (f.IsVararg) { sb.Append(fromToken(tok[index++], s)); } sb.Append(fromToken(tok[index++], s)); // ')' if (f.Body.Count > 1) { sb.Append(options.EOL); indent++; sb.Append(DoChunk(f.Body)); sb.Append(nldedent()); } else if (f.Body.Count == 0) { sb.Append(" "); } else { sb.Append(" " + DoStatement(f.Body[0])); sb.Append(" "); } sb.Append(fromToken(tok[index++], s)); // <end> ret = sb.ToString(); } else if (e is BinOpExpr) { //int i = 0; string left = DoExpr((e as BinOpExpr).Lhs, s); string op = fromToken(tok[index++], s); string right = DoExpr((e as BinOpExpr).Rhs, s); ret = string.Format("{0} {1} {2}", left, op, right); } else if (e is BoolExpr) { ret = fromToken(tok[index++], s); } else if (e is CallExpr && (!(e is StringCallExpr) && !(e is TableCallExpr))) { CallExpr c = e as CallExpr; StringBuilder sb = new StringBuilder(); sb.Append(DoExpr(c.Base, s) // <base> + fromToken(tok[index++], s)); // '(' for (int i = 0; i < c.Arguments.Count; i++) { sb.Append(DoExpr(c.Arguments[i], s)); if (i != c.Arguments.Count - 1) { sb.Append(fromToken(tok[index++], s)); // ', ' sb.Append(" "); } } sb.Append(fromToken(tok[index++], s)); // ')' ret = sb.ToString(); } else if (e is StringCallExpr) { StringCallExpr sc = e as StringCallExpr; ret = string.Format("{0} {1}", DoExpr(sc.Base, s), DoExpr(sc.Arguments[0], s)); } else if (e is TableCallExpr) { TableCallExpr sc = e as TableCallExpr; ret = string.Format("{0} {1}", DoExpr(sc.Base, s), DoExpr(sc.Arguments[0], s)); } else if (e is IndexExpr) { IndexExpr i = e as IndexExpr; ret = string.Format("{0}{1}{2}{3}", DoExpr(i.Base, s), fromToken(tok[index++], s), DoExpr(i.Index, s), fromToken(tok[index++], s)); } else if (e is InlineFunctionExpression) // |<args>| -> <exprs> { InlineFunctionExpression ife = e as InlineFunctionExpression; StringBuilder sb = new StringBuilder(); sb.Append(fromToken(tok[index++], s)); // '|; for (int i = 0; i < ife.Arguments.Count; i++) { sb.Append(fromToken(tok[index++], s)); // <arg name> if (i != ife.Arguments.Count - 1 || ife.IsVararg) { sb.Append(fromToken(tok[index++], s)); // ',' sb.Append(" "); } } if (ife.IsVararg) { sb.Append(fromToken(tok[index++], s)); // '...' sb.Append(" "); } sb.Append(fromToken(tok[index++], s)); // '|' sb.Append(" "); sb.Append(fromToken(tok[index++], s)); // '->' sb.Append(" "); for (int i2 = 0; i2 < ife.Expressions.Count; i2++) { sb.Append(DoExpr(ife.Expressions[i2], s)); if (i2 != ife.Expressions.Count - 1) { sb.Append(fromToken(tok[index++], s)); // ',' sb.Append(" "); } } ret = sb.ToString(); } else if (e is TableConstructorKeyExpr) { TableConstructorKeyExpr t = e as TableConstructorKeyExpr; ret = fromToken(tok[index++], s) + DoExpr(t.Key, s) + fromToken(tok[index++], s) + " " + fromToken(tok[index++], s) + " " + DoExpr(t.Value, s); } else if (e is MemberExpr) { MemberExpr m = e as MemberExpr; ret = DoExpr(m.Base, s) + fromToken(tok[index++], s) + fromToken(tok[index++], s); } else if (e is NilExpr) { ret = fromToken(tok[index++], s); } else if (e is NumberExpr) { ret = fromToken(tok[index++], s); } else if (e is StringExpr) { ret = fromToken(tok[index++], s); } else if (e is TableConstructorStringKeyExpr) { TableConstructorStringKeyExpr tcske = e as TableConstructorStringKeyExpr; ret = fromToken(tok[index++], s); // key ret += " "; ret += fromToken(tok[index++], s); // '=' ret += " "; ret += DoExpr(tcske.Value, s); // value } else if (e is TableConstructorExpr) { TableConstructorExpr t = e as TableConstructorExpr; StringBuilder sb = new StringBuilder(); sb.Append(fromToken(tok[index++], s)); // '{' sb.Append(" "); bool needNewLines = false; if (t.EntryList.Count > 4) { needNewLines = true; } for (int i = 0; i < t.EntryList.Count; i++) { string tmp = DoExpr(t.EntryList[i], s); if (tmp.Length > 10) { needNewLines = true; } sb.Append(tmp); if (i != t.EntryList.Count - 1) { sb.Append(fromToken(tok[index++], s)); // ',' sb.Append(" "); } } if (t.EntryList.Count > 0) // empty table constructor is just { } { sb.Append(" "); } sb.Append(fromToken(tok[index++], s)); // '}' ret = sb.ToString(); } else if (e is UnOpExpr) { UnOpExpr u = e as UnOpExpr; string sc = fromToken(tok[index++], s); if (u.Op.Length != 1) { sc += " "; } ret = sc + DoExpr(u.Rhs, s); } else if (e is TableConstructorValueExpr) { ret = DoExpr(((TableConstructorValueExpr)e).Value, s); } else if (e is VarargExpr) { ret = fromToken(tok[index++], s); } else if (e is VariableExpression) { ret = fromToken(tok[index++], s); } else if (e is TableConstructorNamedFunctionExpr) { ret = DoStatement(((TableConstructorNamedFunctionExpr)e).Value); } if (ret != null) { if (e.ParenCount > 0) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < e.ParenCount; i++) { sb.Append(fromToken(tok[startP++], s)); } sb.Append(ret); for (int i = 0; i < e.ParenCount; i++) { sb.Append(fromToken(tok[index++], s)); } return(sb.ToString()); } else { return(ret); } } //return string.Format("{0}{1}{2}", "(".Repeat(e.ParenCount), ret, ")".Repeat(e.ParenCount)); throw new NotImplementedException(e.GetType().Name + " is not implemented"); }
public virtual void Visit(CallExpr expr) { }
public override void Visit(CallExpr expr) { expr.callee.Accept(this); }
private static void* __CopyValue(CallExpr.__Internal native) { var ret = Marshal.AllocHGlobal(44); global::CppSharp.Parser.AST.CallExpr.__Internal.cctor_1(ret, new global::System.IntPtr(&native)); return ret.ToPointer(); }
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result) { result = new CallExpr(this, null, args); return(true); }
private CallExpr(CallExpr.__Internal native, bool skipVTables = false) : this(__CopyValue(native), skipVTables) { __ownsNativeInstance = true; NativeToManagedMap[__Instance] = this; }
Expression ParseSuffixedExpr(Scope scope, bool onlyDotColon = false) { // base primary expression Expression prim = ParsePrimaryExpr(scope); while (true) { if (tok.IsSymbol('.') || tok.IsSymbol(':')) { string symb = tok.Get().Data; // '.' or ':' // TODO: should we allow keywords? if (!tok.Is(TokenType.Ident)) { error("<Ident> expected"); } Token id = tok.Get(); MemberExpr m = new MemberExpr(); m.Base = prim; m.Indexer = symb; m.Ident = id.Data; prim = m; } else if (!onlyDotColon && tok.ConsumeSymbol('[')) { Expression ex = ParseExpr(scope); if (!tok.ConsumeSymbol(']')) { error("']' expected"); } IndexExpr i = new IndexExpr(); i.Base = prim; i.Index = ex; prim = i; } else if (!onlyDotColon && tok.ConsumeSymbol('(')) { List <Expression> args = new List <Expression>(); while (!tok.ConsumeSymbol(')')) { Expression ex = ParseExpr(scope); args.Add(ex); if (!tok.ConsumeSymbol(',')) { if (tok.ConsumeSymbol(')')) { break; } else { error("')' expected"); } } } CallExpr c = new CallExpr(); c.Base = prim; c.Arguments = args; prim = c; } else if (!onlyDotColon && (tok.Is(TokenType.SingleQuoteString) || tok.Is(TokenType.DoubleQuoteString) || tok.Is(TokenType.LongString))) { //string call StringCallExpr e = new StringCallExpr(); e.Base = prim; e.Arguments = new List <Expression> { new StringExpr(tok.Peek().Data) { StringType = tok.Peek().Type } }; tok.Get(); prim = e; } else if (!onlyDotColon && tok.IsSymbol('{')) { // table call Expression ex = ParseExpr(scope); TableCallExpr t = new TableCallExpr(); t.Base = prim; t.Arguments = new List <Expression> { ex }; prim = t; } else { break; } } return(prim); }