Inheritance: Node
コード例 #1
0
 public void PostWalk(Arg node)
 {
     PostProcess(node);
 }
コード例 #2
0
 // Arg
 public bool Walk(Arg node)
 {
     return Process(node);
 }
コード例 #3
0
 public string Visit(PyAst.Arg node) => (node.Name is null ? "" : node.Name + " = ") + Visit(node.Expression);
コード例 #4
0
ファイル: CallExpression.cs プロジェクト: mstram/ironruby
 public CallExpression(Expression target, Arg[] args) {
     _target = target;
     _args = args;
 }
コード例 #5
0
ファイル: Parser.cs プロジェクト: bdoot/IronLanguages
        // arglist:
        //             expression                     rest_of_arguments
        //             expression "=" expression      rest_of_arguments
        //             expression "for" gen_expr_rest
        //
        private Arg[] FinishArgListOrGenExpr() {
            Arg a = null;
            
            if (_sink != null) {
                _sink.StartParameters(GetSourceSpan());
            }

            Token t = PeekToken();
            if (t.Kind != TokenKind.RightParenthesis && t.Kind != TokenKind.Multiply && t.Kind != TokenKind.Power) {
                var start = GetStart();
                Expression e = ParseExpression();
                if (e is ErrorExpression) {
                    return null;
                }

                if (MaybeEat(TokenKind.Assign)) {               //  Keyword argument
                    a = FinishKeywordArgument(e);

                    if (a == null) {                            // Error recovery
                        a = new Arg(e);
                        a.SetLoc(_globalParent, e.StartIndex, GetEnd());
                    }
                } else if (PeekToken(Tokens.KeywordForToken)) {    //  Generator expression
                    a = new Arg(ParseGeneratorExpression(e));
                    Eat(TokenKind.RightParenthesis);
                    a.SetLoc(_globalParent, start, GetEnd());
                    if (_sink != null) {
                        _sink.EndParameters(GetSourceSpan());
                    }
                    return new Arg[1] { a };       //  Generator expression is the argument
                } else {
                    a = new Arg(e);
                    a.SetLoc(_globalParent, e.StartIndex, e.EndIndex);
                }

                //  Was this all?
                //
                if (MaybeEat(TokenKind.Comma)) {
                    if (_sink != null) {
                        _sink.NextParameter(GetSourceSpan());
                    }
                } else {
                    Eat(TokenKind.RightParenthesis);
                    a.SetLoc(_globalParent, start, GetEnd());
                    if (_sink != null) {
                        _sink.EndParameters(GetSourceSpan());
                    }
                    return new Arg[1] { a };
                }
            }

            return FinishArgumentList(a);
        }
コード例 #6
0
ファイル: Parser.cs プロジェクト: bdoot/IronLanguages
 private void CheckUniqueArgument(List<Arg> names, Arg arg) {
     if (arg != null && arg.Name != null) {
         for (int i = 0; i < names.Count; i++) {
             if (names[i].Name == arg.Name) {
                 ReportSyntaxError(IronPython.Resources.DuplicateKeywordArg);
             }
         }
     }
 }
コード例 #7
0
 // Arg
 public virtual bool Walk(Arg node)
 {
     return false;
 }
コード例 #8
0
ファイル: JavascriptGenerator.cs プロジェクト: valdisz/PyToJs
 public override void PostWalk(Arg node)
 {
     CommonPostWalk(node);
 }
コード例 #9
0
ファイル: Parser.cs プロジェクト: FabioNascimento/DICommander
        //arglist: (argument ',')* (argument [',']| '*' test [',' '**' test] | '**' test)
        //argument: [test '='] test    # Really [keyword '='] test
        private Arg[] FinishArgumentList(Arg first)
        {
            const TokenKind terminator = TokenKind.RightParenthesis;
            List<Arg> l = new List<Arg>();
            Dictionary<SymbolId, SymbolId> names = new Dictionary<SymbolId, SymbolId>();

            if (first != null) {
                l.Add(first);
                CheckUniqueArgument(names, first);
            }

            // Parse remaining arguments
            while (true) {
                if (MaybeEat(terminator)) {
                    break;
                }
                Location start = GetStart();
                Arg a;
                if (MaybeEat(TokenKind.Multiply)) {
                    Expression t = ParseTest();
                    a = new Arg(SymbolTable.Star, t);
                } else if (MaybeEat(TokenKind.Power)) {
                    Expression t = ParseTest();
                    a = new Arg(SymbolTable.StarStar, t);
                } else {
                    Expression e = ParseTest();
                    if (MaybeEat(TokenKind.Assign)) {
                        a = FinishKeywordArgument(e);
                        CheckUniqueArgument(names, a);
                    } else {
                        a = new Arg(e);
                    }
                }
                a.SetLoc(GetExternal(), start, GetEnd());
                l.Add(a);
                if (MaybeEat(TokenKind.Comma)) {
                    context.Sink.NextParameter(GetSpan());
                } else {
                    Eat(terminator);
                    break;
                }
            }

            context.Sink.EndParameters(GetSpan());

            Arg[] ret = l.ToArray();
            return ret;
        }
