| public Error ( int code, Mono.CSharp.Location loc, string error ) : void | ||
| code | int | |
| loc | Mono.CSharp.Location | |
| error | string | |
| Résultat | void | |
public static void Error_InvalidConstantType(TypeSpec t, Location loc, Report Report)
{
if (t.IsGenericParameter) {
Report.Error (1959, loc,
"Type parameter `{0}' cannot be declared const", TypeManager.CSharpName (t));
} else {
Report.Error (283, loc,
"The type `{0}' cannot be declared const", TypeManager.CSharpName (t));
}
}
static public void Save(string name, bool saveDebugInfo, Report Report)
{
#if GMCS_SOURCE
PortableExecutableKinds pekind;
ImageFileMachine machine;
switch (RootContext.Platform)
{
case Platform.X86:
pekind = PortableExecutableKinds.Required32Bit;
machine = ImageFileMachine.I386;
break;
case Platform.X64:
pekind = PortableExecutableKinds.PE32Plus;
machine = ImageFileMachine.AMD64;
break;
case Platform.IA64:
pekind = PortableExecutableKinds.PE32Plus;
machine = ImageFileMachine.IA64;
break;
case Platform.AnyCPU:
default:
pekind = PortableExecutableKinds.ILOnly;
machine = ImageFileMachine.I386;
break;
}
#endif
try {
#if GMCS_SOURCE
Assembly.Builder.Save(Basename(name), pekind, machine);
#else
Assembly.Builder.Save(Basename(name));
#endif
}
catch (COMException) {
if ((RootContext.StrongNameKeyFile == null) || (!RootContext.StrongNameDelaySign))
{
throw;
}
// FIXME: it seems Microsoft AssemblyBuilder doesn't like to delay sign assemblies
Report.Error(1548, "Couldn't delay-sign the assembly with the '" +
RootContext.StrongNameKeyFile +
"', Use MCS with the Mono runtime or CSC to compile this assembly.");
}
catch (System.IO.IOException io) {
Report.Error(16, "Could not write to file `" + name + "', cause: " + io.Message);
return;
}
catch (System.UnauthorizedAccessException ua) {
Report.Error(16, "Could not write to file `" + name + "', cause: " + ua.Message);
return;
}
catch (System.NotImplementedException nie) {
Report.RuntimeMissingSupport(Location.Null, nie.Message);
return;
}
//
// Write debuger symbol file
//
if (saveDebugInfo)
{
SymbolWriter.WriteSymbolFile();
}
}
public static void Error_GlobalNamespaceRedefined(Report report, Location loc)
{
report.Error (1681, loc, "The global extern alias cannot be redefined");
}
static void Error_FriendAccessNameNotMatching (string other_name, Report Report)
{
Report.Error (281,
"Friend access was granted to `{0}', but the output assembly is named `{1}'. Try adding a reference to `{0}' or change the output assembly name to match it",
other_name, CodeGen.Assembly.Name.FullName);
}
public override void Error_NamespaceDoesNotExist (Location loc, string name, Report Report)
{
Report.Error (400, loc, "The type or namespace name `{0}' could not be found in the global namespace (are you missing an assembly reference?)",
name);
}
public bool CheckExistingMembersOverloads (MemberCore member, string name, ParametersCompiled parameters, Report Report)
{
ArrayList entries = (ArrayList)member_hash [name];
if (entries == null)
return true;
int method_param_count = parameters.Count;
for (int i = entries.Count - 1; i >= 0; --i) {
CacheEntry ce = (CacheEntry) entries [i];
if (ce.Container != member.Parent.PartialContainer)
return true;
Type [] p_types;
AParametersCollection pd;
if ((ce.EntryType & EntryType.Property) != 0) {
pd = TypeManager.GetParameterData ((PropertyInfo) ce.Member);
p_types = pd.Types;
} else {
MethodBase mb = (MethodBase) ce.Member;
// TODO: This is more like a hack, because we are adding generic methods
// twice with and without arity name
if (TypeManager.IsGenericMethod (mb) && !member.MemberName.IsGeneric)
continue;
pd = TypeManager.GetParameterData (mb);
p_types = pd.Types;
}
if (p_types.Length != method_param_count)
continue;
if (method_param_count > 0) {
int ii = method_param_count - 1;
Type type_a, type_b;
do {
type_a = parameters.Types [ii];
type_b = p_types [ii];
#if GMCS_SOURCE
if (TypeManager.IsGenericParameter (type_a) && type_a.DeclaringMethod != null)
type_a = typeof (TypeParameter);
if (TypeManager.IsGenericParameter (type_b) && type_b.DeclaringMethod != null)
type_b = typeof (TypeParameter);
#endif
if ((pd.FixedParameters [ii].ModFlags & Parameter.Modifier.ISBYREF) !=
(parameters.FixedParameters [ii].ModFlags & Parameter.Modifier.ISBYREF))
type_a = null;
} while (type_a == type_b && ii-- != 0);
if (ii >= 0)
continue;
//
// Operators can differ in return type only
//
if (member is Operator) {
Operator op = TypeManager.GetMethod ((MethodBase) ce.Member) as Operator;
if (op != null && op.ReturnType != ((Operator) member).ReturnType)
continue;
}
//
// Report difference in parameter modifiers only
//
if (pd != null && member is MethodCore) {
ii = method_param_count;
while (ii-- != 0 && parameters.FixedParameters [ii].ModFlags == pd.FixedParameters [ii].ModFlags &&
parameters.ExtensionMethodType == pd.ExtensionMethodType);
if (ii >= 0) {
MethodCore mc = TypeManager.GetMethod ((MethodBase) ce.Member) as MethodCore;
Report.SymbolRelatedToPreviousError (ce.Member);
if ((member.ModFlags & Modifiers.PARTIAL) != 0 && (mc.ModFlags & Modifiers.PARTIAL) != 0) {
if (parameters.HasParams || pd.HasParams) {
Report.Error (758, member.Location,
"A partial method declaration and partial method implementation cannot differ on use of `params' modifier");
} else {
Report.Error (755, member.Location,
"A partial method declaration and partial method implementation must be both an extension method or neither");
}
} else {
if (member is Constructor) {
Report.Error (851, member.Location,
"Overloaded contructor `{0}' cannot differ on use of parameter modifiers only",
member.GetSignatureForError ());
} else {
Report.Error (663, member.Location,
"Overloaded method `{0}' cannot differ on use of parameter modifiers only",
member.GetSignatureForError ());
}
}
return false;
}
}
}
if ((ce.EntryType & EntryType.Method) != 0) {
Method method_a = member as Method;
Method method_b = TypeManager.GetMethod ((MethodBase) ce.Member) as Method;
if (method_a != null && method_b != null && (method_a.ModFlags & method_b.ModFlags & Modifiers.PARTIAL) != 0) {
const int partial_modifiers = Modifiers.STATIC | Modifiers.UNSAFE;
if (method_a.IsPartialDefinition == method_b.IsPartialImplementation) {
if ((method_a.ModFlags & partial_modifiers) == (method_b.ModFlags & partial_modifiers) ||
method_a.Parent.IsUnsafe && method_b.Parent.IsUnsafe) {
if (method_a.IsPartialImplementation) {
method_a.SetPartialDefinition (method_b);
entries.RemoveAt (i);
} else {
method_b.SetPartialDefinition (method_a);
}
continue;
}
if ((method_a.ModFlags & Modifiers.STATIC) != (method_b.ModFlags & Modifiers.STATIC)) {
Report.SymbolRelatedToPreviousError (ce.Member);
Report.Error (763, member.Location,
"A partial method declaration and partial method implementation must be both `static' or neither");
}
Report.SymbolRelatedToPreviousError (ce.Member);
Report.Error (764, member.Location,
"A partial method declaration and partial method implementation must be both `unsafe' or neither");
return false;
}
Report.SymbolRelatedToPreviousError (ce.Member);
if (method_a.IsPartialDefinition) {
Report.Error (756, member.Location, "A partial method `{0}' declaration is already defined",
member.GetSignatureForError ());
}
Report.Error (757, member.Location, "A partial method `{0}' implementation is already defined",
member.GetSignatureForError ());
return false;
}
Report.SymbolRelatedToPreviousError (ce.Member);
IMethodData duplicate_member = TypeManager.GetMethod ((MethodBase) ce.Member);
if (member is Operator && duplicate_member is Operator) {
Report.Error (557, member.Location, "Duplicate user-defined conversion in type `{0}'",
member.Parent.GetSignatureForError ());
return false;
}
bool is_reserved_a = member is AbstractPropertyEventMethod || member is Operator;
bool is_reserved_b = duplicate_member is AbstractPropertyEventMethod || duplicate_member is Operator;
if (is_reserved_a || is_reserved_b) {
Report.Error (82, member.Location, "A member `{0}' is already reserved",
is_reserved_a ?
TypeManager.GetFullNameSignature (ce.Member) :
member.GetSignatureForError ());
return false;
}
} else {
Report.SymbolRelatedToPreviousError (ce.Member);
}
Report.Error (111, member.Location,
"A member `{0}' is already defined. Rename this member or use different parameter types",
member.GetSignatureForError ());
return false;
}
return true;
}
//
// Outputs XML documentation comment from tokenized comments.
//
public bool OutputDocComment(string asmfilename, Report Report)
{
XmlTextWriter w = null;
try {
w = new XmlTextWriter (docfilename, null);
w.Indentation = 4;
w.Formatting = Formatting.Indented;
w.WriteStartDocument ();
w.WriteStartElement ("doc");
w.WriteStartElement ("assembly");
w.WriteStartElement ("name");
w.WriteString (Path.ChangeExtension (asmfilename, null));
w.WriteEndElement (); // name
w.WriteEndElement (); // assembly
w.WriteStartElement ("members");
XmlCommentOutput = w;
GenerateDocComment (Report);
w.WriteFullEndElement (); // members
w.WriteEndElement ();
w.WriteWhitespace (Environment.NewLine);
w.WriteEndDocument ();
return true;
} catch (Exception ex) {
Report.Error (1569, "Error generating XML documentation file `{0}' (`{1}')", docfilename, ex.Message);
return false;
} finally {
if (w != null)
w.Close ();
}
}
/// <summary>
/// Common method for Obsolete error/warning reporting.
/// </summary>
public static void Report_ObsoleteMessage (ObsoleteAttribute oa, string member, Location loc, Report Report)
{
if (oa.IsError) {
Report.Error (619, loc, "`{0}' is obsolete: `{1}'", member, oa.Message);
return;
}
if (oa.Message == null || oa.Message.Length == 0) {
Report.Warning (612, 1, loc, "`{0}' is obsolete", member);
return;
}
Report.Warning (618, 2, loc, "`{0}' is obsolete: `{1}'", member, oa.Message);
}
public void EmbedResources()
{
//
// Add Win32 resources
//
if (Compiler.Settings.Win32ResourceFile != null)
{
Builder.DefineUnmanagedResource(Compiler.Settings.Win32ResourceFile);
}
else
{
Builder.DefineVersionInfoResource(vi_product, vi_product_version, vi_company, vi_copyright, vi_trademark);
}
if (Compiler.Settings.Win32IconFile != null)
{
builder_extra.DefineWin32IconResource(Compiler.Settings.Win32IconFile);
}
if (Compiler.Settings.Resources != null)
{
if (Compiler.Settings.Target == Target.Module)
{
Report.Error(1507, "Cannot link resource file when building a module");
}
else
{
int counter = 0;
foreach (var res in Compiler.Settings.Resources)
{
if (!File.Exists(res.FileName))
{
Report.Error(1566, "Error reading resource file `{0}'", res.FileName);
continue;
}
if (res.IsEmbeded)
{
Stream stream;
if (counter++ < 10)
{
stream = File.OpenRead(res.FileName);
}
else
{
// TODO: SRE API requires resource stream to be available during AssemblyBuilder::Save
// we workaround it by reading everything into memory to compile projects with
// many embedded resource (over 3500) references
stream = new MemoryStream(File.ReadAllBytes(res.FileName));
}
module.Builder.DefineManifestResource(res.Name, stream, res.Attributes);
}
else
{
Builder.AddResourceFile(res.Name, Path.GetFileName(res.FileName), res.Attributes);
}
}
}
}
}
public void Resolve()
{
if (Compiler.Settings.Unsafe && module.PredefinedTypes.SecurityAction.Define())
{
//
// Emits [assembly: SecurityPermissionAttribute (SecurityAction.RequestMinimum, SkipVerification = true)]
// when -unsafe option was specified
//
Location loc = Location.Null;
MemberAccess system_security_permissions = new MemberAccess(new MemberAccess(
new QualifiedAliasMember(QualifiedAliasMember.GlobalAlias, "System", loc), "Security", loc), "Permissions", loc);
var req_min = module.PredefinedMembers.SecurityActionRequestMinimum.Resolve(loc);
Arguments pos = new Arguments(1);
pos.Add(new Argument(req_min.GetConstant(null)));
Arguments named = new Arguments(1);
named.Add(new NamedArgument("SkipVerification", loc, new BoolLiteral(Compiler.BuiltinTypes, true, loc)));
Attribute g = new Attribute("assembly",
new MemberAccess(system_security_permissions, "SecurityPermissionAttribute"),
new Arguments[] { pos, named }, loc, false);
g.AttachTo(module, module);
// Disable no-location warnings (e.g. obsolete) for compiler generated attribute
Compiler.Report.DisableReporting();
try {
var ctor = g.Resolve();
if (ctor != null)
{
g.ExtractSecurityPermissionSet(ctor, ref declarative_security);
}
} finally {
Compiler.Report.EnableReporting();
}
}
if (module.OptAttributes == null)
{
return;
}
// Ensure that we only have GlobalAttributes, since the Search isn't safe with other types.
if (!module.OptAttributes.CheckTargets())
{
return;
}
cls_attribute = module.ResolveAssemblyAttribute(module.PredefinedAttributes.CLSCompliant);
if (cls_attribute != null)
{
is_cls_compliant = cls_attribute.GetClsCompliantAttributeValue();
}
if (added_modules != null && Compiler.Settings.VerifyClsCompliance && is_cls_compliant)
{
foreach (var m in added_modules)
{
if (!m.IsCLSCompliant)
{
Report.Error(3013,
"Added modules must be marked with the CLSCompliant attribute to match the assembly",
m.Name);
}
}
}
Attribute a = module.ResolveAssemblyAttribute(module.PredefinedAttributes.RuntimeCompatibility);
if (a != null)
{
var val = a.GetNamedValue("WrapNonExceptionThrows") as BoolConstant;
if (val != null)
{
wrap_non_exception_throws = val.Value;
}
}
}
static void Error_664(Location loc, string type, string suffix)
{
Report.Error(664, loc,
"Literal of type double cannot be implicitly converted to type `{0}'. Add suffix `{1}' to create a literal of this type",
type, suffix);
}
public CompilerSettings ParseArguments (string[] args)
{
CompilerSettings settings = new CompilerSettings ();
List<string> response_file_list = null;
bool parsing_options = true;
stop_argument = false;
source_file_index = new Dictionary<string, int> ();
for (int i = 0; i < args.Length; i++) {
string arg = args[i];
if (arg.Length == 0)
continue;
if (arg[0] == '@') {
string[] extra_args;
string response_file = arg.Substring (1);
if (response_file_list == null)
response_file_list = new List<string> ();
if (response_file_list.Contains (response_file)) {
report.Error (1515, "Response file `{0}' specified multiple times", response_file);
return null;
}
response_file_list.Add (response_file);
extra_args = LoadArgs (response_file);
if (extra_args == null) {
report.Error (2011, "Unable to open response file: " + response_file);
return null;
}
args = AddArgs (args, extra_args);
continue;
}
if (parsing_options) {
if (arg == "--") {
parsing_options = false;
continue;
}
bool dash_opt = arg[0] == '-';
bool slash_opt = arg[0] == '/';
if (dash_opt) {
switch (ParseOptionUnix (arg, ref args, ref i, settings)) {
case ParseResult.Error:
case ParseResult.Success:
continue;
case ParseResult.Stop:
stop_argument = true;
return settings;
case ParseResult.UnknownOption:
if (UnknownOptionHandler != null) {
var ret = UnknownOptionHandler (args, i);
if (ret != -1) {
i = ret;
continue;
}
}
break;
}
}
if (dash_opt || slash_opt) {
// Try a -CSCOPTION
string csc_opt = dash_opt ? "/" + arg.Substring (1) : arg;
switch (ParseOption (csc_opt, ref args, settings)) {
case ParseResult.Error:
case ParseResult.Success:
continue;
case ParseResult.UnknownOption:
// Need to skip `/home/test.cs' however /test.cs is considered as error
if ((slash_opt && arg.Length > 3 && arg.IndexOf ('/', 2) > 0))
break;
if (UnknownOptionHandler != null) {
var ret = UnknownOptionHandler (args, i);
if (ret != -1) {
i = ret;
continue;
}
}
Error_WrongOption (arg);
return null;
case ParseResult.Stop:
stop_argument = true;
return settings;
}
}
}
ProcessSourceFiles (arg, false, settings.SourceFiles);
}
return settings;
}
public override void ApplyAttributeBuilder(Attribute a, CustomAttributeBuilder cb)
{
if (a.Type == TypeManager.in_attribute_type && ModFlags == Modifier.OUT)
{
Report.Error(36, a.Location, "An out parameter cannot have the `In' attribute");
return;
}
if (a.Type == TypeManager.param_array_type)
{
Report.Error(674, a.Location, "Do not use `System.ParamArrayAttribute'. Use the `params' keyword instead");
return;
}
if (a.Type == TypeManager.out_attribute_type && (ModFlags & Modifier.REF) == Modifier.REF &&
TypeManager.in_attribute_type != null && !OptAttributes.Contains(TypeManager.in_attribute_type))
{
Report.Error(662, a.Location,
"Cannot specify only `Out' attribute on a ref parameter. Use both `In' and `Out' attributes or neither");
return;
}
if (a.Type == TypeManager.cls_compliant_attribute_type)
{
Report.Warning(3022, 1, a.Location, "CLSCompliant attribute has no meaning when applied to parameters. Try putting it on the method instead");
}
// TypeManager.default_parameter_value_attribute_type is null if !NET_2_0, or if System.dll is not referenced
if (a.Type == TypeManager.default_parameter_value_attribute_type)
{
object val = a.GetParameterDefaultValue();
if (val != null)
{
Type t = val.GetType();
if (t.IsArray || TypeManager.IsSubclassOf(t, TypeManager.type_type))
{
if (parameter_type == TypeManager.object_type)
{
if (!t.IsArray)
{
t = TypeManager.type_type;
}
Report.Error(1910, a.Location, "Argument of type `{0}' is not applicable for the DefaultValue attribute",
TypeManager.CSharpName(t));
}
else
{
Report.Error(1909, a.Location, "The DefaultValue attribute is not applicable on parameters of type `{0}'",
TypeManager.CSharpName(parameter_type));;
}
return;
}
}
if (parameter_type == TypeManager.object_type ||
(val == null && !TypeManager.IsValueType(parameter_type)) ||
(val != null && TypeManager.TypeToCoreType(val.GetType()) == parameter_type))
{
builder.SetConstant(val);
}
else
{
Report.Error(1908, a.Location, "The type of the default value should match the type of the parameter");
}
return;
}
base.ApplyAttributeBuilder(a, cb);
}
protected virtual void ErrorDuplicateName(Parameter p)
{
Report.Error(100, p.Location, "The parameter name `{0}' is a duplicate", p.Name);
}
// TODO: rewrite this code (to kill N bugs and make it faster) and use standard ApplyAttribute way.
public AssemblyName GetAssemblyName(string name, string output)
{
if (OptAttributes != null)
{
foreach (Attribute a in OptAttributes.Attrs)
{
// cannot rely on any resolve-based members before you call Resolve
if (a.ExplicitTarget == null || a.ExplicitTarget != "assembly")
{
continue;
}
// TODO: This code is buggy: comparing Attribute name without resolving is wrong.
// However, this is invoked by CodeGen.Init, when none of the namespaces
// are loaded yet.
// TODO: Does not handle quoted attributes properly
switch (a.Name)
{
case "AssemblyKeyFile":
case "AssemblyKeyFileAttribute":
case "System.Reflection.AssemblyKeyFileAttribute":
if (RootContext.StrongNameKeyFile != null)
{
Report.SymbolRelatedToPreviousError(a.Location, a.GetSignatureForError());
Report.Warning(1616, 1, "Option `{0}' overrides attribute `{1}' given in a source file or added module",
"keyfile", "System.Reflection.AssemblyKeyFileAttribute");
}
else
{
string value = a.GetString();
if (value != null && value.Length != 0)
{
RootContext.StrongNameKeyFile = value;
}
}
break;
case "AssemblyKeyName":
case "AssemblyKeyNameAttribute":
case "System.Reflection.AssemblyKeyNameAttribute":
if (RootContext.StrongNameKeyContainer != null)
{
Report.SymbolRelatedToPreviousError(a.Location, a.GetSignatureForError());
Report.Warning(1616, 1, "Option `{0}' overrides attribute `{1}' given in a source file or added module",
"keycontainer", "System.Reflection.AssemblyKeyNameAttribute");
}
else
{
string value = a.GetString();
if (value != null && value.Length != 0)
{
RootContext.StrongNameKeyContainer = value;
}
}
break;
case "AssemblyDelaySign":
case "AssemblyDelaySignAttribute":
case "System.Reflection.AssemblyDelaySignAttribute":
RootContext.StrongNameDelaySign = a.GetBoolean();
break;
}
}
}
AssemblyName an = new AssemblyName();
an.Name = Path.GetFileNameWithoutExtension(name);
// note: delay doesn't apply when using a key container
if (RootContext.StrongNameKeyContainer != null)
{
an.KeyPair = new StrongNameKeyPair(RootContext.StrongNameKeyContainer);
return(an);
}
// strongname is optional
if (RootContext.StrongNameKeyFile == null)
{
return(an);
}
string AssemblyDir = Path.GetDirectoryName(output);
// the StrongName key file may be relative to (a) the compiled
// file or (b) to the output assembly. See bugzilla #55320
// http://bugzilla.ximian.com/show_bug.cgi?id=55320
// (a) relative to the compiled file
string filename = Path.GetFullPath(RootContext.StrongNameKeyFile);
bool exist = File.Exists(filename);
if ((!exist) && (AssemblyDir != null) && (AssemblyDir != String.Empty))
{
// (b) relative to the outputed assembly
filename = Path.GetFullPath(Path.Combine(AssemblyDir, RootContext.StrongNameKeyFile));
exist = File.Exists(filename);
}
if (exist)
{
using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read)) {
byte[] snkeypair = new byte [fs.Length];
fs.Read(snkeypair, 0, snkeypair.Length);
if (RootContext.StrongNameDelaySign)
{
// delayed signing - DO NOT include private key
SetPublicKey(an, snkeypair);
}
else
{
// no delay so we make sure we have the private key
try {
CryptoConvert.FromCapiPrivateKeyBlob(snkeypair);
an.KeyPair = new StrongNameKeyPair(snkeypair);
}
catch (CryptographicException) {
if (snkeypair.Length == 16)
{
// error # is different for ECMA key
Report.Error(1606, "Could not sign the assembly. " +
"ECMA key can only be used to delay-sign assemblies");
}
else
{
Error_AssemblySigning("The specified file `" + RootContext.StrongNameKeyFile + "' does not have a private key");
}
return(null);
}
}
}
}
else
{
Error_AssemblySigning("The specified file `" + RootContext.StrongNameKeyFile + "' does not exist");
return(null);
}
return(an);
}
/// <summary>
/// Verifies that any pending abstract methods or interface methods
/// were implemented.
/// </summary>
public bool VerifyPendingMethods(Report Report)
{
int top = pending_implementations.Length;
bool errors = false;
int i;
for (i = 0; i < top; i++){
TypeSpec type = pending_implementations [i].type;
int j = 0;
bool base_implements_type = type.IsInterface &&
container.BaseType != null &&
container.BaseType.ImplementsInterface (type);
foreach (var mi in pending_implementations [i].methods){
if (mi == null)
continue;
if (type.IsInterface){
var need_proxy =
pending_implementations [i].need_proxy [j];
if (need_proxy != null) {
DefineProxy (type, need_proxy, mi);
continue;
}
if (pending_implementations [i].optional)
continue;
MethodSpec candidate = null;
if (base_implements_type || BaseImplements (type, mi, out candidate))
continue;
if (candidate == null) {
MethodData md = pending_implementations [i].found [j];
if (md != null)
candidate = md.method.Spec;
}
Report.SymbolRelatedToPreviousError (mi);
if (candidate != null) {
Report.SymbolRelatedToPreviousError (candidate);
if (candidate.IsStatic) {
Report.Error (736, container.Location,
"`{0}' does not implement interface member `{1}' and the best implementing candidate `{2}' is static",
container.GetSignatureForError (), mi.GetSignatureForError (), TypeManager.CSharpSignature (candidate));
} else if ((candidate.Modifiers & Modifiers.PUBLIC) == 0) {
Report.Error (737, container.Location,
"`{0}' does not implement interface member `{1}' and the best implementing candidate `{2}' in not public",
container.GetSignatureForError (), mi.GetSignatureForError (), candidate.GetSignatureForError ());
} else {
Report.Error (738, container.Location,
"`{0}' does not implement interface member `{1}' and the best implementing candidate `{2}' return type `{3}' does not match interface member return type `{4}'",
container.GetSignatureForError (), mi.GetSignatureForError (), TypeManager.CSharpSignature (candidate),
TypeManager.CSharpName (candidate.ReturnType), TypeManager.CSharpName (mi.ReturnType));
}
} else {
Report.Error (535, container.Location, "`{0}' does not implement interface member `{1}'",
container.GetSignatureForError (), mi.GetSignatureForError ());
}
} else {
Report.SymbolRelatedToPreviousError (mi);
Report.Error (534, container.Location, "`{0}' does not implement inherited abstract member `{1}'",
container.GetSignatureForError (), mi.GetSignatureForError ());
}
errors = true;
j++;
}
}
return errors;
}
public void Parse (SourceFile file, ModuleContainer module, ParserSession session, Report report)
{
Stream input;
try {
input = File.OpenRead (file.Name);
} catch {
report.Error (2001, "Source file `{0}' could not be found", file.Name);
return;
}
// Check 'MZ' header
if (input.ReadByte () == 77 && input.ReadByte () == 90) {
report.Error (2015, "Source file `{0}' is a binary file and not a text file", file.Name);
input.Close ();
return;
}
input.Position = 0;
SeekableStreamReader reader = new SeekableStreamReader (input, ctx.Settings.Encoding, session.StreamReaderBuffer);
Parse (reader, file, module, session, report);
if (ctx.Settings.GenerateDebugInfo && report.Errors == 0 && !file.HasChecksum) {
input.Position = 0;
var checksum = session.GetChecksumAlgorithm ();
file.SetChecksum (checksum.ComputeHash (input));
}
reader.Dispose ();
input.Close ();
}
public void Save()
{
PortableExecutableKinds pekind = PortableExecutableKinds.ILOnly;
ImageFileMachine machine;
switch (Compiler.Settings.Platform)
{
case Platform.X86:
pekind |= PortableExecutableKinds.Required32Bit;
machine = ImageFileMachine.I386;
break;
case Platform.X64:
pekind |= PortableExecutableKinds.PE32Plus;
machine = ImageFileMachine.AMD64;
break;
case Platform.IA64:
machine = ImageFileMachine.IA64;
break;
case Platform.AnyCPU32Preferred:
#if STATIC
pekind |= PortableExecutableKinds.Preferred32Bit;
machine = ImageFileMachine.I386;
break;
#else
throw new NotSupportedException();
#endif
case Platform.Arm:
#if STATIC
machine = ImageFileMachine.ARM;
break;
#else
throw new NotSupportedException();
#endif
case Platform.AnyCPU:
default:
machine = ImageFileMachine.I386;
break;
}
Compiler.TimeReporter.Start(TimeReporter.TimerType.OutputSave);
try {
if (Compiler.Settings.Target == Target.Module)
{
SaveModule(pekind, machine);
}
else
{
Builder.Save(module.Builder.ScopeName, pekind, machine);
}
} catch (Exception e) {
Report.Error(16, "Could not write to file `" + name + "', cause: " + e.Message);
}
Compiler.TimeReporter.Stop(TimeReporter.TimerType.OutputSave);
// Save debug symbols file
if (symbol_writer != null && Compiler.Report.Errors == 0)
{
// TODO: it should run in parallel
Compiler.TimeReporter.Start(TimeReporter.TimerType.DebugSave);
var filename = file_name + ".mdb";
try {
// We mmap the file, so unlink the previous version since it may be in use
File.Delete(filename);
} catch {
// We can safely ignore
}
module.WriteDebugSymbol(symbol_writer);
using (FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.Write)) {
symbol_writer.CreateSymbolFile(module.Builder.ModuleVersionId, fs);
}
Compiler.TimeReporter.Stop(TimeReporter.TimerType.DebugSave);
}
}
protected override void ErrorDuplicateName (Parameter p, Report Report)
{
Report.Error (833, p.Location, "`{0}': An anonymous type cannot have multiple properties with the same name",
p.Name);
}
public static void Error_InvalidModifier(Location l, string name)
{
Report.Error(106, l, "The modifier `" + name + "' is not valid for this item");
}
public static string GetPackageFlags (string packages, Report report)
{
ProcessStartInfo pi = new ProcessStartInfo ();
pi.FileName = "pkg-config";
pi.RedirectStandardOutput = true;
pi.UseShellExecute = false;
pi.Arguments = "--libs " + packages;
Process p = null;
try {
p = Process.Start (pi);
} catch (Exception e) {
if (report == null)
throw;
report.Error (-27, "Couldn't run pkg-config: " + e.Message);
return null;
}
if (p.StandardOutput == null) {
if (report == null)
throw new ApplicationException ("Specified package did not return any information");
report.Warning (-27, 1, "Specified package did not return any information");
p.Close ();
return null;
}
string pkgout = p.StandardOutput.ReadToEnd ();
p.WaitForExit ();
if (p.ExitCode != 0) {
if (report == null)
throw new ApplicationException (pkgout);
report.Error (-27, "Error running pkg-config. Check the above output.");
p.Close ();
return null;
}
p.Close ();
return pkgout;
}
void EmitFieldSize(int buffer_size)
{
int type_size = BuiltinTypeSpec.GetSize(MemberType);
if (buffer_size > int.MaxValue / type_size)
{
Report.Error(1664, Location, "Fixed size buffer `{0}' of length `{1}' and type `{2}' exceeded 2^31 limit",
GetSignatureForError(), buffer_size.ToString(), MemberType.GetSignatureForError());
return;
}
AttributeEncoder encoder;
MethodSpec ctor;
var char_set = CharSetValue ?? Module.DefaultCharSet ?? 0;
#if STATIC
//
// Set struct layout without resolving StructLayoutAttribute which is not always available
//
TypeAttributes attribs = TypeAttributes.SequentialLayout;
switch (char_set)
{
case CharSet.None:
case CharSet.Ansi:
attribs |= TypeAttributes.AnsiClass;
break;
case CharSet.Auto:
attribs |= TypeAttributes.AutoClass;
break;
case CharSet.Unicode:
attribs |= TypeAttributes.UnicodeClass;
break;
}
fixed_buffer_type.__SetAttributes(fixed_buffer_type.Attributes | attribs);
fixed_buffer_type.__SetLayout(0, buffer_size * type_size);
#else
ctor = Module.PredefinedMembers.StructLayoutAttributeCtor.Resolve(Location);
if (ctor == null)
{
return;
}
var field_size = Module.PredefinedMembers.StructLayoutSize.Resolve(Location);
var field_charset = Module.PredefinedMembers.StructLayoutCharSet.Resolve(Location);
if (field_size == null || field_charset == null)
{
return;
}
encoder = new AttributeEncoder();
encoder.Encode((short)LayoutKind.Sequential);
encoder.EncodeNamedArguments(
new [] { field_size, field_charset },
new Constant [] {
new IntConstant(Compiler.BuiltinTypes, buffer_size * type_size, Location),
new IntConstant(Compiler.BuiltinTypes, (int)char_set, Location)
}
);
fixed_buffer_type.SetCustomAttribute((ConstructorInfo)ctor.GetMetaInfo(), encoder.ToArray());
#endif
//
// Don't emit FixedBufferAttribute attribute for private types
//
if ((ModFlags & Modifiers.PRIVATE) != 0)
{
return;
}
ctor = Module.PredefinedMembers.FixedBufferAttributeCtor.Resolve(Location);
if (ctor == null)
{
return;
}
encoder = new AttributeEncoder();
encoder.EncodeTypeName(MemberType);
encoder.Encode(buffer_size);
encoder.EncodeEmptyNamedArguments();
FieldBuilder.SetCustomAttribute((ConstructorInfo)ctor.GetMetaInfo(), encoder.ToArray());
}
public static void Error_GlobalNamespaceRedefined (Location loc, Report Report)
{
Report.Error (1681, loc, "You cannot redefine the global extern alias");
}
protected override bool DoDefineMembers()
{
PredefinedType builder_type;
PredefinedMember <MethodSpec> bf;
PredefinedMember <MethodSpec> bs;
PredefinedMember <MethodSpec> sr;
PredefinedMember <MethodSpec> se;
PredefinedMember <MethodSpec> sm;
bool has_task_return_type = false;
var pred_members = Module.PredefinedMembers;
if (return_type.Kind == MemberKind.Void)
{
builder_type = Module.PredefinedTypes.AsyncVoidMethodBuilder;
bf = pred_members.AsyncVoidMethodBuilderCreate;
bs = pred_members.AsyncVoidMethodBuilderStart;
sr = pred_members.AsyncVoidMethodBuilderSetResult;
se = pred_members.AsyncVoidMethodBuilderSetException;
sm = pred_members.AsyncVoidMethodBuilderSetStateMachine;
}
else if (return_type == Module.PredefinedTypes.Task.TypeSpec)
{
builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilder;
bf = pred_members.AsyncTaskMethodBuilderCreate;
bs = pred_members.AsyncTaskMethodBuilderStart;
sr = pred_members.AsyncTaskMethodBuilderSetResult;
se = pred_members.AsyncTaskMethodBuilderSetException;
sm = pred_members.AsyncTaskMethodBuilderSetStateMachine;
task = pred_members.AsyncTaskMethodBuilderTask.Get();
}
else
{
builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilderGeneric;
bf = pred_members.AsyncTaskMethodBuilderGenericCreate;
bs = pred_members.AsyncTaskMethodBuilderGenericStart;
sr = pred_members.AsyncTaskMethodBuilderGenericSetResult;
se = pred_members.AsyncTaskMethodBuilderGenericSetException;
sm = pred_members.AsyncTaskMethodBuilderGenericSetStateMachine;
task = pred_members.AsyncTaskMethodBuilderGenericTask.Get();
has_task_return_type = true;
}
set_result = sr.Get();
set_exception = se.Get();
builder_factory = bf.Get();
builder_start = bs.Get();
var istate_machine = Module.PredefinedTypes.IAsyncStateMachine;
var set_statemachine = sm.Get();
if (!builder_type.Define() || !istate_machine.Define() || set_result == null || builder_factory == null ||
set_exception == null || set_statemachine == null || builder_start == null ||
!Module.PredefinedTypes.INotifyCompletion.Define())
{
Report.Error(1993, Location,
"Cannot find compiler required types for asynchronous functions support. Are you targeting the wrong framework version?");
return(base.DoDefineMembers());
}
var bt = builder_type.TypeSpec;
//
// Inflate generic Task types
//
if (has_task_return_type)
{
var task_return_type = return_type.TypeArguments;
if (mutator != null)
{
task_return_type = mutator.Mutate(task_return_type);
}
bt = bt.MakeGenericType(Module, task_return_type);
set_result = MemberCache.GetMember(bt, set_result);
set_exception = MemberCache.GetMember(bt, set_exception);
set_statemachine = MemberCache.GetMember(bt, set_statemachine);
if (task != null)
{
task = MemberCache.GetMember(bt, task);
}
}
builder = AddCompilerGeneratedField("$builder", new TypeExpression(bt, Location));
var set_state_machine = new Method(this, new TypeExpression(Compiler.BuiltinTypes.Void, Location),
Modifiers.COMPILER_GENERATED | Modifiers.DEBUGGER_HIDDEN | Modifiers.PUBLIC,
new MemberName("SetStateMachine"),
ParametersCompiled.CreateFullyResolved(
new Parameter(new TypeExpression(istate_machine.TypeSpec, Location), "stateMachine", Parameter.Modifier.NONE, null, Location),
istate_machine.TypeSpec),
null);
ToplevelBlock block = new ToplevelBlock(Compiler, set_state_machine.ParameterInfo, Location);
block.IsCompilerGenerated = true;
set_state_machine.Block = block;
Members.Add(set_state_machine);
if (!base.DoDefineMembers())
{
return(false);
}
//
// Fabricates SetStateMachine method
//
// public void SetStateMachine (IAsyncStateMachine stateMachine)
// {
// $builder.SetStateMachine (stateMachine);
// }
//
var mg = MethodGroupExpr.CreatePredefined(set_statemachine, bt, Location);
mg.InstanceExpression = new FieldExpr(builder, Location);
var param_reference = block.GetParameterReference(0, Location);
param_reference.Type = istate_machine.TypeSpec;
param_reference.eclass = ExprClass.Variable;
var args = new Arguments(1);
args.Add(new Argument(param_reference));
set_state_machine.Block.AddStatement(new StatementExpression(new Invocation(mg, args)));
if (has_task_return_type)
{
hoisted_return = LocalVariable.CreateCompilerGenerated(bt.TypeArguments[0], StateMachineMethod.Block, Location);
}
return(true);
}
public void AddUsingExternalAlias (string alias, Location loc, Report Report)
{
// TODO: Do this in parser
bool not_first = using_clauses != null || DeclarationFound;
if (using_aliases != null && !not_first) {
foreach (UsingAliasEntry uae in using_aliases) {
if (uae is LocalUsingAliasEntry) {
not_first = true;
break;
}
}
}
if (not_first)
Report.Error (439, loc, "An extern alias declaration must precede all other elements");
if (alias == "global") {
Error_GlobalNamespaceRedefined (loc, Report);
return;
}
AddUsingAlias (new UsingAliasEntry (alias, loc));
}
private FullNamedExpression Lookup(DeclSpace ds, string name, Location loc, bool ignore_cs0104)
{
//
// Check whether it's in the namespace.
//
FullNamedExpression fne = ns.Lookup(ds, name, loc);
//
// Check aliases.
//
if (using_aliases != null)
{
foreach (UsingAliasEntry ue in using_aliases)
{
if (ue.Alias == name)
{
if (fne != null)
{
if (Doppelganger != null)
{
// TODO: Namespace has broken location
//Report.SymbolRelatedToPreviousError (fne.Location, null);
Report.SymbolRelatedToPreviousError(ue.Location, null);
Report.Error(576, loc,
"Namespace `{0}' contains a definition with same name as alias `{1}'",
GetSignatureForError(), name);
}
else
{
return(fne);
}
}
return(ue.Resolve(Doppelganger));
}
}
}
if (fne != null)
{
return(fne);
}
if (IsImplicit)
{
return(null);
}
//
// Check using entries.
//
FullNamedExpression match = null;
foreach (Namespace using_ns in GetUsingTable())
{
match = using_ns.Lookup(ds, name, loc);
if (match == null || !(match is TypeExpr))
{
continue;
}
if (fne != null)
{
if (!ignore_cs0104)
{
Error_AmbiguousTypeReference(loc, name, fne, match);
}
return(null);
}
fne = match;
}
return(fne);
}
bool CheckReachableExit (Report report)
{
if (block.HasReachableClosingBrace && ReturnType.Kind != MemberKind.Void) {
// FIXME: Flow-analysis on MoveNext generated code
if (!IsIterator) {
report.Error (1643, StartLocation,
"Not all code paths return a value in anonymous method of type `{0}'", GetSignatureForError ());
return false;
}
}
return true;
}
public static void Error_GlobalNamespaceRedefined(Location loc)
{
Report.Error(1681, loc, "You cannot redefine the global extern alias");
}
public static void Error1599 (Location loc, TypeSpec t, Report Report)
{
Report.Error (1599, loc, "Method or delegate cannot return type `{0}'", t.GetSignatureForError ());
}
public override void Error_NamespaceDoesNotExist(DeclSpace ds, Location loc, string name)
{
Report.Error(400, loc, "The type or namespace name `{0}' could not be found in the global namespace (are you missing an assembly reference?)",
name);
}
protected virtual void ErrorDuplicateName (Parameter p, Report Report)
{
Report.Error (100, p.Location, "The parameter name `{0}' is a duplicate", p.Name);
}
public static void Error_InvalidNumberOfTypeArguments(Type t, Location loc)
{
Report.SymbolRelatedToPreviousError(t);
Report.Error(305, loc, "Using the generic type `{0}' requires `{1}' type argument(s)",
TypeManager.CSharpName(t), TypeManager.GetNumberOfTypeArguments(t).ToString());
}
static void Error_InvalidModifier (Modifiers mod, Location l, Report Report)
{
Report.Error (106, l, "The modifier `{0}' is not valid for this item",
Name (mod));
}
static void Error_TypeArgumentsCannotBeUsed(Location loc, string type, string name)
{
Report.Error(308, loc, "The non-generic {0} `{1}' cannot be used with the type arguments",
type, name);
}
static public void Save (string name, bool saveDebugInfo, Report Report)
{
PortableExecutableKinds pekind;
ImageFileMachine machine;
switch (RootContext.Platform) {
case Platform.X86:
pekind = PortableExecutableKinds.Required32Bit;
machine = ImageFileMachine.I386;
break;
case Platform.X64:
pekind = PortableExecutableKinds.PE32Plus;
machine = ImageFileMachine.AMD64;
break;
case Platform.IA64:
pekind = PortableExecutableKinds.PE32Plus;
machine = ImageFileMachine.IA64;
break;
case Platform.AnyCPU:
default:
pekind = PortableExecutableKinds.ILOnly;
machine = ImageFileMachine.I386;
break;
}
try {
Assembly.Builder.Save (Basename (name), pekind, machine);
}
catch (COMException) {
if ((RootContext.StrongNameKeyFile == null) || (!RootContext.StrongNameDelaySign))
throw;
// FIXME: it seems Microsoft AssemblyBuilder doesn't like to delay sign assemblies
Report.Error (1548, "Couldn't delay-sign the assembly with the '" +
RootContext.StrongNameKeyFile +
"', Use MCS with the Mono runtime or CSC to compile this assembly.");
}
catch (System.IO.IOException io) {
Report.Error (16, "Could not write to file `"+name+"', cause: " + io.Message);
return;
}
catch (System.UnauthorizedAccessException ua) {
Report.Error (16, "Could not write to file `"+name+"', cause: " + ua.Message);
return;
}
catch (System.NotImplementedException nie) {
Report.RuntimeMissingSupport (Location.Null, nie.Message);
return;
}
//
// Write debuger symbol file
//
if (saveDebugInfo)
SymbolWriter.WriteSymbolFile ();
}
public void Error_UnderlyingType(Location loc)
{
Report.Error(1008, loc,
"Type byte, sbyte, short, ushort, int, uint, long or ulong expected");
}
public virtual void Error_FinallyClause (Report Report)
{
Report.Error (157, loc, "Control cannot leave the body of a finally clause");
}
protected override bool DoDefineMembers()
{
action = Module.PredefinedTypes.Action.Resolve();
PredefinedType builder_type;
PredefinedMember <MethodSpec> bf;
PredefinedMember <MethodSpec> sr;
PredefinedMember <MethodSpec> se;
bool has_task_return_type = false;
var pred_members = Module.PredefinedMembers;
if (return_type.Kind == MemberKind.Void)
{
builder_type = Module.PredefinedTypes.AsyncVoidMethodBuilder;
bf = pred_members.AsyncVoidMethodBuilderCreate;
sr = pred_members.AsyncVoidMethodBuilderSetResult;
se = pred_members.AsyncVoidMethodBuilderSetException;
}
else if (return_type == Module.PredefinedTypes.Task.TypeSpec)
{
builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilder;
bf = pred_members.AsyncTaskMethodBuilderCreate;
sr = pred_members.AsyncTaskMethodBuilderSetResult;
se = pred_members.AsyncTaskMethodBuilderSetException;
task = pred_members.AsyncTaskMethodBuilderTask.Get();
}
else
{
builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilderGeneric;
bf = pred_members.AsyncTaskMethodBuilderGenericCreate;
sr = pred_members.AsyncTaskMethodBuilderGenericSetResult;
se = pred_members.AsyncTaskMethodBuilderGenericSetException;
task = pred_members.AsyncTaskMethodBuilderGenericTask.Get();
has_task_return_type = true;
}
set_result = sr.Get();
set_exception = se.Get();
var builder_factory = bf.Get();
if (!builder_type.Define() || set_result == null || builder_factory == null || set_exception == null)
{
Report.Error(1993, Location,
"Cannot find compiler required types for asynchronous functions support. Are you targeting the wrong framework version?");
return(base.DoDefineMembers());
}
var bt = builder_type.TypeSpec;
//
// Inflate generic Task types
//
if (has_task_return_type)
{
var task_return_type = return_type.TypeArguments;
if (mutator != null)
{
task_return_type = mutator.Mutate(task_return_type);
}
bt = bt.MakeGenericType(Module, task_return_type);
builder_factory = MemberCache.GetMember <MethodSpec> (bt, builder_factory);
set_result = MemberCache.GetMember <MethodSpec> (bt, set_result);
set_exception = MemberCache.GetMember <MethodSpec> (bt, set_exception);
if (task != null)
{
task = MemberCache.GetMember <PropertySpec> (bt, task);
}
}
builder = AddCompilerGeneratedField("$builder", new TypeExpression(bt, Location));
if (!base.DoDefineMembers())
{
return(false);
}
var block = instance_constructors[0].Block;
var mg = MethodGroupExpr.CreatePredefined(builder_factory, bt, Location);
block.AddStatement(
new StatementExpression(new SimpleAssign(
new FieldExpr(builder, Location),
new Invocation(mg, new Arguments(0)),
Location)));
if (has_task_return_type)
{
hoisted_return = LocalVariable.CreateCompilerGenerated(bt.TypeArguments[0], block, Location);
}
return(true);
}
public static void Error_1008 (Location loc, Report Report)
{
Report.Error (1008, loc,
"Type byte, sbyte, short, ushort, int, uint, long or ulong expected");
}
public void Error_DuplicateName(Report r)
{
r.Error(100, Location, "The parameter name `{0}' is a duplicate", Name);
}
public static void Error_UnknownLabel (Location loc, string label, Report Report)
{
Report.Error(159, loc, "The label `{0}:' could not be found within the scope of the goto statement",
label);
}
public static void Error_1008(Location loc, Report Report)
{
Report.Error(1008, loc,
"Type byte, sbyte, short, ushort, int, uint, long or ulong expected");
}
public static void Error_InvalidConstantType (TypeSpec t, Location loc, Report Report)
{
if (t.IsGenericParameter) {
Report.Error (1959, loc,
"Type parameter `{0}' cannot be declared const", t.GetSignatureForError ());
} else {
Report.Error (283, loc,
"The type `{0}' cannot be declared const", t.GetSignatureForError ());
}
}
public static void Error_VariableOfStaticClass(Location loc, string variable_name, TypeSpec static_class, Report Report)
{
Report.SymbolRelatedToPreviousError(static_class);
Report.Error(723, loc, "`{0}': cannot declare variables of static types",
variable_name);
}
public bool Define (DeclSpace parent, string method_full_name, Report Report)
{
TypeContainer container = parent.PartialContainer;
PendingImplementation pending = container.PendingImplementations;
if (pending != null){
implementing = pending.IsInterfaceMethod (method.MethodName, member.InterfaceType, this);
if (member.InterfaceType != null){
if (implementing == null){
if (member is PropertyBase) {
Report.Error (550, method.Location, "`{0}' is an accessor not found in interface member `{1}{2}'",
method.GetSignatureForError (), TypeManager.CSharpName (member.InterfaceType),
member.GetSignatureForError ().Substring (member.GetSignatureForError ().LastIndexOf ('.')));
} else {
Report.Error (539, method.Location,
"`{0}.{1}' in explicit interface declaration is not a member of interface",
TypeManager.CSharpName (member.InterfaceType), member.ShortName);
}
return false;
}
if (implementing.IsAccessor && !(method is AbstractPropertyEventMethod)) {
Report.SymbolRelatedToPreviousError (implementing);
Report.Error (683, method.Location, "`{0}' explicit method implementation cannot implement `{1}' because it is an accessor",
member.GetSignatureForError (), TypeManager.CSharpSignature (implementing));
return false;
}
} else {
if (implementing != null) {
AbstractPropertyEventMethod prop_method = method as AbstractPropertyEventMethod;
if (prop_method == null) {
if (implementing.IsAccessor) {
Report.SymbolRelatedToPreviousError (implementing);
Report.Error (470, method.Location, "Method `{0}' cannot implement interface accessor `{1}'",
method.GetSignatureForError (), TypeManager.CSharpSignature (implementing));
}
} else if (implementing.DeclaringType.IsInterface) {
if (!implementing.IsAccessor) {
Report.SymbolRelatedToPreviousError (implementing);
Report.Error (686, method.Location, "Accessor `{0}' cannot implement interface member `{1}' for type `{2}'. Use an explicit interface implementation",
method.GetSignatureForError (), TypeManager.CSharpSignature (implementing), container.GetSignatureForError ());
} else {
PropertyBase.PropertyMethod pm = prop_method as PropertyBase.PropertyMethod;
if (pm != null && pm.HasCustomAccessModifier && (pm.ModFlags & Modifiers.PUBLIC) == 0) {
Report.SymbolRelatedToPreviousError (implementing);
Report.Error (277, method.Location, "Accessor `{0}' must be declared public to implement interface member `{1}'",
method.GetSignatureForError (), implementing.GetSignatureForError ());
}
}
}
}
}
}
//
// For implicit implementations, make sure we are public, for
// explicit implementations, make sure we are private.
//
if (implementing != null){
//
// Setting null inside this block will trigger a more
// verbose error reporting for missing interface implementations
//
// The "candidate" function has been flagged already
// but it wont get cleared
//
if (member.IsExplicitImpl){
if (method.ParameterInfo.HasParams && !implementing.Parameters.HasParams) {
Report.SymbolRelatedToPreviousError (implementing);
Report.Error (466, method.Location, "`{0}': the explicit interface implementation cannot introduce the params modifier",
method.GetSignatureForError ());
}
} else {
if (implementing.DeclaringType.IsInterface) {
//
// If this is an interface method implementation,
// check for public accessibility
//
if ((flags & MethodAttributes.MemberAccessMask) != MethodAttributes.Public)
{
implementing = null;
}
} else if ((flags & MethodAttributes.MemberAccessMask) == MethodAttributes.Private){
// We may never be private.
implementing = null;
} else if ((modifiers & Modifiers.OVERRIDE) == 0){
//
// We may be protected if we're overriding something.
//
implementing = null;
}
}
//
// Static is not allowed
//
if ((modifiers & Modifiers.STATIC) != 0){
implementing = null;
}
}
//
// If implementing is still valid, set flags
//
if (implementing != null){
//
// When implementing interface methods, set NewSlot
// unless, we are overwriting a method.
//
if (implementing.DeclaringType.IsInterface){
if ((modifiers & Modifiers.OVERRIDE) == 0)
flags |= MethodAttributes.NewSlot;
}
flags |= MethodAttributes.Virtual | MethodAttributes.HideBySig;
// Set Final unless we're virtual, abstract or already overriding a method.
if ((modifiers & (Modifiers.VIRTUAL | Modifiers.ABSTRACT | Modifiers.OVERRIDE)) == 0)
flags |= MethodAttributes.Final;
//
// clear the pending implementation flag (requires explicit methods to be defined first)
//
parent.PartialContainer.PendingImplementations.ImplementMethod (method.MethodName,
member.InterfaceType, this, member.IsExplicitImpl);
//
// Update indexer accessor name to match implementing abstract accessor
//
if (!implementing.DeclaringType.IsInterface && !member.IsExplicitImpl && implementing.IsAccessor)
method_full_name = implementing.MemberDefinition.Name;
}
DefineMethodBuilder (container, method_full_name, method.ParameterInfo);
if (builder == null)
return false;
// if (container.CurrentType != null)
// declaring_type = container.CurrentType;
// else
declaring_type = container.Definition;
if (implementing != null && member.IsExplicitImpl) {
container.TypeBuilder.DefineMethodOverride (builder, (MethodInfo) implementing.GetMetaInfo ());
}
return true;
}
void EmitFieldSize(int buffer_size)
{
int type_size = BuiltinTypeSpec.GetSize(MemberType);
if (buffer_size > int.MaxValue / type_size)
{
Report.Error(1664, Location, "Fixed size buffer `{0}' of length `{1}' and type `{2}' exceeded 2^31 limit",
GetSignatureForError(), buffer_size.ToString(), TypeManager.CSharpName(MemberType));
return;
}
AttributeEncoder encoder;
var ctor = Module.PredefinedMembers.StructLayoutAttributeCtor.Resolve(Location);
if (ctor == null)
{
return;
}
var field_size = Module.PredefinedMembers.StructLayoutSize.Resolve(Location);
var field_charset = Module.PredefinedMembers.StructLayoutCharSet.Resolve(Location);
if (field_size == null || field_charset == null)
{
return;
}
var char_set = CharSet ?? Module.DefaultCharSet ?? 0;
encoder = new AttributeEncoder();
encoder.Encode((short)LayoutKind.Sequential);
encoder.EncodeNamedArguments(
new [] { field_size, field_charset },
new Constant [] {
new IntConstant(Compiler.BuiltinTypes, buffer_size * type_size, Location),
new IntConstant(Compiler.BuiltinTypes, (int)char_set, Location)
}
);
fixed_buffer_type.SetCustomAttribute((ConstructorInfo)ctor.GetMetaInfo(), encoder.ToArray());
//
// Don't emit FixedBufferAttribute attribute for private types
//
if ((ModFlags & Modifiers.PRIVATE) != 0)
{
return;
}
ctor = Module.PredefinedMembers.FixedBufferAttributeCtor.Resolve(Location);
if (ctor == null)
{
return;
}
encoder = new AttributeEncoder();
encoder.EncodeTypeName(MemberType);
encoder.Encode(buffer_size);
encoder.EncodeEmptyNamedArguments();
FieldBuilder.SetCustomAttribute((ConstructorInfo)ctor.GetMetaInfo(), encoder.ToArray());
}
public static void Error_NamespaceNotFound (Location loc, string name, Report Report)
{
Report.Error (246, loc, "The type or namespace name `{0}' could not be found. Are you missing a using directive or an assembly reference?",
name);
switch (name) {
case "Gtk": case "GtkSharp":
MsgtryPkg ("gtk-sharp");
break;
case "Gdk": case "GdkSharp":
MsgtryPkg ("gdk-sharp");
break;
case "Glade": case "GladeSharp":
MsgtryPkg ("glade-sharp");
break;
case "System.Drawing":
case "System.Web.Services":
case "System.Web":
case "System.Data":
case "System.Windows.Forms":
MsgtryRef (name);
break;
}
}
static void Error_InvalidModifier(Modifiers mod, Location l, Report Report)
{
Report.Error(106, l, "The modifier `{0}' is not valid for this item",
Name(mod));
}
public virtual void Error_NamespaceDoesNotExist (Location loc, string name, Report Report)
{
if (name.IndexOf ('`') > 0) {
FullNamedExpression retval = Lookup (RootContext.ToplevelTypes.Compiler, SimpleName.RemoveGenericArity (name), loc);
if (retval != null) {
Error_TypeArgumentsCannotBeUsed (retval, loc);
return;
}
} else {
Type t = LookForAnyGenericType (name);
if (t != null) {
Error_InvalidNumberOfTypeArguments (t, loc);
return;
}
}
Report.Error (234, loc, "The type or namespace name `{0}' does not exist in the namespace `{1}'. Are you missing an assembly reference?",
name, GetSignatureForError ());
}
protected override bool DoDefineMembers()
{
var builtin_types = Compiler.BuiltinTypes;
var ctor_parameters = ParametersCompiled.CreateFullyResolved(
new [] {
new Parameter(new TypeExpression(builtin_types.Object, Location), "object", Parameter.Modifier.NONE, null, Location),
new Parameter(new TypeExpression(builtin_types.IntPtr, Location), "method", Parameter.Modifier.NONE, null, Location)
},
new [] {
builtin_types.Object,
builtin_types.IntPtr
}
);
Constructor = new Constructor(this, Constructor.ConstructorName,
Modifiers.PUBLIC, null, ctor_parameters, null, Location);
Constructor.Define();
//
// Here the various methods like Invoke, BeginInvoke etc are defined
//
// First, call the `out of band' special method for
// defining recursively any types we need:
//
var p = parameters;
if (!p.Resolve(this))
{
return(false);
}
//
// Invoke method
//
// Check accessibility
foreach (var partype in p.Types)
{
if (!IsAccessibleAs(partype))
{
Report.SymbolRelatedToPreviousError(partype);
Report.Error(59, Location,
"Inconsistent accessibility: parameter type `{0}' is less accessible than delegate `{1}'",
TypeManager.CSharpName(partype), GetSignatureForError());
}
}
var ret_type = ReturnType.ResolveAsType(this);
if (ret_type == null)
{
return(false);
}
//
// We don't have to check any others because they are all
// guaranteed to be accessible - they are standard types.
//
if (!IsAccessibleAs(ret_type))
{
Report.SymbolRelatedToPreviousError(ret_type);
Report.Error(58, Location,
"Inconsistent accessibility: return type `" +
TypeManager.CSharpName(ret_type) + "' is less " +
"accessible than delegate `" + GetSignatureForError() + "'");
return(false);
}
CheckProtectedModifier();
if (Compiler.Settings.StdLib && ret_type.IsSpecialRuntimeType)
{
Method.Error1599(Location, ret_type, Report);
return(false);
}
TypeManager.CheckTypeVariance(ret_type, Variance.Covariant, this);
InvokeBuilder = new Method(this, null, ReturnType, MethodModifiers, new MemberName(InvokeMethodName), p, null);
InvokeBuilder.Define();
//
// Don't emit async method for compiler generated delegates (e.g. dynamic site containers)
//
if (!IsCompilerGenerated)
{
DefineAsyncMethods(Parameters.CallingConvention);
}
return(true);
}
public static void Error1599 (Location loc, TypeSpec t, Report Report)
{
Report.Error (1599, loc, "Method or delegate cannot return type `{0}'", TypeManager.CSharpName (t));
}
public override void Error_FinallyClause(Report Report)
{
Report.Error(1625, loc, "Cannot yield in the body of a finally clause");
}
public static void CheckUnsafeOption(Location loc, Report Report)
{
if (!Unsafe) {
Report.Error (227, loc,
"Unsafe code requires the `unsafe' command line option to be specified");
}
}
void SetEntryPoint()
{
if (!Compiler.Settings.NeedsEntryPoint)
{
if (Compiler.Settings.MainClass != null)
{
Report.Error(2017, "Cannot specify -main if building a module or library");
}
return;
}
PEFileKinds file_kind;
switch (Compiler.Settings.Target)
{
case Target.Library:
case Target.Module:
file_kind = PEFileKinds.Dll;
break;
case Target.WinExe:
file_kind = PEFileKinds.WindowApplication;
break;
default:
file_kind = PEFileKinds.ConsoleApplication;
break;
}
if (entry_point == null)
{
string main_class = Compiler.Settings.MainClass;
if (main_class != null)
{
// TODO: Handle dotted names
var texpr = module.GlobalRootNamespace.LookupType(module, main_class, 0, LookupMode.Probing, Location.Null);
if (texpr == null)
{
Report.Error(1555, "Could not find `{0}' specified for Main method", main_class);
return;
}
var mtype = texpr.Type.MemberDefinition as ClassOrStruct;
if (mtype == null)
{
Report.Error(1556, "`{0}' specified for Main method must be a valid class or struct", main_class);
return;
}
Report.Error(1558, mtype.Location, "`{0}' does not have a suitable static Main method", mtype.GetSignatureForError());
}
else
{
string pname = file_name == null ? name : Path.GetFileName(file_name);
Report.Error(5001, "Program `{0}' does not contain a static `Main' method suitable for an entry point",
pname);
}
return;
}
Builder.SetEntryPoint(entry_point.MethodBuilder, file_kind);
}
public void Error_DuplicateName (Report r)
{
r.Error (100, Location, "The parameter name `{0}' is a duplicate", Name);
}
void Error_AssemblySigning(string text)
{
Report.Error(1548, "Error during assembly signing. " + text);
}
public override void Error_FinallyClause(Report Report)
{
Report.Error (1625, loc, "Cannot yield in the body of a finally clause");
}
public void ApplyAttributeBuilder(Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
{
if (a.IsValidSecurityAttribute())
{
a.ExtractSecurityPermissionSet(ctor, ref declarative_security);
return;
}
if (a.Type == pa.AssemblyCulture)
{
string value = a.GetString();
if (value == null || value.Length == 0)
{
return;
}
if (Compiler.Settings.Target == Target.Exe)
{
a.Error_AttributeEmitError("The executables cannot be satelite assemblies, remove the attribute or keep it empty");
return;
}
if (value == "neutral")
{
value = "";
}
if (Compiler.Settings.Target == Target.Module)
{
SetCustomAttribute(ctor, cdata);
}
else
{
builder_extra.SetCulture(value, a.Location);
}
IsSatelliteAssembly = true;
return;
}
if (a.Type == pa.AssemblyVersion)
{
string value = a.GetString();
if (value == null || value.Length == 0)
{
return;
}
var vinfo = IsValidAssemblyVersion(value, true);
if (vinfo == null)
{
a.Error_AttributeEmitError(string.Format("Specified version `{0}' is not valid", value));
return;
}
if (Compiler.Settings.Target == Target.Module)
{
SetCustomAttribute(ctor, cdata);
}
else
{
builder_extra.SetVersion(vinfo, a.Location);
}
return;
}
if (a.Type == pa.AssemblyAlgorithmId)
{
const int pos = 2; // skip CA header
uint alg = (uint)cdata [pos];
alg |= ((uint)cdata [pos + 1]) << 8;
alg |= ((uint)cdata [pos + 2]) << 16;
alg |= ((uint)cdata [pos + 3]) << 24;
if (Compiler.Settings.Target == Target.Module)
{
SetCustomAttribute(ctor, cdata);
}
else
{
builder_extra.SetAlgorithmId(alg, a.Location);
}
return;
}
if (a.Type == pa.AssemblyFlags)
{
const int pos = 2; // skip CA header
uint flags = (uint)cdata[pos];
flags |= ((uint)cdata [pos + 1]) << 8;
flags |= ((uint)cdata [pos + 2]) << 16;
flags |= ((uint)cdata [pos + 3]) << 24;
// Ignore set PublicKey flag if assembly is not strongnamed
if ((flags & (uint)AssemblyNameFlags.PublicKey) != 0 && public_key == null)
{
flags &= ~(uint)AssemblyNameFlags.PublicKey;
}
if (Compiler.Settings.Target == Target.Module)
{
SetCustomAttribute(ctor, cdata);
}
else
{
builder_extra.SetFlags(flags, a.Location);
}
return;
}
if (a.Type == pa.TypeForwarder)
{
TypeSpec t = a.GetArgumentType();
if (t == null || TypeManager.HasElementType(t))
{
Report.Error(735, a.Location, "Invalid type specified as an argument for TypeForwardedTo attribute");
return;
}
if (emitted_forwarders == null)
{
emitted_forwarders = new Dictionary <ITypeDefinition, Attribute> ();
}
else if (emitted_forwarders.ContainsKey(t.MemberDefinition))
{
Report.SymbolRelatedToPreviousError(emitted_forwarders[t.MemberDefinition].Location, null);
Report.Error(739, a.Location, "A duplicate type forward of type `{0}'",
t.GetSignatureForError());
return;
}
emitted_forwarders.Add(t.MemberDefinition, a);
if (t.MemberDefinition.DeclaringAssembly == this)
{
Report.SymbolRelatedToPreviousError(t);
Report.Error(729, a.Location, "Cannot forward type `{0}' because it is defined in this assembly",
t.GetSignatureForError());
return;
}
if (t.IsNested)
{
Report.Error(730, a.Location, "Cannot forward type `{0}' because it is a nested type",
t.GetSignatureForError());
return;
}
builder_extra.AddTypeForwarder(t.GetDefinition(), a.Location);
return;
}
if (a.Type == pa.Extension)
{
a.Error_MisusedExtensionAttribute();
return;
}
if (a.Type == pa.InternalsVisibleTo)
{
string assembly_name = a.GetString();
if (assembly_name.Length == 0)
{
return;
}
#if STATIC
ParsedAssemblyName aname;
ParseAssemblyResult r = Fusion.ParseAssemblyName(assembly_name, out aname);
if (r != ParseAssemblyResult.OK)
{
Report.Warning(1700, 3, a.Location, "Assembly reference `{0}' is invalid and cannot be resolved",
assembly_name);
return;
}
if (aname.Version != null || aname.Culture != null || aname.ProcessorArchitecture != ProcessorArchitecture.None)
{
Report.Error(1725, a.Location,
"Friend assembly reference `{0}' is invalid. InternalsVisibleTo declarations cannot have a version, culture or processor architecture specified",
assembly_name);
return;
}
if (public_key != null && !aname.HasPublicKey)
{
Report.Error(1726, a.Location,
"Friend assembly reference `{0}' is invalid. Strong named assemblies must specify a public key in their InternalsVisibleTo declarations",
assembly_name);
return;
}
#endif
}
else if (a.Type == pa.RuntimeCompatibility)
{
wrap_non_exception_throws_custom = true;
}
else if (a.Type == pa.AssemblyFileVersion)
{
string value = a.GetString();
if (string.IsNullOrEmpty(value) || IsValidAssemblyVersion(value, false) == null)
{
Report.Warning(1607, 1, a.Location, "The version number `{0}' specified for `{1}' is invalid",
value, a.Name);
return;
}
}
SetCustomAttribute(ctor, cdata);
}
public static void Error_VariableOfStaticClass (Location loc, string variable_name, TypeSpec static_class, Report Report)
{
Report.SymbolRelatedToPreviousError (static_class);
Report.Error (723, loc, "`{0}': cannot declare variables of static types",
variable_name);
}
public static void Error(int code, string err, Report ec)
{
ec.Error(code, err);
}
