public override void ErrorReported(ScriptSource source, string message, SourceSpan span, int errorCode, Severity severity) { _source = source; _message = message; _span = span; _errorCode = errorCode; // _severity = severity; }
private ScriptCodeParseResult GetCommandPropertiesAndParse(string code, out ScriptSource source) { ScriptCodeParseResult result = ScriptCodeParseResult.IncompleteStatement; try { ScriptSource command = this.Engine.CreateScriptSourceFromString(code, SourceCodeKind.InteractiveCode); result = command.GetCodeProperties(this.Engine.GetCompilerOptions(this.ScriptScope)); source = command; } catch (ParseException error) { if (error.CanContinue) { result = ScriptCodeParseResult.IncompleteStatement; } else { result = ScriptCodeParseResult.Invalid; Console.ErrorOutput.WriteLine("//[parse]: {0}", error.Message); } source = null; } //catch (Exception e) //{ // source = null; // Console.ErrorOutput.WriteLine("**->{0}", e); //} return result; }
public void ExecutePythonCode(string code) { pySource = pyEngine.CreateScriptSourceFromString(code,SourceCodeKind.InteractiveCode); object output = pySource.Execute(pyScope); if (output != null) Console.Echo(pyEngine.Operations.Format(output)); ShowResults(); }
public void Init(string player) { m_scope = m_engine.CreateScope(); m_scope.SetVariable("player", player); m_scope.SetVariable("ClearBox", BoxState.Clear); m_scope.SetVariable("XBox", BoxState.X); m_scope.SetVariable("OBox", BoxState.O); source = m_engine.CreateScriptSourceFromString(System.IO.File.ReadAllText("AI.py"), SourceCodeKind.AutoDetect); }
static ShaderCompiler() { Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("GreenBox3D.ContentPipeline.Graphics.ShaderCompiler.rb"); StreamReader reader = new StreamReader(stream); HelperSource = ScriptManager.Engine.CreateScriptSourceFromString(reader.ReadToEnd(), SourceCodeKind.File); reader.Close(); }
public override void ErrorReported( ScriptSource source, string message, SourceSpan span, int errorCode, Severity severity) { _writer.WriteLine("Error starting at line {0} column {1}", span.Start.Line, span.Start.Column); _writer.WriteLine(message); }
public PythonLoader(string code, string className = "PyClass") { //creating engine and stuff engine = Python.CreateEngine(); scope = engine.CreateScope(); //loading and compiling code source = engine.CreateScriptSourceFromString(code, Microsoft.Scripting.SourceCodeKind.Statements); compiled = source.Compile(); }
/// <summary> /// Stores the reported error. /// </summary> /// <param name="source">The source in which the error occurred.</param> /// <param name="message">The error message.</param> /// <param name="span">The location of the error in the script file.</param> /// <param name="errorCode">The error code.</param> /// <param name="severity">The severity of the error.</param> public override void ErrorReported(ScriptSource source, string message, SourceSpan span, int errorCode, Severity severity) { var error = new ScriptErrorInformation { Line = span.Start.Line, Column = span.Start.Column, Message = message, Severity = Translate(severity), }; m_Errors.Add(error); }
public void CompileCodeFromClass(string code, string className) { //loading and compiling code Source = Engine.CreateScriptSourceFromString(code, SourceCodeKind.Statements); _compiled = Source.Compile(); //now executing this code (the code should contain a class) _compiled.Execute(Scope); //now creating an object that could be used to access the stuff inside a python script _pythonClass = Engine.Operations.Invoke(Scope.GetVariable(className)); }
public void ProcessCode(string code) { // check if we're in the revit context // if so, add relevant assemblies var assemblies = AppDomain.CurrentDomain.GetAssemblies(); if ( assemblies.Any(x => x.FullName.Contains("RevitAPI")) && assemblies.Any(x => x.FullName.Contains("RevitAPIUI")) ) { code = "import clr\nclr.AddReference('RevitAPI')\nclr.AddReference('RevitAPIUI')\nfrom Autodesk.Revit.DB import *\nimport Autodesk\n" + code; } this.source = engine.CreateScriptSourceFromString(code, SourceCodeKind.Statements); }
public clsPyInterface(string codePreRun = "") { this.pythonVars = new Dictionary<string,object>(); this.pyEngine = Python.CreateEngine( #if DEBUG //new Dictionary<string, object>() { {"Debug", true} } #endif ); this.pyScope = this.pyEngine.CreateScope(); this.pySource = this.pyEngine.CreateScriptSourceFromString("raise BaseException('" + pyDefaultError + "')"); this.pyCodePreRun = codePreRun + "\n"; this.lastError = ""; }
public pyDissector(string fileName) { engine = Python.CreateEngine(); scope = engine.CreateScope(); var runtime = engine.Runtime; runtime.LoadAssembly(typeof(PacketDotNet.Packet).Assembly); runtime.LoadAssembly(typeof(pyDissector).Assembly); src = engine.CreateScriptSourceFromFile(fileName); program = src.Compile(); var result = program.Execute(scope); var filterString = scope.GetVariable<string>("nativeFilterString"); myFilter = filterGen.genFilter(filterString); parseFunc = scope.GetVariable<Func<Packet, HLPacket>>("parsePacket"); }
public ReplayReader() { // Lib should be in SearchPath, but we need to add our own python files as well ICollection<string> paths = m_engine.GetSearchPaths(); paths.Add(m_blizzScriptPath); m_engine.SetSearchPaths(paths); // create global scope, we only need 1 of those m_scope = m_engine.CreateScope(); // load our API file we're going to communicate with m_source = m_engine.CreateScriptSourceFromFile(m_blizzScriptPath + m_replayLibPyFile); m_source.Execute(m_scope); }
public override void Setup() { runtime_ = new JavaScriptRuntime(new JavaScriptRuntimeSettings()); engine_ = runtime_.CreateEngine(); var baseline = new ScriptSource("test://init.js", @"(function(global) { global.buffer = new ArrayBuffer(1024); global.typedArray = new Uint8ClampedArray(buffer); global.dataView = new DataView(buffer, 1); })(this);"); engine_.Execute(baseline); buffer_ = (JavaScriptArrayBuffer)engine_.GetGlobalVariable("buffer"); typedArray_ = (JavaScriptTypedArray)engine_.GetGlobalVariable("typedArray"); dataView_ = (JavaScriptDataView)engine_.GetGlobalVariable("dataView"); }
public void InformationalDisplayOfAllSymbolProperties() { engine_.RuntimeExceptionRaised += Engine__RuntimeExceptionRaised; engine_.SetGlobalFunction("echo", (eng, ctor, thisObj, args) => { // Log.Message(string.Format(args.First().ToString(), (object[])args.Skip(1).ToArray())); Assert.AreEqual(args.First().ToString(), "length, prototype, name, iterator, species, unscopables, for, keyFor, caller, arguments"); return eng.UndefinedValue; }); var src = new ScriptSource("[eval code]", @"(function() { var x = Object.getOwnPropertyNames(Symbol).join(', '); echo(x); })();"); engine_.Execute(src); }
private void Compile() { try { _source = _engine.CreateScriptSourceFromString("import clr" + Environment.NewLine + "clr.AddReference('mtrand')" + Environment.NewLine); _source.Execute(_scope); _source = _engine.CreateScriptSourceFromString(textBox_CodeIn.Text); dynamic res2 = _source.Execute(_scope); if (res2 != null) textBox_CodeOut.Text += Environment.NewLine + ">>> " + _builtin.str(res2); textBox_CodeOut.SelectionStart = textBox_CodeOut.TextLength; } catch (System.Exception ex) { MessageBox.Show(ex.Message, "Error compile"); } toolStripStatusLabel.Text = "Compile done"; }
public override void ErrorReported(ScriptSource source, string message, SourceSpan span, int errorCode, Severity severity) { throw new SyntaxErrorException(message, HostingHelpers.GetSourceUnit(source), span, errorCode, severity); }
private void RunCommandLine(string []args) { Debug.Assert(_engine != null); string arglist=""; string python_module="test"; string python_class="exampleclass"; for (int i=0;i+1<args.Length;i+=2) { if (IsSanitized(args[i+1])) { if (args[i]=="PythonModule") { python_module=args[i+1]; }else if (args[i]=="PythonClass") { python_class=args[i+1]; }else { _scope.SetVariable(args[i],args[i+1]); if (arglist.Length!=0) arglist+=","; arglist+=args[i]+"="+args[i+1]; } } } ScriptSource initsource=_engine.CreateScriptSourceFromString("import sys;sys.path+=[\"../../liboh/scripts/ironpython\",\"../../../liboh/scripts/ironpython\",\"scripts/ironpython\",\"ironpython\",\"../../liboh/scripts/ironpython/site-packages\",\"../../../liboh/scripts/ironpython/site-packages\",\"scripts/ironpython/site-packages\",\"ironpython/site_packages\",\"../lib/scripts/ironpython\",\"../lib/scripts/ironpython/site-packages\"];print sys.path;from "+python_module+" import "+python_class,SourceCodeKind.Statements); initsource.Execute(_scope); initsource=_engine.CreateScriptSourceFromString(python_class+"("+arglist+")",SourceCodeKind.Expression); _pythonObject=initsource.Execute(_scope); _scope.SetVariable("retval",_pythonObject); _processMessageSource=_engine.CreateScriptSourceFromString("retval.processMessage(header,body)",SourceCodeKind.Expression); _processRPCSource=_engine.CreateScriptSourceFromString("retval.processRPC(header,name,args)",SourceCodeKind.Expression); _processTickSource=_engine.CreateScriptSourceFromString("retval.tick(curTime)",SourceCodeKind.Expression); }
public override void ErrorReported(ScriptSource source, string message, SourceSpan span, int errorCode, Severity severity) { OnError.Invoke(source,message,span,errorCode,severity); }
public ScriptCommandBase(ScriptSource scriptSource, ScriptScope scriptScope) { this.source = scriptSource; this.scope = scriptScope; }
public ScriptCommand(ScriptSource scriptSource, ScriptScope scriptScope) : base(scriptSource, scriptScope) { }
public override void ErrorReported(ScriptSource source, string message, SourceSpan span, int errorCode, Severity severity) { Errors.AppendLine(string.Format("{0}:{1} - {2} at Line {3}", new object[] { severity.ToString(), errorCode.ToString(), message, span.Start.Line.ToString() })); }
public void SetSource(string code) { this.pySource = this.pyEngine.CreateScriptSourceFromString(this.pyCodePreRun + code); }
public Parser(string Source, ErrorSink errorSink) { source = Ruby.CreateRuntime().GetEngine("rb").CreateScriptSourceFromString(Source); this.errorSink = errorSink; }
public override void ErrorReported(ScriptSource source, string message, SourceSpan span, int errorCode, Severity severity) { Errors.Add(string.Format("{0} (line {1})", message, span.Start.Line)); }
public void ProcessCode(string code) { _source = _engine.CreateScriptSourceFromString(code, SourceCodeKind.Statements); }
void scriptSourceInit() { lock (_scriptLock) { if (_scriptSource == null) { _scriptSource = ScriptContext.Current.ScriptRuntime.GetEngine(LanguageId).CreateScriptSourceFromString(Code, SourceCodeKind); } } }
/// <summary> /// Adds error to the error list. /// </summary> /// <param name="_scrpsrcScriptSource">Script.</param> /// <param name="_sErrorMsg">Error message.</param> /// <param name="_srcspanSpanning">Span.</param> /// <param name="_iCode">Code.</param> /// <param name="sevSeverity">Severity.</param> public override void ErrorReported(ScriptSource _scrpsrcScriptSource, string _sErrorMsg, SourceSpan _srcspanSpanning, int _iCode, Severity sevSeverity) { Errorlist.Add(_sErrorMsg); }
public override void ErrorReported(ScriptSource source, string message, SourceSpan span, int errorCode, Severity severity) { if (severity==Severity.Warning) c.warnings.Add(new Errors.CommonWarning(message, c.compilerOptions.SourceFileName, span.Start.Line, span.Start.Column)); else c.errorsList.Add(new Errors.CommonCompilerError(message, c.compilerOptions.SourceFileName, span.Start.Line, span.Start.Column)); }
public void LoadCode(string code) { Source = Engine.CreateScriptSourceFromString(code, SourceCodeKind.Statements); Source.Compile(); }