コード例 #10
0
ファイル: Parser.cs プロジェクト: FabioNascimento/DICommander
 private Arg FinishKeywordArgument(Expression t)
 {
     NameExpression n = t as NameExpression;
     if (n == null) {
         ReportSyntaxError("expected name");
         Arg arg = new Arg(SymbolTable.StringToId(""), t);
         arg.SetLoc(GetExternal(), t.Start, t.End);
         return arg;
     } else {
         Expression val = ParseTest();
         Arg arg = new Arg(n.Name, val);
         arg.SetLoc(GetExternal(), n.Start, val.End);
         return arg;
     }
 }
コード例 #11
0
ファイル: Parser.cs プロジェクト: FabioNascimento/DICommander
        // arglist ::=
        //             test                     rest_of_arguments
        //             test "=" test            rest_of_arguments
        //             test "for" gen_expr_rest
        //
        private Arg[] FinishArgListOrGenExpr()
        {
            Arg a = null;

            context.Sink.StartParameters(GetSpan());

            Token t = PeekToken();
            if (t.Kind != TokenKind.RightParenthesis && t.Kind != TokenKind.Multiply && t.Kind != TokenKind.Power) {
                Location start = GetStart();
                Expression e = ParseTest();
                if (MaybeEat(TokenKind.Assign)) {               //  Keyword argument
                    a = FinishKeywordArgument(e);

                    if (a == null) {                            // Error recovery
                        a = new Arg(e);
                        a.SetLoc(GetExternal(), e.Start, GetEnd());
                    }
                } else if (PeekToken(Tokens.KeywordForToken)) {    //  Generator expression
                    a = new Arg(ParseGeneratorExpression(e));
                    Eat(TokenKind.RightParenthesis);
                    a.SetLoc(GetExternal(), start, GetEnd());
                    context.Sink.EndParameters(GetSpan());
                    return new Arg[1] { a };       //  Generator expression is the argument
                } else {
                    a = new Arg(e);
                    a.SetLoc(GetExternal(), e.Start, e.End);
                }

                //  Was this all?
                //
                if (MaybeEat(TokenKind.Comma)) {
                    context.Sink.NextParameter(GetSpan());
                } else {
                    Eat(TokenKind.RightParenthesis);
                    a.SetLoc(GetExternal(), start, GetEnd());
                    context.Sink.EndParameters(GetSpan());
                    return new Arg[1] { a };
                }
            }

            return FinishArgumentList(a);
        }
コード例 #12
0
ファイル: Parser.cs プロジェクト: FabioNascimento/DICommander
 private void CheckUniqueArgument(Dictionary<SymbolId, SymbolId> names, Arg arg)
 {
     if (arg != null && arg.Name != SymbolTable.Empty) {
         SymbolId name = arg.Name;
         if (names.ContainsKey(name)) {
             ReportSyntaxError("duplicate keyword argument");
         }
         names[name] = name;
     }
 }
コード例 #13
0
ファイル: Parser.cs プロジェクト: octavioh/ironruby
 private void CheckUniqueArgument(Dictionary<SymbolId, SymbolId> names, Arg arg) {
     if (arg != null && arg.Name != SymbolId.Empty) {
         SymbolId name = arg.Name;
         if (names.ContainsKey(name)) {
             ReportSyntaxError(IronPython.Resources.DuplicateKeywordArg);
         }
         names[name] = name;
     }
 }
コード例 #14
0
ファイル: Parser.cs プロジェクト: tnachen/ironruby
 private Arg FinishKeywordArgument(Expression t) {
     NameExpression n = t as NameExpression;
     if (n == null) {
         ReportSyntaxError(IronPython.Resources.ExpectedName);
         Arg arg = new Arg(null, t);
         arg.SetLoc(t.Start, t.End);
         return arg;
     } else {
         Expression val = ParseExpression();
         Arg arg = new Arg(SymbolTable.IdToString(n.Name), val);
         arg.SetLoc(n.Start, val.End);
         return arg;
     }
 }
