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