public string ConvertToPInvokeCode(NativeProcedure proc)
{
ErrorProvider ep = new ErrorProvider();
CodeTypeDeclarationCollection col = ConvertToCodeDom(proc, ep);
return(ConvertCodeDomToPInvokeCodeImpl(col, ep));
}
public CodeTypeDeclarationCollection ConvertToCodeDom(NativeProcedure proc, ErrorProvider ep)
{
NativeSymbolBag bag = new NativeSymbolBag(_storage);
bag.AddProcedure(proc);
return(ConvertBagToCodeDom(bag, ep));
}
public void SaveAndLoad6()
{
NativeFunctionPointer fptr = new NativeFunctionPointer("f1");
Assert.Equal(NativeCallingConvention.WinApi, fptr.CallingConvention);
fptr.CallingConvention = NativeCallingConvention.Pascal;
fptr.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeChar);
NativeProcedure proc = new NativeProcedure("p1");
Assert.Equal(NativeCallingConvention.WinApi, proc.CallingConvention);
proc.CallingConvention = NativeCallingConvention.CDeclaration;
proc.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeChar);
var ns = new BasicSymbolStorage();
ns.AddProcedure(proc);
ns.AddDefinedType(fptr);
NativeDefinedType temp = null;
NativeFunctionPointer retPtr = null;
Assert.True(ns.TryGetGlobalSymbol(fptr.Name, out temp));
retPtr = (NativeFunctionPointer)temp;
Assert.Equal(NativeCallingConvention.Pascal, retPtr.CallingConvention);
NativeProcedure retProc = null;
Assert.True(ns.TryGetGlobalSymbol(proc.Name, out retProc));
Assert.Equal(NativeCallingConvention.CDeclaration, retProc.CallingConvention);
}
public void BagSaveAndLoad1()
{
NativeProcedure p1 = new NativeProcedure("p1");
p1.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeBoolean);
NativeTypeDef td = new NativeTypeDef("LPWSTR", new NativePointer(BuiltinType.NativeWChar));
p1.Signature.Parameters.Add(new NativeParameter("param1", new NativeNamedType("LPWSTR", td)));
Assert.Equal("boolean p1(LPWSTR param1)", p1.DisplayName);
Assert.Equal("p1(Sig(boolean)(Sal)(param1(LPWSTR(LPWSTR(*(wchar))))(Sal)))", SymbolPrinter.Convert(p1));
var ns = new BasicSymbolStorage();
ns.AddProcedure(p1);
ns.AddTypeDef(td);
NativeSymbolBag bag = new NativeSymbolBag(ns);
NativeProcedure ret1 = null;
Assert.True(bag.TryGetGlobalSymbol("p1", out ret1));
bag.AddProcedure(ret1);
Assert.True(bag.TryResolveSymbolsAndValues());
Assert.Equal(SymbolPrinter.Convert(p1), SymbolPrinter.Convert(ret1));
}
public static void RunScript(string pth)
{
var basedir = Path.GetDirectoryName(pth);
Interpreter.CreateSymbolTableDelegate extension = _ => new Dictionary <Symbol, object>()
{
// generic stuff
{ Symbol.FromString("sprintf"), NativeProcedure.Create <string, List <object>, string>((fmt, parts) => Sprintf(fmt, parts)) },
// roughgrep stuff
{ Symbol.FromString("make-runner"), NativeProcedure.Create <string, string, string, object>((bin, arg, workdir) => MakeRunner(bin, arg, workdir)) },
{ Symbol.FromString("add-command"), NativeProcedure.Create <string, CmdRunner, object>((pat, cmspec) => AddCommand(pat, cmspec)) },
{ Symbol.FromString("path-rel"), NativeProcedure.Create <string, string>(s => Path.Combine(basedir, s)) },
{ Symbol.FromString("set-arg"), NativeProcedure.Create <string, object>(s => SetArg(s)) },
{ Symbol.FromString("set-tutorial"), NativeProcedure.Create <string, object>(s => SetTutorial(s)) },
};
var interpreter = new Interpreter(new[] { extension }, new ReadOnlyFileSystemAccessor());
using (Stream script = File.OpenRead(pth))
using (TextReader reader = new StreamReader(script))
{
var res = interpreter.Evaluate(reader);
if (res.Error != null)
{
Logic.Tutorial = res.Error.Message;
}
}
}
/// <summary>
/// Verification of the generated code
/// </summary>
/// <param name="ns"></param>
/// <remarks></remarks>
private static void VerifyGeneratedStorage(BasicSymbolStorage ns)
{
NativeProcedure proc = null;
VerifyTrue(ns.TryGetGlobalSymbol("SendMessageA", out proc));
VerifyTrue(ns.TryGetGlobalSymbol("SendMessageW", out proc));
VerifyTrue(ns.TryGetGlobalSymbol("GetForegroundWindow", out proc));
VerifyTrue(ns.TryGetGlobalSymbol("CreateWellKnownSid", out proc));
NativeTypeDef typedef = null;
VerifyTrue(ns.TryGetGlobalSymbol("LPCSTR", out typedef));
VerifyTrue(ns.TryGetGlobalSymbol("LPWSTR", out typedef));
NativeType defined = null;
VerifyTrue(ns.TryGetType("WNDPROC", out defined));
VerifyTrue(ns.TryGetType("HOOKPROC", out defined));
VerifyTrue(ns.TryGetType("tagPOINT", out defined));
VerifyTrue(ns.TryGetType("_SYSTEM_INFO", out defined));
NativeConstant c = null;
VerifyTrue(ns.TryGetGlobalSymbol("WM_PAINT", out c));
VerifyTrue(ns.TryGetGlobalSymbol("WM_LBUTTONDOWN", out c));
}
private void WriteProcedure(NativeProcedure proc)
{
_writer.WriteNameKind(NativeNameKind.Procedure);
_writer.WriteString(proc.Name);
_writer.WriteInt32((int)proc.CallingConvention);
_writer.WriteString(proc.DllName);
WriteSignature(proc.Signature);
}
private void VerifyProc(ParseResult result, int index, string str)
{
Assert.NotNull(result);
Assert.True(index < result.NativeProcedures.Count, "Invalid procedure index");
NativeProcedure proc = result.NativeProcedures[index];
Assert.Equal(str, proc.DisplayName);
}
private void VerifyProcSal(ParseResult result, int index, string str)
{
Assert.NotNull(result);
Assert.True(index < result.NativeProcedures.Count, "Invalid procedure index");
NativeProcedure proc = result.NativeProcedures[index];
Assert.Equal(str, proc.Signature.CalculateSignature(proc.Name, true));
}
public void ProcedureSimple()
{
var p = new NativeProcedure("ptr");
p.CallingConvention = NativeCallingConvention.CDeclaration;
p.Signature = new NativeSignature();
p.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeInt32);
TestRoundTrip(p);
}
private NativeGlobalSymbol ImportProcedure()
{
var proc = new NativeProcedure(_reader.ReadString());
proc.CallingConvention = (NativeCallingConvention)_reader.ReadInt32();
proc.DllName = _reader.ReadString();
proc.Signature = ImportSignature();
return(new NativeGlobalSymbol(proc));
}
public void Child6()
{
NativeProcedure proc = new NativeProcedure("proc");
proc.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeByte);
VerifyTree(proc, "proc(Sig(byte)(Sal))");
proc.Signature.Parameters.Add(new NativeParameter("p1", new NativeBuiltinType(BuiltinType.NativeChar)));
VerifyTree(proc, "proc(Sig(byte)(Sal)(p1(char)(Sal)))");
}
public void Child7()
{
NativeProcedure proc = new NativeProcedure("proc");
proc.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeByte);
proc.Signature.Parameters.Add(new NativeParameter("p1", new NativeBuiltinType(BuiltinType.NativeChar)));
proc.Signature.ReplaceChild(proc.Signature.ReturnType, new NativeBuiltinType(BuiltinType.NativeFloat));
VerifyTree(proc, "proc(Sig(float)(Sal)(p1(char)(Sal)))");
proc.Signature.ReplaceChild(proc.Signature.Parameters[0], new NativeParameter("p2", new NativeBuiltinType(BuiltinType.NativeChar)));
VerifyTree(proc, "proc(Sig(float)(Sal)(p2(char)(Sal)))");
}
public void Proc1()
{
NativeSymbolBag bag = new NativeSymbolBag();
NativeProcedure p1 = new NativeProcedure("p1");
p1.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeDouble);
bag.AddProcedure(p1);
Assert.True(bag.TryResolveSymbolsAndValues());
}
public void Proc4()
{
NativeSymbolBag bag = new NativeSymbolBag();
NativeProcedure p1 = new NativeProcedure("p1");
p1.Signature.ReturnType = new NativeNamedType("foo");
p1.Signature.Parameters.Add(new NativeParameter("param1", new NativeBuiltinType(BuiltinType.NativeDouble)));
bag.AddProcedure(p1);
Assert.False(bag.TryResolveSymbolsAndValues());
}
public void Proc6()
{
NativeSymbolBag bag = new NativeSymbolBag();
NativeProcedure p1 = new NativeProcedure("p1");
p1.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeInt32, true);
p1.Signature.Parameters.Add(new NativeParameter("param1", new NativeNamedType("foo")));
bag.AddProcedure(p1);
bag.AddTypeDef(new NativeTypeDef("foo", new NativeBuiltinType(BuiltinType.NativeFloat)));
Assert.True(bag.TryResolveSymbolsAndValues());
}
public void Proc1()
{
NativeProcedure p1 = new NativeProcedure("p1");
p1.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeByte);
var ns = new BasicSymbolStorage();
ns.AddProcedure(p1);
NativeProcedure retp1 = null;
Assert.True(ns.TryGetGlobalSymbol(p1.Name, out retp1));
Assert.Equal(p1.DisplayName, retp1.DisplayName);
}
public void FindOrLoad4()
{
var ns = new BasicSymbolStorage();
NativeProcedure p1 = new NativeProcedure("p1");
p1.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeBoolean);
ns.AddProcedure(p1);
NativeSymbolBag bag = new NativeSymbolBag(ns);
NativeProcedure p = null;
Assert.False(bag.Storage.TryGetGlobalSymbol("p1", out p));
Assert.True(bag.TryGetGlobalSymbol("p1", out p));
Assert.True(bag.TryGetGlobalSymbol("p1", out p));
}
public void Sal2()
{
NativeProcedure p1 = new NativeProcedure("p1");
p1.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeChar);
p1.Signature.ReturnTypeSalAttribute = new NativeSalAttribute(new NativeSalEntry(SalEntryType.Deref, "foo"));
var ns = new BasicSymbolStorage();
ns.AddProcedure(p1);
NativeProcedure retp1 = null;
Assert.True(ns.TryGetGlobalSymbol(p1.Name, out retp1));
Assert.Equal("Deref(foo)", retp1.Signature.ReturnTypeSalAttribute.DisplayName);
}
/// <summary>
/// Generate a procedure from the specified proc
/// </summary>
/// <param name="ntProc"></param>
/// <returns></returns>
/// <remarks></remarks>
public CodeMemberMethod GenerateProcedure(NativeProcedure ntProc)
{
if (ntProc == null)
{
throw new ArgumentNullException("ntProc");
}
// Create the proc
NativeSignature ntSig = ntProc.Signature;
string procComment = "Return Type: ";
CodeMemberMethod proc = new CodeMemberMethod();
proc.Name = ntProc.Name;
proc.ReturnType = GenerateTypeReferenceImpl(ntSig.ReturnType, ref procComment);
proc.UserData[TransformConstants.ReturnType] = ntSig.ReturnType;
if (ntSig.ReturnTypeSalAttribute != null)
{
proc.UserData[TransformConstants.ReturnTypeSal] = ntSig.ReturnTypeSalAttribute;
}
else
{
proc.UserData[TransformConstants.ReturnTypeSal] = new NativeSalAttribute();
}
proc.Attributes = MemberAttributes.Public | MemberAttributes.Static;
proc.UserData[TransformConstants.Procedure] = ntProc;
proc.UserData[TransformConstants.ReturnType] = ntSig.ReturnType;
proc.UserData[TransformConstants.ReturnTypeSal] = ntSig.ReturnTypeSalAttribute;
// Add the DLL import attribute
string dllName = ntProc.DllName;
if (string.IsNullOrEmpty(dllName))
{
dllName = "<Unknown>";
}
proc.CustomAttributes.Add(MarshalAttributeFactory.CreateDllImportAttribute(dllName, ntProc.Name, ntProc.CallingConvention));
// Generate the parameters
proc.Parameters.AddRange(GenerateParameters(ntProc.Signature, ref procComment));
proc.Comments.Add(new CodeCommentStatement(procComment, true));
return(proc);
}
public void Sal3()
{
NativeParameter param = new NativeParameter("p");
param.SalAttribute = new NativeSalAttribute(SalEntryType.Deref);
param.NativeType = new NativeBuiltinType(BuiltinType.NativeChar);
NativeProcedure p1 = new NativeProcedure("p1");
p1.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeChar);
p1.Signature.Parameters.Add(param);
var ns = new BasicSymbolStorage();
ns.AddProcedure(p1);
NativeProcedure retp1 = null;
Assert.True(ns.TryGetGlobalSymbol(p1.Name, out retp1));
Assert.Equal("Deref", retp1.Signature.Parameters[0].SalAttribute.DisplayName);
}
public static void Main(string[] args)
{
NativeStorage ns = NativeStorage.LoadFromAssemblyPath;
NativeSymbolBag bag = new NativeSymbolBag(ns);
NativeProcedure ntProc = null;
bag.TryFindOrLoadProcedure("FindFirstFileW", ntProc);
bag.TryFindOrLoadProcedure("FindNextFileW", ntProc);
bag.TryFindOrLoadProcedure("FindClose", ntProc);
bag.TryFindOrLoadProcedure("GetSystemDirectoryW", ntProc);
bag.TryFindOrLoadProcedure("GetWindowTextW", ntProc);
bag.TryFindOrLoadProcedure("EnumWindows", ntProc);
bag.TryFindOrLoadProcedure("GetComputerNameW", ntProc);
bag.TryFindOrLoadProcedure("CreateWellKnownSid", ntProc);
bag.TryFindOrLoadProcedure("CopySid", ntProc);
bag.TryFindOrLoadProcedure("IsEqualSid", ntProc);
bag.TryFindOrLoadProcedure("SHGetFileInfoW", ntProc);
bag.TryFindOrLoadProcedure("GetEnvironmentVariableW", ntProc);
bag.TryFindOrLoadProcedure("atoi", ntProc);
NativeDefinedType ntDefined = null;
NativeTypeDef ntTypedef = null;
bag.TryFindOrLoadDefinedType("WNDPROC", ntDefined);
bag.TryFindOrLoadDefinedType("WNDENUMPROC", ntDefined);
bag.TryFindOrLoadDefinedType("COMSTAT", ntDefined);
bag.TryFindOrLoadDefinedType("_DCB", ntDefined);
bag.TryFindOrLoadDefinedType("_IMAGE_LINENUMBER", ntDefined);
BasicConverter convert = new BasicConverter(LanguageType.VisualBasic, ns);
string code = convert.ConvertToPInvokeCode(bag);
code = "' Generated File ... Re-Run PInvokeTestGen to regenerate this file" + Constants.vbCrLf + "Namespace Generated" + Constants.vbCrLf + code + Constants.vbCrLf + "End Namespace";
IO.File.WriteAllText(args(0), code);
}
public void Proc4()
{
NativeStruct s1 = new NativeStruct("s1");
s1.Members.Add(new NativeMember("m1", new NativeBuiltinType(BuiltinType.NativeByte)));
NativeProcedure p1 = new NativeProcedure("p1");
p1.Signature.ReturnType = s1;
var ns = new BasicSymbolStorage();
ns.AddProcedure(p1);
NativeProcedure retp1 = null;
Assert.True(ns.TryGetGlobalSymbol(p1.Name, out retp1));
Assert.Equal(p1.DisplayName, retp1.DisplayName);
NativeDefinedType rets1 = null;
Assert.False(ns.TryGetGlobalSymbol(s1.Name, out rets1));
}
public static Interpreter CreateItpl()
{
Interpreter.CreateSymbolTableDelegate appExt = _ => new Dictionary <Symbol, object>()
{
{ Symbol.FromString("repl"), NativeProcedure.Create(() => { RunRepl(); return(None.Instance); }) },
{ Symbol.FromString("os-system"), NativeProcedure.Create <string, string, Process>((cmd, arg) =>
ConvenienceRun(cmd, arg, null)) },
{ Symbol.FromString("unzip"), NativeProcedure.Create <string, string, None>((zipfile, targetdir) =>
{
ZipFile.ExtractToDirectory(zipfile, targetdir);
return(None.Instance);
}) },
{ Symbol.FromString("wget"), NativeProcedure.Create <string, string, None>((url, fname) =>
{
new WebClient().DownloadFile(url, fname);
return(None.Instance);
}) },
{ Symbol.FromString("ps-wait"), NativeProcedure.Create <Process, int>(p => {
p.WaitForExit();
return(p.ExitCode);
}) },
{ Symbol.FromString("print"), NativeProcedure.Create <object, object>(o => {
Console.WriteLine(Schemy.Utils.PrintExpr(o));
return(None.Instance);
}) },
{ Symbol.FromString("os-exit"), NativeProcedure.Create <int, object>(exitCode => {
System.Environment.Exit(exitCode);
return(None.Instance);
}) },
{ Symbol.FromString("cd"), NativeProcedure.Create <string, None>(path => {
System.Environment.CurrentDirectory = path;
return(None.Instance);
}) },
{ Symbol.FromString("pwd"), NativeProcedure.Create(() => System.Environment.CurrentDirectory) },
{ Sym("getenv"), NativeProcedure.Create <string, string>((s) => System.Environment.GetEnvironmentVariable(s)) },
{ Sym("path-join"), NativeProcedure.Create <List <object>, string> (parts => Path.Combine(parts.Cast <string>().ToArray())) },
{ Sym("path-tempfile"), NativeProcedure.Create(() => Path.GetTempFileName()) },
{ Sym("path-temppath"), NativeProcedure.Create(() => Path.GetTempPath()) },
{ Sym("path-random"), NativeProcedure.Create(() => Path.GetRandomFileName()) },
{ Sym("path-remove"), NativeProcedure.Create <string, None>(pth => {
File.Delete(pth);
return(None.Instance);
}) },
{ Sym("s-format"), NativeProcedure.Create <string, List <object>, string>((formatString, args) =>
String.Format(formatString, args.ToArray())) },
{ Sym("help"), NativeProcedure.Create(() => AppInterpreter.Environment.store.Keys.Select(k => k.AsString).Cast <object>().ToList()) },
{ Symbol.FromString("s-join"), NativeProcedure.Create <string, List <object>, string> ((sep, strings) => String.Join(sep, strings.Cast <string>().ToArray())) },
{ Symbol.FromString("guess-file"), NativeProcedure.Create <string, List <object>, string>((defaultName, l) =>
{
var found = l.Cast <string>().FirstOrDefault(e => File.Exists(e));
return(found == null ? defaultName : found);
}) },
};
var itpl = new Interpreter(new[] { appExt });
return(itpl);
}
public static void AddProcedure(this INativeSymbolStorage storage, NativeProcedure procedure) => storage.Add(new NativeGlobalSymbol(procedure));
public void Sal2()
{
NativeProcedure proc = new NativeProcedure();
Assert.NotNull(proc.Signature.ReturnTypeSalAttribute);
}
public void Pre()
{
NativeProcedure proc = new NativeProcedure();
Assert.NotNull(proc.Signature);
}
static void Main(string[] args)
{
Interpreter.CreateSymbolTableDelegate extension = _ => new Dictionary <Symbol, object>()
{
{ Symbol.FromString("get-current-os"), NativeProcedure.Create(() => GetCurrentSystem()) },
{ Symbol.FromString("chain"), new NativeProcedure(funcs => new Function(input => funcs.Cast <Function>().Select(b => input = b(input)).Last())) },
{ Symbol.FromString("say-hi"), NativeProcedure.Create <Function>(() => name => $"Hello {name}!") },
{ Symbol.FromString("man-freebsd"), NativeProcedure.Create <Function>(() => cmd => GetUrl($"https://www.freebsd.org/cgi/man.cgi?query={cmd}&format=ascii")) },
{ Symbol.FromString("man-linux"), NativeProcedure.Create <Function>(() => cmd => GetUrl($"http://man7.org/linux/man-pages/man1/{cmd}.1.html")) },
{ Symbol.FromString("truncate-string"), NativeProcedure.Create <int, Function>(len => input => ((string)input).Substring(0, len)) },
};
var interpreter = new Interpreter(new[] { extension }, new ReadOnlyFileSystemAccessor());
if (args.Contains("--repl")) // start the REPL with all implemented functions
{
interpreter.REPL(Console.In, Console.Out);
return;
}
else
{
// starts a TCP server that receives request (cmd <data>) and sends response back.
var engines = new Dictionary <string, Function>();
foreach (var fn in Directory.GetFiles(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "*.ss"))
{
Console.WriteLine($"Loading file {fn}");
LoadScript(interpreter, fn);
engines[Path.GetFileNameWithoutExtension(fn)] = (Function)interpreter.Environment[Symbol.FromString("EXECUTE")];
}
string ip = "127.0.0.1"; int port = 8080;
var server = new TcpListener(IPAddress.Parse(ip), port);
server.Start();
Console.WriteLine($"Server started at {ip}:{port}");
try
{
using (var c = server.AcceptTcpClient())
using (var cs = c.GetStream())
using (var sr = new StreamReader(cs))
using (var sw = new StreamWriter(cs))
{
Console.WriteLine($"Client accepted at {c.Client.RemoteEndPoint}");
while (!sr.EndOfStream)
{
string line = sr.ReadLine();
string[] parsed = line.Split(new[] { ' ' }, 2);
if (parsed.Length != 2)
{
sw.WriteLine($"cannot parse {line}");
sw.Flush();
}
else
{
string engine = parsed[0], request = parsed[1];
if (!engines.ContainsKey(engine))
{
sw.WriteLine($"engine not found: {engine}");
sw.Flush();
}
else
{
string output = (string)(engines[engine](request));
sw.WriteLine(output);
sw.Flush();
}
}
}
}
}
catch (IOException) { }
}
}
public NativeGlobalSymbol(NativeProcedure procedure) : this(procedure.NativeName, procedure)
{
}