コード例 #15
0
 // Arg
 public virtual bool Walk(Arg node)
 {
     return true;
 }
コード例 #16
0
ファイル: JavascriptGenerator.cs プロジェクト: valdisz/PyToJs
        public override bool Walk(Arg node)
        {
            if (!String.IsNullOrWhiteSpace(node.Name))
            {
                sink.Add(src, "Named parameters are not supported.", node.Span, NAMED_PARAMETER, Severity.FatalError);
            }

            CommonWalk(node);

            return true;
        }
コード例 #17
0
 public virtual void PostWalk(Arg node)
 {
 }
コード例 #18
0
ファイル: Parser.cs プロジェクト: techarch/ironruby
 private void CheckUniqueArgument(Dictionary<string, string> names, Arg arg) {
     if (arg != null && arg.Name != null) {
         string name = arg.Name;
         if (names.ContainsKey(name)) {
             ReportSyntaxError(IronPython.Resources.DuplicateKeywordArg);
         }
         names[name] = name;
     }
 }
コード例 #19
0
 // Arg
 public override bool Walk(Arg node) {
     node.Parent = _currentScope;
     return base.Walk(node);
 }
コード例 #20
0
ファイル: Parser.cs プロジェクト: bdoot/IronLanguages
 private Arg FinishKeywordArgument(Expression t) {
     NameExpression n = t as NameExpression;
     if (n == null) {
         ReportSyntaxError(IronPython.Resources.ExpectedName);
         Arg arg = new Arg(null, t);
         arg.SetLoc(_globalParent, t.StartIndex, t.EndIndex);
         return arg;
     } else {
         Expression val = ParseExpression();
         Arg arg = new Arg(n.Name, val);
         arg.SetLoc(_globalParent, n.StartIndex, val.EndIndex);
         return arg;
     }
 }
コード例 #21
0
 public CallExpression(Expression target, Arg[] args, bool hasArgsTuple, bool hasKeywordDictionary, int keywordCount, int extraArgs)
 {
     this.target = target;
     this.args = args;
     this.hasArgsTuple = hasArgsTuple;
     this.hasKeywordDict = hasKeywordDictionary;
     this.keywordCount = keywordCount;
     this.extraArgs = extraArgs;
 }
コード例 #22
0
ファイル: Parser.cs プロジェクト: bdoot/IronLanguages
        //arglist: (argument ',')* (argument [',']| '*' expression [',' '**' expression] | '**' expression)
        //argument: [expression '='] expression    # Really [keyword '='] expression
        private Arg[] FinishArgumentList(Arg first) {
            const TokenKind terminator = TokenKind.RightParenthesis;
            List<Arg> l = new List<Arg>();

            if (first != null) {
                l.Add(first);
            }

            // Parse remaining arguments
            while (true) {
                if (MaybeEat(terminator)) {
                    break;
                }
                var start = GetStart();
                Arg a;
                if (MaybeEat(TokenKind.Multiply)) {
                    Expression t = ParseExpression();
                    a = new Arg("*", t);
                } else if (MaybeEat(TokenKind.Power)) {
                    Expression t = ParseExpression();
                    a = new Arg("**", t);
                } else {
                    Expression e = ParseExpression();
                    if (MaybeEat(TokenKind.Assign)) {
                        a = FinishKeywordArgument(e);
                        CheckUniqueArgument(l, a);
                    } else {
                        a = new Arg(e);
                    }
                }
                a.SetLoc(_globalParent, start, GetEnd());
                l.Add(a);
                if (MaybeEat(TokenKind.Comma)) {
                    if (_sink != null) {
                        _sink.NextParameter(GetSourceSpan());
                    }
                } else {
                    Eat(terminator);
                    break;
                }
            }

            if (_sink != null) {
                _sink.EndParameters(GetSourceSpan());
            }

            Arg[] ret = l.ToArray();
            return ret;
        }
コード例 #23
0
ファイル: ResolveWalker.cs プロジェクト: Rpinski/SharpDevelop
		public override bool Walk(Arg node)
		{
			writer.WriteLine("Arg: " + node.Name.ToString());
			return base.Walk(node);
		}