public FunctionDefinition(string name, Parameter[] parameters, Statement body) { ContractUtils.RequiresNotNullItems(parameters, "parameters"); if (name == null) { _name = "<lambda$" + Interlocked.Increment(ref _lambdaId) + ">"; _isLambda = true; } else { _name = name; } _parameters = parameters; _body = body; }
private Parameter ParseParameterName(HashSet<string> names, ParameterKind kind) { string name = ReadName(); if (name != null) { CheckUniqueParameter(names, name); } else { return null; } Parameter parameter = new Parameter(name, kind); parameter.SetLoc(_globalParent, GetStart(), GetEnd()); return parameter; }
internal arguments(Parameter[] parameters) : this(parameters as IList<Parameter>) { }
public override void PostWalk(Parameter node) { }
public override bool Walk(Parameter node) { Content(node.Name); Define(node.Name); return false; }
private Parameter ParseParameterName(Dictionary<SymbolId, object> names, ParameterKind kind) { SymbolId name = ReadName(); if (name != SymbolId.Empty) { CheckUniqueParameter(names, name); } else { return null; } Parameter parameter = new Parameter(name, kind); parameter.SetLoc(GetStart(), GetEnd()); return parameter; }
internal Parameter[] Revert() { List<Parameter> parameters = new List<Parameter>(); int argIdx = args.Count - 1; for (int defIdx = defaults.Count - 1; defIdx >= 0; defIdx--, argIdx--) { Name name = (Name)args[argIdx]; Parameter p = new Parameter(name.id); p.DefaultValue = expr.Revert(defaults[defIdx]); parameters.Add(p); } while (argIdx >= 0) { Name name = (Name)args[argIdx--]; parameters.Add(new Parameter(name.id)); } parameters.Reverse(); if (vararg != null) parameters.Add(new Parameter(vararg, ParameterKind.List)); if (kwarg != null) parameters.Add(new Parameter(kwarg, ParameterKind.Dictionary)); return parameters.ToArray(); }
public FunctionDefinition(string name, Parameter[] parameters, Statement body, SourceUnit sourceUnit) : this(name, parameters, body) { }
internal static ParameterResult MakeParameterResult(ProjectState state, Parameter curParam) { string name = curParam.Name; if (curParam.IsDictionary) { name = "**" + name; } else if (curParam.IsList) { name = "*" + curParam.Name; } if (curParam.DefaultValue != null) { // TODO: Support all possible expressions for default values, we should // probably have a PythonAst walker for expressions or we should add ToCodeString() // onto Python ASTs so they can round trip ConstantExpression defaultValue = curParam.DefaultValue as ConstantExpression; if (defaultValue != null) { name = name + " = " + PythonOps.Repr(state.CodeContext, defaultValue.Value); } NameExpression nameExpr = curParam.DefaultValue as NameExpression; if (nameExpr != null) { name = name + " = " + nameExpr.Name; } DictionaryExpression dict = curParam.DefaultValue as DictionaryExpression; if (dict != null) { if (dict.Items.Count == 0) { name = name + " = {}"; } else { name = name + " = {...}"; } } ListExpression list = curParam.DefaultValue as ListExpression; if (list != null) { if (list.Items.Count == 0) { name = name + " = []"; } else { name = name + " = [...]"; } } TupleExpression tuple = curParam.DefaultValue as TupleExpression; if (tuple != null) { if (tuple.Items.Count == 0) { name = name + " = ()"; } else { name = name + " = (...)"; } } } var newParam = new ParameterResult(name); return newParam; }
// Parameter public override bool Walk(Parameter node) { node.Parent = _currentScope; return base.Walk(node); }
private static FunctionAttributes ComputeFlags(Parameter[] parameters) { FunctionAttributes fa = FunctionAttributes.None; if (parameters != null) { int i; for (i = 0; i < parameters.Length; i++) { Parameter p = parameters[i]; if (p.IsDictionary || p.IsList) break; } // Check for the list and dictionary parameters, which must be the last(two) if (i < parameters.Length && parameters[i].IsList) { i++; fa |= FunctionAttributes.ArgumentList; } if (i < parameters.Length && parameters[i].IsDictionary) { i++; fa |= FunctionAttributes.KeywordDictionary; } // All parameters must now be exhausted Debug.Assert(i == parameters.Length); } return fa; }
public FunctionDefinition(string name, Parameter[] parameters, SourceUnit sourceUnit) : this(name, parameters, null, sourceUnit) { }
public VariableDef DefineVariable(Parameter node, AnalysisUnit unit) { return Variables[node.Name] = new LocatedVariableDef(unit.DeclaringModule.ProjectEntry, node); }
public string Visit(PyAst.Parameter node) { var maybeStar = node.IsList ? "*" : ""; return(maybeStar + node.Name + (node.DefaultValue == null ? "" : $" = {Visit(node.DefaultValue)}")); }
// genexpr_for ::= "for" target_list "in" or_test [genexpr_iter] // genexpr_iter ::= (genexpr_for | genexpr_if) * // // "for" has NOT been eaten before entering this method private Expression ParseGeneratorExpression(Expression expr) { ForStatement root = ParseGenExprFor(); Statement current = root; for (; ; ) { if (PeekToken(Tokens.KeywordForToken)) { current = NestGenExpr(current, ParseGenExprFor()); } else if (PeekToken(Tokens.KeywordIfToken)) { current = NestGenExpr(current, ParseGenExprIf()); } else { // Generator Expressions have an implicit function definition and yield around their expression. // (x for i in R) // becomes: // def f(): // for i in R: yield (x) ExpressionStatement ys = new ExpressionStatement(new YieldExpression(expr)); ys.Expression.SetLoc(_globalParent, expr.IndexSpan); ys.SetLoc(_globalParent, expr.IndexSpan); NestGenExpr(current, ys); break; } } // We pass the outermost iterable in as a parameter because Python semantics // say that this one piece is computed at definition time rather than iteration time const string fname = "<genexpr>"; Parameter parameter = new Parameter("__gen_$_parm__", 0); FunctionDefinition func = new FunctionDefinition(fname, new Parameter[] { parameter }, root); func.IsGenerator = true; func.SetLoc(_globalParent, root.StartIndex, GetEnd()); func.HeaderIndex = root.EndIndex; // Transform the root "for" statement Expression outermost = root.List; NameExpression ne = new NameExpression("__gen_$_parm__"); ne.SetLoc(_globalParent, outermost.IndexSpan); root.List = ne; GeneratorExpression ret = new GeneratorExpression(func, outermost); ret.SetLoc(_globalParent, expr.StartIndex, GetEnd()); return ret; }
public override bool Walk(Parameter node) { node.Parent = _binder._currentScope; node.PythonVariable = _binder.DefineParameter(node.Name); return(false); }
public override bool Walk(Parameter node) { _fc.Define(node.Name); return true; }
internal override AstExpression Revert() { Statement stmt = new ExpressionStatement(new YieldExpression(expr.Revert(elt))); int comprehensionIdx = generators.Count - 1; AstExpression list; do { comprehension c = (comprehension)generators[comprehensionIdx]; if (c.ifs != null && c.ifs.Count != 0) { int ifIdx = c.ifs.Count - 1; while (ifIdx >= 0) { IfStatementTest ist = new IfStatementTest(expr.Revert(c.ifs[ifIdx]), stmt); stmt = new IfStatement(new IfStatementTest[] { ist }, null); ifIdx--; } } list = expr.Revert(c.iter); stmt = new ForStatement(expr.Revert(c.target), list, stmt, null); comprehensionIdx--; } while (comprehensionIdx >= 0); ((ForStatement)stmt).List = new NameExpression(generatorFnArgName); Parameter parameter = new Parameter(generatorFnArgName, 0); FunctionDefinition functionDefinition = new FunctionDefinition(generatorFnName, new Parameter[] { parameter }, stmt); functionDefinition.IsGenerator = true; return new GeneratorExpression(functionDefinition, list); }
public override bool Walk(Parameter node) { node.Variable = _binder.DefineParameter(node.Name); return false; }
internal Name(Parameter para) : this(para.Name, Param.Instance) { GetSourceLocation(para); }
private static FunctionAttributes ComputeFlags(Parameter[] parameters) { FunctionAttributes fa = FunctionAttributes.None; if (parameters != null) { int i; for (i = 0; i < parameters.Length; i++) { Parameter p = parameters[i]; if (p.IsDictionary || p.IsList) break; } // Check for the list and dictionary parameters, which must be the last(two) if (i < parameters.Length && parameters[i].IsList) { i++; fa |= FunctionAttributes.ArgumentList; } if (i < parameters.Length && parameters[i].IsDictionary) { i++; fa |= FunctionAttributes.KeywordDictionary; } // All parameters must now be exhausted if (i < parameters.Length) { throw new ArgumentException(IronPython.Resources.InvalidParameters, "parameters"); } } return fa; }
// parameter ::= // identifier | "(" sublist ")" Parameter ParseParameter(int position, Dictionary<SymbolId, object> names) { Token t = PeekToken(); Parameter parameter = null; switch (t.Kind) { case TokenKind.LeftParenthesis: // sublist NextToken(); Expression ret = ParseSublist(names); Eat(TokenKind.RightParenthesis); TupleExpression tret = ret as TupleExpression; if (tret != null) { parameter = new SublistParameter(position, tret); } else { parameter = new Parameter(((NameExpression)ret).Name); } parameter.SetLoc(ret.Span); break; case TokenKind.Name: // identifier NextToken(); SymbolId name = FixName((SymbolId)t.Value); parameter = new Parameter(name); CompleteParameterName(parameter, name, names); break; default: ReportSyntaxError(_lookahead); break; } return parameter; }
private static Type GetGeneratorDelegateType(Parameter[] parameters, bool wrapper) { return PythonCallTargets.GetGeneratorTargetType(wrapper, parameters.Length); }
private void AddOptinonalParam(StringBuilder sb, Parameter p) { JavascriptGenerator gen = new JavascriptGenerator(src, sink); p.DefaultValue.Walk(gen); sb.AppendFormat("{0}if (typeof({1}) == 'undefined') {{", Indent(), p.Name ); sb.AppendLine(); sb.AppendFormat("{0}{1} = {2};", Indent(indent + 1), p.Name, gen.ToString() ); sb.AppendLine(); sb.AppendFormat("{0}}}", Indent()); sb.AppendLine(); }
public FunctionDefinition(SymbolId name, Parameter[] parameters, SourceUnit sourceUnit) : this(name, parameters, null, sourceUnit) { }
public override bool Walk(Parameter node) { node.Parent = _binder._currentScope; node.PythonVariable = _binder.DefineParameter(node.Name); return false; }
public FunctionDefinition(SymbolId name, Parameter[] parameters, Statement body, SourceUnit sourceUnit) { _name = name; _parameters = parameters; _body = body; _sourceUnit = sourceUnit; }
private Parameter ParseParameterName(Dictionary<string, object> names, ParameterKind kind) { string name = ReadName(); if (name != null) { CheckUniqueParameter(names, name); } else { return null; } Parameter parameter = new Parameter(name, kind); parameter.SetLoc(GetStart(), GetEnd()); return parameter; }
/// <summary> /// Determines delegate type for the Python function /// </summary> private static Type GetDelegateType(Parameter[] parameters, bool wrapper, out Delegate originalTarget) { return PythonCallTargets.GetPythonTargetType(wrapper, parameters.Length, out originalTarget); }
// parameter ::= // identifier | "(" sublist ")" private Parameter ParseParameter(int position, HashSet<string> names) { Token t = PeekToken(); Parameter parameter = null; switch (t.Kind) { case TokenKind.LeftParenthesis: // sublist NextToken(); Expression ret = ParseSublist(names); Eat(TokenKind.RightParenthesis); TupleExpression tret = ret as TupleExpression; NameExpression nameRet; if (tret != null) { parameter = new SublistParameter(position, tret); } else if ((nameRet = ret as NameExpression) != null) { parameter = new Parameter(nameRet.Name); } else { ReportSyntaxError(_lookahead); } if (parameter != null) { parameter.SetLoc(_globalParent, ret.IndexSpan); } break; case TokenKind.Name: // identifier NextToken(); string name = FixName((string)t.Value); parameter = new Parameter(name); CompleteParameterName(parameter, name, names); break; default: ReportSyntaxError(_lookahead); break; } return parameter; }
public FunctionDefinition(string name, Parameter[] parameters, SourceUnit sourceUnit) : this(name, parameters, (Statement)null) { }
public SelfNameFinder(FunctionDefinition function, Parameter self) { _function = function; _self = self; }
// Parameter public override bool Walk(Parameter node) { node.Parent = _currentScope; return(base.Walk(node)); }