static void InitializeCompiler(Compiler.CompilerContext ctx)
{
if (compiler_initialized)
{
return;
}
lock (compiler_initializer) {
if (compiler_initialized)
{
return;
}
// TODO: This smells like pretty big issue
// AppDomain.CurrentDomain.AssemblyLoad += (sender, e) => { throw new NotImplementedException (); };
// Add all currently loaded assemblies
foreach (System.Reflection.Assembly a in AppDomain.CurrentDomain.GetAssemblies())
{
Compiler.GlobalRootNamespace.Instance.AddAssemblyReference(a);
}
Compiler.TypeManager.InitCoreTypes(ctx);
Compiler.TypeManager.InitOptionalCoreTypes(ctx);
compiler_initialized = true;
}
}
public Shell(MainWindow container) : base()
{
this.container = container;
WrapMode = WrapMode.Word;
CreateTags ();
Pango.FontDescription font_description = new Pango.FontDescription();
font_description.Family = "Monospace";
ModifyFont(font_description);
TextIter end = Buffer.EndIter;
Buffer.InsertWithTagsByName (ref end, "Mono C# Shell, type 'help;' for help\n\nEnter statements or expressions below.\n", "Comment");
ShowPrompt (false);
context = new CompilerContext (new CompilerSettings (), new ConsoleReportPrinter ());
evaluator = new Evaluator (context);
evaluator.DescribeTypeExpressions = true;
evaluator.InteractiveBaseClass = typeof (InteractiveGraphicsBase);
evaluator.Run ("LoadAssembly (\"System.Drawing\");");
evaluator.Run ("using System; using System.Linq; using System.Collections; using System.Collections.Generic; using System.Drawing;");
if (!MainClass.Debug){
GuiStream error_stream = new GuiStream ("Error", (x, y) => Output (x, y));
StreamWriter gui_output = new StreamWriter (error_stream);
gui_output.AutoFlush = true;
Console.SetError (gui_output);
GuiStream stdout_stream = new GuiStream ("Stdout", (x, y) => Output (x, y));
gui_output = new StreamWriter (stdout_stream);
gui_output.AutoFlush = true;
Console.SetOut (gui_output);
}
}
public void Simple ()
{
//string content = @"class A { }";
string content = @"
class Foo
{
void Bar ()
{
completionList.Add (""delegate"" + sb, ""md-keyword"", GettextCatalog.GetString (""Creates anonymous delegate.""), ""delegate"" + sb + "" {"" + Document.Editor.EolMarker + stateTracker.Engine.ThisLineIndent + TextEditorProperties.IndentString + ""|"" + Document.Editor.EolMarker + stateTracker.Engine.ThisLineIndent +""};"");
}
}"
;
var stream = new MemoryStream (Encoding.UTF8.GetBytes (content));
var ctx = new CompilerContext (new CompilerSettings (), new AssertReportPrinter ());
ModuleContainer module = new ModuleContainer (ctx);
var file = new SourceFile ("test", "asdfas", 0);
CSharpParser parser = new CSharpParser (
new SeekableStreamReader (stream, Encoding.UTF8),
new CompilationSourceFile (module, file),
ctx.Report,
new ParserSession ());
RootContext.ToplevelTypes = module;
Location.Initialize (new List<SourceFile> { file });
parser.parse ();
Assert.AreEqual (0, ctx.Report.Errors);
module.Accept (new TestVisitor ());
}
static void Main(string[] args)
{
var compilerContext = new CompilerContext(new CompilerSettings(), new ConsoleReportPrinter());
var evaluator = new Evaluator(compilerContext);
// Make it reference our own assembly so it can use IFoo
evaluator.ReferenceAssembly(typeof(IFoo).Assembly);
// Feed it some code
evaluator.Compile(
@"
public class Foo : MonoCompilerDemo.IFoo
{
public string Bar(string s) { return s.ToUpper(); }
}");
for (; ; )
{
string line = Console.ReadLine();
if (line == null) break;
object result;
bool result_set;
evaluator.Evaluate(line, out result, out result_set);
if (result_set) Console.WriteLine(result);
}
}
public virtual Type LookupTypeReflection (CompilerContext ctx, string name, Location loc, bool must_be_unique)
{
Type found_type = null;
foreach (Assembly a in referenced_assemblies) {
Type t = GetTypeInAssembly (a, name);
if (t == null)
continue;
if (!must_be_unique)
return t;
if (found_type == null) {
found_type = t;
continue;
}
// When type is forwarded
if (t.Assembly == found_type.Assembly)
continue;
ctx.Report.SymbolRelatedToPreviousError (found_type);
ctx.Report.SymbolRelatedToPreviousError (t);
if (loc.IsNull) {
Error_AmbiguousPredefinedType (ctx, loc, name, found_type);
} else {
ctx.Report.Error (433, loc, "The imported type `{0}' is defined multiple times", name);
}
return found_type;
}
return found_type;
}
private static void InitializeEvaluator()
{
_Interop.VarStorage["ReplVersion"] = typeof(Program).Assembly.GetName().Version;
var settings = new CompilerSettings() {
StdLib = true
};
var reportPrinter = new ConsoleReportPrinter();
var ctx = new CompilerContext(settings, reportPrinter);
evaluator = new Evaluator(ctx);
evaluator.ReferenceAssembly(typeof(_Interop).Assembly);
evaluator.Run(
@"
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
");
evaluator.Run("var _v = _Interop.VarStorage;");
evaluator.Run("var _h = _Interop.History;");
evaluator.Run("_Interop.VoidMethod exit = _Interop.Exit;");
evaluator.Run("_Interop.ReturnStringListMethod globals = _Interop.GetGlobals");
}
public void FeatureIsNotAvailable (CompilerContext compiler, Location loc, string feature)
{
string version;
switch (compiler.Settings.Version) {
case LanguageVersion.ISO_1:
version = "1.0";
break;
case LanguageVersion.ISO_2:
version = "2.0";
break;
case LanguageVersion.V_3:
version = "3.0";
break;
case LanguageVersion.V_4:
version = "4.0";
break;
case LanguageVersion.V_5:
version = "5.0";
break;
default:
throw new InternalErrorException ("Invalid feature version", compiler.Settings.Version);
}
Error (1644, loc,
"Feature `{0}' cannot be used because it is not part of the C# {1} language specification",
feature, version);
}
public static DynamicContext Create()
{
if (dc != null)
{
return(dc);
}
lock (compiler_initializer) {
if (dc != null)
{
return(dc);
}
var settings = new Compiler.CompilerSettings()
{
WarningLevel = 0
};
var cc = new Compiler.CompilerContext(settings, ErrorPrinter.Instance)
{
IsRuntimeBinder = true
};
//
// Any later loaded assemblies are handled internally by GetAssemblyDefinition
// domain.AssemblyLoad cannot be used as that would be too destructive as we
// would hold all loaded assemblies even if they can be never visited
//
// TODO: Remove this code and rely on GetAssemblyDefinition only
//
var module = new Compiler.ModuleContainer(cc);
module.HasTypesFullyDefined = true;
// Setup fake assembly, it's used mostly to simplify checks like friend-access
var temp = new Compiler.AssemblyDefinitionDynamic(module, "dynamic");
module.SetDeclaringAssembly(temp);
var importer = new Compiler.ReflectionImporter(module, cc.BuiltinTypes)
{
IgnorePrivateMembers = false,
IgnoreCompilerGeneratedField = false
};
// Import all currently loaded assemblies
// TODO: Rewrite this to populate type cache on-demand, that should greatly
// reduce our start-up cost
var domain = AppDomain.CurrentDomain;
foreach (var a in AppDomain.CurrentDomain.GetAssemblies())
{
importer.ImportAssembly(a, module.GlobalRootNamespace);
}
cc.BuiltinTypes.CheckDefinitions(module);
module.InitializePredefinedTypes();
dc = new DynamicContext(module, importer);
}
return(dc);
}
private void resetEvaluator()
{
m_errorStream = new StringBuilder();
//StreamReader sr =
TextWriter tw = new StringWriter(m_errorStream);
var ctx = new Mono.CSharp.CompilerContext(
new Mono.CSharp.CompilerSettings()
{
AssemblyReferences = new List <string>()
{
typeof(ILMath).Assembly.FullName,
typeof(System.Drawing.PointF).Assembly.FullName,
typeof(System.Linq.Queryable).Assembly.FullName
},
//Unsafe = true
}, new StreamReportPrinter(tw));
var eval = new Mono.CSharp.Evaluator(ctx);
// reset line colors (thread safe)
ILNumerics.Drawing.Plotting.ILLinePlot.NextColors = new ILColorEnumerator();
string m_head = @"
using System;
using System.Drawing;
using System.Collections.Generic;
using System.Linq;
using ILNumerics;
using ILNumerics.Drawing;
using ILNumerics.Drawing.Plotting;";
eval.Run(m_head);
m_evaluator = eval;
}
void tokenize_file (CompilationUnit file, CompilerContext ctx)
{
Stream input;
try {
input = File.OpenRead (file.Name);
} catch {
Report.Error (2001, "Source file `" + file.Name + "' could not be found");
return;
}
using (input){
SeekableStreamReader reader = new SeekableStreamReader (input, RootContext.Encoding);
Tokenizer lexer = new Tokenizer (reader, file, ctx);
int token, tokens = 0, errors = 0;
while ((token = lexer.token ()) != Token.EOF){
tokens++;
if (token == Token.ERROR)
errors++;
}
Console.WriteLine ("Tokenized: " + tokens + " found " + errors + " errors");
}
return;
}
public ScriptingEngine()
{
tokenSource = new CancellationTokenSource();
taskFactory = new TaskFactory(tokenSource.Token);
context = new CompilerContext(new Mono.CSharp.CompilerSettings(), new ConsoleReportPrinter());
evaluator = new Evaluator(context);
evaluator.InteractiveBaseClass = typeof(ScriptingInteractiveBase);
evaluator.DescribeTypeExpressions = true;
ScriptingInteractiveBase.Evaluator = evaluator;
var errorStream = new GuiStream(TextType.Error, OnConsoleOutput);
var guiOutput = new StreamWriter(errorStream);
guiOutput.AutoFlush = true;
Console.SetError(guiOutput);
ScriptingInteractiveBase.Output = guiOutput;
var stdoutStream = new GuiStream(TextType.Output, OnConsoleOutput);
guiOutput = new StreamWriter(stdoutStream);
guiOutput.AutoFlush = true;
Console.SetOut(guiOutput);
ScriptingInteractiveBase.Error = guiOutput;
codeCompletion = new CSharpCompletion(this);
Evaluate("using System; using System.Linq; using System.Collections; using System.Collections.Generic;");
//init the code completion so that the first character typed is not delayed
//var readOnlyDocument = new ReadOnlyDocument(new StringTextSource(""), "init.csx");
//codeCompletion.GetCompletions(readOnlyDocument, 0);
}
public static DynamicContext Create ()
{
if (dc != null)
return dc;
lock (compiler_initializer) {
if (dc != null)
return dc;
var reporter = new Compiler.Report (ErrorPrinter.Instance) {
WarningLevel = 0
};
var cc = new Compiler.CompilerContext (reporter) {
IsRuntimeBinder = true
};
//IList<Compiler.PredefinedTypeSpec> core_types = null;
//// HACK: To avoid re-initializing static TypeManager types, like string_type
//if (!Compiler.RootContext.EvalMode) {
// core_types = Compiler.TypeManager.InitCoreTypes ();
//}
//
// Any later loaded assemblies are handled internally by GetAssemblyDefinition
// domain.AssemblyLoad cannot be used as that would be too destructive as we
// would hold all loaded assemblies even if they can be never visited
//
// TODO: Remove this code and rely on GetAssemblyDefinition only
//
var module = new Compiler.ModuleContainer (cc);
var temp = new Compiler.AssemblyDefinitionDynamic (module, "dynamic");
module.SetDeclaringAssembly (temp);
// Import all currently loaded assemblies
var domain = AppDomain.CurrentDomain;
temp.Create (domain, System.Reflection.Emit.AssemblyBuilderAccess.Run);
var importer = new Compiler.ReflectionImporter (cc.BuildinTypes) {
IgnorePrivateMembers = false
};
Compiler.RootContext.ToplevelTypes = module;
foreach (var a in AppDomain.CurrentDomain.GetAssemblies ()) {
importer.ImportAssembly (a, module.GlobalRootNamespace);
}
if (!Compiler.RootContext.EvalMode) {
cc.BuildinTypes.CheckDefinitions (module);
module.InitializePredefinedTypes ();
}
dc = new DynamicContext (module, importer);
}
return dc;
}
public ModuleContainer (CompilerContext context, bool isUnsafe)
: base (null, null, MemberName.Null, null, Kind.Root)
{
this.is_unsafe = isUnsafe;
this.context = context;
types = new ArrayList ();
anonymous_types = new Hashtable ();
}
public ModuleCompiled(CompilerContext context, bool isUnsafe)
: base(null)
{
this.is_unsafe = isUnsafe;
this.context = context;
types = new List<TypeContainer> ();
anonymous_types = new Dictionary<int, List<AnonymousTypeClass>> ();
}
public Report (CompilerContext context, ReportPrinter printer)
{
if (context == null)
throw new ArgumentNullException ("settings");
if (printer == null)
throw new ArgumentNullException ("printer");
this.settings = context.Settings;
this.printer = printer;
}
//
// Initializes the code generator variables for interactive use (repl)
//
static public void InitDynamic (CompilerContext ctx, string name)
{
current_domain = AppDomain.CurrentDomain;
AssemblyName an = Assembly.GetAssemblyName (name, name);
Assembly.Builder = current_domain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Run);
RootContext.ToplevelTypes = new ModuleCompiled (ctx, true);
RootContext.ToplevelTypes.Builder = Assembly.Builder.DefineDynamicModule (Basename (name), false);
Assembly.Name = Assembly.Builder.GetName ();
}
public static DynamicMetaObject Bind(DynamicMetaObject target, Compiler.Expression expr, BindingRestrictions restrictions, DynamicMetaObject errorSuggestion)
{
var report = new Compiler.Report(ErrorPrinter.Instance)
{
WarningLevel = 0
};
var ctx = new Compiler.CompilerContext(report);
Compiler.RootContext.ToplevelTypes = new Compiler.ModuleContainer(ctx, true);
InitializeCompiler(ctx);
Expression res;
try {
// TODO: ResolveOptions
Compiler.ResolveContext rc = new Compiler.ResolveContext(new RuntimeBinderContext(ctx));
// Static typemanager and internal caches are not thread-safe
lock (resolver) {
expr = expr.Resolve(rc);
}
if (expr == null)
{
throw new RuntimeBinderInternalCompilerException("Expression resolved to null");
}
res = expr.MakeExpression(new Compiler.BuilderContext());
} catch (RuntimeBinderException e) {
if (errorSuggestion != null)
{
return(errorSuggestion);
}
if (binder_exception_ctor == null)
{
binder_exception_ctor = typeof(RuntimeBinderException).GetConstructor(new[] { typeof(string) });
}
//
// Uses target type to keep expressions composition working
//
res = Expression.Throw(Expression.New(binder_exception_ctor, Expression.Constant(e.Message)), target.LimitType);
} catch (Exception) {
if (errorSuggestion != null)
{
return(errorSuggestion);
}
throw;
}
return(new DynamicMetaObject(res, restrictions));
}
public void Setup()
{
var builder = new StringBuilder();
var writer = new StringWriter(builder);
var printer = new StreamReportPrinter(writer);
var settings = new CompilerSettings();
settings.AssemblyReferences.Add("DbTool.Testing");
var context = new CompilerContext(settings, printer);
_evaluator = new Evaluator(context);
}
public ModuleContainer (CompilerContext context)
: base (null, null, MemberName.Null, null, 0)
{
this.context = context;
caching_flags &= ~(Flags.Obsolete_Undetected | Flags.Excluded_Undetected);
types = new List<TypeContainer> ();
anonymous_types = new Dictionary<int, List<AnonymousTypeClass>> ();
global_ns = new GlobalRootNamespace ();
alias_ns = new Dictionary<string, RootNamespace> ();
}
public static DynamicContext Create ()
{
if (dc != null)
return dc;
lock (compiler_initializer) {
if (dc != null)
return dc;
var settings = new Compiler.CompilerSettings () {
WarningLevel = 0
};
var cc = new Compiler.CompilerContext (settings, ErrorPrinter.Instance) {
IsRuntimeBinder = true
};
//
// Any later loaded assemblies are handled internally by GetAssemblyDefinition
// domain.AssemblyLoad cannot be used as that would be too destructive as we
// would hold all loaded assemblies even if they can be never visited
//
// TODO: Remove this code and rely on GetAssemblyDefinition only
//
var module = new Compiler.ModuleContainer (cc);
module.HasTypesFullyDefined = true;
// Setup fake assembly, it's used mostly to simplify checks like friend-access
var temp = new Compiler.AssemblyDefinitionDynamic (module, "dynamic");
module.SetDeclaringAssembly (temp);
var importer = new Compiler.ReflectionImporter (module, cc.BuiltinTypes) {
IgnorePrivateMembers = false,
IgnoreCompilerGeneratedField = false
};
// Import all currently loaded assemblies
// TODO: Rewrite this to populate type cache on-demand, that should greatly
// reduce our start-up cost
var domain = AppDomain.CurrentDomain;
foreach (var a in AppDomain.CurrentDomain.GetAssemblies ()) {
importer.ImportAssembly (a, module.GlobalRootNamespace);
}
cc.BuiltinTypes.CheckDefinitions (module);
module.InitializePredefinedTypes ();
dc = new DynamicContext (module, importer);
}
return dc;
}
//
// Our constructor
//
private Iterator(CompilerContext ctx, IMethodData method, TypeContainer host, TypeSpec iterator_type, bool is_enumerable)
: base(new ToplevelBlock (ctx, method.Block, ParametersCompiled.EmptyReadOnlyParameters, method.Block.StartLocation),
TypeManager.bool_type,
method.Location)
{
this.OriginalMethod = method;
this.OriginalIteratorType = iterator_type;
this.IsEnumerable = is_enumerable;
this.Host = host;
this.type = method.ReturnType;
IteratorHost = Block.ChangeToIterator (this, method.Block);
}
public void ImportTypes (CompilerContext ctx)
{
foreach (Assembly a in referenced_assemblies) {
try {
ctx.MetaImporter.ImportAssembly (a, this);
} catch (TypeLoadException e) {
ctx.Report.Error (11, Location.Null, e.Message);
} catch (System.IO.FileNotFoundException) {
ctx.Report.Error (12, Location.Null, "An assembly `{0}' is used without being referenced",
a.FullName);
}
}
}
public void ComputeNamespace (CompilerContext ctx, Type extensionType)
{
foreach (Assembly a in referenced_assemblies) {
try {
ComputeNamespaces (a, extensionType);
} catch (TypeLoadException e) {
ctx.Report.Error (11, Location.Null, e.Message);
} catch (System.IO.FileNotFoundException) {
ctx.Report.Error (12, Location.Null, "An assembly `{0}' is used without being referenced",
a.FullName);
}
}
}
public Evaluator (CompilerSettings settings, Report report)
{
ctx = new CompilerContext (settings, report);
module = new ModuleContainer (ctx);
module.Evaluator = this;
// FIXME: Importer needs this assembly for internalsvisibleto
module.SetDeclaringAssembly (new AssemblyDefinitionDynamic (module, "evaluator"));
importer = new ReflectionImporter (module, ctx.BuildinTypes);
InteractiveBaseClass = typeof (InteractiveBase);
fields = new Dictionary<string, Tuple<FieldSpec, FieldInfo>> ();
}
public void Init()
{
var printer = new StreamReportPrinter(_stringWriter);
var settings = new CompilerSettings();
settings.AssemblyReferences.AddRange(InitialAssemblies);
var context = new CompilerContext(settings, printer);
_evaluator = new Evaluator(context)
{
InteractiveBaseClass = typeof (DbToolInteractive),
DescribeTypeExpressions = true,
};
ReferenceAssemblies(typeof(Database).Assembly, typeof(DynamicSqlQuery).Assembly);
Using(InitialUsings);
DbToolInteractive.Evaluator = _evaluator;
DbToolInteractive.Output = _stringWriter;
}
private CompilerContext CreateContext([NotNull] string source)
{
var settings = new CompilerSettings
{
Target = Target.Library,
TargetExt = ".dll",
LoadDefaultReferences = true,
ShowFullPaths = false,
StdLib = true,
};
var context = new CompilerContext(settings, new ConsoleReportPrinter(_logger));
context.SourceFiles.Add(new SourceFile("Source", source, 0));
_report = new Report(context, new ConsoleReportPrinter(_logger));
return context;
}
// This method evaluates the given code and returns a CompilerOutput object
public static CompilerOutput evaluateCode(string code)
{
CompilerOutput compilerOutput = new CompilerOutput ();
/*
var compilerContext = new CompilerContext(new CompilerSettings(), new ConsoleReportPrinter());
var evaluator = new Evaluator(compilerContext);
*/
var reportWriter = new StringWriter();
var settings = new CompilerSettings();
var printer = new ConsoleReportPrinter(reportWriter);
var compilerContext = new CompilerContext (settings, printer);
var reports = new Report(compilerContext, printer);
var evaluator = new Evaluator(compilerContext);
var myString = "";
originalConsoleOut_global = Console.Out; // preserve the original stream
using(var writer = new StringWriter())
{
Console.SetOut(writer);
evaluator.Run (code);
evaluator.Run ("MainClass m1 = new MainClass(); m1.Main();");
//bConsole.WriteLine ("after executing code");
if (reports.Errors > 0) {
Console.WriteLine ("reportWriter.ToString: \n" + reportWriter.ToString ());
compilerOutput.errors = reportWriter.ToString ();
}
writer.Flush(); // make sure everything is written out of consule
myString = writer.GetStringBuilder().ToString();
compilerOutput.consoleOut = myString;
}
Console.SetOut(originalConsoleOut_global); // restore Console.Out
return compilerOutput;
}
///////////////////////////////////////////////////////////////////////
private void Initialize()
{
CompilerSettings sett = new CompilerSettings();
ReportPrinter prnt = new ConsoleReportPrinter();
// TODO programatically add references for all flynn assemblies
sett.AssemblyReferences.Add("Flynn.Core.dll");
sett.AssemblyReferences.Add("Flynn.X10.dll");
sett.AssemblyReferences.Add("Flynn.Cron.dll");
sett.AssemblyReferences.Add("Flynn.Utilities.dll");
CompilerContext ctx = new CompilerContext(sett, prnt);
_eval = new Evaluator(ctx);
_eval.Run(Resources.CSharpEngine_InitUsings);
_eval.Run(Resources.CSharpEngine_InitScript);
}
public Evaluator (CompilerContext ctx)
{
this.ctx = ctx;
module = new ModuleContainer (ctx);
module.Evaluator = this;
source_file = new CompilationSourceFile (module);
module.AddTypeContainer (source_file);
startup_files = ctx.SourceFiles.Count;
// FIXME: Importer needs this assembly for internalsvisibleto
module.SetDeclaringAssembly (new AssemblyDefinitionDynamic (module, "evaluator"));
importer = new ReflectionImporter (module, ctx.BuiltinTypes);
InteractiveBaseClass = typeof (InteractiveBase);
fields = new Dictionary<string, Tuple<FieldSpec, FieldInfo>> ();
}
public Evaluator (CompilerSettings settings, Report report)
{
ctx = new CompilerContext (settings, report);
module = new ModuleContainer (ctx);
module.Evaluator = this;
source_file = new CompilationSourceFile ("{interactive}", "", 1);
source_file.NamespaceContainer = new NamespaceContainer (null, module, null, source_file);
ctx.SourceFiles.Add (source_file);
// FIXME: Importer needs this assembly for internalsvisibleto
module.SetDeclaringAssembly (new AssemblyDefinitionDynamic (module, "evaluator"));
importer = new ReflectionImporter (module, ctx.BuiltinTypes);
InteractiveBaseClass = typeof (InteractiveBase);
fields = new Dictionary<string, Tuple<FieldSpec, FieldInfo>> ();
}
public static DynamicMetaObject Bind (DynamicMetaObject target, Compiler.Expression expr, BindingRestrictions restrictions, DynamicMetaObject errorSuggestion)
{
var report = new Compiler.Report (ErrorPrinter.Instance) { WarningLevel = 0 };
var ctx = new Compiler.CompilerContext (report);
Compiler.RootContext.ToplevelTypes = new Compiler.ModuleContainer (ctx, true);
InitializeCompiler (ctx);
Expression res;
try {
// TODO: ResolveOptions
Compiler.ResolveContext rc = new Compiler.ResolveContext (new RuntimeBinderContext (ctx));
// Static typemanager and internal caches are not thread-safe
lock (resolver) {
expr = expr.Resolve (rc);
}
if (expr == null)
throw new RuntimeBinderInternalCompilerException ("Expression resolved to null");
res = expr.MakeExpression (new Compiler.BuilderContext ());
} catch (RuntimeBinderException e) {
if (errorSuggestion != null)
return errorSuggestion;
if (binder_exception_ctor == null)
binder_exception_ctor = typeof (RuntimeBinderException).GetConstructor (new[] { typeof (string) });
//
// Uses target type to keep expressions composition working
//
res = Expression.Throw (Expression.New (binder_exception_ctor, Expression.Constant (e.Message)), target.LimitType);
} catch (Exception) {
if (errorSuggestion != null)
return errorSuggestion;
throw;
}
return new DynamicMetaObject (res, restrictions);
}
public DebuggerWindow(PluginContext context, String hackPath)
{
this.InitializeComponent();
Trace.Listeners.Add(this.listener);
var compilerSettings = new CompilerSettings
{
Unsafe = true,
};
compilerSettings.AssemblyReferences.Add("System.dll");
compilerSettings.AssemblyReferences.Add("System.Core.dll");
compilerSettings.AssemblyReferences.Add(typeof(MessageBox).Assembly.CodeBase); // PresentationFramework.dll
compilerSettings.AssemblyReferences.Add(Path.Combine(hackPath, "SharpCraft.dll"));
var compilerContext = new CompilerContext(compilerSettings, new DebuggerReportPrinter());
evaluator = new Evaluator(compilerContext);
evaluator.Compile("using System;");
evaluator.Compile("using TinkerWorX.SharpCraft;");
CompositionTarget.Rendering += CompositionTarget_Rendering;
}
public MonoCSharpExecutor()
{
_reportBuilder = new StringBuilder();
var writer = new StringWriter(_reportBuilder);
var printer = new StreamReportPrinter(writer);
var settings = new CompilerSettings();
var context = new CompilerContext(settings, printer);
_evaluator = new Evaluator(context);
_evaluator.InteractiveBaseClass = typeof (InteractiveStuff);
_evaluator.ReferenceAssembly(typeof(HttpContext).Assembly);
_evaluator.ReferenceAssembly(typeof(VisualFarmRepo).Assembly);
_evaluator.ReferenceAssembly(typeof(BondegardFacade).Assembly);
_evaluator.ReferenceAssembly(typeof(IVFSConfig).Assembly);
Execute("using System;");
Execute("using System.Linq;");
Execute("using System.Web;");
Execute("using VisualFarmStudio.Core.Domain;");
Execute("using VisualFarmStudio.Core.Repository;");
Execute("using VisualFarmStudio.Lib.Model;");
Execute("using VisualFarmStudio.Lib.Containers;");
}
public void Simple ()
{
//string content = @"class A { }";
string content = @"
class Foo
{
void Bar ()
{
completionList.Add (""delegate"" + sb, ""md-keyword"", GettextCatalog.GetString (""Creates anonymous delegate.""), ""delegate"" + sb + "" {"" + Document.Editor.EolMarker + stateTracker.Engine.ThisLineIndent + TextEditorProperties.IndentString + ""|"" + Document.Editor.EolMarker + stateTracker.Engine.ThisLineIndent +""};"");
}
}"
;
var stream = new MemoryStream (Encoding.UTF8.GetBytes (content));
var ctx = new CompilerContext (new CompilerSettings (), new Report (new AssertReportPrinter ()));
ModuleContainer module = new ModuleContainer (ctx);
CSharpParser parser = new CSharpParser (
new SeekableStreamReader (stream, Encoding.UTF8),
new CompilationUnit ("name", "path", 0),
module);
RootContext.ToplevelTypes = module;
Location.AddFile (ctx.Report, "asdfas");
Location.Initialize ();
parser.LocationsBag = new LocationsBag ();
parser.parse ();
var m = module.Types[0].Methods[0] as Method;
var s = m.Block.FirstStatement;
var o = s.loc.Column;
module.Accept (new TestVisitor ());
}
public static MethodSpec GetConstructor(CompilerContext ctx, TypeSpec container_type, TypeSpec delType)
{
var ctor = MemberCache.FindMember(delType, MemberFilter.Constructor(null), BindingRestriction.DeclaredOnly);
return((MethodSpec)ctor);
}
public static AParametersCollection GetParameters(CompilerContext ctx, TypeSpec delType)
{
var invoke_mb = GetInvokeMethod(ctx, delType);
return(invoke_mb.Parameters);
}
public RuntimeBinderContext(Compiler.CompilerContext ctx)
{
this.ctx = ctx;
}
public TypeExpr LookupType(CompilerContext ctx, string name, int arity, bool silent, Location loc)
{
if (types == null)
{
return(null);
}
TypeExpr te;
if (arity == 0 && cached_types.TryGetValue(name, out te))
{
return(te);
}
IList <TypeSpec> found;
if (!types.TryGetValue(name, out found))
{
return(null);
}
TypeSpec best = null;
foreach (var ts in found)
{
if (ts.Arity == arity)
{
if (best == null)
{
best = ts;
continue;
}
var pts = best as BuildinTypeSpec;
if (pts == null)
{
pts = ts as BuildinTypeSpec;
}
if (pts != null)
{
ctx.Report.SymbolRelatedToPreviousError(best);
ctx.Report.SymbolRelatedToPreviousError(ts);
// TODO: This should use different warning number but we want to be csc compatible
ctx.Report.Warning(1685, 1, loc,
"The predefined type `{0}.{1}' is redefined in the source code. Ignoring the local type definition",
pts.Namespace, pts.Name);
best = pts;
continue;
}
if (best.MemberDefinition.IsImported && ts.MemberDefinition.IsImported)
{
ctx.Report.SymbolRelatedToPreviousError(best);
ctx.Report.SymbolRelatedToPreviousError(ts);
if (silent)
{
ctx.Report.Warning(1685, 1, loc,
"The predefined type `{0}' is defined in multiple assemblies. Using definition from `{1}'",
ts.GetSignatureForError(), best.MemberDefinition.DeclaringAssembly.Name);
}
else
{
ctx.Report.Error(433, loc, "The imported type `{0}' is defined multiple times", ts.GetSignatureForError());
}
break;
}
if (best.MemberDefinition.IsImported)
{
best = ts;
}
if ((best.Modifiers & Modifiers.INTERNAL) != 0 && !best.MemberDefinition.IsInternalAsPublic(RootContext.ToplevelTypes.DeclaringAssembly))
{
continue;
}
if (silent)
{
continue;
}
if (ts.MemberDefinition.IsImported)
{
ctx.Report.SymbolRelatedToPreviousError(ts);
}
ctx.Report.Warning(436, 2, loc,
"The type `{0}' conflicts with the imported type of same name'. Ignoring the imported type definition",
best.GetSignatureForError());
}
//
// Lookup for the best candidate with closest arity match
//
if (arity < 0)
{
if (best == null)
{
best = ts;
}
else if (System.Math.Abs(ts.Arity + arity) < System.Math.Abs(best.Arity + arity))
{
best = ts;
}
}
}
if (best == null)
{
return(null);
}
if ((best.Modifiers & Modifiers.INTERNAL) != 0 && !best.MemberDefinition.IsInternalAsPublic(RootContext.ToplevelTypes.DeclaringAssembly))
{
return(null);
}
te = new TypeExpression(best, Location.Null);
// TODO MemberCache: Cache more
if (arity == 0 && !silent)
{
cached_types.Add(name, te);
}
return(te);
}
//
// Initializes the code generator variables
//
static public bool Init(string name, string output, bool want_debugging_support, CompilerContext ctx)
{
FileName = output;
AssemblyName an = Assembly.GetAssemblyName(name, output);
if (an == null)
{
return(false);
}
if (an.KeyPair != null)
{
// If we are going to strong name our assembly make
// sure all its refs are strong named
foreach (Assembly a in GlobalRootNamespace.Instance.Assemblies)
{
AssemblyName ref_name = a.GetName();
byte [] b = ref_name.GetPublicKeyToken();
if (b == null || b.Length == 0)
{
ctx.Report.Error(1577, "Assembly generation failed " +
"-- Referenced assembly '" +
ref_name.Name +
"' does not have a strong name.");
//Environment.Exit (1);
}
}
}
current_domain = AppDomain.CurrentDomain;
try {
Assembly.Builder = current_domain.DefineDynamicAssembly(an,
AssemblyBuilderAccess.RunAndSave | COMPILER_ACCESS, Dirname(name));
}
catch (ArgumentException) {
// specified key may not be exportable outside it's container
if (RootContext.StrongNameKeyContainer != null)
{
ctx.Report.Error(1548, "Could not access the key inside the container `" +
RootContext.StrongNameKeyContainer + "'.");
Environment.Exit(1);
}
throw;
}
catch (CryptographicException) {
if ((RootContext.StrongNameKeyContainer != null) || (RootContext.StrongNameKeyFile != null))
{
ctx.Report.Error(1548, "Could not use the specified key to strongname the assembly.");
Environment.Exit(1);
}
return(false);
}
// Get the complete AssemblyName from the builder
// (We need to get the public key and token)
Assembly.Name = Assembly.Builder.GetName();
//
// Pass a path-less name to DefineDynamicModule. Wonder how
// this copes with output in different directories then.
// FIXME: figure out how this copes with --output /tmp/blah
//
// If the third argument is true, the ModuleBuilder will dynamically
// load the default symbol writer.
//
try {
RootContext.ToplevelTypes.Builder = Assembly.Builder.DefineDynamicModule(
Basename(name), Basename(output), want_debugging_support);
#if !MS_COMPATIBLE
// TODO: We should use SymbolWriter from DefineDynamicModule
if (want_debugging_support && !SymbolWriter.Initialize(RootContext.ToplevelTypes.Builder, output))
{
ctx.Report.Error(40, "Unexpected debug information initialization error `{0}'",
"Could not find the symbol writer assembly (Mono.CompilerServices.SymbolWriter.dll)");
return(false);
}
#endif
} catch (ExecutionEngineException e) {
ctx.Report.Error(40, "Unexpected debug information initialization error `{0}'",
e.Message);
return(false);
}
return(true);
}
public static DynamicContext Create()
{
if (dc != null)
{
return(dc);
}
lock (compiler_initializer) {
if (dc != null)
{
return(dc);
}
var reporter = new Compiler.Report(ErrorPrinter.Instance)
{
WarningLevel = 0
};
var settings = new Compiler.CompilerSettings();
var cc = new Compiler.CompilerContext(settings, reporter)
{
IsRuntimeBinder = true
};
//IList<Compiler.PredefinedTypeSpec> core_types = null;
//// HACK: To avoid re-initializing static TypeManager types, like string_type
//if (!Compiler.RootContext.EvalMode) {
// core_types = Compiler.TypeManager.InitCoreTypes ();
//}
//
// Any later loaded assemblies are handled internally by GetAssemblyDefinition
// domain.AssemblyLoad cannot be used as that would be too destructive as we
// would hold all loaded assemblies even if they can be never visited
//
// TODO: Remove this code and rely on GetAssemblyDefinition only
//
var module = new Compiler.ModuleContainer(cc);
module.HasTypesFullyDefined = true;
var temp = new Compiler.AssemblyDefinitionDynamic(module, "dynamic");
module.SetDeclaringAssembly(temp);
// Import all currently loaded assemblies
var domain = AppDomain.CurrentDomain;
temp.Create(domain, System.Reflection.Emit.AssemblyBuilderAccess.Run);
var importer = new Compiler.ReflectionImporter(module, cc.BuiltinTypes)
{
IgnorePrivateMembers = false
};
foreach (var a in AppDomain.CurrentDomain.GetAssemblies())
{
importer.ImportAssembly(a, module.GlobalRootNamespace);
}
cc.BuiltinTypes.CheckDefinitions(module);
module.InitializePredefinedTypes();
dc = new DynamicContext(module, importer);
}
return(dc);
}
public static ParametersCompiled MergeGenerated(CompilerContext ctx, ParametersCompiled userParams, bool checkConflicts, Parameter compilerParams, TypeSpec compilerTypes)
{
return(MergeGenerated(ctx, userParams, checkConflicts,
new Parameter [] { compilerParams },
new TypeSpec [] { compilerTypes }));
}
public AssemblyBuilderIKVM(AssemblyBuilder builder, CompilerContext ctx)
: base(ctx)
{
this.builder = builder;
}
public Driver(CompilerContext ctx)
{
this.ctx = ctx;
}
TypeExpr CreateSiteType(CompilerContext ctx, bool isStatement, int dyn_args_count)
{
int default_args = isStatement ? 1 : 2;
bool has_ref_out_argument = false;
FullNamedExpression[] targs = new FullNamedExpression[dyn_args_count + default_args];
targs [0] = new TypeExpression(TypeManager.call_site_type, loc);
for (int i = 0; i < dyn_args_count; ++i)
{
Type arg_type;
Argument a = arguments [i];
if (a.Type == TypeManager.null_type)
{
arg_type = TypeManager.object_type;
}
else
{
arg_type = TypeManager.TypeToReflectionType(a.Type);
}
if (a.ArgType == Argument.AType.Out || a.ArgType == Argument.AType.Ref)
{
has_ref_out_argument = true;
}
targs [i + 1] = new TypeExpression(arg_type, loc);
}
TypeExpr del_type = null;
if (!has_ref_out_argument)
{
string d_name = isStatement ? "Action`" : "Func`";
Type t = TypeManager.CoreLookupType(ctx, "System", d_name + (dyn_args_count + default_args), Kind.Delegate, false);
if (t != null)
{
if (!isStatement)
{
targs[targs.Length - 1] = new TypeExpression(TypeManager.TypeToReflectionType(type), loc);
}
del_type = new GenericTypeExpr(t, new TypeArguments(targs), loc);
}
}
// No appropriate predefined delegate found
if (del_type == null)
{
Type rt = isStatement ? TypeManager.void_type : type;
Parameter[] p = new Parameter [dyn_args_count + 1];
p[0] = new Parameter(targs [0], "p0", Parameter.Modifier.NONE, null, loc);
for (int i = 1; i < dyn_args_count + 1; ++i)
{
p[i] = new Parameter(targs[i], "p" + i.ToString("X"), arguments[i - 1].Modifier, null, loc);
}
TypeContainer parent = CreateSiteContainer();
Delegate d = new Delegate(parent.NamespaceEntry, parent, new TypeExpression(rt, loc),
Modifiers.INTERNAL | Modifiers.COMPILER_GENERATED,
new MemberName("Container" + container_counter++.ToString("X")),
new ParametersCompiled(p), null);
d.DefineType();
d.Define();
parent.AddDelegate(d);
del_type = new TypeExpression(d.TypeBuilder, loc);
}
TypeExpr site_type = new GenericTypeExpr(TypeManager.generic_call_site_type, new TypeArguments(del_type), loc);
return(site_type);
}
public static void CreateIterator(IMethodData method, TypeContainer parent, int modifiers, CompilerContext ctx)
{
bool is_enumerable;
Type iterator_type;
Type ret = method.ReturnType;
if (ret == null)
{
return;
}
if (!CheckType(ret, out iterator_type, out is_enumerable))
{
ctx.Report.Error(1624, method.Location,
"The body of `{0}' cannot be an iterator block " +
"because `{1}' is not an iterator interface type",
method.GetSignatureForError(),
TypeManager.CSharpName(ret));
return;
}
ParametersCompiled parameters = method.ParameterInfo;
for (int i = 0; i < parameters.Count; i++)
{
Parameter p = parameters [i];
Parameter.Modifier mod = p.ModFlags;
if ((mod & Parameter.Modifier.ISBYREF) != 0)
{
ctx.Report.Error(1623, p.Location,
"Iterators cannot have ref or out parameters");
return;
}
if (p is ArglistParameter)
{
ctx.Report.Error(1636, method.Location,
"__arglist is not allowed in parameter list of iterators");
return;
}
if (parameters.Types [i].IsPointer)
{
ctx.Report.Error(1637, p.Location,
"Iterators cannot have unsafe parameters or " +
"yield types");
return;
}
}
if ((modifiers & Modifiers.UNSAFE) != 0)
{
ctx.Report.Error(1629, method.Location, "Unsafe code may not appear in iterators");
return;
}
Iterator iter = new Iterator(ctx, method, parent, iterator_type, is_enumerable);
iter.Storey.DefineType();
}
public bool Validate(CompilerContext compiler, bool isExplicit)
{
((IMethodData)method).Block.Accept(this);
return(can_inline && (isExplicit || statements < MAX_INLINE_STATEMENTS));
}
public AssemblyBuilderExtension(CompilerContext ctx)
{
this.ctx = ctx;
}
public AssemblyBuilderMonoSpecific(AssemblyBuilder ab, CompilerContext ctx)
: base(ctx)
{
this.builder = ab;
}
