internal override void GenerateDocComment(DocumentationBuilder builder)
{
foreach (var tc in types)
{
tc.GenerateDocComment(builder);
}
}
public override void GenerateDocComment(DocumentationBuilder builder)
{
foreach (var tc in containers)
{
tc.GenerateDocComment(builder);
}
}
//
// Generates xml doc comments (if any), and if required,
// handle warning report.
//
internal virtual void GenerateDocComment(DocumentationBuilder builder)
{
if (DocComment == null) {
if (IsExposedFromAssembly ()) {
Constructor c = this as Constructor;
if (c == null || !c.IsDefault ())
Report.Warning (1591, 4, Location,
"Missing XML comment for publicly visible type or member `{0}'", GetSignatureForError ());
}
return;
}
try {
builder.GenerateDocumentationForMember (this);
} catch (Exception e) {
throw new InternalErrorException (this, e);
}
}
internal override void GenerateDocComment (DocumentationBuilder builder)
{
if (IsPartialPart)
return;
base.GenerateDocComment (builder);
foreach (var member in members)
member.GenerateDocComment (builder);
}
internal override void GenerateDocComment (DocumentationBuilder builder)
{
base.GenerateDocComment (builder);
if (DefaultStaticConstructor != null)
DefaultStaticConstructor.GenerateDocComment (builder);
if (InstanceConstructors != null)
foreach (Constructor c in InstanceConstructors)
c.GenerateDocComment (builder);
if (Types != null)
foreach (TypeContainer tc in Types)
tc.GenerateDocComment (builder);
if (Constants != null)
foreach (Const c in Constants)
c.GenerateDocComment (builder);
if (Fields != null)
foreach (FieldBase f in Fields)
f.GenerateDocComment (builder);
if (Events != null)
foreach (Event e in Events)
e.GenerateDocComment (builder);
if (Indexers != null)
foreach (Indexer ix in Indexers)
ix.GenerateDocComment (builder);
if (Properties != null)
foreach (Property p in Properties)
p.GenerateDocComment (builder);
if (Methods != null)
foreach (MethodOrOperator m in Methods)
m.GenerateDocComment (builder);
if (Operators != null)
foreach (Operator o in Operators)
o.GenerateDocComment (builder);
}
public DocumentationReference ConvertXmlDoc(DocumentationBuilder doc)
{
var result = new DocumentationReference();
if (doc.ParsedName != null) {
if (doc.ParsedName.Name == "<this>") {
result.SymbolKind = SymbolKind.Indexer;
} else {
result.MemberName = doc.ParsedName.Name;
}
if (doc.ParsedName.Left != null) {
result.DeclaringType = ConvertToType(doc.ParsedName.Left);
} else if (doc.ParsedBuiltinType != null) {
result.DeclaringType = ConvertToType(doc.ParsedBuiltinType);
}
if (doc.ParsedName.TypeParameters != null) {
for (int i = 0; i < doc.ParsedName.TypeParameters.Count; i++) {
result.TypeArguments.Add(ConvertToType(doc.ParsedName.TypeParameters [i]));
}
}
} else if (doc.ParsedBuiltinType != null) {
result.SymbolKind = SymbolKind.TypeDefinition;
result.DeclaringType = ConvertToType(doc.ParsedBuiltinType);
}
if (doc.ParsedParameters != null) {
result.HasParameterList = true;
result.Parameters.AddRange(doc.ParsedParameters.Select(ConvertXmlDocParameter));
}
if (doc.ParsedOperator != null) {
result.SymbolKind = SymbolKind.Operator;
result.OperatorType = (OperatorType)doc.ParsedOperator;
if (result.OperatorType == OperatorType.Implicit || result.OperatorType == OperatorType.Explicit) {
var returnTypeParam = result.Parameters.LastOrNullObject();
returnTypeParam.Remove(); // detach from parameter list
var returnType = returnTypeParam.Type;
returnType.Remove();
result.ConversionOperatorReturnType = returnType;
}
if (result.Parameters.Count == 0) {
// reset HasParameterList if necessary
result.HasParameterList = false;
}
}
return result;
}
public override void GenerateDocComment(DocumentationBuilder builder)
{
if (containers != null) {
foreach (var tc in containers)
tc.GenerateDocComment (builder);
}
}
//
// Main compilation method
//
public bool Compile()
{
var settings = ctx.Settings;
//
// If we are an exe, require a source file for the entry point or
// if there is nothing to put in the assembly, and we are not a library
//
if (settings.FirstSourceFile == null &&
((settings.Target == Target.Exe || settings.Target == Target.WinExe || settings.Target == Target.Module) ||
settings.Resources == null))
{
Report.Error(2008, "No files to compile were specified");
return(false);
}
TimeReporter tr = new TimeReporter(settings.Timestamps);
ctx.TimeReporter = tr;
tr.StartTotal();
var module = new ModuleContainer(ctx);
RootContext.ToplevelTypes = module;
tr.Start(TimeReporter.TimerType.ParseTotal);
Parse(module);
tr.Stop(TimeReporter.TimerType.ParseTotal);
if (Report.Errors > 0)
{
return(false);
}
if (settings.TokenizeOnly || settings.ParseOnly)
{
tr.StopTotal();
tr.ShowStats();
return(true);
}
var output_file = settings.OutputFile;
string output_file_name;
if (output_file == null)
{
var source_file = settings.FirstSourceFile;
if (source_file == null)
{
Report.Error(1562, "If no source files are specified you must specify the output file with -out:");
return(false);
}
output_file_name = source_file.Name;
int pos = output_file_name.LastIndexOf('.');
if (pos > 0)
{
output_file_name = output_file_name.Substring(0, pos);
}
output_file_name += settings.TargetExt;
output_file = output_file_name;
}
else
{
output_file_name = Path.GetFileName(output_file);
}
#if STATIC
var importer = new StaticImporter(module);
var references_loader = new StaticLoader(importer, ctx);
tr.Start(TimeReporter.TimerType.AssemblyBuilderSetup);
var assembly = new AssemblyDefinitionStatic(module, references_loader, output_file_name, output_file);
assembly.Create(references_loader.Domain);
tr.Stop(TimeReporter.TimerType.AssemblyBuilderSetup);
// Create compiler types first even before any referenced
// assembly is loaded to allow forward referenced types from
// loaded assembly into compiled builder to be resolved
// correctly
tr.Start(TimeReporter.TimerType.CreateTypeTotal);
module.CreateType();
importer.AddCompiledAssembly(assembly);
tr.Stop(TimeReporter.TimerType.CreateTypeTotal);
references_loader.LoadReferences(module);
tr.Start(TimeReporter.TimerType.PredefinedTypesInit);
if (!ctx.BuiltinTypes.CheckDefinitions(module))
{
return(false);
}
tr.Stop(TimeReporter.TimerType.PredefinedTypesInit);
references_loader.LoadModules(assembly, module.GlobalRootNamespace);
#else
var assembly = new AssemblyDefinitionDynamic(module, output_file_name, output_file);
module.SetDeclaringAssembly(assembly);
var importer = new ReflectionImporter(module, ctx.BuiltinTypes);
assembly.Importer = importer;
var loader = new DynamicLoader(importer, ctx);
loader.LoadReferences(module);
if (!ctx.BuiltinTypes.CheckDefinitions(module))
{
return(false);
}
if (!assembly.Create(AppDomain.CurrentDomain, AssemblyBuilderAccess.Save))
{
return(false);
}
module.CreateType();
loader.LoadModules(assembly, module.GlobalRootNamespace);
#endif
module.InitializePredefinedTypes();
tr.Start(TimeReporter.TimerType.UsingResolve);
foreach (var source_file in ctx.SourceFiles)
{
source_file.NamespaceContainer.Resolve();
}
tr.Stop(TimeReporter.TimerType.UsingResolve);
tr.Start(TimeReporter.TimerType.ModuleDefinitionTotal);
module.Define();
tr.Stop(TimeReporter.TimerType.ModuleDefinitionTotal);
if (Report.Errors > 0)
{
return(false);
}
if (settings.DocumentationFile != null)
{
var doc = new DocumentationBuilder(module);
doc.OutputDocComment(output_file, settings.DocumentationFile);
}
assembly.Resolve();
if (Report.Errors > 0)
{
return(false);
}
tr.Start(TimeReporter.TimerType.EmitTotal);
assembly.Emit();
tr.Stop(TimeReporter.TimerType.EmitTotal);
if (Report.Errors > 0)
{
return(false);
}
tr.Start(TimeReporter.TimerType.CloseTypes);
module.CloseType();
tr.Stop(TimeReporter.TimerType.CloseTypes);
tr.Start(TimeReporter.TimerType.Resouces);
assembly.EmbedResources();
tr.Stop(TimeReporter.TimerType.Resouces);
if (Report.Errors > 0)
{
return(false);
}
assembly.Save();
#if STATIC
references_loader.Dispose();
#endif
tr.StopTotal();
tr.ShowStats();
return(Report.Errors == 0);
}
//
// Generates xml doc comments (if any), and if required,
// handle warning report.
//
internal virtual void GenerateDocComment (DocumentationBuilder builder)
{
if (DocComment == null) {
if (IsExposedFromAssembly ()) {
Constructor c = this as Constructor;
if (c == null || !c.IsDefault ())
Report.Warning (1591, 4, Location,
"Missing XML comment for publicly visible type or member `{0}'", GetSignatureForError ());
}
return;
}
try {
builder.GenerateDocumentationForMember (this);
} catch (Exception e) {
throw new InternalErrorException (this, e);
}
}
internal override void GenerateDocComment (DocumentationBuilder builder)
{
base.GenerateDocComment (builder);
foreach (var member in members)
member.GenerateDocComment (builder);
}
//
// Main compilation method
//
public bool Compile ()
{
var settings = ctx.Settings;
//
// If we are an exe, require a source file for the entry point or
// if there is nothing to put in the assembly, and we are not a library
//
if (settings.FirstSourceFile == null &&
((settings.Target == Target.Exe || settings.Target == Target.WinExe || settings.Target == Target.Module) ||
settings.Resources == null)) {
Report.Error (2008, "No files to compile were specified");
return false;
}
if (settings.Platform == Platform.AnyCPU32Preferred && (settings.Target == Target.Library || settings.Target == Target.Module)) {
Report.Error (4023, "Platform option `anycpu32bitpreferred' is valid only for executables");
return false;
}
TimeReporter tr = new TimeReporter (settings.Timestamps);
ctx.TimeReporter = tr;
tr.StartTotal ();
var module = new ModuleContainer (ctx);
RootContext.ToplevelTypes = module;
tr.Start (TimeReporter.TimerType.ParseTotal);
Parse (module);
tr.Stop (TimeReporter.TimerType.ParseTotal);
if (Report.Errors > 0)
return false;
if (settings.TokenizeOnly || settings.ParseOnly) {
tr.StopTotal ();
tr.ShowStats ();
return true;
}
var output_file = settings.OutputFile;
string output_file_name;
if (output_file == null) {
var source_file = settings.FirstSourceFile;
if (source_file == null) {
Report.Error (1562, "If no source files are specified you must specify the output file with -out:");
return false;
}
output_file_name = source_file.Name;
int pos = output_file_name.LastIndexOf ('.');
if (pos > 0)
output_file_name = output_file_name.Substring (0, pos);
output_file_name += settings.TargetExt;
output_file = output_file_name;
} else {
output_file_name = Path.GetFileName (output_file);
if (string.IsNullOrEmpty (Path.GetFileNameWithoutExtension (output_file_name)) ||
output_file_name.IndexOfAny (Path.GetInvalidFileNameChars ()) >= 0) {
Report.Error (2021, "Output file name is not valid");
return false;
}
}
#if STATIC
var importer = new StaticImporter (module);
var references_loader = new StaticLoader (importer, ctx);
tr.Start (TimeReporter.TimerType.AssemblyBuilderSetup);
var assembly = new AssemblyDefinitionStatic (module, references_loader, output_file_name, output_file);
assembly.Create (references_loader.Domain);
tr.Stop (TimeReporter.TimerType.AssemblyBuilderSetup);
// Create compiler types first even before any referenced
// assembly is loaded to allow forward referenced types from
// loaded assembly into compiled builder to be resolved
// correctly
tr.Start (TimeReporter.TimerType.CreateTypeTotal);
module.CreateContainer ();
importer.AddCompiledAssembly (assembly);
tr.Stop (TimeReporter.TimerType.CreateTypeTotal);
references_loader.LoadReferences (module);
tr.Start (TimeReporter.TimerType.PredefinedTypesInit);
if (!ctx.BuiltinTypes.CheckDefinitions (module))
return false;
tr.Stop (TimeReporter.TimerType.PredefinedTypesInit);
references_loader.LoadModules (assembly, module.GlobalRootNamespace);
#else
var assembly = new AssemblyDefinitionDynamic (module, output_file_name, output_file);
module.SetDeclaringAssembly (assembly);
var importer = new ReflectionImporter (module, ctx.BuiltinTypes);
assembly.Importer = importer;
var loader = new DynamicLoader (importer, ctx);
loader.LoadReferences (module);
if (!ctx.BuiltinTypes.CheckDefinitions (module))
return false;
if (!assembly.Create (AppDomain.CurrentDomain, AssemblyBuilderAccess.Save))
return false;
module.CreateContainer ();
loader.LoadModules (assembly, module.GlobalRootNamespace);
#endif
module.InitializePredefinedTypes ();
tr.Start (TimeReporter.TimerType.ModuleDefinitionTotal);
module.Define ();
tr.Stop (TimeReporter.TimerType.ModuleDefinitionTotal);
if (Report.Errors > 0)
return false;
if (settings.DocumentationFile != null) {
var doc = new DocumentationBuilder (module);
doc.OutputDocComment (output_file, settings.DocumentationFile);
}
assembly.Resolve ();
if (Report.Errors > 0)
return false;
tr.Start (TimeReporter.TimerType.EmitTotal);
assembly.Emit ();
tr.Stop (TimeReporter.TimerType.EmitTotal);
if (Report.Errors > 0){
return false;
}
tr.Start (TimeReporter.TimerType.CloseTypes);
module.CloseContainer ();
tr.Stop (TimeReporter.TimerType.CloseTypes);
tr.Start (TimeReporter.TimerType.Resouces);
if (!settings.WriteMetadataOnly)
assembly.EmbedResources ();
tr.Stop (TimeReporter.TimerType.Resouces);
if (Report.Errors > 0)
return false;
assembly.Save ();
#if STATIC
references_loader.Dispose ();
#endif
tr.StopTotal ();
tr.ShowStats ();
return Report.Errors == 0;
}
internal override void GenerateDocComment (DocumentationBuilder builder)
{
foreach (var tc in containers)
tc.GenerateDocComment (builder);
}
//
// Generates xml doc comments (if any), and if required,
// handle warning report.
//
internal virtual void GenerateDocComment (DocumentationBuilder builder)
{
if (DocComment == null) {
if (IsExposedFromAssembly ()) {
var td = this as TypeDefinition;
if (td != null && td.PartialContainer != null) {
//
// This partial part does not have comment but some other part can have
//
foreach (var tc in Parent.Containers) {
if (tc.PartialContainer == td.PartialContainer && tc.DocComment != null)
return;
}
}
Constructor c = this as Constructor;
if (c == null || !c.IsDefault ())
Report.Warning (1591, 4, Location,
"Missing XML comment for publicly visible type or member `{0}'", GetSignatureForError ());
}
return;
}
try {
builder.GenerateDocumentationForMember (this);
} catch (Exception e) {
throw new InternalErrorException (this, e);
}
}