public static Dictionary<string, object> FromPythonDict(IronPython.Runtime.Dict pythonDict)
{
Dictionary<string, object> dict = new Dictionary<string,object>();
foreach ( object key in pythonDict.Keys)
{
string propName = key as string;
if (propName == null)
{
throw new System.ArgumentException("Property name is not a string");
}
object propVal = pythonDict[key];
if (propVal is IronPython.Runtime.Dict)
{
dict.Add(propName, FromPythonDict(propVal as IronPython.Runtime.Dict));
}
else if (propVal is IronPython.Runtime.List)
{
dict.Add(propName, FromPythonList(propVal as IronPython.Runtime.List));
}
else if (propVal is IronMath.BigInteger)
{
IronMath.BigInteger val = propVal as IronMath.BigInteger;
dict.Add(propName, val.ToInt64());
}
else
{
dict.Add(propName, propVal);
}
}
return dict;
}
/// <summary>
/// Convert IronPython List into ILBaseArray
/// </summary>
/// <param name="list">IronPython List (must be filled with Python ints or floats)</param>
/// <returns>ILBaseArray</returns>
public static ILBaseArray array(IronPython.Runtime.List list)
{
List<int> size = new List<int>();
Type type = typeof(double);
PythonListHelper.GetListDimensionsAndType(ref size, list, ref type);
if (!PythonListHelper.CheckList(ref size, list, 0, ref type))
{
throw new ArgumentException("List is not rectangular or not of constant type!");
}
if (type == typeof(Double))
{
return new ILArray<Double>(list);
}
else if (type == typeof(Int32))
{
return new ILArray<Int32>(list);
}
else throw new ArgumentException("List type is not int or float");
}
internal CodeSpan(IronPython.Compiler.Location start, IronPython.Compiler.Location end)
{
this.startLine = start.Line;
this.startColumn = start.Column;
this.endLine = end.Line;
this.endColumn = end.Column;
}
public static DomainEntityCollection<Relationship> MakeGroup(IronPython.Runtime.List lst)
{
DomainEntityCollection<Relationship> retval = new DomainEntityCollection<Relationship>();
foreach (var c in lst)
{
retval.Add(new Relationship(null) { Code = (string)c });
}
return retval;
}
public static void PerformModuleReload(
IronPython.Runtime.PythonContext context,
IronPython.Runtime.PythonDictionary dict)
{
context.DomainManager.LoadAssembly(typeof(System.Xml.Linq.XDocument).Assembly);
dict["FOO"] = "bar";
System.Console.WriteLine("Module Load");
}
public static object get_state(IronPython.Runtime.CodeContext context, object value)
{
object prev_value = null;
if (context.LanguageContext.HasModuleState(_stateKey))
{
prev_value = context.LanguageContext.GetModuleState(_stateKey);
}
context.LanguageContext.SetModuleState(_stateKey, value);
return prev_value;
}
public IronPython.Runtime.List this[IronPython.Runtime.Slice xslice, IronPython.Runtime.Slice yslice]
{
get
{
if ((xslice.start == null) || (xslice.stop == null) || (yslice.start == null) || (yslice.stop == null))
{
throw new ILArgumentException("mgrid: start and stop of slices must be provided");
}
double xStep = 1, yStep = 1, xStart = 0, yStart = 0, xStop = 1, yStop = 1;
//
if (xslice.start is int) xStart = (double)(int)(xslice.start);
if (xslice.start is double) xStart = (double)(xslice.start);
if (xslice.stop is int) xStop = (double)(int)(xslice.stop);
if (xslice.stop is double) xStop = (double)(xslice.stop);
//
if (yslice.start is int) yStart = (double)(int)(yslice.start);
if (yslice.start is double) yStart = (double)(yslice.start);
if (yslice.stop is int) yStop = (double)(int)(yslice.stop);
if (yslice.stop is double) yStop = (double)(yslice.stop);
//
if (xslice.step == null)
{
if (xStop >= xStart) xStep = 1;
else xStep = -1;
}
else
{
if (xslice.step is int) xStep = (double)(int)(xslice.step);
if (xslice.step is double) xStep = (double)(xslice.step);
}
if (yslice.step == null)
{
if (yStop >= yStart) yStep = 1;
else yStep = -1;
}
else
{
if (yslice.step is int) yStep = (double)(int)(yslice.step);
if (yslice.step is double) yStep = (double)(yslice.step);
}
//
IronPython.Runtime.List list = new IronPython.Runtime.List();
int nx = (int)Math.Floor((xStop - xStart) / xStep) + 1;
int ny = (int)Math.Floor((yStop - yStart) / yStep) + 1;
ILArray<double> x = ILMath.counter(xStart, xStep, nx);
ILArray<double> y = ILMath.counter(yStart, yStep, ny);
List<ILArray<double>> meshgrid = ILMath.meshgrid(x, y);
list.Add(meshgrid[0]); list.Add(meshgrid[1]);
return list;
}
}
internal static ComplexF[] List_to_ComplexArray(IronPython.Runtime.List list_object)
{
ComplexF[] _fft = new ComplexF[list_object.Count];
for (int i = 0 ; i < _fft.Length ; i++)
{
try
{
if (list_object[i].GetType() == typeof(System.Numerics.Complex))
{
System.Numerics.Complex c = (System.Numerics.Complex)list_object[i];
_fft[i] = new ComplexF((float)c.Real, (float)c.Imaginary);
}
else
{
_fft[i] = new ComplexF(float.Parse(list_object[i].ToString()), 0);
}
} catch (Exception)
{
throw;
}
}
return _fft;
}
public void Analyze(IronPython.Compiler.Ast.FunctionDefinition function)
{
this.argument = 0;
this.function = function;
foreach (Expression param in function.Parameters) {
param.Walk(this);
argument++;
}
}
private void PushScope(IronPython.Compiler.Ast.ClassDefinition cls)
{
PushScope(new ClassScope(module, current, cls));
}
public Compiler(IList<string> sourcesFiles, string OutputAssembly, IronPython.Hosting.CompilerSink compilerSink)
: base(sourcesFiles, OutputAssembly, compilerSink)
{
}
internal keyword(IronPython.Compiler.Ast.Arg arg)
: this() {
_arg = arg.Name;
_value = Convert(arg.Expression);
}
public FunctionDefinitionInfo(IronPython.Compiler.Ast.FunctionDefinition function)
{
this.function = function;
}
public override bool Walk(IronPython.Compiler.Ast.FunctionDefinition node) {
UpdateLoops(node);
return base.Walk(node);
}
public override bool Walk(IronPython.Compiler.Ast.ClassDefinition node) {
UpdateLoops(node);
return false;
}
public void PostWalk(IronPython.Compiler.Ast.FunctionDefinition node)
{
AssertCurrent(node); current = current.Parent;
}
/// <summary>
/// Recurively builds an stack-trace string from the IronPython traceback.
/// </summary>
/// <param name="traceback"></param>
/// <returns></returns>
private StringBuilder BuildTraceback(IronPython.Runtime.Exceptions.TraceBack traceback)
{
StringBuilder traceBuilder = new StringBuilder();
if (traceback == null)
return traceBuilder;
if (traceback.tb_next != null)
{
traceBuilder.AppendFormat("{0}\r\n", BuildTraceback(traceback.tb_next));
}
if (traceback.tb_frame != null && traceback.tb_frame is IronPython.Runtime.Exceptions.TraceBackFrame)
{
IronPython.Runtime.Exceptions.TraceBackFrame frame = (IronPython.Runtime.Exceptions.TraceBackFrame)traceback.tb_frame;
if (frame.f_code != null)
{
traceBuilder.AppendFormat("at {0} Line {1}",
frame.f_code.co_filename,
traceback.tb_lineno);
}
}
return traceBuilder;
}
public static LinkedList<object> FromPythonList(IronPython.Runtime.List pythonList)
{
LinkedList<object> list = new LinkedList<object>();
foreach (object obj in pythonList)
{
if (obj is IronPython.Runtime.Dict)
{
list.AddLast(FromPythonDict(obj as IronPython.Runtime.Dict));
}
else if (obj is IronPython.Runtime.List)
{
list.AddLast(FromPythonList(obj as IronPython.Runtime.List));
}
else if (obj is IronMath.BigInteger)
{
IronMath.BigInteger val = obj as IronMath.BigInteger;
list.AddLast(val.ToInt64());
}
else
{
list.AddLast(obj);
}
}
return list;
}
public ClassDefinition(IronPython.Compiler.Ast.ClassDefinition @class)
{
this.@class = @class;
}
/// <summary>
/// Log Errors/Warnings/Messages when the compiler reports them.
/// </summary>
/// <param name="path">Path to the file where the error was found (null/empty if N/A)</param>
/// <param name="message">Text of the error/warning/message</param>
/// <param name="startLine">First line of the block containing the error (0 if N/A)</param>
/// <param name="startColumn">First column of the block containing the error (0 if N/A)</param>
/// <param name="endLine">Last line of the block containing the error (0 if N/A)</param>
/// <param name="endColumn">Last column of the block containing the error (0 if N/A)</param>
/// <param name="errorCode">Code corresponding to the error</param>
/// <param name="severity">Error/Warning/Message</param>
public override void AddError(string path, string message, string lineText, IronPython.Hosting.CodeSpan location, int errorCode, IronPython.Hosting.Severity severity)
{
if (ProjectDirectory != null && !System.IO.Path.IsPathRooted(path))
path = System.IO.Path.Combine(ProjectDirectory, path);
// Based on the type of event (error/warning/message), report the corresponding type of problem to MSBuild
switch(severity)
{
case IronPython.Hosting.Severity.Error:
{
buildSucceeded = false;
taskLogger.LogError(String.Empty, "PY" + errorCode.ToString(), String.Empty, path, location.StartLine, location.StartColumn, location.EndLine, location.EndColumn, message);
break;
}
case IronPython.Hosting.Severity.Warning:
{
taskLogger.LogWarning(String.Empty, "PY" + errorCode.ToString(), String.Empty, path, location.StartLine, location.StartColumn, location.EndLine, location.EndColumn, message);
break;
}
case IronPython.Hosting.Severity.Message:
{
taskLogger.LogMessage(message);
break;
}
}
}
private void WalkLoopBody(IronPython.Compiler.Ast.Statement body, bool isFinally) {
bool inLoop = _inLoop;
bool inFinally = _inFinally;
int loopId = ++_loopId;
_inFinally = false;
_inLoop = true;
_loopIds.Add(loopId, isFinally);
body.Walk(this);
_inLoop = inLoop;
_inFinally = inFinally;
LoopOrFinallyIds.Remove(loopId);
}
// FunctionDefinition
public bool Walk(IronPython.Compiler.Ast.FunctionDefinition node)
{
current = node; return Process(node);
}
public override void PostWalk(IronPython.Compiler.Ast.EmptyStatement node) {
UpdateLoops(node);
base.PostWalk(node);
}
public override void PostWalk(IronPython.Compiler.Ast.FunctionDefinition node)
{
PopScope();
}
public override bool Walk(IronPython.Compiler.Ast.WithStatement node) {
UpdateLoops(node);
return base.Walk(node);
}
// FunctionDefinition
public override bool Walk(IronPython.Compiler.Ast.FunctionDefinition node)
{
// Name is defined in the enclosing scope
Define(node.Name, new FunctionDefinition(node));
// process the default arg values in the outer scope
foreach (Expression e in node.Defaults) {
e.Walk(this);
}
// process the decorators in the outer scope
if (node.Decorators != null) {
node.Decorators.Walk(this);
}
PushScope(node);
argumentAnalyzer.Analyze(node);
return true;
}
public InferredClass GetClass(IronPython.Compiler.Ast.ClassDefinition cls)
{
Debug.Assert(scopes.ContainsKey(cls));
return new InferredClass(scopes[cls] as ClassScope);
}
private void PushScope(IronPython.Compiler.Ast.FunctionDefinition func)
{
PushScope(new FunctionScope(module, current, func));
}
// ClassDefinition
public override bool Walk(IronPython.Compiler.Ast.ClassDefinition node)
{
Define(node.Name, new ClassDefinition(node));
// Base references are in the outer scope
foreach (Expression b in node.Bases) b.Walk(this);
// And so is the __name__ reference
Reference(SymbolTable.Name);
PushScope(node);
// define the __doc__
SymbolId doc = SymbolTable.Doc;
Define(doc, new DirectDefinition(typeof(string)));
// Walk the body
node.Body.Walk(this);
return false;
}
public ExperimentalCompiler(IList<string> sourcesFiles, string outputAssembly, IronPython.Hosting.CompilerSink compilerSink)
{
this.sourceFiles = (List<string>)sourcesFiles;
this.outputAssembly = outputAssembly;
this.errorSink = compilerSink;
}
