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 CommandProxies(ITypeDiscoverer typeDiscoverer, ITypeImporter typeImporter, ICodeGenerator codeGenerator, WebConfiguration configuration)
{
_typeDiscoverer = typeDiscoverer;
_typeImporter = typeImporter;
_codeGenerator = codeGenerator;
_configuration = configuration;
}
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);
}
