public override void Execute(string src, Uri uri, HttpListenerContext p, WebConfig wc, StreamWriter sw)
{
var bcp = new JScriptCodeProvider();
var ass = AssemblyInitializer.Init(bcp, src, sw, ini);
var page = AssemblyPageResolver.Resolve(ass);
page.Response = sw;
uri = new Uri("http://localhost/" + Path.GetFileName(uri.LocalPath));
page.Info = new HttpInfo(Get.Create(uri), uri, wc.DataDir, p);
page.IncludePage = new Action <string>(f =>
{
new Language().Execute(File.ReadAllText(wc.DataDir + f), uri, p, wc, sw);
});
page.Redirect = new Action <string>(f =>
{
p.Response.Redirect(f);
});
page.Isset = new Predicate <object>(b =>
{
return(StandardScriptApi.isset(b));
});
page.Get = page.Info.Get;
page.OnLoad();
}
public static object JSEval(string JSCode, string Output, List <string> Assemblies)
{
JScriptCodeProvider codeProvider = new JScriptCodeProvider();
ICodeCompiler icc = codeProvider.CreateCompiler();
System.CodeDom.Compiler.CompilerParameters parameters = new CompilerParameters();
parameters.GenerateExecutable = true;
foreach (string s in Assemblies)
{
parameters.ReferencedAssemblies.Add(s);
}
parameters.OutputAssembly = Output;
CompilerResults results = icc.CompileAssemblyFromSource(parameters, JSCode);
if (results.Errors.Count > 0)
{
string Errors = string.Empty;
foreach (CompilerError CompErr in results.Errors)
{
Errors += "Line number " + CompErr.Line +
", Error Number: " + CompErr.ErrorNumber +
", '" + CompErr.ErrorText + ";" +
Environment.NewLine + Environment.NewLine;
}
return(Errors);
}
else
{
Process.Start(Output);
return("Succes!");
}
}
public static void Run(string[] args)
{
//ScriptManager.RegisterStartupScript(Page, GetType(), "clicktest", "clicktest()", true);
//ClientScript.RegisterStartupScript(this.GetType(), "clear", "<script>test()</script>");
string Source = @"
package Test
{
class HelloWorld
{
function Hello(name) { return ""Hello, "" + name; }
}
}";
var provider = new JScriptCodeProvider();
var compiler = provider.CreateCompiler();
var parameters = new CompilerParameters {
GenerateInMemory = true
};
var results = compiler.CompileAssemblyFromSource(parameters, Source);
var assembly = results.CompiledAssembly;
dynamic instance = Activator.CreateInstance(assembly.GetType("Test.HelloWorld"));
var result = instance.Hello("World");
Console.WriteLine("Result: {0}", result);
}
static Evaluator()
{
CompilerParameters compilerParams = new CompilerParameters();
compilerParams.TreatWarningsAsErrors = false;
compilerParams.GenerateExecutable = false;
compilerParams.GenerateInMemory = true;
JScriptCodeProvider provider = new JScriptCodeProvider();
CompilerResults compile = provider.CompileAssemblyFromSource(compilerParams, _jscriptSource);
foreach (Module module in compile.CompiledAssembly.GetModules())
{
foreach (Type type in module.GetTypes())
{
foreach (MethodInfo methodInfo in type.GetMethods(BindingFlags.Public | BindingFlags.Static))
{
if (methodInfo.Name == "Eval")
{
_evaluator = methodInfo;
return;
}
}
}
}
}
public CompilerResults Build(string dirWithSrc)
{
string[] sources = GetSourcesFromDir(dirWithSrc, new string[] { ".js" });
var csc = new JScriptCodeProvider();
var parameters = new CompilerParameters();
parameters.OutputAssembly = OutputFile;
parameters.GenerateExecutable = Executable;
parameters.GenerateInMemory = GenerateInMemory;
parameters.IncludeDebugInformation = IncludeDebugInfo;
parameters.ReferencedAssemblies.AddRange(IncludedLibraries.ToArray());
parameters.EmbeddedResources.AddRange(EmbeddedResources.ToArray());
parameters.LinkedResources.AddRange(LinkedResources.ToArray());
if (MainClass != null)
{
parameters.MainClass = MainClass;
}
CompilerResults results = csc.CompileAssemblyFromSource(parameters, sources);
return(results);
}
static object JsExecute(
string script,
string[] refs,
string type,
string func,
params object[] args)
{
JScriptCodeProvider jsc = new JScriptCodeProvider();
CompilerParameters parameters = new CompilerParameters(refs, "test.dll", true);
parameters.GenerateExecutable = false;
CompilerResults results = jsc.CompileAssemblyFromFile(parameters, new string[] { script });
if (results.Errors.Count > 0)
{
Console.WriteLine("Errors: ");
foreach (CompilerError err in results.Errors)
{
Console.WriteLine(err.ToString());
}
return(null);
}
Assembly ass = results.CompiledAssembly;
Type c = ass.GetType(type);
MethodInfo f = c.GetMethod(func);
return(f.Invoke(null, args));
}
/// <summary>
/// Compile script by file.
/// </summary>
/// <param name="file"></param>
private static bool CompileScript(string file)
{
var sourceFile = new FileInfo(file);
CodeDomProvider provider = null;
var csc = new CSharpCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v4.0" } });
// TODO: maybe allow custom references like CS-Script
var parameters = new CompilerParameters(new[]
{"mscorlib.dll", "System.Core.dll", "System.Windows.Forms.dll", "NFSScript.dll"})
{
GenerateExecutable = false,
GenerateInMemory = true
};
// TODO this doesn't support C#6 and above
// we can fix that with this CodeDom provider from nuget:
// https://www.nuget.org/packages/Microsoft.CodeDom.Providers.DotNetCompilerPlatform/
// then we can do this:
// new Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider();
// TODO perhaps add support for F#
// that comes in the form of another custom package
// https://github.com/fsprojects/FSharp.Compiler.CodeDom
// since we're at it, why not PowerShell?
// https://github.com/adamdriscoll/PowerShellCodeDomProvider
switch (sourceFile.Extension.ToUpperInvariant())
{
case ".CS":
provider = new CSharpCodeProvider();
break;
case ".VB":
provider = new VBCodeProvider();
break;
case ".JS":
provider = new JScriptCodeProvider();
break;
}
if (provider == null) return false;
var results = provider.CompileAssemblyFromFile(parameters, file);
if (results.Errors.HasErrors)
{
foreach (CompilerError r in results.Errors)
{
Log.Print(NFSScriptLoader.ERROR_TAG, r.ToString());
}
return false;
}
var ass = results.CompiledAssembly;
var script = new ModScript(ass, Path.GetFileName(file));
_scripts.Add(script);
Log.Print(NFSScriptLoader.INFO_TAG, $"Loaded {script.File}");
return true;
}
public static CompilerResults CompileFromJScriptSourceFile(String sourceFile, CompilerParameters cParams)
{
using (CodeDomProvider provider = new JScriptCodeProvider())
{
CompilerResults res = provider.CompileAssemblyFromFile(cParams, sourceFile);
return(res);
}
}
static JScript()
{
Assembly assembly = new JScriptCodeProvider().CompileAssemblyFromSource(
new CompilerParameters {
GenerateInMemory = true
}, Properties.Resources.gettkjs).CompiledAssembly;
infoGetTK = assembly.GetType("JScript").GetMethod("tk");
}
public CaptchaEvaluator()
{
ICodeCompiler compiler = new JScriptCodeProvider().CreateCompiler();
CompilerParameters parameters = new CompilerParameters {
GenerateInMemory = true
};
CompilerResults results = compiler.CompileAssemblyFromSource(parameters, _jscriptSource);
Assembly assembly = results.CompiledAssembly;
_evaluatorType = assembly.GetType("CaptchaEvaluator.CaptchaEvaluator");
}
/// <summary>
/// 初始化脚本引擎
/// </summary>
private void InitJscriptEngine()
{
JScriptCodeProvider compiler = new JScriptCodeProvider();
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateInMemory = true;
CompilerResults results;
results = compiler.CompileAssemblyFromSource(parameters, _JscriptCode);
Assembly assembly = results.CompiledAssembly;
_EvaluatorType = assembly.GetType("JsEvalClass.JsEvalClass");
_Evaluator = Activator.CreateInstance(_EvaluatorType);
}
/// <summary>
/// Include and compile a JScript Module(s). Can be the contents of a file read with File.ReadContents().
/// </summary>
/// <param name="source">The JScript source.</param>
/// <param name="assemblies">An array of any additional assemblies required.</param>
/// <param name="dllName">An optional path to create a dll output, use "" to perform in-memory.</param>
/// <returns>"FAILED" or "SUCCESS"</returns>
public static Primitive IncludeJScript(Primitive source, Primitive assemblies, Primitive dllName)
{
try
{
CompilerParameters compilerParams = SetReferences(assemblies, dllName, true);
JScriptCodeProvider provider = new JScriptCodeProvider();
CompilerResults compile = provider.CompileAssemblyFromSource(compilerParams, source);
return(PostCompile(compile));
}
catch (Exception ex)
{
Utilities.OnError(Utilities.GetCurrentMethod(), ex);
}
return("FAILED");
}
static JsEvaluator()
{
//VsaEngine eng = new VsaEngine(true);
//Closure
//en
CodeDomProvider c = new JScriptCodeProvider();
CompilerParameters parameters = new CompilerParameters();;
parameters.GenerateInMemory = true;
CompilerResults results = c.CompileAssemblyFromSource(parameters, _jscriptSource);
Assembly assembly = results.CompiledAssembly;
_evaluatorType = assembly.GetType("Evaluator.Evaluator");
_evaluator = Activator.CreateInstance(_evaluatorType);
}
//构造函数
static EvalMethod()
{
CodeDomProvider _provider = new JScriptCodeProvider();
ICodeCompiler _iCode = _provider.CreateCompiler();
CompilerParameters _parameters = new CompilerParameters();
_parameters.GenerateInMemory = true;
CompilerResults _result;
_result = _iCode.CompileAssemblyFromSource(_parameters, _jsClass);
Assembly _assembly = _result.CompiledAssembly;
_evalType = _assembly.GetType("theEval");
_evalObject = Activator.CreateInstance(_evalType);
}
private static object GetEvaluator()
{
CompilerParameters parameters;
parameters = new CompilerParameters();
parameters.GenerateInMemory = true;
JScriptCodeProvider jp = new JScriptCodeProvider();
CompilerResults results = jp.CompileAssemblyFromSource(parameters, _evaluatorSourceCode);
Assembly assembly = results.CompiledAssembly;
_evaluatorType = assembly.GetType("Evaluator.Evaluator");
return(Activator.CreateInstance(_evaluatorType));
}
private static void Initialize()
{
CodeDomProvider compiler = new JScriptCodeProvider();
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateInMemory = true;
parameters.ReferencedAssemblies.Add("system.dll");
CompilerResults results = compiler.CompileAssemblyFromSource(parameters, _jscriptEvalClass);
Assembly assembly = results.CompiledAssembly;
_evaluatorType = assembly.GetType("JScriptEvaluator");
_evaluatorInstance = Activator.CreateInstance(_evaluatorType);
}
static public void Main()
{
string[] source = new string[] {
@"import System;
class JsProgram {
function Print(mes){
Console.WriteLine(mes);
}
function Hello(world){
Print(world);
}
function proc(){
var world = ""World"";
var bool = true;
if(bool == true){
Print(""True is True"");
}
else{
Print(""False is True"");
}
Hello(world);
}
}"
};
var compiler = new JScriptCodeProvider();
var opt = new CompilerParameters();
opt.ReferencedAssemblies.Add("System.dll");
opt.GenerateExecutable = false;
opt.GenerateInMemory = true;
var result = compiler.CompileAssemblyFromSource(opt, source);
if (result.Errors.Count > 0)
{
Console.WriteLine("Compile Error");
return;
}
var js = result.CompiledAssembly;
dynamic jsProg = js.CreateInstance("JsProgram");
jsProg.proc();
/*
* True is True
* World
*/
}
public ICompilerResult Compile()
{
CompilerParameters options = new CompilerParameters();
if (_target != null)
{
AddCompilerOption("/target:" + _target);
}
if (_platform != null)
{
AddCompilerOption("/platform:" + _platform);
}
//options.GenerateExecutable = _generateExecutable;
options.GenerateExecutable = IsTargetExecutable(_target);
options.GenerateInMemory = _generateInMemory;
options.IncludeDebugInformation = _debugInformation;
// WarningLevel : from http://msdn.microsoft.com/en-us/library/13b90fz7.aspx
// 0 Turns off emission of all warning messages.
// 1 Displays severe warning messages.
// 2 Displays level 1 warnings plus certain, less-severe warnings, such as warnings about hiding class members.
// 3 Displays level 2 warnings plus certain, less-severe warnings, such as warnings about expressions that always evaluate to true or false.
// 4 (the default) Displays all level 3 warnings plus informational warnings.
options.WarningLevel = _warningLevel;
options.OutputAssembly = _outputAssembly;
options.CompilerOptions = _compilerOptions;
//foreach (string assembly in _referencedAssemblies)
foreach (ReferencedAssembly assembly in _referencedAssemblies)
{
options.ReferencedAssemblies.Add(assembly.File);
}
foreach (ResourceFile resource in _embeddedResources)
{
options.EmbeddedResources.Add(resource.File);
}
CodeDomProvider provider = new JScriptCodeProvider();
CompilerResults result = provider.CompileAssemblyFromFile(options, _sources.ToArray());
provider.Dispose();
return(new CodeDomProviderCompilerResult(result));
}
static Evaluator()
{
ICodeCompiler compiler;
compiler = new JScriptCodeProvider().CreateCompiler();
CompilerParameters parameters;
parameters = new CompilerParameters();
parameters.GenerateInMemory = true;
CompilerResults results;
results = compiler.CompileAssemblyFromSource(parameters, _jscriptSource);
Assembly assembly = results.CompiledAssembly;
_evaluatorType = assembly.GetType("Evaluator.Evaluator");
_evaluator = Activator.CreateInstance(_evaluatorType);
}
public string onStartUp(string fn)
{
string Source = System.IO.File.ReadAllText(fn);
var provider = new JScriptCodeProvider();
var compiler = provider.CreateCompiler();
var parameters = new CompilerParameters {
GenerateInMemory = true
};
var results = compiler.CompileAssemblyFromSource(parameters, Source);
var assembly = results.CompiledAssembly;
dynamic instance = Activator.CreateInstance(assembly.GetType("StartupConfiguration"));
var result = instance.getStartup3DFile(this.app);
string sr = result.ToString();
return(sr);
}
public static Assembly LoadMacroAssembly(MacroModule mod)
{
if (mod.Type == MacroType.Assembly)
{
return(Assembly.LoadFrom(mod.Path));
}
else if (mod.Type == MacroType.JavaScript)
{
ICodeCompiler compiler = new JScriptCodeProvider().CreateCompiler();
CompilerParameters param = new CompilerParameters();
param.CompilerOptions += "/debug";
param.GenerateInMemory = true;
param.GenerateExecutable = true;
//param.ReferencedAssemblies.Add("mscorlib"); //要るの？
param.ReferencedAssemblies.Add("System.Drawing.dll");
param.ReferencedAssemblies.Add(GetMyExePath());
param.ReferencedAssemblies.Add(GetGTerminalPath());
foreach (string x in mod.AdditionalAssemblies)
{
if (x.Length > 0)
{
param.ReferencedAssemblies.Add(x);
}
}
CompilerResults result = compiler.CompileAssemblyFromFile(param, mod.Path);
if (result.Errors.Count > 0)
{
StringBuilder bld = new StringBuilder();
bld.Append(GApp.Strings.GetString("Message.MacroExec.FailedToCompileScript"));
foreach (CompilerError err in result.Errors)
{
bld.Append(String.Format("Line {0} Column {1} : {2}\n", err.Line, err.Column, err.ErrorText));
}
throw new Exception(bld.ToString());
}
return(result.CompiledAssembly);
}
else
{
throw new Exception("Unsupported macro module type " + mod.Type.ToString() + " is specified.");
}
}
static void Main()
{
Console.WriteLine("What string do you want the custom program to display?");
string message = Console.ReadLine();
Console.WriteLine("How many times do you want the program to display this message?");
int nDisplays = int.Parse(Console.ReadLine());
CodeCompileUnit unit = GenerateProgram(message, nDisplays);
// Set up options for source code style
CodeGeneratorOptions opts = new CodeGeneratorOptions();
opts.BracingStyle = "C";
opts.IndentString = "\t";
// Create code generators and write code files
CodeDomProvider[] providers = new CodeDomProvider[3];
providers[0] = new CSharpCodeProvider();
providers[1] = new VBCodeProvider();
providers[2] = new JScriptCodeProvider();
// providers[3] = new VJSharpCodeProvider();
string[] fileNames = { "MyCodeCS.cs", "MyCodeVB.vb", "MyCodeJS.js" };
for (int i = 0; i < providers.Length; i++)
{
ICodeGenerator gen = providers[i].CreateGenerator();
StreamWriter sw = new StreamWriter(fileNames[i]);
gen.GenerateCodeFromCompileUnit(unit, sw, opts);
sw.Close();
}
string[] assemblyFileNames = { "MyCodeCS.exe", "MyCodeVB.exe",
"MyCodeJS.exe" };
CompilerParameters compilerParams = new CompilerParameters();
compilerParams.GenerateExecutable = true;
for (int i = 0; i < providers.Length; i++)
{
ICodeCompiler compiler = providers[i].CreateCompiler();
compilerParams.OutputAssembly = assemblyFileNames[i];
compiler.CompileAssemblyFromFile(compilerParams, fileNames[i]);
}
}
public static CompilerResults CompileFromJScriptSourceStream(Stream sourceStream, CompilerParameters cParams)
{
String tmpFile = Path.GetTempFileName();
using (FileStream output = new FileStream(tmpFile, FileMode.Create))
{
byte[] buffer = new byte[sourceStream.Length];
sourceStream.Seek(0, SeekOrigin.Begin);
sourceStream.Read(buffer, 0, buffer.Length);
output.Write(buffer, 0, buffer.Length);
}
using (CodeDomProvider provider = new JScriptCodeProvider())
{
CompilerResults res = provider.CompileAssemblyFromFile(cParams, tmpFile);
File.Delete(tmpFile);
return(res);
}
}
/// <summary>
/// Performs the actual compiling of the <see cref="Assembly"/>. Will be called by the
/// <see cref="ScriptAssemblyCache"/> if the source didn't exist in the cache.
/// </summary>
/// <param name="sourceCode">The source code to compile.</param>
/// <param name="filePath">The file path to give the generated <see cref="Assembly"/>.</param>
/// <returns>The generated <see cref="Assembly"/>. Can be null if there was any errors generating it.</returns>
protected virtual Assembly CompileSourceToAssembly(string sourceCode, string filePath)
{
CompilerResults results;
// Set up the compiler parameters
var p = new CompilerParameters
{
GenerateInMemory = false, IncludeDebugInformation = false, OutputAssembly = filePath
};
// Compile
using (var provider = new JScriptCodeProvider())
{
results = provider.CompileAssemblyFromSource(p, sourceCode);
}
// Store the compilation errors
if (results.Errors.Count > 0)
{
const string errmsg = "Error compiling JScript assembly: {0}";
if (log.IsErrorEnabled)
{
foreach (var err in results.Errors.OfType <CompilerError>())
{
log.ErrorFormat(errmsg, err);
}
}
Debug.Assert(!results.Errors.HasErrors, "One or more errors when compiling JScript assembly.");
_compilationErrors = results.Errors.OfType <CompilerError>().ToImmutable();
}
else
{
_compilationErrors = _emptyCompilerErrors;
}
// Return the compiled assembly
return(results.CompiledAssembly);
}
//public static void Test_GetNewIndexedDirectory_01()
//{
// Trace.WriteLine("Test_GetNewIndexedDirectory_01");
// string dir = @"c:\pib\_dl\_jd\_new\pdf";
// Trace.WriteLine("dir \"{0}\"", dir);
// string newDir = zfile.GetNewIndexedDirectory(dir);
// Trace.WriteLine("new dir \"{0}\"", newDir);
//}
public static void Test_JScript_01()
{
Trace.WriteLine("Test_JScript_01");
CodeDomProvider provider = new JScriptCodeProvider();
CompilerParameters para = new CompilerParameters();
para.GenerateInMemory = true;
// string jscode =
// @"class Sample
// {
// var mytext=’This is JScript’;
// }";
string jscode = zfile.ReadAllText("magazine3k.js");
//string jscode = "function test_javascript_01() { return \"toto\"; }";
CompilerResults result = provider.CompileAssemblyFromSource(para, jscode);
Assembly assembly = result.CompiledAssembly;
Type jsType = assembly.GetType("magazine3k.test");
//object jsObject = Activator.CreateInstance(jsType);
//object retValue = jsType.InvokeMember("text", BindingFlags.GetField, null, jsObject, null);
//wr.WriteLine("text : {0}", retValue);
//object retValue = jsType.InvokeMember("test_01", BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static, null, null, null);
// BindingFlags.CreateInstance BindingFlags.GetField | BindingFlags.SetField BindingFlags.GetProperty | BindingFlags.SetProperty
//object retValue = jsType.InvokeMember("test_01", BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.InvokeMethod, null, null, null);
object retValue = jsType.InvokeMember("test_01", BindingFlags.Public | BindingFlags.Static | BindingFlags.InvokeMethod, null, null, null);
Trace.WriteLine("magazine3k.test.test_01() : {0}", retValue);
jsType = assembly.GetType("magazine3k.magazine3k");
object jsObject = Activator.CreateInstance(jsType);
jsType.InvokeMember("init", BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod, null, jsObject, null);
Trace.WriteLine("magazine3k.magazine3k.init()");
string s = "wjSWs:VK00ZX.BmUr+K5yxa.hK1sA?UYYqB51IUqPKffxQ";
retValue = jsType.InvokeMember("encrypt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod, null, jsObject, new object[] { s });
Trace.WriteLine("magazine3k.magazine3k.encrypt(\"{0}\") : \"{1}\"", s, retValue);
}
public JScriptEval()
{
var compiler = new JScriptCodeProvider();
var parameters = new CompilerParameters {
GenerateInMemory = true
};
string jscriptSource =
@"package Evaluator
{
class Evaluator
{
public function Eval(expr : String)
{
return eval(expr);
}
}
}";
var results = compiler.CompileAssemblyFromSource(parameters, jscriptSource);
var assembly = results.CompiledAssembly;
evaluatorType = assembly.GetType("Evaluator.Evaluator");
evaluator = Activator.CreateInstance(evaluatorType);
}
public static CompilerException Compile(string modDirectory, string outputDirectory)
{
CommonToolUtilities.RefreshHashes();
string modName = Path.GetDirectoryName(modDirectory);
string jsonFile, modInfo;
CodeDomProvider cdcp = new CSharpCodeProvider();
string ext = "*.cs";
#region validating ModInfo.json
jsonFile = modDirectory + "\\ModInfo.json";
if (!File.Exists(jsonFile))
{
File.WriteAllText(jsonFile, "{\"name\":\"" + modName + "\",\"author\":\"<unknown>\"}");
Console.WriteLine("Warning: You do not have a ModInfo.json file.\n\tUsing the default ModInfo...");
}
try
{
JsonData json = JsonMapper.ToObject(File.ReadAllText(jsonFile));
if (!json.Has("name"))
{
throw new CompilerException("Missing ModInfo filed 'name'");
}
else
{
modName = (string)json["name"];
}
if (!json.Has("author"))
{
throw new CompilerException("Missing ModInfo filed 'author'");
}
if (json.Has("code"))
{
JsonData jCode = json["code"];
if (jCode.Has("codeType"))
{
switch (jCode["codeType"].ToString().ToLower().Trim())
{
case "vb":
case "vb.net":
case "basic":
case "basic.net":
case "vbasic":
case "vbasic.net":
case "visualbasic":
case "visualbasic.net":
case "visual basic":
case "visual basic.net":
cdcp = new VBCodeProvider();
ext = "*.vb";
Console.WriteLine("Using Visual Basic.NET (VBCodeDomProvider)...");
break;
case "js":
case "js.net":
case "jscript":
case "jscript.net":
case "javascript":
case "javascript.net":
cdcp = new JScriptCodeProvider();
ext = "*.js";
Console.WriteLine("Using JScript.NET (JScriptCodeProvider)...");
break;
case "cs":
case "c#":
case "csharp":
case "visual cs":
case "visual c#":
case "visual csharp":
// inited as C#
Console.WriteLine("Using C# (CSharpCodeProvider)...");
break;
default:
Console.WriteLine("Language not explicitely defined, using C# (CSharpCodeProvider)...");
break;
}
}
}
//if (!json.Has("version"))
// throw new CompileException("Missing ModInfo field 'version'");
//if (!json.Has("info"))
// throw new CompileException("Missing ModInfo field 'info'");
modInfo = (string)json;
}
catch (Exception e)
{
throw new CompilerException("Invalid file: ModInfo.json", e);
}
#endregion
#region compile the code
List <string> toCompile = new List <string>();
foreach (string file in Directory.EnumerateFiles(modDirectory, ext, SearchOption.AllDirectories))
{
toCompile.Add(file);
}
CompilerParameters cp = new CompilerParameters()
{
GenerateExecutable = false,
GenerateInMemory = false,
OutputAssembly = outputDirectory + "\\" + modName + ".tapimod"
};
string
xna = Environment.GetEnvironmentVariable("XNAGSv4") + "\\References\\Windows\\x86\\",
wpf = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86)
+ "\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework\\v4.0\\Profile\\Client\\",
here = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
cp.ReferencedAssemblies.Add("tAPI.exe");
cp.ReferencedAssemblies.Add("Microsoft.JScript.dll");
cp.ReferencedAssemblies.Add("Microsoft.VisualBasic.dll");
cp.ReferencedAssemblies.Add("Microsoft.CSharp.dll");
cp.ReferencedAssemblies.Add("Accessibility.dll");
cp.ReferencedAssemblies.Add("mscorlib.dll");
cp.ReferencedAssemblies.Add("System.dll");
cp.ReferencedAssemblies.Add("System.Core.dll");
cp.ReferencedAssemblies.Add("System.Drawing.dll");
cp.ReferencedAssemblies.Add("System.Windows.Forms.dll");
cp.ReferencedAssemblies.Add("System.Numerics.dll");
cp.ReferencedAssemblies.Add("System.Xml.dll");
cp.ReferencedAssemblies.Add(wpf + "PresentationCore.dll");
cp.ReferencedAssemblies.Add(wpf + "PresentationFramework.dll");
cp.ReferencedAssemblies.Add(wpf + "WindowsBase.dll");
cp.ReferencedAssemblies.Add(xna + "Microsoft.Xna.Framework.dll");
cp.ReferencedAssemblies.Add(xna + "Microsoft.Xna.Framework.Xact.dll");
cp.ReferencedAssemblies.Add(xna + "Microsoft.Xna.Framework.Game.dll");
cp.ReferencedAssemblies.Add(xna + "Microsoft.Xna.Framework.Graphics.dll");
CompilerResults cr = cdcp.CompileAssemblyFromFile(cp, toCompile.ToArray());
if (cr.Errors.HasErrors)
{
return(CompilerException.CreateException(cr.Errors));
}
#endregion
#region save to .tapimod file
/*
* How a .tapimod file looks like:
*
* - version (uint)
*
* - modinfo (string)
*
* - file amount (int)
*
* files:
* - file name (string)
* - file data length (int)
*
* files:
* - file data (byte[])
*
* - assembly data
*/
// VBCodeProvider automatically adds '.dll'
string mod = outputDirectory + (cdcp is VBCodeProvider ? ".tapimod.dll" : ".tapimod");
List <Tuple <string, byte[]> > files = new List <Tuple <string, byte[]> >();
foreach (string fileName in Directory.EnumerateFiles(modDirectory, "*.*", SearchOption.AllDirectories))
{
if (!Path.GetExtension(fileName).EndsWith(ext.Substring(2)))
{
files.Add(new Tuple <string, byte[]>(fileName.Substring(modDirectory.Length + 1).Replace('\\', '/'), File.ReadAllBytes(fileName)));
}
}
BinBuffer bb = new BinBuffer();
bb.Write(Constants.versionAssembly);
bb.Write(modInfo);
bb.Write(files.Count);
foreach (Tuple <string, byte[]> pfile in files)
{
bb.Write(pfile.Item1);
bb.Write(pfile.Item2.Length);
}
foreach (Tuple <string, byte[]> pfile in files)
{
bb.Write(pfile.Item2);
}
bb.Pos = 0;
File.WriteAllBytes(cdcp is VBCodeProvider ? Path.ChangeExtension(mod, null) : mod, bb.ReadBytes(bb.GetSize()));
// generate false hashes
CommonToolUtilities.AddHashes(modName, modDirectory);
#endregion
return(null);
}
public static Assembly LoadMacroAssembly(MacroModule mod)
{
if (mod.Type == MacroType.Assembly)
{
return(Assembly.LoadFrom(mod.Path));
}
else if (mod.Type == MacroType.JavaScript)
{
JScriptCodeProvider compiler = new JScriptCodeProvider();
CompilerParameters param = new CompilerParameters();
param.IncludeDebugInformation = true;
param.GenerateInMemory = false; //これがプラグインをロードできるかどうかの決め手になった。周辺をすべて理解したわけではないが、とりあえずこれでよしとする。深入りしている時間はあまりないし
param.GenerateExecutable = true;
StringCollection sc = param.ReferencedAssemblies;
bool[] assyAdded = new bool[9];
foreach (Assembly assy in AppDomain.CurrentDomain.GetAssemblies())
{
try {
string assyFilePath = new Uri(assy.CodeBase).LocalPath;
string assyFileName = Path.GetFileName(assyFilePath).ToLower(CultureInfo.InvariantCulture);
switch (assyFileName)
{
case "system.drawing.dll":
assyAdded[0] = true;
break;
case "system.windows.forms.dll":
assyAdded[1] = true;
break;
case "poderosa.plugin.dll":
assyAdded[2] = true;
break;
case "poderosa.core.dll":
assyAdded[3] = true;
break;
case "granados.dll":
assyAdded[4] = true;
break;
case "poderosa.protocols.dll":
assyAdded[5] = true;
break;
case "poderosa.terminalemulator.dll":
assyAdded[6] = true;
break;
case "poderosa.terminalsession.dll":
assyAdded[7] = true;
break;
case "poderosa.macro.dll":
assyAdded[8] = true;
break;
case "poderosa.monolithic.exe":
// FIXME: it is better to use the name of the entry assembly.
// but how can we know the entry assembly is the monolithic type ?
assyAdded[2] =
assyAdded[3] =
assyAdded[4] =
assyAdded[5] =
assyAdded[6] =
assyAdded[7] =
assyAdded[8] = true;
break;
default:
continue;
}
Debug.WriteLine("(LoadMacroAssembly) add to ReferencedAssemblies: " + assyFilePath);
sc.Add(assyFilePath);
}
catch (Exception) {
}
}
foreach (bool flag in assyAdded)
{
if (!flag)
{
throw new Exception(MacroPlugin.Instance.Strings.GetString("Message.MacroExec.MissingAssemblies"));
}
}
foreach (string x in mod.AdditionalAssemblies)
{
if (x.Length > 0)
{
sc.Add(x);
}
}
CompilerResults result = compiler.CompileAssemblyFromFile(param, mod.Path);
if (result.Errors.Count > 0)
{
StringBuilder bld = new StringBuilder();
bld.Append(MacroPlugin.Instance.Strings.GetString("Message.MacroExec.FailedToCompileScript"));
foreach (CompilerError err in result.Errors)
{
bld.Append(String.Format("Line {0} Column {1} : {2}\n", err.Line, err.Column, err.ErrorText));
}
throw new Exception(bld.ToString());
}
Debug.WriteLineIf(DebugOpt.Macro, "Compiled:" + result.PathToAssembly + " FullName:" + result.CompiledAssembly.FullName);
//AppDomain.CurrentDomain.Load(result.CompiledAssembly.FullName, result.Evidence);
return(result.CompiledAssembly);
}
else
{
throw new Exception("Unsupported macro module type " + mod.Type.ToString() + " is specified.");
}
}
static IntropJSCHelper()
{
MJScriptCodeProvider = new JScriptCodeProvider();
parameters.GenerateInMemory = true;
}
/// <summary>
/// Generates an Assembly from a script filename
/// </summary>
/// <param name="filename">The filename of the script</param>
/// <param name="references">Assembly references for the script</param>
/// <returns>The generated assembly</returns>
public Assembly CreateAssembly(string filename, IList references)
{
// ensure that compilerErrors is null
compilerErrors = null;
string extension = Path.GetExtension(filename);
// Select the correct CodeDomProvider based on script file extension
CodeDomProvider codeProvider = null;
switch (extension)
{
case ".cs":
codeProvider = new CSharpCodeProvider();
break;
case ".vb":
codeProvider = new CSharpCodeProvider();
break;
case ".js":
codeProvider = new JScriptCodeProvider();
break;
default:
throw new InvalidOperationException("Script files must have a .cs, .vb, or .js extension, for C#, Visual Basic.NET, or JScript respectively.");
}
ICodeCompiler compiler = codeProvider.CreateCompiler();
// Set compiler parameters
CompilerParameters compilerParams = new CompilerParameters();
compilerParams.CompilerOptions = "/target:library /optimize";
compilerParams.GenerateExecutable = false;
compilerParams.GenerateInMemory = true;
compilerParams.IncludeDebugInformation = false;
compilerParams.ReferencedAssemblies.Add("mscorlib.dll");
compilerParams.ReferencedAssemblies.Add("System.dll");
// Add custom references
foreach (string reference in references)
{
if (!compilerParams.ReferencedAssemblies.Contains(reference))
{
compilerParams.ReferencedAssemblies.Add(reference);
}
}
// Do the compilation
CompilerResults results = compiler.CompileAssemblyFromFile(compilerParams,
filename);
//Do we have any compiler errors
if (results.Errors.Count > 0)
{
compilerErrors = results.Errors;
throw new Exception(
"Compiler error(s) encountered and saved to AssemblyFactory.CompilerErrors");
}
Assembly createdAssembly = results.CompiledAssembly;
return(createdAssembly);
}
