public static CodeCompileUnit Demo1() { // evaluates a simple expression var res = new CodeDomResolver(); Console.WriteLine(res.Evaluate(SlangParser.ParseExpression("5*4-7"))); // takes this file and get a codedom from it var ccu = SlangParser.ReadCompileUnitFrom("..\\..\\Demo1.cs"); ccu.ReferencedAssemblies.Add("CodeDomGoKit.dll"); ccu.ReferencedAssemblies.Add(typeof(CodeObject).Assembly.GetName().ToString()); // now patch the parsed codedom so it's correct // NOTE: slang can't actually bind to this because it is a paramarray method // but we don't care here because it's not necessary. Slang only binds to what // it needs to and we never need the return type anyway (which is void) SlangPatcher.Patch(ccu); // now write it out in VB Console.WriteLine(CodeDomUtility.ToString(ccu, "vb")); // return the code we generated so we can use it for other demos // yay recycling Console.WriteLine("Press any key..."); Console.ReadKey(); Console.Clear(); return(ccu); }
static void RunResolver() { byte[] data; using (var stream = File.OpenRead(@"myfile.bin")) { data = new byte[(int)stream.Length]; stream.Read(data, 0, data.Length); } // create a resolver var res = new CodeDomResolver(); // read the resolver sample into the compile unit CodeCompileUnit ccu; using (var stm = File.OpenRead(@"..\..\Resolver.cs")) ccu = SlangParser.ReadCompileUnitFrom(stm); // remember to patch it! SlangPatcher.Patch(ccu); Console.Error.WriteLine(CU.ToString(ccu)); // add the compile unit to the resolver res.CompileUnits.Add(ccu); // prepare the resolver // any time you add compile units you'll need // to call Refresh() res.Refresh(); // go through all expressions in the // graph and try to get their type CodeDomVisitor.Visit(ccu, (ctx) => { var expr = ctx.Target as CodeExpression; if (null != expr) { // we want everything except CodeTypeReferenceExpression var ctre = expr as CodeTypeReferenceExpression; if (null == ctre) { // get the scope of the expression var scope = res.GetScope(expr); CodeTypeReference ctr = res.TryGetTypeOfExpression(expr, scope); if (null != ctr) { Console.WriteLine(CU.ToString(expr) + " is type: " + CU.ToString(ctr)); Console.WriteLine("Scope Dump:"); Console.WriteLine(scope.ToString()); } } } }); }
static void RunTemplate() { // compute the primes. algorithm borrowed // from SLax at https://stackoverflow.com/questions/1510124/program-to-find-prime-numbers var primesMax = 100; var primesArr = Enumerable.Range(0, (int)Math.Floor(2.52 * Math.Sqrt(primesMax) / Math.Log(primesMax))).Aggregate( Enumerable.Range(2, primesMax - 1).ToList(), (result, index) => { var bp = result[index]; var sqr = bp * bp; result.RemoveAll(i => i >= sqr && i % bp == 0); return(result); } ).ToArray(); // read the template into the compile unit CodeCompileUnit ccu; using (var stm = File.OpenRead(@"..\..\Template.cs")) ccu = SlangParser.ReadCompileUnitFrom(stm); // patch it either before or after modifying it SlangPatcher.Patch(ccu); // find the target namespace and change it var ns = ccu.TryGetNamespace("T_NAMESPACE"); ns.Name = "TestNS"; // find the target class var type = ns.TryGetType("T_TYPE"); // change the name type.Name = "TestPrimes"; // get the Primes field: var primes = type.TryGetMember("Primes") as CodeMemberField; // change the init expression to the primes array primes.InitExpression = CU.Literal(primesArr); // fixup any references to T_NAMESPACE or T_TYPE CodeDomVisitor.Visit(ccu, (ctx) => { var ctr = ctx.Target as CodeTypeReference; if (null != ctr) { ctr.BaseType = ctr.BaseType.Replace("T_NAMESPACE", ns.Name).Replace("T_TYPE", type.Name); } }); // already patched prior // SlangPatcher.Patch(ccu); // now write the result out Console.WriteLine(CU.ToString(ccu)); }
static void RunBinding() { // we'll need the resolver in a bit var res = new CodeDomResolver(); // read the binding sample into the compile unit CodeCompileUnit ccu; using (var stm = File.OpenRead(@"..\..\Binding.cs")) ccu = SlangParser.ReadCompileUnitFrom(stm); // add the compile unit to the resolver res.CompileUnits.Add(ccu); // prepare the resolver res.Refresh(); // get the first class available var tdecl = ccu.Namespaces[1].Types[0]; // capture the scope at the typedecl level var scope = res.GetScope(tdecl); // create a new binder with that scope var binder = new CodeDomBinder(scope); // get the method group for Test(...) var methodGroup = binder.GetMethodGroup(tdecl, "Test", BindingFlags.Public | BindingFlags.Instance); // select the method that can take a string value var m = binder.SelectMethod(BindingFlags.Public, methodGroup, new CodeTypeReference[] { new CodeTypeReference(typeof(string)) }, null); Console.WriteLine(CU.ToString((CodeMemberMethod)m)); // select the method that can take a short value // (closest match accepts int) m = binder.SelectMethod(BindingFlags.Public, methodGroup, new CodeTypeReference[] { new CodeTypeReference(typeof(short)) }, null); Console.WriteLine(CU.ToString((CodeMemberMethod)m)); }
static int Main(string[] args) { var result = 0; string outputfile = null; string codeclass = null; string codenamespace = null; string codelanguage = null; string t4language = null; string t4arguments = null; bool noserialize = false; bool ifstale = false; bool mutable = false; TextReader input = null; TextWriter output = null; try { var asms = new List <string>(args.Length); var inputs = new List <string>(args.Length); if (0 == args.Length) { _PrintUsage(); result = -1; } else if (args[0].StartsWith("/")) { throw new ArgumentException("Missing input file."); } else { int start = 0; // process the command line args for (start = 0; start < args.Length; ++start) { var a = args[start]; if (a.StartsWith("/")) { break; } inputs.Add(a); } for (var i = start; i < args.Length; ++i) { switch (args[i]) { case "/output": if (args.Length - 1 == i) // check if we're at the end { throw new ArgumentException(string.Format("The parameter \"{0}\" is missing an argument", args[i].Substring(1))); } ++i; // advance outputfile = args[i]; break; case "/language": if (args.Length - 1 == i) // check if we're at the end { throw new ArgumentException(string.Format("The parameter \"{0}\" is missing an argument", args[i].Substring(1))); } ++i; // advance codelanguage = args[i]; break; case "/t4language": if (args.Length - 1 == i) // check if we're at the end { throw new ArgumentException(string.Format("The parameter \"{0}\" is missing an argument", args[i].Substring(1))); } ++i; // advance t4language = args[i]; break; case "/t4args": if (args.Length - 1 == i) // check if we're at the end { throw new ArgumentException(string.Format("The parameter \"{0}\" is missing an argument", args[i].Substring(1))); } ++i; // advance t4arguments = args[i]; break; case "/class": if (args.Length - 1 == i) // check if we're at the end { throw new ArgumentException(string.Format("The parameter \"{0}\" is missing an argument", args[i].Substring(1))); } ++i; // advance codeclass = args[i]; break; case "/namespace": if (args.Length - 1 == i) // check if we're at the end { throw new ArgumentException(string.Format("The parameter \"{0}\" is missing an argument", args[i].Substring(1))); } ++i; // advance codenamespace = args[i]; break; case "/asms": if (args.Length - 1 == i) // check to see if we're at the end { throw new ArgumentException(string.Format("The parameter \"{0}\" is missing an argument", args[i].Substring(1))); } ++i; while (i < args.Length && !args[i].StartsWith("/")) { asms.Add(args[i]); ++i; } if (0 == asms.Count) { throw new ArgumentException(string.Format("The parameter \"{0}\" is missing an argument", args[i - 1].Substring(1))); } break; case "/ifstale": ifstale = true; break; case "/mutable": mutable = true; break; case "/noserialize": noserialize = true; break; default: throw new ArgumentException(string.Format("Unknown switch {0}", args[i])); } } // now build it. if (string.IsNullOrEmpty(t4language)) { t4language = "cs"; } if (string.IsNullOrEmpty(codelanguage)) { if (!string.IsNullOrEmpty(outputfile)) { codelanguage = Path.GetExtension(outputfile); if (codelanguage.StartsWith(".")) { codelanguage = codelanguage.Substring(1); } } if (string.IsNullOrEmpty(codelanguage)) { codelanguage = "cs"; } } var stale = true; if (ifstale && null != outputfile) { stale = false; foreach (var f in inputs) { if (_IsStale(f, outputfile) || _IsStale(_CodeBase, outputfile)) { stale = true; break; } } } if (!stale) { Console.Error.WriteLine("{0} skipped cook of {1} because it was not stale.", _Name, outputfile); } else { // main build code here if (null != outputfile) { Console.Error.Write("{0} is cooking {1}.", _Name, outputfile); } else { Console.Error.Write("{0} is cooking deslanged code.", _Name); } #region Load Builder CodeCompileUnit builderCcu = null; using (var stm = typeof(Program).Assembly.GetManifestResourceStream("Deslang.Shared.CodeDomBuilder.cs")) { builderCcu = SlangParser.ReadCompileUnitFrom(stm); } builderCcu.ReferencedAssemblies.Add(typeof(CodeObject).Assembly.GetName().ToString()); SlangPatcher.Patch(builderCcu); #endregion var donor = builderCcu.Namespaces[1].Types[0]; Console.Error.WriteLine(); var sb = new StringBuilder(); var sw = new StringWriter(sb); var ccus = new CodeCompileUnit[inputs.Count]; var targs = new Dictionary <string, object>(); if (null != t4arguments) { var ta = t4arguments.Split('&'); for (var i = 0; i < ta.Length; i++) { var tap = ta[i].Split('='); var n = tap[0]; object o = null; if (1 < tap.Length) { o = Uri.UnescapeDataString(tap[1]); } targs[n] = o; } } for (var i = 0; i < ccus.Length; i++) { var f = inputs[i]; sb.Clear(); input = new StreamReader(f); SlangPreprocessor.Preprocess(input, sw, targs, t4language); input.Close(); input = null; var ccu = SlangParser.ParseCompileUnit(sw.ToString()); if (0 == i) { ccu.ReferencedAssemblies.AddRange(asms.ToArray()); ccu.ReferencedAssemblies.Add(typeof(CodeObject).Assembly.GetName().ToString()); } ccus[i] = ccu; } // now our unpatched input is in ccus SlangPatcher.Patch(ccus); var co = SlangPatcher.GetNextUnresolvedElement(ccus); int l = 0, c = 0; long p = 0L; if (null != co) { Console.Error.Write("Warning - input was not entirely resolved. Output may not be valid. Next unresolved element is: " + CodeDomUtility.ToString(co)); var o = co.UserData["slang:line"]; if (o is int) { l = (int)o; } o = co.UserData["slang:column"]; if (o is int) { c = (int)o; } o = co.UserData["slang:position"]; if (o is long) { p = (long)o; } } if (l + c + p > 0) { Console.Error.WriteLine(" at line {0}, column {1}, position {2}", l, c, p); } else { Console.Error.WriteLine(); } var ns = new CodeNamespace(); var ccuFinal = new CodeCompileUnit(); ccuFinal.Namespaces.Add(ns); if (!noserialize) { // now they're patched. Let's serialize. // create our namespace and compileunit. if (string.IsNullOrEmpty(codeclass)) { codeclass = "Deslanged"; } var cls = new CodeTypeDeclaration(codeclass); cls.IsClass = true; cls.IsPartial = true; cls.TypeAttributes = TypeAttributes.NotPublic; for (var i = 0; i < ccus.Length; i++) { var ccuInit = C.Literal(ccus[i], new CodeDomTypeConverter()); V.Visit(ccuInit, (ctx) => { var tr = ctx.Target as CodeTypeReference; if (null != tr) { if (tr.BaseType.StartsWith("System.CodeDom.")) { tr.BaseType = tr.BaseType.Substring(15); } else if (tr.BaseType.StartsWith("System.Reflection.")) { tr.BaseType = tr.BaseType.Substring(18); } } // look for our uses of codedombuilder var mi = ctx.Target as CodeMethodInvokeExpression; if (null != mi) { var tref = mi.Method.TargetObject as CodeTypeReferenceExpression; if (null != tref) { if (0 == string.Compare("CD.CodeDomBuilder", tref.Type.BaseType, StringComparison.InvariantCulture)) { mi.Method.TargetObject = C.TypeRef(codeclass); // find the method in our donor type; var m = C.GetByName(mi.Method.MethodName, donor.Members); if (null != m) // if it hasn't already been moved { // move it m.Name = "_" + m.Name; m.Attributes = (m.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Private; donor.Members.Remove(m); cls.Members.Add(m); } mi.Method.MethodName = "_" + mi.Method.MethodName; } } } }); var name = Path.GetFileNameWithoutExtension(inputs[i]); if (mutable) { var fld = C.Field(typeof(CodeCompileUnit), name, MemberAttributes.Public | MemberAttributes.Static, ccuInit); cls.Members.Add(fld); } else { var prop = C.Property(typeof(CodeCompileUnit), name, MemberAttributes.Public | MemberAttributes.Static); prop.GetStatements.Add(C.Return(ccuInit)); cls.Members.Add(prop); } } if (!string.IsNullOrEmpty(codenamespace)) { ns.Name = codenamespace; } ns.Types.Add(cls); ns.Imports.Add(new CodeNamespaceImport("System.CodeDom")); ns.Imports.Add(new CodeNamespaceImport("System.Reflection")); } else { foreach (var ccu in ccus) { foreach (CodeDirective dir in ccu.StartDirectives) { ccuFinal.StartDirectives.Add(dir); } foreach (CodeDirective dir in ccu.EndDirectives) { ccuFinal.EndDirectives.Add(dir); } foreach (CodeAttributeDeclaration attr in ccu.AssemblyCustomAttributes) { ccuFinal.AssemblyCustomAttributes.Add(attr); } foreach (CodeNamespace cns in ccu.Namespaces) { var ccns = CodeDomUtility.GetByName(cns.Name, ccuFinal.Namespaces); if (null == ccns) { ccns = new CodeNamespace(); ccns.Name = cns.Name; ccuFinal.Namespaces.Add(ccns); } foreach (CodeNamespaceImport nsi in cns.Imports) { var found = false; foreach (CodeNamespaceImport nnsi in ccns.Imports) { if (nnsi.Namespace.Equals(nsi.Namespace, StringComparison.Ordinal)) { found = true; break; } } if (!found) { ccns.Imports.Add(nsi); } } foreach (CodeCommentStatement ccs in cns.Comments) { ccns.Comments.Add(ccs); } foreach (CodeTypeDeclaration td in cns.Types) { ccns.Types.Add(td); } } } } // we're ready with ccuFinal var prov = CodeDomProvider.CreateProvider(codelanguage); var opts = new CodeGeneratorOptions(); opts.BlankLinesBetweenMembers = false; opts.VerbatimOrder = true; if (null == outputfile) { output = Console.Out; } else { // open the file and truncate it if necessary var stm = File.Open(outputfile, FileMode.Create); stm.SetLength(0); output = new StreamWriter(stm); } prov.GenerateCodeFromCompileUnit(ccuFinal, output, opts); } } } #if !DEBUG catch (Exception ex) { result = _ReportError(ex); } #endif finally { if (null != input) { input.Close(); input = null; } if (null != outputfile && null != output) { output.Close(); output = null; } } return(result); }