public override void ToSpecifiedRegister(ICodeGenerator g, Register result) { string opCode; string shifter; int multiplier; switch(array.ExpressionType) { case ExpressionType.WordArray: opCode="LDR"; shifter=",LSL 2"; multiplier=4; break; case ExpressionType.ByteArray: opCode="LDRB"; shifter=""; multiplier=1; break; default: throw new Exception("Can't index an expression of type "+array.ExpressionType); } throw new NotImplementedException("NIY"); // // array.LoadToNewRegister(g, arrayRegister => // index.ToRegisterOrImmediate(g, // indexRegister => g.Emit(OpCodes.TODO, opCode+" "+result+",["+arrayRegister+",+"+indexRegister+shifter+"]"), // indexImmediate => g.Emit(OpCodes.TODO, opCode+" "+result+",["+arrayRegister+",+#"+indexImmediate*multiplier+"]"))); }
public TypescriptCodeProvider() { var unity = new UnityContainer(); var startup = new Startup(unity); startup.Initialize(); _codeGenerator = unity.Resolve<ICodeGenerator>(); }
public SchemaBrowserVM(ISchemaBrowserModel iSchemaBrowserModel, ICodeGenerator iCodeGenerator, DbConnectionInfo dbConnectionInfo) { model = iSchemaBrowserModel; codeGenerator = iCodeGenerator; currentDb = dbConnectionInfo; GeneratCodeCommand = new DelegateCommand<object>(GeneratCode); }
public MethodVirtualizer(IMethodVirtualizerInfoWrapper wrapper, ICodeGenerator codeGenerator) { ArgumentUtility.CheckNotNull ("wrapper", wrapper); ArgumentUtility.CheckNotNull ("codeGenerator", codeGenerator); _wrapper = wrapper; _codeGenerator = codeGenerator; }
public static CodeGenFile[] Generate(ICodeGeneratorDataProvider provider, string directory, ICodeGenerator[] codeGenerators) { directory = GetSafeDir(directory); CleanDir(directory); var generatedFiles = new List<CodeGenFile>(); foreach (var generator in codeGenerators.OfType<IPoolCodeGenerator>()) { var files = generator.Generate(provider.poolNames); generatedFiles.AddRange(files); writeFiles(directory, files); } foreach (var generator in codeGenerators.OfType<IComponentCodeGenerator>()) { var files = generator.Generate(provider.componentInfos); generatedFiles.AddRange(files); writeFiles(directory, files); } foreach (var generator in codeGenerators.OfType<IBlueprintsCodeGenerator>()) { var files = generator.Generate(provider.blueprintNames); generatedFiles.AddRange(files); writeFiles(directory, files); } return generatedFiles.ToArray(); }
// given a variable name, this method will check to see if the // name is a valid identifier name. if this is not the case, then // at the moment will replace all the blank space with underscores. public static string GenerateIdName(string name, ICodeGenerator codeGen) { if (codeGen.IsValidIdentifier(name)) { return name; } string ret = name.Replace(' ', '_'); if (! codeGen.IsValidIdentifier(ret)) { ret = "_" + ret; UnicodeCategory unc; for (int i = 1; i < ret.Length; i++) { unc = Char.GetUnicodeCategory(ret[i]); if ( UnicodeCategory.UppercaseLetter != unc && UnicodeCategory.LowercaseLetter != unc && UnicodeCategory.TitlecaseLetter != unc && UnicodeCategory.ModifierLetter != unc && UnicodeCategory.OtherLetter != unc && UnicodeCategory.LetterNumber != unc && UnicodeCategory.NonSpacingMark != unc && UnicodeCategory.SpacingCombiningMark != unc && UnicodeCategory.DecimalDigitNumber != unc && UnicodeCategory.ConnectorPunctuation != unc ) { ret = ret.Replace(ret[i], '_'); } // if } // for } return ret; }
public static void Generate (DataSet dataSet, CodeNamespace codeNamespace, ICodeGenerator codeGen) { CustomDataClassGenerator.CreateDataSetClasses ( dataSet, codeNamespace, codeGen, null); }
public CommandProxies(ITypeDiscoverer typeDiscoverer, ITypeImporter typeImporter, ICodeGenerator codeGenerator, WebConfiguration configuration) { _typeDiscoverer = typeDiscoverer; _typeImporter = typeImporter; _codeGenerator = codeGenerator; _configuration = configuration; }
public override void SetUp () { base.SetUp (); _typeDeclaration = new CodeTypeDeclaration (); CodeDomProvider provider = new VBCodeProvider (); _codeGenerator = provider.CreateGenerator (); }
public virtual void Initialize() { DependenciesMock = new Mock<ICodeGeneratorDependencies>(); ArgumentsMock = new Mock<ICodeGeneratorGenerateArguments>(); CodeGenerator = new Logics.CodeGenerator(DependenciesMock.Object); }
public ReservationController(ITwilioMessageRepository repository, IMessageProvider<TwilioMessage> twilioMessageProvider, IPersonRepository personRepository, ICodeGenerator codeGenerator) { _twilioRepository = repository; _personRepository = personRepository; _twilioMessageProvider = twilioMessageProvider; _codeGenerator = codeGenerator; }
public EntityFrameworkMappingGenerator( ICodeGenerator codeGenerator, IPluginsContainer<IConceptMapping> plugins, ILogProvider logProvider) { _plugins = plugins; _codeGenerator = codeGenerator; _performanceLogger = logProvider.GetLogger("Performance"); }
public void InitBase() { provider = new CSharpCodeProvider (); generator = provider.CreateGenerator (); options = new CodeGeneratorOptions (); writer = new StringWriter (); writer.NewLine = "\n"; }
public QueryProxies( ITypeDiscoverer typeDiscoverer, ICodeGenerator codeGenerator, WebConfiguration configuration) { _typeDiscoverer = typeDiscoverer; _codeGenerator = codeGenerator; _configuration = configuration; }
// overcome bug in ANTLR 3.2 public TemplateParser(ITokenStream input, RecognizerSharedState state, ICodeGenerator gen, TemplateName enclosingTemplateName) : base(null, null) { this.input = input; this.state = state; if (gen != null) this.gen = gen; this._enclosingTemplateName = enclosingTemplateName; }
public CaptchaMiddleware( RequestDelegate next, ICodeGenerator codeGenerator, IGraphicGenerator graphicGenerator) { _next = next; _codeGenerator = codeGenerator; _graphicGenerator = graphicGenerator; }
public Phase2Parser( TokenizerBase tokenStream, ICodeGenerator gen ) : base(tokenStream) { this.gen = gen; loops = new Stack(); withs = new Stack(); } // Phase2Parser constructor
public CompositeClassGenerator( BaseCustomTool customTool, ICodeGenerator codeGenerator, string inputFileName) { _codeGenerator = codeGenerator; _inputFileName = inputFileName; _vsHelper = new VsHelper(); EnvDTE.Project project = _vsHelper.GetProject(); _assemblies = _vsHelper.GetReferencedAssemblies(customTool, false); _projectDirectory = _vsHelper.GetProjectDirectory(); }
public CommandSecurityProxies( ITypeDiscoverer typeDiscoverer, ICodeGenerator codeGenerator, ICommandSecurityManager commandSecurityManager, WebConfiguration configuration) { _typeDiscoverer = typeDiscoverer; _codeGenerator = codeGenerator; _configuration = configuration; _commandSecurityManager = commandSecurityManager; }
public NHibernateMappingGenerator( ICodeGenerator codeGenerator, IPluginsContainer<IConceptMappingCodeGenerator> plugins, IDomainObjectModel domainObjectModel, ILogProvider logProvider) { _plugins = plugins; _codeGenerator = codeGenerator; _domainObjectModel = domainObjectModel; _performanceLogger = logProvider.GetLogger("Performance"); }
public CaptionsGenerator( IPluginsContainer<ICaptionsGeneratorPlugin> plugins, ICodeGenerator codeGenerator, ILogProvider logProvider ) { _plugins = plugins; _codeGenerator = codeGenerator; _logger = logProvider.GetLogger("CaptionsGenerator"); _sourceLogger = logProvider.GetLogger("Mvc Captions source"); }
public Parser(Tokenizer tokenizer, ICodeGenerator codeGenerator) { Contract.Requires(tokenizer != null); Contract.Requires(codeGenerator != null); _tokenizer = tokenizer; _codeGenerator = codeGenerator; _codeGenerator.InitSymbolTables( classSymTable: _classSymTable, methodSymTable: _methodSymTable); }
public static void Generate(ICodeGeneratorDataProvider provider, string directory, ICodeGenerator[] codeGenerators) { directory = GetSafeDir(directory); CleanDir(directory); foreach (var generator in codeGenerators.OfType<IPoolCodeGenerator>()) { writeFiles(directory, generator.Generate(provider.poolNames)); } foreach (var generator in codeGenerators.OfType<IComponentCodeGenerator>()) { writeFiles(directory, generator.Generate(provider.componentInfos)); } }
public static void Generate() { var generatedFolder = getEntitasProjectDir() + "/Tests/Tests/Entitas/CodeGenerator/Fixtures/Generated/"; var codeGenerators = new ICodeGenerator[] { new ComponentExtensionsGenerator(), new ComponentIndicesGenerator(), new ContextAttributesGenerator(), new ContextsGenerator(), new BlueprintsGenerator() }; var types = new [] { typeof(AnimatingComponent), typeof(CComponent), typeof(ComponentWithFieldsAndProperties), typeof(CustomPrefixComponent), typeof(DefaultContextComponent), typeof(MovableComponent), typeof(MultipleContextAndDefaultContextComponent), typeof(NamespaceComponent), typeof(OtherContextComponent), typeof(PersonComponent), typeof(SomeClass), typeof(SomeClassHideInBlueprintInspector), typeof(SomeStruct), typeof(UserComponent) }; var contexts = new [] { "ContextA", "ContextB", "ContextC", "OtherContext", "SomeContext", "SomeOtherContext" }; var blueprints = new [] { "Gem", "Blocker" }; var provider = new TypeReflectionProvider(types, contexts, blueprints); var files = CodeGenerator.Generate(provider, generatedFolder, codeGenerators); foreach(var file in files) { Console.WriteLine("Generated: " + file.fileName); } Console.WriteLine("Done. Press any key..."); Console.Read(); }
public static void GenerateMIDICode(ICodeGenerator generator, MidiSequence sequence, string midiName, TextWriter writer) { CodeNamespace e = new CodeNamespace("AutoGenerated"); CodeTypeDeclaration declaration = new CodeTypeDeclaration(midiName); declaration.Members.Add(CreateSequenceMethod(sequence)); for (int i = 0; i < sequence.NumberOfTracks; i++) { int num2 = i + 1; declaration.Members.Add(CreateTrackMethod("CreateTrack" + num2.ToString(), sequence[i])); } e.Types.Add(declaration); generator.GenerateCodeFromNamespace(e, writer, new CodeGeneratorOptions()); }
public void SetUp() { _fileSystemMock = MockRepository.GenerateStrictMock<IFileSystem> (); _assemblyDefinition1 = AssemblyDefinitionObjectMother.CreateMultiModuleAssemblyDefinition (); _tracker = MockRepository.GenerateStrictMock<IAssemblyTracker>(); _checker = MockRepository.GenerateMock<IMixinChecker>(); //_referenceGenerator = MockRepository.GenerateStrictMock<IReferenceGenerator>(); _codeGenerator = MockRepository.GenerateStrictMock<ICodeGenerator>(); _generator = new ConstructorGenerator.ConstructorGenerator (_checker, _codeGenerator); }
public CaptionsResourceGenerator( IPluginsContainer<ICaptionsResourceGeneratorPlugin> plugins, CaptionsInitialCodePlugin initialCodePlugin, ICodeGenerator codeGenerator, IAssemblyGenerator assemblyGenerator, ILogProvider logProvider) { _plugins = plugins; _initialCodePlugin = initialCodePlugin; _codeGenerator = codeGenerator; _assemblyGenerator = assemblyGenerator; _logger = logProvider.GetLogger("CaptionsResourceGenerator"); _performanceLogger = logProvider.GetLogger("Performance"); }
public static void Main(string[] args) { var assembly = Assembly.GetAssembly(typeof(CodeGenerator)); var codeGenerators = new ICodeGenerator[] { new ComponentExtensionsGenerator(), new IndicesLookupGenerator(), new PoolAttributeGenerator(), new PoolsGenerator(), new SystemExtensionsGenerator() }; CodeGenerator.Generate(assembly.GetTypes(), new string[0], "Generated/", codeGenerators); Console.WriteLine("Done. Press any key..."); Console.Read(); }
static void generate() { var assembly = Assembly.GetAssembly(typeof(ReadmeSnippets)); var generatedFolder = getEntitasProjectDir() + "/Readme/Readme/Generated/"; var codeGenerators = new ICodeGenerator[] { new ComponentsGenerator(), new ComponentLookupGenerator(), new PoolAttributeGenerator(), new PoolsGenerator(), new SystemsGenerator() }; CodeGenerator.Generate(assembly.GetTypes(), new string[0], generatedFolder, codeGenerators); Console.WriteLine("Done. Press any key..."); Console.Read(); }
public static void Generate() { var types = Assembly.GetAssembly(typeof(Entity)).GetTypes(); var config = new CodeGeneratorConfig(EntitasPreferencesEditor.LoadConfig()); var codeGenerators = new ICodeGenerator[] { new ComponentExtensionsGenerator(), new IndicesLookupGenerator(), new PoolAttributeGenerator(), new PoolsGenerator(), new SystemExtensionsGenerator() }; Entitas.CodeGenerator.CodeGenerator.Generate(types, config.pools, config.generatedFolderPath, codeGenerators); AssetDatabase.Refresh(); }
public static CodeCompileUnit CreateCodeCompileUnit( Type proxyType, ICodeGenerator generator) { return(CreateCodeCompileUnit(proxyType, generator, new XmlRpcProxyCodeGenOptions())); }
public abstract void GenCode(ICodeGenerator cg);
/// <summary> /// Compiles the generated code in the output assembly. /// </summary> /// <param name="unit">The code graph to compile.</param> /// <param name="source">The current source in use.</param> private void GenerateOutput(CodeCompileUnit unit, RunnerSource source) { if (GeneratorHost.Instance.GeneratorOptions.OutputSource) { OnProgress("Generating source code output ... "); ICodeGenerator gen = GeneratorHost.Instance.GeneratorOptions.Provider.CreateGenerator(); CodeGeneratorOptions opt = new CodeGeneratorOptions(); opt.BracingStyle = "C"; string ns = GeneratorHost.Instance.GeneratorOptions.TargetNamespace; string path = ""; // If a namespace isn't defined and the source file is an XmlSchema, // we use the targetnamespace of the schema as the namespace for the classes. if (ns == String.Empty) { XmlSchema sch = null; try { using (FileStream fs = new FileStream(source.FileName, FileMode.Open)) sch = XmlSchema.Read(fs, null); } catch { } if (sch != null) { ns = sch.TargetNamespace; } } // Review folder organization. if (GeneratorHost.Instance.GeneratorOptions.CreateNamespaceFolders) { // Replace target namespace dots with slashes path = GeneratorHost.Instance.GeneratorOptions.TargetFolder + Path.DirectorySeparatorChar + ns.Replace('.', Path.DirectorySeparatorChar); } else if (GeneratorHost.Instance.GeneratorOptions.TargetFolder != String.Empty) { path = GeneratorHost.Instance.GeneratorOptions.TargetFolder; } else { path = Path.GetDirectoryName(source.FileName); } if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } path += Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(source.FileName); if (GeneratorHost.Instance.GeneratorOptions.Provider is Microsoft.CSharp.CSharpCodeProvider) { path += ".cs"; } else if (GeneratorHost.Instance.GeneratorOptions.Provider is Microsoft.VisualBasic.VBCodeProvider) { path += ".vb"; } else { // Dummy extension for other unknown languages. path += ".code"; } // Write source code to the output file. using (FileStream fs = new FileStream(path, FileMode.Create)) { OnProgress("Writing " + path + " source file ... "); StreamWriter w = new StreamWriter(fs); gen.GenerateCodeFromCompileUnit(unit, w, opt); w.Flush(); } OnFileFinished(path); } if (GeneratorHost.Instance.GeneratorOptions.OutputCompiled) { OnProgress("Generating compiled output ... "); ICodeCompiler comp = GeneratorHost.Instance.GeneratorOptions.Provider.CreateCompiler(); CompilerParameters param = new CompilerParameters(); param.TreatWarningsAsErrors = false; param.OutputAssembly = GeneratorHost.Instance.GeneratorOptions.TargetFolder + Path.DirectorySeparatorChar + GeneratorHost.Instance.GeneratorOptions.TargetAssembly; // Add referenced assemblies. string[] assemblies = new string[GeneratorHost.Instance.GeneratorOptions.AssemblyReferences.Count]; GeneratorHost.Instance.GeneratorOptions.AssemblyReferences.CopyTo(assemblies); param.ReferencedAssemblies.AddRange(assemblies); CompilerResults results = comp.CompileAssemblyFromDom(param, unit); StringWriter w = new StringWriter(); foreach (string msg in results.Output) { Console.WriteLine(msg); } if (results.Errors.Count != 0) { foreach (CompilerError error in results.Errors) { w.WriteLine(error); } throw new InvalidOperationException(w.ToString()); } } }
public override void GenCode(ICodeGenerator cg) { RightOperand.GenCode(cg); (LeftOperand as IAssignable).AssignValue(cg); }
/// <summary> /// Initializes a new silo server. /// </summary> /// <param name="args">The command line arguments given to the Main() method</param> /// <param name="customTypeResolver">The type resolver, if any, responsible for resolving Type objects by their assembly qualified name</param> /// <param name="codeGenerator">The code generator to create proxy and servant types</param> /// <param name="postMortemSettings"> /// Settings to control how and if minidumps are collected - when set to null, default values are used ( /// <see /// cref="PostMortemSettings" /> /// ) /// </param> /// <param name="heartbeatSettings">The settings for heartbeat mechanism, if none are specified, then default settings are used</param> /// <param name="latencySettings">The settings for latency measurements, if none are specified, then default settings are used</param> /// <param name="endPointSettings">The settings for the endpoint itself (max. number of concurrent calls, etc...)</param> /// <param name="endPointName">The name of this silo, used for debugging (and logging)</param> public OutOfProcessSiloServer(string[] args, ITypeResolver customTypeResolver = null, ICodeGenerator codeGenerator = null, PostMortemSettings postMortemSettings = null, HeartbeatSettings heartbeatSettings = null, LatencySettings latencySettings = null, EndPointSettings endPointSettings = null, string endPointName = null) { if (postMortemSettings != null && !postMortemSettings.IsValid) { throw new ArgumentException("postMortemSettings"); } Log.InfoFormat("Silo Server starting, args ({0}): \"{1}\", {2} custom type resolver", args.Length, string.Join(" ", args), customTypeResolver != null ? "with" : "without" ); int pid; if (args.Length >= 1 && int.TryParse(args[0], out pid)) { _parentProcessId = pid; _parentProcess = Process.GetProcessById(pid); _parentProcess.EnableRaisingEvents = true; _parentProcess.Exited += ParentProcessOnExited; } if (Log.IsDebugEnabled) { Log.DebugFormat("Args.Length: {0}", args.Length); } if (args.Length >= 10) { if (postMortemSettings != null) { Log.Info("Ignoring post-mortem settings specified from the command-line"); } else { var settings = new PostMortemSettings(); bool.TryParse(args[1], out settings.CollectMinidumps); bool.TryParse(args[2], out settings.SuppressErrorWindows); bool.TryParse(args[3], out settings.HandleAccessViolations); bool.TryParse(args[4], out settings.HandleCrtAsserts); bool.TryParse(args[5], out settings.HandleCrtPureVirtualFunctionCalls); int tmp; int.TryParse(args[6], out tmp); settings.RuntimeVersions = (CRuntimeVersions)tmp; int.TryParse(args[7], out settings.NumMinidumpsRetained); settings.MinidumpFolder = args[8]; settings.MinidumpName = args[9]; if (!settings.IsValid) { Log.ErrorFormat("Received invalid post-mortem debugger settings: {0}", settings); } else { postMortemSettings = settings; } } } _registry = new DefaultImplementationRegistry(); _waitHandle = new ManualResetEvent(false); _customTypeResolver = customTypeResolver; _postMortemSettings = postMortemSettings; if (_postMortemSettings != null) { Log.InfoFormat("Using post-mortem debugger: {0}", _postMortemSettings); if (!NativeMethods.LoadPostmortemDebugger()) { int err = Marshal.GetLastWin32Error(); Log.ErrorFormat("Unable to load the post-mortem debugger dll: {0}", err); } if (_postMortemSettings.CollectMinidumps) { if (NativeMethods.InitDumpCollection(_postMortemSettings.NumMinidumpsRetained, _postMortemSettings.MinidumpFolder, _postMortemSettings.MinidumpName)) { Log.InfoFormat("Installed post-mortem debugger; up to {0} mini dumps will automatically be saved to: {1}", _postMortemSettings.NumMinidumpsRetained, _postMortemSettings.MinidumpFolder ); } } NativeMethods.InstallPostmortemDebugger(_postMortemSettings.HandleAccessViolations, _postMortemSettings.SuppressErrorWindows, _postMortemSettings.HandleCrtAsserts, _postMortemSettings.HandleCrtPureVirtualFunctionCalls, _postMortemSettings.RuntimeVersions); } _endPoint = new SocketEndPoint(EndPointType.Server, endPointName, codeGenerator: codeGenerator, heartbeatSettings: heartbeatSettings, latencySettings: latencySettings, endPointSettings: endPointSettings ); _endPoint.OnConnected += EndPointOnOnConnected; _endPoint.OnDisconnected += EndPointOnOnDisconnected; _endPoint.OnFailure += EndPointOnOnFailure; }
/// <summary> /// This will generate an early-bound wrapper for WMI class, /// add it as a source file to the current project; instantiate /// the newly-generated type and return it as a drag component. /// </summary> /// <param name="designerHost"> </param> public override IComponent[] CreateDragComponents(IDesignerHost designerHost) { try { Project[] projects = VSUtils.GetProjects(GetNodeSite()); if (projects == null) { return(null); } //This is an assumtion that's working so far. //TODO: verify this is the right way to determine the startup project //in the solution: Project curProject = projects[0]; ProjectItems projItems = curProject.ProjectItems; if (projItems == null) { return(null); } string curProjSuffix = VSUtils.MapProjectGuidToSuffix(new Guid(curProject.Kind)); if (curProjSuffix == string.Empty) { //neither a VB nor a CS project throw new Exception(WMISys.GetString("WMISE_Invalid_Project_Type_For_CodeGen")); } Guid curProjectType = new Guid(curProject.Kind); string wrapperFileName = className + "." + curProjSuffix; CodeTypeDeclaration newType = null; if (!mgmtClassObj.GetStronglyTypedClassCode(true, true, out newType)) { throw new Exception(WMISys.GetString("WMISE_Code_Generation_Failed")); } ICodeGenerator cg = VSUtils.MapProjectGuidToCodeGenerator(curProjectType); //construct generated code Namespace name (in the form "System.Management.root.cimv2") string[] nsParts = nsName.ToLower().Split(new Char[] { '\\' }); string codeNSName = "System.Management"; for (int i = 0; i < nsParts.Length; i++) { codeNSName += nsParts[i] + "."; } codeNSName = codeNSName.Substring(0, codeNSName.Length - 1); System.CodeDom.CodeNamespace cn = new System.CodeDom.CodeNamespace(codeNSName); // Add imports to the code cn.Imports.Add(new CodeNamespaceImport("System")); cn.Imports.Add(new CodeNamespaceImport("System.ComponentModel")); cn.Imports.Add(new CodeNamespaceImport("System.Management")); cn.Imports.Add(new CodeNamespaceImport("System.Collections")); // Add class to the namespace cn.Types.Add(newType); //Now create the output file TextWriter tw = new StreamWriter(new FileStream(Path.GetTempPath() + "\\" + wrapperFileName, FileMode.Create)); // And write it to the file cg.GenerateCodeFromNamespace(cn, tw, new CodeGeneratorOptions()); ProjectItem newItem = projItems.AddFromFileCopy(Path.GetTempPath() + "\\" + wrapperFileName); if (newItem == null) { throw new Exception(WMISys.GetString("WMISE_Could_Not_Add_File_to_Project")); } File.Delete(Path.GetTempPath() + "\\" + wrapperFileName); Object comp = Activator.CreateInstance(designerHost.GetType(codeNSName + "." + newType.Name)); if (comp == null) { throw new Exception(WMISys.GetString("WMISE_Could_Not_Instantiate_Management_Class")); } return(new IComponent[] { (IComponent)comp }); //The commented-out block below implements the solution with VS custom code generator: /* * //create a new file containing the path to the instance object * string tempFileName = Path.GetTempPath() + this.className + ".wmi"; * StreamWriter sw = File.AppendText(tempFileName); * if (sw == null) * { * return null; * } * * sw.WriteLine(WmiHelper.MakeClassPath(this.serverName, * this.nsName, * this.className)); * * sw.Flush(); * sw.Close(); * ProjectItem newItem = projItems.AddFromFileCopy(tempFileName); * if (newItem == null) * { * return null; * } * File.Delete(tempFileName); * VSUtils.SetGenerator(newItem, "WMICodeGenerator"); * return null; //is this OK??? */ } catch (Exception exc) { MessageBox.Show(WMISys.GetString("WMISE_Exception", exc.Message, exc.StackTrace)); return(null); } }
public SendPasswordResetCodeStrategy(IConfigurationManager configurationManager, ICommunicationService communicationService, ICodeGenerator codeGenerator, IUserReadRepository userReadRepository, IUserWriteRepository userWriteRepository, ICandidateReadRepository candidateReadRepository, ILogService logger) { _communicationService = communicationService; _codeGenerator = codeGenerator; _userReadRepository = userReadRepository; _userWriteRepository = userWriteRepository; _candidateReadRepository = candidateReadRepository; _logger = logger; _passwordResetCodeExpiryDays = configurationManager.GetAppSetting <int>("PasswordResetCodeExpiryDays"); }
/// <summary> /// constructor /// </summary> /// <param name="success"></param> /// <param name="msg"></param> /// <param name="codegen"></param> public CompileResult(bool success, string msg, ICodeGenerator codegen) { Success = success; Message = msg; CodeGenerator = codegen; }
private MethodDefinition GenerateFactoryMethod(TypeDefinition targetType, int index, ICodeGenerator codeGenerator) { if (!targetType.CanMapType()) { return(null); } MethodDefinition targetTypeCtor = targetType.GetMappingConstructor(); if (targetTypeCtor == null) { return(null); } var factory = new MethodDefinition($"<{targetType.Name}>_generated_{index}", MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.Static, ModuleDefinition.ImportReference(targetType)); factory.Parameters.Add(new ParameterDefinition("serviceProvider", ParameterAttributes.None, Import.System.IServiceProvider)); ILProcessor factoryProcessor = factory.Body.GetILProcessor(); MethodReference getServiceMethod = Import.DependencyInjection.ServiceProviderServiceExtensionsGetService; foreach (ParameterDefinition parameter in targetTypeCtor.Parameters) { factoryProcessor.Emit(OpCodes.Ldarg_0); var genericGetService = new GenericInstanceMethod(getServiceMethod); genericGetService.GenericArguments.Add(ModuleDefinition.ImportReference(parameter.ParameterType)); factoryProcessor.Emit(OpCodes.Call, genericGetService); } factoryProcessor.Emit(OpCodes.Newobj, ModuleDefinition.ImportReference(targetTypeCtor)); factoryProcessor.Emit(OpCodes.Ret); IMethodGenerator methodGenerator = codeGenerator?.Method(factory); if (methodGenerator != null) { var parameters = string.Join(", ", targetTypeCtor.Parameters.Select(x => $"serviceProvider.GetService<{x.ParameterType.NameCSharp(true)}>()")); methodGenerator.Append($"return new {targetType.NameCSharp(true)}({parameters});", factoryProcessor.Body.Instructions.First()); methodGenerator.Append(Environment.NewLine); } return(factory); }
//TODO: out parameters... yuck private TypeDefinition GenerateAutoDIClass(Mapping mapping, Settings settings, ICodeGenerator codeGenerator, out MethodDefinition initMethod) { var containerType = new TypeDefinition(Constants.Namespace, Constants.TypeName, TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Abstract | TypeAttributes.Sealed | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit) { BaseType = Import.System.Object }; FieldDefinition globalServiceProvider = ModuleDefinition.CreateStaticReadonlyField(Constants.GlobalServiceProviderName, false, Import.System.IServiceProvider); containerType.Fields.Add(globalServiceProvider); MethodDefinition configureMethod = GenerateAddServicesMethod(mapping, settings, containerType, codeGenerator); containerType.Methods.Add(configureMethod); initMethod = GenerateInitMethod(configureMethod, globalServiceProvider); containerType.Methods.Add(initMethod); MethodDefinition disposeMethod = GenerateDisposeMethod(globalServiceProvider); containerType.Methods.Add(disposeMethod); return(containerType); }
public WriteConstructor(ICodeGenerator <AccessModifier> writeAccessModifier, ICodeGenerator <IEnumerable <Parameter> > writeParams, ICodeGenerator <CodeBlock> writeCodeBlock) { this.writeAccessModifier = writeAccessModifier; this.writeParams = writeParams; this.writeCodeBlock = writeCodeBlock; }
private Assembly BuildAssemblyFromWsdl(string strWsdl) { // Use an XmlTextReader to get the Web Service description StringReader wsdlStringReader = new StringReader(strWsdl); XmlTextReader tr = new XmlTextReader(wsdlStringReader); ServiceDescription sd = ServiceDescription.Read(tr); tr.Close(); // WSDL service description importer CodeNamespace cns = new CodeNamespace("OW.Tools.WebServices.DynamicProxy"); sdi = new ServiceDescriptionImporter(); //sdi.AddServiceDescription(sd, null, null); // check for optional imports in the root WSDL CheckForImports(wsdl); sdi.ProtocolName = protocolName; sdi.Import(cns, null); // change the base class CodeTypeDeclaration ctDecl = cns.Types[0]; cns.Types.Remove(ctDecl); ctDecl.BaseTypes[0] = new CodeTypeReference("OW.Tools.WebServices.SoapHttpClientProtocolEx"); cns.Types.Add(ctDecl); // source code generation CSharpCodeProvider cscp = new CSharpCodeProvider(); ICodeGenerator icg = cscp.CreateGenerator(); StringBuilder srcStringBuilder = new StringBuilder(); StringWriter sw = new StringWriter(srcStringBuilder); icg.GenerateCodeFromNamespace(cns, sw, null); proxySource = srcStringBuilder.ToString(); sw.Close(); // assembly compilation CompilerParameters cp = new CompilerParameters(); cp.ReferencedAssemblies.Add("System.dll"); cp.ReferencedAssemblies.Add("System.Xml.dll"); cp.ReferencedAssemblies.Add("System.Web.Services.dll"); cp.ReferencedAssemblies.Add("System.Data.dll"); cp.ReferencedAssemblies.Add(Assembly. GetExecutingAssembly().Location); cp.GenerateExecutable = false; cp.GenerateInMemory = false; cp.IncludeDebugInformation = false; ICodeCompiler icc = cscp.CreateCompiler(); CompilerResults cr = icc.CompileAssemblyFromSource(cp, proxySource); if (cr.Errors.Count > 0) { throw new Exception(string.Format(@"Build failed: {0} errors", cr.Errors.Count)); } ass = cr.CompiledAssembly; //rename temporary assembly in order to cache it for later use RenameTempAssembly(cr.PathToAssembly); // create proxy instance proxyInstance = CreateInstance(typeName); return(ass); }
private static void RegisterCodeGenerator(CompilerOutput name, ICodeGenerator generator) { BackendMap[name] = generator; }
/// <summary> /// Generate a full qualified main class name /// </summary> /// <param name="cg">The code generator class to be used</param> /// <returns>The fully qualified class name</returns> public static string GetMainClassName(this ICodeGenerator cg) { return(cg.MainClassNamespace + "." + cg.MainClassName); }
public VoidBlock(ICodeGenerator CodeGenerator) { this.codeGen = CodeGenerator; }
public DomainEventsController(MetaDbContext metaDbContext, CodeGenDbContext codeGenDbContext, IMapper mapper, ICodeGenerator generator) { _metaDbContext = metaDbContext; _codeGenDbContext = codeGenDbContext; _mapper = mapper; _generator = generator; }
protected override byte[] GenerateCode(string inputFileName, string inputFileContent) { CodeCompileUnit codeCompileUnit; if (string.IsNullOrEmpty(inputFileContent) || IsLocalizedFile(inputFileName)) { if (base.CodeGeneratorProgress != null) { NativeMethods.ThrowOnFailure(base.CodeGeneratorProgress.Progress(100, 100)); } return(null); } using (MemoryStream codeStream = new MemoryStream()) { using (StreamWriter streamWriter = new StreamWriter(codeStream, Encoding.UTF8)) { IDictionary nodeDictionary = new Hashtable(StringComparer.OrdinalIgnoreCase); IDictionary nodePositionDictionary = new Hashtable(StringComparer.OrdinalIgnoreCase); using (IResourceReader resourceReader = ResXResourceReader.FromFileContents(inputFileContent)) { ResXResourceReader resXResourceReader = resourceReader as ResXResourceReader; if (resXResourceReader != null) { resXResourceReader.UseResXDataNodes = true; string inputDirectoryName = Path.GetDirectoryName(inputFileName); resXResourceReader.BasePath = Path.GetFullPath(inputDirectoryName); } foreach (DictionaryEntry resourceEntry in resourceReader) { ResXDataNode resXNode = (ResXDataNode)resourceEntry.Value; nodeDictionary.Add(resourceEntry.Key, resXNode); nodePositionDictionary.Add(resourceEntry.Key, resXNode.GetNodePosition()); } } string resourceNamespace = this.GetResourcesNamespace(); string inputFileNameWithoutExtension = Path.GetFileNameWithoutExtension(inputFileName); List <Tools.ResourceErrorData> unmatchableResources = new List <Tools.ResourceErrorData>(); if (resourceNamespace != null) { codeCompileUnit = Tools.StronglyTypedResourceBuilderEx.Create(this.GetType(), nodeDictionary, inputFileNameWithoutExtension, base.FileNameSpace, resourceNamespace, this.CodeProvider, GenerateInternalClass, unmatchableResources); } else { codeCompileUnit = Tools.StronglyTypedResourceBuilderEx.Create(this.GetType(), nodeDictionary, inputFileNameWithoutExtension, base.FileNameSpace, this.CodeProvider, GenerateInternalClass, unmatchableResources); } if (base.CodeGeneratorProgress != null) { foreach (Tools.ResourceErrorData resourceErrorData in unmatchableResources) { Point nodePosition = (Point)nodePositionDictionary[resourceErrorData.ResourceKey]; base.CodeGeneratorProgress.GeneratorError(1, 1, resourceErrorData.ErrorString, (uint)nodePosition.Y, (uint)nodePosition.X); } base.CodeGeneratorProgress.Progress(70, 100); } this.HandleCodeCompileUnit(codeCompileUnit); if (base.CodeGeneratorProgress != null) { base.CodeGeneratorProgress.Progress(0x4b, 100); } ICodeGenerator codeGenerator = this.CodeProvider.CreateGenerator(); codeGenerator.GenerateCodeFromCompileUnit(codeCompileUnit, streamWriter, null); if (base.CodeGeneratorProgress != null) { NativeMethods.ThrowOnFailure(base.CodeGeneratorProgress.Progress(100, 100)); } streamWriter.Flush(); codeStream.Flush(); return(EnsureSilverlighCompatibility(codeStream.ToArray(), codeCompileUnit)); } } }
public DbSeeder(ICodeGenerator codeGenerator, ElectionDbContext context) { this.codeGenerator = codeGenerator; this.context = context; }
public void SetUp() { provider = new CSharpCodeProvider(); generator = provider.CreateGenerator(); options = new CodeGeneratorOptions(); }
public static string CreateCode( Type proxyType, ICodeGenerator generator) { return(CreateCode(proxyType, generator, new XmlRpcProxyCodeGenOptions())); }
public Generator(ICodeGenerator generator) { this.generator = generator; }
/// <summary>Shows the code form with the given <paramref name="generator"/>.</summary> /// <param name="generator">The generator.</param> private void ShowCodeForm(ICodeGenerator generator) { Contract.Requires(generator != null); LinkedWindowFeatures.ShowCodeGeneratorForm(currentProject.Classes, generator); }
public override void GenCode(ICodeGenerator cg) { cg.GetGenerator.Emit(OpCodes.Ldstr, Value); }
private MethodDefinition GenerateAddServicesMethod(Mapping mapping, Settings settings, TypeDefinition containerType, ICodeGenerator codeGenerator) { var method = new MethodDefinition("AddServices", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Static, Import.System.Void); var serviceCollection = new ParameterDefinition("collection", ParameterAttributes.None, Import.DependencyInjection.IServiceCollection); method.Parameters.Add(serviceCollection); IMethodGenerator methodGenerator = codeGenerator?.Method(method); ILProcessor processor = method.Body.GetILProcessor(); VariableDefinition exceptionList = null; VariableDefinition exception = null; if (settings.DebugExceptions) { var genericType = ModuleDefinition.ImportReference(Import.System.Collections.List.Type.MakeGenericInstanceType(Import.System.Exception)); exceptionList = new VariableDefinition(genericType); exception = new VariableDefinition(Import.System.Exception); method.Body.Variables.Add(exceptionList); method.Body.Variables.Add(exception); MethodReference listCtor = Import.System.Collections.List.Ctor; listCtor = listCtor.MakeGenericDeclaringType(Import.System.Exception); Instruction createListInstruction = Instruction.Create(OpCodes.Newobj, listCtor); processor.Append(createListInstruction); processor.Emit(OpCodes.Stloc, exceptionList); methodGenerator?.Append("List<Exception> list = new List<Exception>();", createListInstruction); methodGenerator?.Append(Environment.NewLine); } MethodReference funcCtor = Import.System.Func2Ctor; if (mapping != null) { int factoryIndex = 0; var factoryMethods = new Dictionary <string, MethodDefinition>(); foreach (Registration registration in mapping) { try { Logger.Debug($"Processing map for {registration.TargetType.FullName}", DebugLogLevel.Verbose); if (!factoryMethods.TryGetValue(registration.TargetType.FullName, out MethodDefinition factoryMethod)) { factoryMethod = GenerateFactoryMethod(registration.TargetType, factoryIndex, codeGenerator); if (factoryMethod == null) { Logger.Debug($"No acceptable constructor for '{registration.TargetType.FullName}', skipping map", DebugLogLevel.Verbose); continue; } factoryMethods[registration.TargetType.FullName] = factoryMethod; factoryIndex++; containerType.Methods.Add(factoryMethod); } var tryStart = Instruction.Create(OpCodes.Ldarg_0); //collection parameter processor.Append(tryStart); TypeReference importedKey = ModuleDefinition.ImportReference(registration.Key); Logger.Debug( $"Mapping {importedKey.FullName} => {registration.TargetType.FullName} ({registration.Lifetime})", DebugLogLevel.Default); processor.Emit(OpCodes.Ldtoken, importedKey); processor.Emit(OpCodes.Call, Import.System.Type.GetTypeFromHandle); processor.Emit(OpCodes.Ldtoken, ModuleDefinition.ImportReference(registration.TargetType)); processor.Emit(OpCodes.Call, Import.System.Type.GetTypeFromHandle); processor.Emit(OpCodes.Ldnull); processor.Emit(OpCodes.Ldftn, factoryMethod); processor.Emit(OpCodes.Newobj, ModuleDefinition.ImportReference( funcCtor.MakeGenericDeclaringType(Import.System.IServiceProvider, ModuleDefinition.ImportReference(registration.TargetType)))); processor.Emit(OpCodes.Ldc_I4, (int)registration.Lifetime); processor.Emit(OpCodes.Call, Import.AutoDI.ServiceCollectionMixins.AddAutoDIService); processor.Emit(OpCodes.Pop); if (settings.DebugExceptions) { Instruction afterCatch = Instruction.Create(OpCodes.Nop); processor.Emit(OpCodes.Leave_S, afterCatch); Instruction handlerStart = Instruction.Create(OpCodes.Stloc, exception); processor.Append(handlerStart); processor.Emit(OpCodes.Ldloc, exceptionList); processor.Emit(OpCodes.Ldstr, $"Error adding type '{registration.TargetType.FullName}' with key '{registration.Key.FullName}'"); processor.Emit(OpCodes.Ldloc, exception); processor.Emit(OpCodes.Newobj, Import.AutoDI.Exceptions.AutoDIExceptionCtor); var listAdd = Import.System.Collections.List.Add; listAdd = listAdd.MakeGenericDeclaringType(Import.System.Exception); processor.Emit(OpCodes.Callvirt, listAdd); Instruction handlerEnd = Instruction.Create(OpCodes.Leave_S, afterCatch); processor.Append(handlerEnd); var exceptionHandler = new ExceptionHandler(ExceptionHandlerType.Catch) { CatchType = Import.System.Exception, TryStart = tryStart, TryEnd = handlerStart, HandlerStart = handlerStart, HandlerEnd = afterCatch }; method.Body.ExceptionHandlers.Add(exceptionHandler); processor.Append(afterCatch); if (methodGenerator != null) { methodGenerator.Append("try" + Environment.NewLine + "{" + Environment.NewLine); methodGenerator.Append($" {serviceCollection.Name}.{Import.AutoDI.ServiceCollectionMixins.AddAutoDIService.Name}(typeof({importedKey.FullNameCSharp()}), typeof({registration.TargetType.FullNameCSharp()}), new Func<{Import.System.IServiceProvider.NameCSharp()}, {registration.TargetType.FullNameCSharp()}>({factoryMethod.Name}), Lifetime.{registration.Lifetime});", tryStart); methodGenerator.Append(Environment.NewLine + "}" + Environment.NewLine + "catch(Exception innerException)" + Environment.NewLine + "{" + Environment.NewLine); methodGenerator.Append($" list.{listAdd.Name}(new {Import.AutoDI.Exceptions.AutoDIExceptionCtor.DeclaringType.Name}(\"Error adding type '{registration.TargetType.FullName}' with key '{registration.Key.FullName}'\", innerException));", handlerStart); methodGenerator.Append(Environment.NewLine + "}" + Environment.NewLine); } } else if (methodGenerator != null) { methodGenerator.Append($"{serviceCollection.Name}.{Import.AutoDI.ServiceCollectionMixins.AddAutoDIService.Name}(typeof({importedKey.FullNameCSharp()}), typeof({registration.TargetType.FullNameCSharp()}), new Func<{Import.System.IServiceProvider.NameCSharp()}, {registration.TargetType.FullNameCSharp()}>({factoryMethod.Name}), Lifetime.{registration.Lifetime});", tryStart); methodGenerator.Append(Environment.NewLine); } } catch (MultipleConstructorException e) { Logger.Error($"Failed to create map for {registration}\r\n{e}"); } catch (Exception e) { Logger.Warning($"Failed to create map for {registration}\r\n{e}"); } } } Instruction @return = Instruction.Create(OpCodes.Ret); if (settings.DebugExceptions) { Instruction loadList = Instruction.Create(OpCodes.Ldloc, exceptionList); processor.Append(loadList); var listCount = Import.System.Collections.List.Count; listCount = listCount.MakeGenericDeclaringType(Import.System.Exception); processor.Emit(OpCodes.Callvirt, listCount); processor.Emit(OpCodes.Ldc_I4_0); processor.Emit(OpCodes.Cgt); processor.Emit(OpCodes.Brfalse_S, @return); Instruction ldStr = Instruction.Create(OpCodes.Ldstr, $"Error in {Constants.TypeName}.AddServices() generated method"); processor.Append(ldStr); processor.Emit(OpCodes.Ldloc, exceptionList); processor.Emit(OpCodes.Newobj, Import.System.AggregateExceptionCtor); processor.Emit(OpCodes.Throw); if (methodGenerator != null) { methodGenerator.Append("if (list.Count > 0)", loadList); methodGenerator.Append(Environment.NewLine + "{" + Environment.NewLine); methodGenerator.Append($" throw new {Import.System.AggregateExceptionCtor.DeclaringType.Name}(\"Error in {Constants.TypeName}.{method.Name}() generated method\", list);", ldStr); methodGenerator.Append(Environment.NewLine + "}" + Environment.NewLine); } } processor.Append(@return); method.Body.OptimizeMacros(); return(method); }
static async Task Main(string[] args) { Console.WriteLine("*********************** Object Model Generator ***********************"); ICodeGenerator generator = null; var arg = ArgumentParser.Parse(args); if (arg.ContainsKey("format")) { if (arg["format"] == "md") { generator = new Generators.MarkdownGenerator(); } else if (arg["format"] == "html") { generator = new Generators.HtmlOmdGenerator(); } else { Console.WriteLine("Invalid format parameter."); WriteUsage(); return; } } else { generator = new Generators.HtmlOmdGenerator(); } if (!arg.ContainsKey("source") && !arg.ContainsKey("assemblies")) { WriteUsage(); return; } GeneratorSettings.ShowPrivateMembers = arg.ContainsKey("showPrivate"); GeneratorSettings.ShowInternalMembers = arg.ContainsKey("showInternal"); if (arg.ContainsKey("output")) { GeneratorSettings.OutputLocation = arg["output"]; } List <Regex> filters = arg.ContainsKey("exclude") ? arg["exclude"].Split(';', StringSplitOptions.RemoveEmptyEntries).Select(f => CreateFilter(f)).ToList() : new List <Regex>(); if (arg.ContainsKey("regexfilter")) { filters.Add(new Regex(arg["regexfilter"])); } string[] source = arg.ContainsKey("source") ? arg["source"].Split(';', StringSplitOptions.RemoveEmptyEntries) : new string[] { }; string[] oldSource = arg.ContainsKey("compareSource") ? arg["compareSource"].Split(';', StringSplitOptions.RemoveEmptyEntries) : null; string[] preprocessors = arg.ContainsKey("preprocessors") ? arg["preprocessors"].Split(';', StringSplitOptions.RemoveEmptyEntries) : null; string[] assemblies = arg.ContainsKey("assemblies") ? arg["assemblies"].Split(';', StringSplitOptions.RemoveEmptyEntries) : new string[] { }; string[] compareAssemblies = arg.ContainsKey("compareAssemblies") ? arg["compareAssemblies"].Split(';', StringSplitOptions.RemoveEmptyEntries) : null; var g = new Generator(generator); //Set up output filename if (string.IsNullOrEmpty(GeneratorSettings.OutputLocation)) { GeneratorSettings.OutputLocation = "./"; } var fi = new System.IO.FileInfo(GeneratorSettings.OutputLocation); if (!fi.Directory.Exists) { throw new System.IO.DirectoryNotFoundException(fi.Directory.FullName); } if (fi.Attributes == System.IO.FileAttributes.Directory) { GeneratorSettings.OutputLocation = System.IO.Path.Combine(GeneratorSettings.OutputLocation, "OMD"); } if (oldSource != null || compareAssemblies != null) { await g.ProcessDiffs(oldSource, source, compareAssemblies, assemblies, preprocessors, filters.ToArray()); } else { await g.Process(source, assemblies, preprocessors, filters.ToArray()); } if (System.Diagnostics.Debugger.IsAttached) { Console.ReadKey(); } }
public ClepsClassNamesCollectorVisitor(CompileStatus status, ClassManager classManager, ICodeGenerator codeGenerator) : base(status, classManager, codeGenerator) { }
public GeneratorTask(ICodeDescriptor descriptor, ICodeGenerator generator) { Descriptor = descriptor; Generator = generator; }
public ClassGenerator(ICodeGenerator child, TestFrameworkData testFrameworkData) { this.child = child; this.testFrameworkData = testFrameworkData; }
public static CodeCompileUnit CreateCodeCompileUnit( Type proxyType, ICodeGenerator generator, XmlRpcProxyCodeGenOptions options) { if (options == null) { throw new ArgumentNullException( "options", "The options parameter cannot be null"); } // create unique names string baseName = proxyType.Name; // string leading "I" if (baseName.StartsWith("I") == true) { baseName = baseName.Remove(0, 1); } string moduleName = String.Format( CultureInfo.InvariantCulture, "{0}{1}.dll", baseName, DEFAULT_SUFFIX); string assemblyName = ""; if (options.Namespace.Length > 0) { assemblyName = options.Namespace; } else { assemblyName = String.Format( CultureInfo.InvariantCulture, "{0}{1}", baseName, DEFAULT_SUFFIX); } string typeName = ""; if (options.TypeName.Length > 0) { typeName = options.TypeName; } else { typeName = assemblyName; } bool implicitAsync = options.ImplicitAsync; bool flattenInterfaces = options.FlattenInterfaces; CodeCompileUnit ccu = BuildCompileUnit( proxyType, assemblyName, moduleName, typeName, implicitAsync, flattenInterfaces); return(ccu); }