private bool ValidateEntryPoint(IMethodMember value)
{
if (((IDeclaredType)value.ParentTarget).IsGeneric)
{
return(false);
}
if (value.Name != "Main")
{
return(false);
}
if (value.Parameters.Count < 0 || value.Parameters.Count > 1)
{
return(false);
}
if (value.Parameters.Count == 0)
{
return(value.ReturnType.Equals(typeof(int).GetTypeReference()) || value.ReturnType.Equals(typeof(void).GetTypeReference()));
}
IMethodParameterMember impm = value.Parameters[value.Parameters.Keys[0]];
if (impm.ParameterType.ArrayElementType == null || impm.ParameterType.ArrayRank == 0)
{
return((impm.ParameterType.Equals(typeof(string).GetTypeReference())) && (value.ReturnType.Equals(typeof(int).GetTypeReference()) || value.ReturnType.Equals(typeof(void).GetTypeReference())));
}
else if (impm.ParameterType.ArrayRank == 1 && impm.ParameterType.ArrayElementType != null)
{
return(((impm.ParameterType.ArrayElementType.ArrayRank == 0 || impm.ParameterType.ArrayElementType.ArrayElementType == null) && impm.ParameterType.ArrayElementType.Equals(typeof(string).GetTypeReference())) && (value.ReturnType.Equals(typeof(int).GetTypeReference()) || value.ReturnType.Equals(typeof(void).GetTypeReference())));
}
return(false);
}
int IMethodMemberDictionary.IndexOf(IMethodMember method)
{
if (!(method is TIntermediateMethod))
{
throw new ArgumentException("method");
}
return(this.IndexOf((TIntermediateMethod)method));
}
public override string GetEntryPointCommand(IMethodMember entrypointMethod, IIntermediateCompilerOptions options)
{
if (entrypointMethod == null)
{
throw new ArgumentNullException("entrypointMethod");
}
return(string.Format(EntryPointCommand, ((IDeclaredType)entrypointMethod.ParentTarget).GetTypeName(CodeGeneratorHelper.DefaultTranslatorOptions)));
}
int IMethodMemberDictionary.IndexOf(IMethodMember method)
{
if (method is TMethod)
{
return(this.IndexOf((TMethod)method));
}
return(-1);
}
public void RegisterGenericMethod(IMethodMember targetSignature, IControlledTypeCollection typeParameters)
{
if (!this.IsGenericDefinition)
{
throw new InvalidOperationException();
}
this.CheckGenericCache();
this.genericCache.RegisterGenericMethod(targetSignature, typeParameters);
}
public int IndexOf(IMethodMember method)
{
int valueIndex = this.master.Values.IndexOf(new MasterDictionaryEntry <IMember>(this, method));
if (valueIndex == -1)
{
return(-1);
}
return(this.identifiers.GetIndexOf(master.Keys[valueIndex]));
}
public void ReferenceDeclaration(IMethodMember declaration)
{
if (declaration is IIntermediateMethodMember)
{
this.ReferenceDeclaration((IIntermediateMethodMember)declaration);
}
else
{
this.Formatter.ReferenceDeclaration(declaration);
}
}
private static void AddImplementations(HashSet <IInterfaceType> results, IMethodMember aM)
{
if (aM != null && aM is IExtendedInstanceMember)
{
var ieimAM = (IExtendedInstanceMember)aM;
foreach (var t in ieimAM.Implementations)
{
results.Add(t);
}
}
}
void _onRaiseMethod_Disposed(object sender, EventArgs e)
{
if (this._onRaiseMethod != null)
{
_onRaiseMethod.Disposed -= new EventHandler(_onRaiseMethod_Disposed);
this._onRaiseMethod = null;
}
if (this.onRaiseMethod != null)
{
this.onRaiseMethod.Dispose();
this.onRaiseMethod = null;
}
}
private ITypeParent OnGetParentImpl()
{
ITypeParent declParent = this.Original.Parent;
if (declParent == null)
{
return(null);
}
else
{
if (this.Original.IsGenericConstruct)
{
if (declParent is IGenericType)
{
IGenericType genericParent = ((IGenericType)(declParent));
if (genericParent.IsGenericConstruct)
{
if (!genericParent.IsGenericDefinition)
{
genericParent = (IGenericType)genericParent.ElementType;
}
return((ITypeParent)genericParent.MakeGenericClosure(this.GenericParameters.Take(genericParent.GenericParameters.Count).ToCollection()));
}
else
{
return((ITypeParent)genericParent);
}
}
else if (declParent is IMethodMember)
{
IMethodMember genericParent = ((IMethodMember)(declParent));
if (genericParent.IsGenericConstruct)
{
if (!genericParent.IsGenericDefinition)
{
genericParent = (IMethodMember)genericParent.GetGenericDefinition();
}
return((ITypeParent)genericParent.MakeGenericClosure(this.GenericParameters.Take(genericParent.GenericParameters.Count).ToCollection()));
}
}
}
return(declParent);
}
}
public void RegisterGenericMethod(IMethodMember targetMethod, IControlledTypeCollection typeParameters)
{
lock (this.syncObject)
{
if (this.disposing)
{
return;
}
if (this.genericCache == null)
{
this.genericCache = new ControlledDictionary <IControlledTypeCollection, TMethod>();
}
TMethod dummy = default(TMethod);
if (!this.ContainsGenericMethod(typeParameters, ref dummy))
{
this.genericCache._Add(typeParameters, (TMethod)targetMethod);
}
}
}
public void RegisterGenericChild(IMethodParent parent, IMethodMember genericChild)
{
lock (syncObject)
{
if (this.disposing)
{
return;
}
if (!(genericChild is TMethod))
{
throw new ArgumentException(ThrowHelper.GetExceptionMessage(ExceptionMessageId.ValueIsWrongType, "genericChild", genericChild.GetType().FullName, typeof(TMethod).FullName), "genericChild");
}
if (this.genericChildCache == null)
{
this.genericChildCache = new Dictionary <IMethodParent, TMethod>();
}
if (!genericChildCache.ContainsKey(parent))
{
genericChildCache.Add(parent, (TMethod)genericChild);
}
}
}
protected abstract IPropertyMethodMember OnGetMethod(IMethodMember originalMethod);
public static IMethodParameterMember <TMethod, TMethodParent> ParamOf <TMethod, TMethodParent>(this string name, IMethodMember <TMethod, TMethodParent> method)
where TMethod :
IMethodMember <TMethod, TMethodParent>
where TMethodParent :
IMethodParent <TMethod, TMethodParent>
{
IMethodParameterMember <TMethod, TMethodParent> result;
method.Parameters.TryGetValue(TypeSystemIdentifiers.GetMemberIdentifier(name), out result);
return(result);
}
public abstract string GetEntryPointCommand(IMethodMember entrypointMethod, IIntermediateCompilerOptions options);
public virtual void TranslateMember(IMethodMember methodMember)
{
this.TranslateMember <IMethodParameterMember, IMethodTypeParameterMember, CodeMemberMethod, IMemberParentType>(methodMember);
}
protected override IPropertyMethodMember OnGetMethod(IMethodMember originalMethod)
{
return(new _MethodMember(this.Parent, (IStructMethodMember)originalMethod));
}
public MethodTypeParameterMember(string name, IMethodMember parentTarget)
: base(name, parentTarget)
{
}
public void RegisterGenericChild(IMethodParent parent, IMethodMember genericChild)
{
throw new NotSupportedException();
}
public void ReferenceDeclaration(IMethodMember declaration)
{
referenceStack.Push(declaration);
}
public void RegisterGenericChild(IMethodParent parent, IMethodMember genericChild)
{
this.CheckGenericCache();
this.genericCache.RegisterGenericChild(parent, genericChild);
}
protected abstract IMethodMember OnGetMethod(IMethodMember original);
/// <summary>
/// Creates a new instance of <see cref="MethodParameterMember"/>
/// with the parameter type, name and target provided.
/// </summary>
/// <param name="nameAndType">The type and name of the parameter.</param>
/// <param name="parentTarget">The place the parameter exists on.</param>
public MethodParameterMember(TypedName nameAndType, IMethodMember parentTarget)
: base(nameAndType, parentTarget)
{
}
public void RegisterGenericMethod(IMethodMember targetSignature, IControlledTypeCollection typeParameters)
{
this.CheckGenericCache();
this.genericCache.RegisterGenericMethod(targetSignature, typeParameters);
}
public void ReferenceDeclaration(IMethodMember declaration)
{
}
public MethodParameterMembers(IMethodMember targetDeclaration)
: base(targetDeclaration)
{
}
protected override IMethodMember OnGetMethod(IMethodMember original)
{
return(new _MethodMember((IClassMethodMember)original, this.Parent));
}
private void CompileToResponse(TemporaryDirectory td, TempFileCollection tfc, List <string> files, Stack <IIntermediateProject> partialCompletions, Dictionary <IIntermediateModule, List <string> > moduleFiles, out IIntermediateCompilerCommandLineModule module, out List <string> commandSequences, out string response)
{
module = (IIntermediateCompilerCommandLineModule)this.Module;
commandSequences = new List <string>();
if (this.Project.OutputType == ProjectOutputType.ConsoleApplication || this.Project.OutputType == ProjectOutputType.WindowsApplication)
{
IMethodMember entryPoint = Project.EntryPoint;
if (entryPoint != null && ((IDeclaredType)entryPoint.ParentTarget).Module != Project.RootModule)
{
IClassType entryPointCover = Project.Partials.AddNew().DefaultNameSpace.Classes.AddNew(Project.Classes.GetUniqueName("_cover"));
entryPointCover.Attributes.AddNew(typeof(CompilerGeneratedAttribute));
entryPointCover.IsStatic = true;
entryPointCover.AccessLevel = DeclarationAccessLevel.Internal;
entryPointCover.Module = Project.RootModule;
IMethodMember coverPoint = entryPointCover.Methods.AddNew(new TypedName(entryPoint.Name, entryPoint.ReturnType));
coverPoint.Attributes.AddNew(typeof(CompilerGeneratedAttribute));
foreach (IMethodParameterMember impm in entryPoint.Parameters.Values)
{
coverPoint.Parameters.AddNew(new TypedName(impm.Name, impm.ParameterType));
}
coverPoint.Summary = "Entrypoint cover method, invokes the true entrypoint in a different module.";
IMethodInvokeExpression imie = entryPoint.GetReference().Invoke();
foreach (IMethodParameterMember impm in entryPoint.Parameters.Values)
{
imie.ArgumentExpressions.Add(impm.GetReference());
}
if (!(coverPoint.ReturnType.Equals(typeof(void).GetTypeReference())))
{
coverPoint.Return(imie);
}
else
{
coverPoint.CallMethod(imie);
}
string entryFile = ProjectTranslator.WriteFile(this.Project, this.Translator, td, tfc, partialCompletions, entryPointCover, ".cs", " ");
moduleFiles[Project.RootModule].Add(entryFile);
files.Add(entryFile);
commandSequences.Add(module.GetEntryPointCommand(coverPoint, this.Options));
this.Project.Partials.Remove((IIntermediateProject)entryPointCover.ParentTarget.ParentTarget);
}
else
{
commandSequences.Add(module.GetEntryPointCommand(entryPoint, this.Options));
}
}
List <string> moduleCommandLines = new List <string>();
foreach (IIntermediateModule iim in this.Project.Modules.Values)
{
string[] moduleFileNames = new string[moduleFiles[iim].Count + (iim == this.Project.RootModule ? this.Options.ExtraFiles.Count() : 0)];
for (int i = 0; i < moduleFiles[iim].Count; i++)
{
moduleFileNames[i] = moduleFiles[iim][i];
}
if (iim == this.Project.RootModule)
{
int exC = this.Options.ExtraFiles.Count();
int exO = moduleFiles[iim].Count;
int index = exO;
foreach (var extraFile in this.Options.ExtraFiles)
{
var tempFile = td.Directories.GetTemporaryDirectory(iim.Name).Files.GetTemporaryFile(Path.GetFileName(extraFile));
tempFile.CloseStream();
File.Copy(extraFile, tempFile.FileName, true);
moduleFileNames[index++] = tempFile.FileName;
}
}
moduleCommandLines.AddRange(module.GetModuleCommand(iim, moduleFileNames, null, this.Options));
}
bool allowPartials = this.Translator.Options.AllowPartials;
this.Translator.Options.AllowPartials = false;
ProjectDependencyReport pdr = new ProjectDependencyReport(this.Project, this.Translator.Options);
pdr.Begin();
this.Translator.Options.AllowPartials = allowPartials;
if (module.Supports(CompilerModuleSupportFlags.Optimization))
{
commandSequences.Add(module.GetOptimizationCommand(this.Options.Optimize, this.Options));
}
if (module.Supports(CompilerModuleSupportFlags.DebuggerSupport))
{
commandSequences.Add(module.GetDebugCommand(this.Options.DebugSupport, this.Options));
}
if (module.Supports(CompilerModuleSupportFlags.XMLDocumentation))
{
commandSequences.Add(module.GetXMLDocumentationCommand(this.Options.GenerateXMLDocs, this.Options));
}
commandSequences.AddRange(module.GetReferencesCommand(Tweaks.TranslateArray(pdr.CompiledAssemblyReferences.ToArray(), a =>
{
return(a.Location);
}), this.Options));
if (module.Supports(CompilerModuleSupportFlags.MultiFileAssemblies))
{
commandSequences.AddRange(moduleCommandLines.ToArray());
}
else
{
commandSequences.Add(module.GetOutputCommand(this.Options.Target, this.Options));
commandSequences.AddRange(module.GetSourcesCommand(files.ToArray(), this.Options));
}
response = null;
if (module.Supports(CompilerModuleSupportFlags.ResponseFile))
{
response = tfc.AddExtension("response");
StreamWriter responseWriter = new StreamWriter(new FileStream(response, FileMode.Create));
//string[] lines = fullCommand.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string s in commandSequences)
{
responseWriter.WriteLine(s);
}
responseWriter.Flush();
responseWriter.Close();
}
}