* expression.cs (BetterFunction): Catch hideous bug which was
preventing us from detecting ambiguous calls due to implicit casts i.e
cs0121.
svn path=/trunk/mcs/; revision=2331
* AllTests.cs: Removed entry for IPHostEntryTest.cs because Mads
removed it and included it in the new DnsTest.cs. This fixes
the build.
svn path=/trunk/mcs/; revision=2329
* exception.h, exception.c: added TypeLoadException.
* object.h, object.c: added mono_array_clone ().
* icall.c: handle throwOnError in AssemblyGetType().
Added Array.Clone().
* opcode.h, opcode.c: use a single value for the opcode val.
Compile fix for non-gcc compilers.
svn path=/trunk/mono/; revision=2318
* Array.cs: make Clone() an internal call.
Mon Feb 11 19:49:25 CET 2002 Paolo Molaro <[email protected]>
* ArrayList.cs: Dick's fix to contructor.
svn path=/trunk/mcs/; revision=2316
* interp.c: added "die on exception" command line argument.
When we segfault, set the message in the exception to "Segmentation
fault" so people can recognise what's going on.
svn path=/trunk/mono/; revision=2310
* Int64Test.cs: Various fixes to make tests work against the ms corlib.
Currency Symbol tests seem to be system dependant. Not sure if this
will work on other systems, so please test it if you can. The most
disturbing one is negative numbers. Should they be (n) or -n ?
svn path=/trunk/mcs/; revision=2305
+
+ * interp.c (ves_exec_method): Compare the element_class type token
+ in the class we got as well, instead of the element class vs the
+ toplevel class.
+
+ This fixes the invalid cast exceptions during unboxing
svn path=/trunk/mono/; revision=2297
* corlib_test.build: Remove duplicate excludes for
* AllTests.cs: Add System.Security.Policy tests. However, commented
this out because NUnit is throwing an exception. Need to figure
that out first.
svn path=/trunk/mcs/; revision=2294
* AllTests.cs: Add Int64Test to the Suite
* Int64Test.cs: Change static member to instance member. This was
causing NUnitConsole some grief. Should be instance member anyway.
svn path=/trunk/mcs/; revision=2293
* AllTests.cs: Remove StringBuilderTest suite. There's a major failure
when it's included and the test errors aren't displayed.
svn path=/trunk/mcs/; revision=2289
* emit-x86.c: make x86_magic_trampoline() handle call instructions
with an imm8 displacement. x86.brg not yet changed to take advantage
of it.
svn path=/trunk/mono/; revision=2288
hack for this to fully work.
2002-01-29 Miguel de Icaza <[email protected]>
* support.cs (Pair): Remove un-needed method. I figured why I was
getting the error in cs-parser.jay, the variable in a foreach loop
is readonly, and the compiler does not really treat this as a variable.
* cs-parser.jay (fixed_statement): Fix grammar. Use ASSIGN
instead of EQUALS in grammar.
* typemanager.cs (VerifyUnmanaged): Report correct error (208)
* expression.cs (Unary.DoResolve): Check whether the argument is
managed or not.
svn path=/trunk/mcs/; revision=2285
* ByteTest.cs:
* Int16Test.cs:
* Int32Test.cs:
* SByteTest.cs:
* UInt16Test.cs:
* UInt32Test.cs:
* UInt64Test.cs: Fixed tests where a "$" was hard coded. Change it to
use NumberFormatInfo.CurrentInfo.CurrencySymbol. Also used
NumberFormatInfo.InvariantInfo.CurrencySymbol where appropriate. These
tests all pass now with mscorlib.
svn path=/trunk/mcs/; revision=2278
* RuntimeArgumentHandle.cs: Added to CVS.
2002-02-08 Duncan Mak <[email protected]>
* UriFormatException.cs: Removed TODO attribute, the docs are
probably wrong here. In any case, this code compiles and should work.
2002-02-08 Duncan Mak <[email protected]>
* IsolatedStorage.cs: Looked at MemberInfo.cs, another fellow
abstract class. Oh, that's what it means! Removed unnesscessary
MonoTODO attributes.
svn path=/trunk/mcs/; revision=2276
* corlib_test.build: compile with mscorlib to test the tests. This
will be our "reference" check to make sure the tests work.
svn path=/trunk/mcs/; revision=2275
* FileIOPermissionTest.cs: Remove intersect test where it was trying
to intersect a permission with itself. This throws an exception
with mscorlib.
svn path=/trunk/mcs/; revision=2273
* FileCodeGroup.cs: New file. All done except for GetHashCode and
Resolve.
* CodeGroup.cs: Fix small bug in ToXml()
* Evidence.cs: Added method stub needed by FileCodeGroup.cs. Added
MonoTODO's too.
svn path=/trunk/mcs/; revision=2271
* MarshalByRefObject.cs: add ToString () method
(apparently needed by nunit).
* _AppDomain.cs: uncomment ToString(): dietmar fixed the bug triggered
by it in the runtime.
svn path=/trunk/mcs/; revision=2268
* NameObjectCollectionBase.cs, NameValueCollection.cs: tweaks to make
it compile and provide the constructor needed by nunitcore.
svn path=/trunk/mcs/; revision=2267
* RequiredFieldValidator.cs -- Oops! Forgot to add in previous commit.
* ChangeLog -- Needed to be updated for this.
svn path=/trunk/mcs/; revision=2257
* CodeGroup.cs: Went as far as I can for now. Need to look at
the (To|From)XML methods when I understand PolicyLevels better.
svn path=/trunk/mcs/; revision=2251
Back from a small vacation due to the exams...
* ListItem.cs, ListItemCollection.cs: Completed
* WebControl.cs -- Minor changes.
* TableStyle.cs, TargetConverter, TemplateColumn -- Fully implemented
* ListBox.cs -- Partial Implementation (See ChangeLog for details)
* ChangeLog -- Verbose details of the work done
* TODO -- Updated list for completed classes.
svn path=/trunk/mcs/; revision=2245
* DBNull.cs: This is my first crack at the DBNull class. I think I
actually got most of the IConvertible methods right, but I haven't
done the research to test whether or not this is the correct
behavior. IConvertible.ToType () is the most iffy of all, IMHO.
svn path=/trunk/mcs/; revision=2244
* interp.c (ves_exec_method): CEE_UNBOX: use element_class for
type check.
* x86.brg: use element_class for type check
* object.h (MONO_CHECK_ARG, MONO_CHECK_ARG_NULL): new macro for
icalls.
* class.c (class_compute_field_layout): set element_class for enums
(mono_class_create_from_typedef): set element_class for normal classes
* icall.c (ves_icall_System_Enum_get_value): impl.
* class.c (mono_class_create_from_typedef): do not set valuetype
flag for System.ValueType and System.Enum
svn path=/trunk/mono/; revision=2237
* serialize.cs: Added a new tool for serializing objects. It
can create new types dynamically, but can only handle
arguments that are of primitive types.
svn path=/trunk/mcs/; revision=2228
* interp.c: exception fixes. Use mono_method_pointer_get ()
to easy porting to other archs. Some support for overflow detection.
Fri Feb 1 16:03:00 CET 2002 Paolo Molaro <[email protected]>
* x86/tramp.c, ppc/tramp.c: implement mono_method_pointer_get ().
Fri Feb 1 16:13:20 CET 2002 Paolo Molaro <[email protected]>
* class.c: add asserts if we are ever going to scribble over memory.
* socket-io.c: not all systems have AF_IRDA defined.
svn path=/trunk/mono/; revision=2223
* configure.in: add some support/fixes for cross-compilation.
Fri Feb 1 15:14:16 CET 2002 Paolo Molaro <[email protected]>
* Makefile.am: support cross-compilation.
svn path=/trunk/mono/; revision=2220
* DataList.cs -- Done a hell lot of work today. I am tired now and will
go to library to study for the exams on Monday.
See ChangeLog for details of what I did today.
* ChangeLog -- Updated in accordance.
svn path=/trunk/mcs/; revision=2219
* TODO: Do I really need destructors? I have added a small description.
I don't think I need them. I am nowhere using any unmanaged code.
svn path=/trunk/mcs/; revision=2218
Microsoft assemblies in preference.)
Removed checksum from Perl regex trial descriptions. Now using a descriptive
string.
svn path=/trunk/mcs/; revision=2216
* RepeatInfo.cs -- Almost done. See ChangeLog for details.
* ChangeLog -- About what's status of RepeatInfo. Vertical direction rendering
is left.
* TODO -- "&" mark for RepeatInfo class.
svn path=/trunk/mcs/; revision=2201
** class.xml: Today's updates... All in WebControls namespace
See System.Web.UI.WebControls/ChangeLog for details.
svn path=/trunk/mono/; revision=2197
* PlaceHolder.cs -- The simplest class one can have!
* PlaceHolderControlBuilder.cs -- Not less simple.
* ChageLog, TODO -- Updates for these files.
svn path=/trunk/mcs/; revision=2196
* RadioButtonList.cs -- Almost done. One method left. See ChangeLog for details
* ChangeLog -- What's been done / left in RadioButton.cs
* TODO -- Marked RadioButtonList with an "&".
svn path=/trunk/mcs/; revision=2195
* _AppDomain.cs: remove ToString() method: it doesn't seem right
to have it in this interface and it screws up the method vtable setup.
svn path=/trunk/mcs/; revision=2191
* CodeGroup.cs: New file. Not nearly done with this, but saving it
in cvs just in case.
* PolicyLevel.cs: Sarted just a bit on this then relized i need CodeGroup
first (among others). Checking in for disaster recovery.
2002-01-29 Nick Drochak <[email protected]>
* PolicyStatementAttribute.cs: New file.
* PolicyException.cs: Use correct namespace
* PolicyLevel.cs: Add [Serializable] to class
svn path=/trunk/mcs/; revision=2189
* support.cs: Api for Pair to set a value. Despite the fact that
the variables are public the MS C# compiler refuses to compile
code that accesses the field if the variable is part of a foreach
statement.
* statement.cs (Fixed): Begin implementation of the fixed
statement.
(Block.AddVariable): Return the VariableInfo on success and null
on failure instead of true/false.
* cs-parser.jay (foreach): Catch errors on variables already
defined (we were ignoring this value before) and properly unwind
the block hierarchy
(fixed_statement): grammar for the fixed statement.
svn path=/trunk/mcs/; revision=2183
* TODO -- Updated
I counted.. and get that out of total 132 implementations, I am done
with 91 (100% status). 132 count includes, enumerations, interfaces,
classes and structs and so does 91 include.
IT'S ABOUT 2/3rd of TOTAL WORK IN WEBCONTROLS!
svn path=/trunk/mcs/; revision=2179
* RadioButton.cs -- Completed
* ChangeLog, TODO -- Updated
I've dropped the idea of going for another build. Too many dependencies
on other namespaces. I don't want to get involved right now. ;-)
svn path=/trunk/mcs/; revision=2172
* EnumCheckAssemblyCollection.cs, assemblies.xml -- Files related to EnumCheck tool
* EnumCheck.cs -- updated
* makefile -- build EnumCheck
Hey Nick, now you can use this tool very beautifully. Just modify the assemblies.xml file.
svn path=/trunk/mcs/; revision=2171
* EnumCheck.cs -- Did some modifications. At least not giving an exception, but
still fails to load or whatever be the problem. I'll try to debug it today.
svn path=/trunk/mcs/; revision=2168
A couple of things are missing, but I will get to that tomorrow.
2002-01-25 Miguel de Icaza <[email protected]>
* expression.cs (UnaryMutator.IsIncrementableNumber): Allow also
pointer types to be incretemented.
(SizeOf): Implement.
* cs-parser.jay (pointer_member_access): Implement
expr->IDENTIFIER production.
* expression.cs (IndexerAccess.DoResolve, ArrayAccess.DoResolve,
MemberAccess.DoResolve, Invocation.DoResolve): Check for pointers
on safe contexts.
(Unary): Implement indirection.
* ecore.cs (Expression.UnsafeError): Reports error 214 (pointer
use in non-unsafe context).
(SimpleName.DoResolve): Check for pointers in field access on safe
contexts.
(Expression.LoadFromPtr): Factor the load-indirect code in this
function. This was duplicated in UnboxCast and ParameterReference
svn path=/trunk/mcs/; revision=2166
* TableItemStyle.cs, Panel.cs -- Completed. :))
* ChangeLog, TODO -- Updated
Now I'd try to go for another build including these files. Hope I succeed soon.
svn path=/trunk/mcs/; revision=2165
* ResourceReader.cs: Finsished reading resource files with just strings
in them. Need to figure out other types, and also resources with
multiple types in the same file.
svn path=/trunk/mcs/; revision=2162
* expression.cs (ComposedCast): report an error if a pointer cast
is used in a safe region.
* ecore.cs (Expression.ConvertExplicit): Add rules for implicit
pointer type casts in unsafe context.
* codegen.cs (EmitContext): Set up IsUnsafe.
* cs-parser.jay (non_expression_type): Add productions for pointer
casts.
svn path=/trunk/mcs/; revision=2154
* expression.cs (Invocation.EmitCall): Remove chunk of buggy
code. We should not use force into static mode if the method is
not virtual. Fixes bug in MIS
svn path=/trunk/mcs/; revision=2153
* expression.cs (Invocation.EmitCall): Remove chunk of buggy
code. We should not use force into static mode if the method is
not virtual. Fixes bug in MIS
svn path=/trunk/mcs/; revision=2152
* statement.cs (Do.Emit, While.Emit, For.Emit,
Statement.EmitBoolExpression): Add support to Do and While to
propagate infinite loop as `I do return' semantics.
Improve the For case to also test for boolean constants.
* attribute.cs (Attribute.ApplyAttributes): Add ParameterBuilder
to the list of attributes we can add.
Remove `EmitContext' argument.
* class.cs (Method.Define): Apply parameter attributes.
(Constructor.Define): Apply parameter attributes.
(MethodCore.LabelParameters): Move here the core of labeling
parameters.
* support.cs (ReflectionParameters.ParameterModifier,
InternalParameters.ParameterModifier): Use IsByRef on the type and
only return the OUT bit for these parameters instead of in/out/ref
flags.
This is because I miss-understood things. The ParameterInfo.IsIn
and IsOut represent whether the parameter has the [In] and [Out]
attributes set.
svn path=/trunk/mcs/; revision=2151
* StructLayoutAttribute.cs: Flag attribute as targetting structs
or classes.
* InAttribute.cs: Flag attribute as targettting a paramter
* OutAttribute.cs: ditto.
* DllImportAttribute.cs: Flag attribute as targetting methods.
* MarshalAsAttribute.cs: Flag attribute as targetting fields,
parameters and returnvalues.
svn path=/trunk/mcs/; revision=2146
* x86/tramp.c (mono_create_trampoline): Do not try to create a
mono_string_new if the return value from the PInvoke code is
NULL.
2002-01-23 Miguel de Icaza <[email protected]>
* genwrapper.pl: Added wrappers for the mono_glob functions.
* glob.c: New file, with globing functions used by the Directory
code.
svn path=/trunk/mono/; revision=2139
* Unix/Errno.cs: Added
* Unix/Wrapper.cs: Updated to new Wrapper
2002-01-23 Miguel de Icaza <[email protected]>
* FileInfo.c (CopyTo, MoveTo): Implement.
* FileStream.cs: Add argument checking to the constructor.
* File.cs: Rewrote most of the file. Implement Copy, Open, Create,
OpenText, OpenWrite, Move. Made pending methods flagged as MonoTODO.
* Directory.cs (Delete): reimplement without using DirectoryInfo.
(Delete): Implement the recursive version.
(GetCreationTime, GetLastWriteTime, GetLastAccessTime): Implement.
(Move): Reimplement.
(getNames): dead code removal.
* Path.cs: define an internal DirectorySeparatorStr that we use in
a few spots.
* Wrapper.cs: Updated to new version.
* DirectoryInfo (Delete): Implement using the Directory API.
2002-01-23 Miguel de Icaza <[email protected]>
* DateTime.cs (UnixEpoch): The Begining of the Unix epoch.
svn path=/trunk/mcs/; revision=2138
* wrapper.c: Changed things so that we can propagate ERRNO back.
Include stdio.h and unistd.h to remove a couple of warnings.
svn path=/trunk/mono/; revision=2134
* genwrapper.pl: Added support for flagging non-CLS compliant
classes and structs with CLSCompliant(false).
Added mkdir, rmdir and rename wrappers.
svn path=/trunk/mono/; revision=2131
* ResourceReader.cs: Implemented constructors. Started on the
GetEnumerator() method. Not done yet, but comitting for
'disaster recovery' purposes.
svn path=/trunk/mcs/; revision=2130
* ResourceReaderTest.cs: Add new file. This test is not done yet.
Wanted to save it in cvs for 'disaster recovery' purposes.
Just in case.
svn path=/trunk/mcs/; revision=2129
* System.build: Start build System.Net.Sockets.Socket.cs,
TcpClient.cs and TcpListener.cs
2002-01-23 Dick Porter <[email protected]>
* SocketException.cs: Implemented
* Socket.cs: Implemented most methods
* LingerOption.cs: Made compile
* AddressFamily.cs: Removed empty auto-generated comments
2002-01-23 Dick Porter <[email protected]>
* SocketAddress.cs: Implemented.
* IPEndPoint.cs: Turned 'Address' field into a real property.
Implemented Create() and Serialize() methods.
* IPAddress.cs: Fixed class constructor, turned 'Address' field
into a real property. Removed undocumented "public
IPAddress(string)" constructor.
* EndPoint.cs: Implemented. All methods return
NotSupportedException to enforce subclass overriding.
* Dns.cs: Replaced fixed-layout Hostent struct and cygwin
P/Invokes with portable internal calls.
2002-01-23 Dick Porter <[email protected]>
* Win32Exception.cs: implement, with support for looking up
runtime errors.
2002-01-23 Dick Porter <[email protected]>
* Marshal.cs: Added GetLastWin32Error()
* ExternalException.cs: Implemented
2002-01-23 Dick Porter <[email protected]>
* System.Xml/XmlNode.cs: Fixed IndexerName attribute so it
compiles under .net 1.0
2002-01-23 Dick Porter <[email protected]>
* Linux.cs: GetFileTime and SetFileTime need to be static
2002-01-23 Dick Porter <[email protected]>
* ManualResetEvent.cs:
* AutoResetEvent.cs: Fixed DOS line endings
svn path=/trunk/mcs/; revision=2127
* socket-io.c:
* icall.c:
* Makefile.am: Added socket support
2002-01-23 Dick Porter <[email protected]>
* sockets.c: Networking support, mostly wrapping BSD socket APIs
with handle code, and translating errno into w32 error codes.
* macros.h: Some w32 macros used with the socket support
* error.c: Implemented GetLastError() and SetLastError()
* Makefile.am: Added sockets, with kludge to override some symbols
2002-01-23 Dick Porter <[email protected]>
* interp.c: Added some kludges to cope with CONV_OVF_I2,
CONV_OVF_I4 and ADD_OVF so that number formatting works. Also
initialise and cleanup the network support.
svn path=/trunk/mono/; revision=2126
* icall.c (ves_icall_appdomain_get_default_assemblies): put this
code back. This should return the assemblies that are loaded by
the runtime on behalf of an application domain.
The current implementation is still broken, it just returns every
assembly loaded, but until we get real applications domain this
will do.
svn path=/trunk/mono/; revision=2125
* AppDomain.cs (GetAssemblies): Use foreach construct instead of
manually getting the enumerator.
(AppDomain.AppDomain): Prime the loaded assemblies with the
assemblies loaded by the runtime in our behalf.
* AppDomainSetup.cs: Remove private keyword, that is the default.
Add a new property DisallowPublisherPolicy.
2002-01-23 Miguel de Icaza <[email protected]>
* Assembly.cs (Assembly.CodeBase): Implement.
(Assembly.FullName): simplistic and broken implementation. Gets
us where we were yesterday.
Code style fix.
svn path=/trunk/mcs/; revision=2124
* icall.c (ves_icall_appdomain_get_cur_domain): Cache the value of
the mono_class_from_name lookup.
(ves_icall_get_parameter_info): ditto.
(ves_icall_appdomain_get_assemblies, add_assembly): Implement new internal
method.
(ves_icall_System_Reflection_Assembly_get_code_base): Another new call.
svn path=/trunk/mono/; revision=2120
* ecore.cs (FieldExpr.Emit): Release temporaries.
* assign.cs (LocalTemporary.Release): new function.
* codegen.cs (EmitContext.GetTemporaryStorage,
EmitContext.FreeTemporaryStorage): Rework the way we deal with
temporary storage. Now we can "put back" localbuilders when we
are done with them
svn path=/trunk/mcs/; revision=2096
* IReflect.cs: corrected GetMember() return type.
* InterfaceMapping.cs, TypeDelegator.cs: implemented.
Tue Jan 22 23:01:11 CET 2002 Paolo Molaro <[email protected]>
* EnumBuilder.cs, TypeBuilder.cs: updates for changes in Type.cs.
* ModuleBuilder.cs: fix lookup of nested types.
Tue Jan 22 22:53:23 CET 2002 Paolo Molaro <[email protected]>
* DirectoryInfo.cs, FileInfo.cs: do not use Debug from the system
assembly in corlib.
Tue Jan 22 22:51:48 CET 2002 Paolo Molaro <[email protected]>
* MonoType.cs, Type.cs: many updates, corrected implementation,
completed stubs.
Tue Jan 22 22:50:29 CET 2002 Paolo Molaro <[email protected]>
* Linux.cs: comment out call to Debug.Assert(): stuff from the System
assembly cannot be used in corlib.
svn path=/trunk/mcs/; revision=2095
* class.c: load also nested classes on class init.
System.ValueType instance methods gets passed boxed
values, unless methods in derived classed that get a pointer to the
data.
* icall.c: use better name parsing code in GetType().
* image.c, image.h: add mono_image_loaded ().
* metadata.c, metadata.h: add mono_metadata_nesting_typedef ().
* reflection.c, reflection.h: added mono_reflection_parse_type().
svn path=/trunk/mono/; revision=2094
in mono/mono/metadata/
* icall.c : Added mapping of internal calls for Manual and Auto reset events
* threads.c : Added the implementation of internal calls for events
* threads.h : Added prototypes of internal calls for events
in mcs/class/corlib/System.Threading/
* NativeEventCalls : Class that contains internal calls shared by Auto
and Manual Reset Events
* AutoResetEvents.cs : Added class AutoResetEvents and its implementation
* ManualResetEvents.cs : Added class ManualResetEvents and its implementation
also added 2 tests in mono/mono/tests/
* autoresetevents.cs
* manualresetevents.cs
svn path=/trunk/mono/; revision=2091
in mono/mono/metadata/
* icall.c : Added mapping of internal calls for Manual and Auto reset events
* threads.c : Added the implementation of internal calls for events
* threads.h : Added prototypes of internal calls for events
in mcs/class/corlib/System.Threading/
* NativeEventCalls : Class that contains internal calls shared by Auto
and Manual Reset Events
* AutoResetEvents.cs : Added class AutoResetEvents and its implementation
* ManualResetEvents.cs : Added class ManualResetEvents and its implementation
also added 2 tests in mono/mono/tests/
* autoresetevents.cs
* manualresetevents.cs
svn path=/trunk/mcs/; revision=2091
* ecore.cs (FieldExpr.Emit): Handle initonly fields specially: we
need to make a copy of the variable to generate verifiable code.
svn path=/trunk/mcs/; revision=2085
* BitArrayTest.cs: wrapped try-catch blocks around several of the tests.
NUnit doesn't properly catch exception here anymore. Must be something
to do with upgrading to .NET.1.0.
svn path=/trunk/mcs/; revision=2075
* AllTests.cs: removed duplicate MemoryStream test
* MemoryStreamTest.cs: wrapped try-catch blocks around read/write/seek
tests. These were throwing exceptions that NUnit wasn't catching. I
don't think it used to behave this way before .NET.1.0.
svn path=/trunk/mcs/; revision=2074
* SerializableAttribute.cs: this attrib can be used on enums, structs,
and delegates too. Added the appropriate usage flags.
svn path=/trunk/mcs/; revision=2072
* ecore.cs (CopyNewMethods): reworked, exposed, made public.
Slower, but more generally useful. Used by the abstract
registering implementation.
* expression.cs (ResolveMemberAccess): Reorder the way we evaluate
the rules for the special rule on Type/instances. First check if
we have the same name, and if so, try that special static path
rather than the instance path.
2002-01-18 Miguel de Icaza <[email protected]>
* cs-parser.jay: Emit 642 (warning: possible empty statement) for
for, while and if.
* class.cs (TypeBuilder.DefineType): Do not allow inheritance from
Enum, ValueType, Delegate or Array for non-corlib compiles.
* cs-tokenizer.cs: Catch long identifiers (645)
* typemanager.cs (IndexerPropetyName): Ravi never tested this
piece of code.
* class.cs (TypeContainer.RegisterRequiredImplementations): Bug
fix, we were returning too early, so we were not registering
pending methods from abstract classes.
Do not register pending methods if the class is abstract.
* expression.cs (Conditional.DoResolve): Report circular implicit
conversions when we neecd to compute it for conditional
expressions.
(Is.DoResolve): If the expression is always of the provided type,
flag warning 183. If the expression can not ever be of the
provided type flag warning 184.
* class.cs: Catch 169 as well.
* ecore.cs (FieldExpr): For now in AddressOf mark as assigned and
read.
Also add more error test cases.
svn path=/trunk/mcs/; revision=2065
* makefile: corcompare works again now, so make xml of missing types
* CorCompare.cs: use exception that .NET v1 throws to get types in mono corlib
svn path=/trunk/mcs/; revision=2051
* TableCellCollection.cs, TableRowCollection.cs,
TableHeaderCell.cs, TableRow.cs -- Completed
* TODO -- Updated. Added a note on "Attributes" to be added to the classes.
svn path=/trunk/mcs/; revision=2046
* interface.cs (Interface.GetInterfaceTypeByName): Only lookup the
hashtable if there are classes or structs defined.
* expression.cs (LocalVariableReference.DoResolve): Simplify this
code, as the constant resolution moved.
* statement.cs (Block.EmitMeta): Resolve all constants as we emit
the metadata, so we can flag error 133.
svn path=/trunk/mcs/; revision=2042
* EnvironmentPermissionAttribute.cs:
* FileDialogPermissionAttribute.cs:
* FileIOPermissionAttribute.cs:
* IsolatedStorageAttribute.cs:
* IsolatedStorageFilePermissionAttribute.cs:
* PermissionSetAttribute.cs:
* PrinciplePermissionAttribute.cs:
* ReflectionPermissionAttribute.cs:
* RegistryPermissionAttribute.cs:
* SiteIdentityPermissionAttribute.cs:
* StrongNamePermissionAttribute.cs:
* UIPermissionAttribute.cs:
* UrlIdentityPermissionAttribute.cs:
* ZoneIdentityPermissionAttribute.cs: New files. Stubbed out with MonoTODOs
* Note: These are all the Attributes in the System.Security.Permissions
namespace. The only missing one is PublishIdentityPermissionAttribute.cs because
we don't have anything for the X509Certificate class.
svn path=/trunk/mcs/; revision=2039
* Environment.cs: Commented out references to
EnvironmentPermissionAttribute, because they're just
stubbed out right now and has no implementation.
svn path=/trunk/mcs/; revision=2038
* ResourceSet.cs: Implemented GetObject (string, bool) and GetString
(string, bool). ResourceSet has no more MonoTODOs! Also added in the
Serializable attribute.
svn path=/trunk/mcs/; revision=2029
of excludes, and now we actually build things.
2002-01-17 Miguel de Icaza <[email protected]>
* Win32Exception.cs: Add.
2002-01-17 Miguel de Icaza <[email protected]>
* TraceListenerCollection.cs: Remove Warnings.
2002-01-17 Miguel de Icaza <[email protected]>
* Dns.cs: Updated to API changes.
* IPAddress.cs: Updated API. Much left to implement.
* Dns.cs: Remove IPToString method
2002-01-17 Miguel de Icaza <[email protected]>
* SocketException.cs: Reimplemented.
svn path=/trunk/mcs/; revision=2023
* const.cs: Allow `unsafe'
* interface.cs: (PopulateMethod): Check for pointers being defined
only if the unsafe context is active.
(PopulateProperty): ditto.
(PopulateIndexer): ditto.
* class.cs (Method, Method.Define): Allow `unsafe' modifier to be
specified. If pointers are present, make sure that they are
present in an unsafe context.
(Constructor, Constructor.Define): ditto.
(Field, Field.Define): ditto.
(Property, Property.Define): ditto.
(Event, Event.Define): ditto.
* decl.cs (MemberCore.UnsafeOK): New function to test that a
pointer is being declared in an unsafe context.
2002-01-16 Miguel de Icaza <[email protected]>
* modifiers.cs (Modifiers.Check): Require a Location argument.
Report error 227 for Unsafe use.
* typemanager.cs: Remove IsPointerType, we should be using Type.IsPointer
svn path=/trunk/mcs/; revision=2014
* statement.cs (For.Emit): If the test is null, then report that
we do `return', as we wont reach anything afterwards.
(Switch.SwitchGoverningType): Track the expression that matched
the conversion.
* driver.cs: Allow negative numbers as an error code to flag.
svn path=/trunk/mcs/; revision=2011
* icall.h : Added the internal calls mapping for CreateMutex_internal
and ReleaseMutex_internal.
* threads.h : Added the prototype of mutexes internal calls.
* threads.c : Added the implementations of mutexes internal calls.
* WaitHandle.cs : Renamed handle to os_handle and make it protected
instead of private.
* Mutex.cs : Write the System.Threading.Mutex methods ( constructors
and the ReleaseMutex)
svn path=/trunk/mono/; revision=2010
* icall.h : Added the internal calls mapping for CreateMutex_internal
and ReleaseMutex_internal.
* threads.h : Added the prototype of mutexes internal calls.
* threads.c : Added the implementations of mutexes internal calls.
* WaitHandle.cs : Renamed handle to os_handle and make it protected
instead of private.
* Mutex.cs : Write the System.Threading.Mutex methods ( constructors
and the ReleaseMutex)
svn path=/trunk/mcs/; revision=2010
* ResourceManager.cs: Removed MonoTODO from GetNeutralResourcesLanguage (Assembly)
because Miguel just implemented the whole class, including the constructor that
I needed (CultureInfo (string)).
svn path=/trunk/mcs/; revision=2007
* ResourceManager.cs: After reading the tutorial from the SDK,
finished all the ResourceManager constructors and removed those
MonoTODO tags. Updated fields after reading the new docs from the
final SDK.
* ResXFileRef.cs, ResXResourceReader.cs: Removed. They are part of
Windows.Forms and require System.Xml, which we don't have access to.
2002-01-13 Duncan Mak <[email protected]>
* ResourceManager.cs: Added more MonoTODOs and cleaned up some
indenting.
svn path=/trunk/mcs/; revision=2005
* IFaceDisco.cs, XMLUtil.cs: Added new files for interface discovery tool.
* makefile: added target for IFaceDisco.exe and added to clean target for same
svn path=/trunk/mcs/; revision=2000
* typemanager.cs (IsPointerType): Utility method which we are going
to need a lot.
* ecore.cs (ImplicitReferenceConversion): A pointer type cannot be cast to
the object type, so we take care of that.
* expression.cs (FullMethodDesc): Also include the return type in descriptions.
* support.cs (ParameterDesc): Fix minor bug which was causing params tags to be
added to non-params parameters :-)
* typemanager.cs (CSharpName): Include 'void' type too.
(void_ptr_type): Include in the set of core types.
* ecore.cs (ConvertImplicit): Make use of ConvertImplicitStandard instead of
duplicating code.
(ConvertImplicitStandard): Handle standard implicit pointer conversions when we have
an unsafe context.
* cs-parser.jay (local_variable_pointer_type): Add support for 'void *' as I had
completely forgotten about it.
2002-01-10 Ravi Pratap <[email protected]>
* cs-parser.jay (pointer_type): Add. This begins our implementation
of parsing rules for unsafe code.
(unsafe_statement): Implement.
(embedded_statement): Modify to include the above.
* statement.cs (Unsafe): Implement new class for unsafe blocks.
* codegen.cs (EmitContext.InUnsafe): Add. This determines
if the current context is an unsafe one.
* cs-parser.jay (local_variable_pointer_type): Since local variable types
are handled differently, we need separate rules for them.
(local_variable_declaration): Update to use local_variable_pointer_type
to allow variable declarations of unmanaged pointer types.
* expression.cs (Unary.ResolveOperator): Ensure that the '&' operator is used only
in unsafe contexts.
* ../errors/cs0214.cs : Add.
svn path=/trunk/mcs/; revision=1998
* cs-parser.jay: Report 1524.
2002-01-14 Miguel de Icaza <[email protected]>
* typemanager.cs (RegisterMethod): drop checking if we have
svn path=/trunk/mcs/; revision=1994
* metaparse.h: removed unused file.
* reflection.c, reflection.h: added stream_data_align () function
to align data in streams and keep stream aligned. Add support for
exception support in method headers.
svn path=/trunk/mono/; revision=1993
* threads.c: Make the runtime's idea of infinite timeouts coincide
with the class library's
Fix a particularly egregious bug in mono_thread_cleanup(). That
code was so utterly bogus it must have been written on a Monday.
svn path=/trunk/mono/; revision=1989
* dump.c: more info in method table dump.
Mon Jan 14 17:01:03 CET 2002 Paolo Molaro <[email protected]>
* reflection.h: add subtypes field to TypeBuilder.
* reflection.c: encode constants for literal fields.
Handle subtypes. Fix user string token (and add a zero byte)
at the end.
svn path=/trunk/mono/; revision=1978
* String.cs: use IndexerName in index char accessor.
Mon Jan 14 17:07:32 CET 2002 Paolo Molaro <[email protected]>
* ModulerBuilder.cs: search also for subtypes in GetTypes().
* TypeBuilder.cs: bugfix in FullName. Implemented DefineNestedType().
svn path=/trunk/mcs/; revision=1977
* typemanager.cs (IsPointerType): Utility method which we are going
to need a lot.
* ecore.cs (ImplicitReferenceConversion): A pointer type cannot be cast to
the object type, so we take care of that.
* expression.cs (FullMethodDesc): Also include the return type in descriptions.
* support.cs (ParameterDesc): Fix minor bug which was causing params tags to be
added to non-params parameters :-)
* typemanager.cs (CSharpName): Include 'void' type too.
(void_ptr_type): Include in the set of core types.
* ecore.cs (ConvertImplicit): Make use of ConvertImplicitStandard instead of
duplicating code.
(ConvertImplicitStandard): Handle standard implicit pointer conversions when we have
an unsafe context.
* cs-parser.jay (local_variable_pointer_type): Add support for 'void *' as I had
completely forgotten about it.
2002-01-10 Ravi Pratap <[email protected]>
* cs-parser.jay (pointer_type): Add. This begins our implementation
of parsing rules for unsafe code.
(unsafe_statement): Implement.
(embedded_statement): Modify to include the above.
* statement.cs (Unsafe): Implement new class for unsafe blocks.
* codegen.cs (EmitContext.InUnsafe): Add. This determines
if the current context is an unsafe one.
* cs-parser.jay (local_variable_pointer_type): Since local variable types
are handled differently, we need separate rules for them.
(local_variable_declaration): Update to use local_variable_pointer_type
to allow variable declarations of unmanaged pointer types.
* expression.cs (Unary.ResolveOperator): Ensure that the '&' operator is used only
in unsafe contexts.
* ../errors/cs0214.cs : Add.
svn path=/trunk/mcs/; revision=1965
* class.cs (Method.EmitDestructor): Implement calling our base
destructor.
* statement.cs (Try.Emit): Fix to reset the InFinally to the old
value of InFinally.
* codegen.cs (EmitContext.EmitTopBlock): Destructors will call
this routine and will wrap the call in a try/catch block. Deal
with the case.
svn path=/trunk/mcs/; revision=1962
(FieldExpr): Added partial support for volatile fields. This does
not work for volatile fields exposed from assemblies, as I can not
figure out how to extract the modreq from it.
Updated all the source files to use this.
svn path=/trunk/mcs/; revision=1959
* reflection.c: don't try to output a code RVA for abstract methods.
Small fixes for method header format. Output parameter info to the
ParamDef table. Save method overriding info to MethodImpl table.
Fix property support. Allow typedef.extends to be a type in the
building assembly.
* verify.c: fix off-by-one error.
svn path=/trunk/mono/; revision=1957
* ecore.cs (Expression.MemberLookup): instead of taking a
parameter `same_type' that was used to tell whether we could
access private members we compute our containing type from the
EmitContext.
Updated all the source files to use this.
* codegen.cs (EmitContext): Compute ContainerType ahead of time,
because it is referenced by MemberLookup very often.
svn path=/trunk/mcs/; revision=1952
* ILGenerator.cs: handle type tokens (used for box opcode).
Thu Jan 10 21:05:23 CET 2002 Paolo Molaro <[email protected]>
* MonoType.cs: add rank to MonoTypeInfo and implement GetArrayRank.
* String.c: eliminate 64k+ method calls in search.
* Type.cs: handle byref and array types in ToString ().
svn path=/trunk/mcs/; revision=1951
* class.c: fix mono_class_from_mono_type () for szarray types.
Remove unused cache check in mono_class_from_type_spec().
* icall.c: *type_from_name () functions handle simple arrays and byref.
* reflection.c: handle byref and szarray types. Handle methods without
body (gets P/Invoke compilation working). Handle types and fields in
get_token ().
* reflection.h: add rank to MonoTypeInfo.
Thu Jan 10 20:59:59 CET 2002 Paolo Molaro <[email protected]>
* interp.c, interp.h: add a flag to mono_create_trampoline ()
to handle runtime methods.
Thu Jan 10 21:01:08 CET 2002 Paolo Molaro <[email protected]>
* x86/tramp.c: mono_create_trampoline (): the runtime argument is
needed to handle correctly delegates, the previous change in handling
the string return type broke them.
svn path=/trunk/mono/; revision=1950
* BufferedStream.cs: Initial implemenation. The synchronous
methods for both reading and writing are implemented. I'll do the
asynchronous methods in a bit.
svn path=/trunk/mcs/; revision=1949
* HyperLinkControlBuilder.cs, Table.cs, TableCell.cs, TableCellControlBuilder.cs, TableRowCollection.cs, TableCellCollection.cs --- Completed all except one. Don't recall which one. See TODO for details.
* HyperLinkColumn.cs, ButtonColumn.cs -- *Columns and *ControlBuilder are proving to be rather simple classes to be implemented. :))
* TODO -- Updated
* ChangeLog -- Oops! Not here.. Will update it :(
svn path=/trunk/mcs/; revision=1946
* typemanager.cs (IndexerPropertyName): If we have a TypeBuilder, use
TypeBuilder.GetCustomAttributes to retrieve what we need.
Get rid of redundant default_member_attr_type as this is the same as
default_member_type which already exists.
* interface.cs, attribute.cs : Update accordingly.
svn path=/trunk/mcs/; revision=1939
(string), as I believe it's correct. However, GetString
(string, CultureInfo) is definitely broken, so I'm marking it with
MonoTODO there. I also added MonoTODO to IntenalGetResourceSet().
svn path=/trunk/mcs/; revision=1935
* ResourceManager.cs: Fixed the GetSatelliteContractVersion()
method. It was missing a cast before. Removed MonoTODO
attribute. ;-) It was tested by John Barn, so this shouldn't
break the build.
svn path=/trunk/mcs/; revision=1934
* BinaryWriter.cs: Initial implementation. And it's all there.
* BinaryReader.cs: The constructor now uses the passed in encoding,
not UTF8 always.
svn path=/trunk/mcs/; revision=1933
* ILGenerator.cs: emit float and doubles.
* ModuleBuilder.cs: off-by-one error fix and GetType()
implementations.
* TypeBuilder.cs: AttributesImpl added.
* UnmanagedMarshal.cs: stubbed out class.
Wed Jan 9 19:37:14 CET 2002 Paolo Molaro <[email protected]>
* MonoMethod.cs: ToString () implementation.
Wed Jan 9 19:35:07 CET 2002 Paolo Molaro <[email protected]>
* MulticastDelegate.cs: add == and != operator stubs.
* String.cs: check for null in == operator.
* Type.cs: use a virtual method to get TypeAttributes.
svn path=/trunk/mcs/; revision=1930
* icall.c: initialize class in type_from_handle ().
Loop also in parent classes for get_method ().
* reflection.c: properly encode class and valuetype types.
Start on encoding TypeBuilder types. Handle fieldrefs.
Use correct length when registering a user string.
Handle ConstructorBuilder and MonoMethod in get_token ().
Make mono_type_get_object () aware of cached types.
* object.c: back out change to mono_string_new ().
svn path=/trunk/mono/; revision=1929
* x86/tramp.c: handle strings returned from functions in external
libraries by converting to a Mono string object after the pinvoke'd
function returns
svn path=/trunk/mono/; revision=1923
* typemanager.cs: Enable IndexerPropertyName again. It does not
work for TYpeBuilders though. Ravi, can you please fix this?
* cs-tokenizer.cs: Accept _ as a name in pp-expressions.
svn path=/trunk/mcs/; revision=1921
* expression.cs (Argument.Emit): Handle the case of ref objects
being passed to ref functions;
(ParameterReference.EmitLoad): Loads the content of the pointer
without dereferencing.
2002-01-07 Miguel de Icaza <[email protected]>
* cs-tokenizer.cs: Implemented the pre-processing expressions.
This also includes Matt Kimball's patch for LookupType.
svn path=/trunk/mcs/; revision=1918
* class.cs (Indexer.DefineMethod): Incorporate the interface
type in the name of the method if we are doing explicit interface
implementation.
* expression.cs (ConversionExists): Remove as it is completely obsolete.
(BetterConversion): Fix extremely trivial bug where we were referring to
ConversionExists instead of StandardConversionExists ! Hooray, things are fine
again !
* ../errors/bug16.cs : Add although we have fixed it.
svn path=/trunk/mcs/; revision=1911
* Environment.cs: Comment out Security attribute and put a MonoTODO
there as a reminder. We need mcs magic to handle security attributes in
corlib.
svn path=/trunk/mcs/; revision=1907
* expression.cs (BaseIndexer): Begin implementation.
* class.cs (TypeContainer.IsInterfaceMethod): Bug fix.
* cs-parser.jay (indexer_declarator): Use qualified_identifier
production directly to remove a shift/reduce, and implement
explicit interface implementation.
* cs-tokenizer.cs: Fix tokenizer, it was consuming one extra char
after a floating point suffix.
* expression.cs (DoNumericPromotions): Improved the conversion for
uint/uint. If we have a constant, we avoid doing a typecast to a
larger type.
* class.cs (Indexer): Implement explicit interface implementation
for indexers.
svn path=/trunk/mcs/; revision=1903
* Button.cs, ButtonColumn.cs, CheckBoxList.cs -- Completed. Uh!
* HyperLinkColumn.cs -- Started off. But feeling sleepy. Will do it
tomorrow. ;-)
* TODO, ChangeLog -- Properly Updated.
svn path=/trunk/mcs/; revision=1898
* EnumCheck.cs -- A very important tool added. Can list the actual
values of an enumeration. do "EnumCheck.exe --help" for details.
* ChangeLog, makefile -- updated
svn path=/trunk/mcs/; revision=1889
* icall.c: hack to make IsSubType work for TypeBuilders.
* reflection.c: emit constructors before methods.
Retrieve param names in mono_param_get_objects().
Sat Jan 5 15:45:14 CET 2002 Paolo Molaro <[email protected]>
* interp.c: allow classname:method name in --debug argument.
Fix box opcode for valuetypes. Fix a few opcode to take a 16 bit
index instead of 32 (stloc, ldloc, starg, etc.).
Sat Jan 5 15:51:06 CET 2002 Paolo Molaro <[email protected]>
* x86/tramp.c: handle short integer return types.
svn path=/trunk/mono/; revision=1852
* Hashtable.cs: the IDictionaryEnumerator returns DictionaryEntries.
Sat Jan 5 15:59:05 CET 2002 Paolo Molaro <[email protected]>
* ILGenerator.cs: fix emission of two-bytes opcodes.
Missing slot for locals array. Throw exceptions on unimplemented
methods.
* OpCode.cs: add a comment: the Value property is useless.
* OpCodes.cs: fix name of tail opcode (Tail -> Tailcall).
Sat Jan 5 15:53:50 CET 2002 Paolo Molaro <[email protected]>
* Enum.cs: dummy ToString impl.
* String.cs: dummy format implementations to get compiler errors
somewhat working.
* Type.cs: implemented filter delegates. FindMembers runs the filter, now.
svn path=/trunk/mcs/; revision=1851
* ArrayList.cs : Setting an index does not implicitly
extend the arraylist : remove FIXME.
Decorate incomplete elements with the TODO attribute.
* BitArray.cs : Insert TODO attributes where appropriate.
* CaseInsensitiveHashcodeProvider.cs: Ditto.
* Hashtable.cs, SortedList.cs : Ditto.
svn path=/trunk/mcs/; revision=1821
* corlib.build: Make new build of corlib_cmp.dll. This is the same
as corlib.dll without Object and ValueType. It is used by
/mcs/tools/corcompare.exe to compare with mscorlib.
svn path=/trunk/mcs/; revision=1819
* TODOAttribute.cs : Add. We use this attribute to tag all bits
in our class libraries that are incomplete.
* Array.cs : Apply attribute wherever we find a FIXME which says we need
something to be implemented there.
* Int32.cs : Ditto.
* MulticastDelegate.cs : Ditto.
* RuntimeFieldHandler.cs, RuntimeMethodHandle.cs, RuntimeTypeHandle.cs : Ditto.
* String.cs : Ditto.
* Type.cs : Ditto.
svn path=/trunk/mcs/; revision=1804
* interface.cs (EmitDefaultMemberAttr): Make this helper method static
so we can call it from elsewhere.
* class.cs (TypeContainer.Emit): Emit the attribute here too. The rule is that
we emit it internally if the class has a defined indexer; otherwise the user
emits it by decorating the class definition with the DefaultMemberAttribute.
* attribute.cs (ApplyAttributes): Perform checks to see that the DefaultMember
attribute is not used on a type which defines an indexer.
* cs-tokenizer.cs (get_cmd_arg): Ensure we trim whitespace and also include the tab
character when we skip whitespace.
* ../errors/cs0646.cs : Add.
svn path=/trunk/mcs/; revision=1800
* interp.c: temporary mul.ovf, mul.ovf.un, add.ovf.un implementations
to get the compiler going.
Thu Jan 3 23:17:17 CET 2002 Paolo Molaro <[email protected]>
* reflection.c: get token for a method ref. Set return type of
constructor to void.
* loader.c: debug message.
* class.c: typo fix.
svn path=/trunk/mono/; revision=1793
* class.cs (Property, Method, Indexer): Emit Final flag on the
method if we are an interface implementation and we are not
abstract.
* ecore.cs (PropertyExpr): New public field `IsBase', tells
whether this property is referencing a `base' method.
* expression.cs (Invocation.EmitCall): take an extra argument:
is_base, this is used to determine whether the `call' or
`callvirt' opcode should be used.
* delegate.cs: update EmitCall.
* class.cs (Method.Define): Set NewSlot for the cases where we are
not implementing an interface method.
(Property.Define): ditto.
svn path=/trunk/mcs/; revision=1790
* corlib.build: Put the linux target at the top. I keep changing the
build for windows 'cause it's at the top. Then when I do make, nothing
changes. It seems like it always takes me half a day to remember
that the linux target comes second. Old age I guess.
svn path=/trunk/mcs/; revision=1788
* HttpRuntime.cs: remove uneeded exception variable from catch and
initialize remaining instance members to avoid compile warnings
* DesignTimeParseData.cs: initialze static member to avoid compile
error
* PropertyConverter.cs: remove uneeded exception variables from
catch blocks.
* FileChangesMonitor.cs: remove redundant using statement; use int
for MAXLEN; capitalize correctly 'WebHashCodeProvider';
fix typo rsLock -> rwLock; Change IsRooted to IsPathRooted;
set out parameter value where needed
* FilePathParser.cs: qualify method GetPathRoot() with 'Path.'
* IISVersionInfo.cs: initialize static member to avoid compile error.
* WebEqualComparer.cs: static member defC shouldn't be readonly;
the string comparer had some typos (fixed)
* WebHashCodeProvider.cs: needed System.Globalization; static member
defHcp shouldn't be readonly; remove double equal typo.
* System.Web.build: don't exclude System.Web.UI anymore
svn path=/trunk/mcs/; revision=1778
* FileAction.cs: Use 0x7FFFFFFF as enum value for error. 0xFFFFFFFF
is too big for Int32.
* FileChangeEventHandler.cs: put missing 'void' return type on delegate
FileChangeEventHandler()
* FileChangedEventArgs.cs: ditto for FileChangedEvent()
* NativeFileChangeEventHandler.cs: ditto for NativeFileChangeEventHandler()
* FileChangesMonitor.cs: add needed namespaces and comment out imcomplete
code.
svn path=/trunk/mcs/; revision=1777
* expression.cs (ArrayCreation.num_automatic_initializers): Keep track
of the number of initializers that require the InitializeArray method.
(CheckIndices): Store the Expression in all cases - not the plain value. Also
update the above field where necessary.
(MakeByteBlob): Update accordingly.
(DoEmit): Call EmitStaticInitializers only if the number of initializers is
greater than 2.
(EmitDynamicInitializers): Update in accordance with the new optimization.
(ArrayAccess.EmitStoreOpcode): Include char type along with short and ushort - the
same OpCode applies.
* cs-parser.jay : Fix some glaring errors I introduced.
svn path=/trunk/mcs/; revision=1776
* parameters.cs (AddVariable, AddConstant): Pass in current_local_parameters
so that we can check for name clashes there too.
* typemanager.cs (default_member_attr_type): The attribute that we need to emit
for interface indexers.
* interfaces.cs (Define): Emit the default member attribute.
* expression.cs (MakeByteBlob): Fix extremely trivial bug where the wrong
variable was being referred to while setting the value ;-)
svn path=/trunk/mcs/; revision=1772
* expression.cs (MakeByteBlob): Optimize: we do not need to fill
byte-by-byte information when we know the data is zero.
Make the block always a multiple of 4, because
DefineInitializedData has a bug.
svn path=/trunk/mcs/; revision=1771
* assign.cs: Fix, we should assign from the temporary, not from
the source.
* expression.cs (MakeByteBlob): Fix my incorrect code.
svn path=/trunk/mcs/; revision=1768
* typemanager.cs (EnumToUnderlying): This function is used to get
the underlying type from an enumeration, because it does not
always work.
* constant.cs: Use the I4_S form for values between -128 and 127.
* statement.cs (Block.LookupLabel): Looks up a label.
(Block): Drop support for labeled blocks.
(LabeledStatement): New kind of statement that represents a label
only.
(Goto): Finally implement this bad boy.
* cs-parser.jay: Update to reflect new mechanism to implement
labels.
svn path=/trunk/mcs/; revision=1764
* codegen.cs (EmitContext.This): a codegen property that keeps the
a single instance of this instead of creating many different this
instances.
* delegate.cs (Delegate.DoResolve): Update to use the property;
* ecore.cs (SimpleName.SimpleNameResolve): Ditto
* expression.cs (BaseAccess.DoResolve): Ditto.
svn path=/trunk/mcs/; revision=1761
* typemanager.cs (methodimpl_attr_type): Add to hold the type
corresponding to System.Runtime.CompilerServices.MethodImplAttribute.
(InitCoreTypes): Update accordingly.
* attribute.cs (Resolve): Remember if the attribute is a MethodImplAttribute
so we can quickly store the state.
(ApplyAttributes): Set the current implementation flags
for InternalCall methods.
svn path=/trunk/mcs/; revision=1758
* PermissionSet.cs SecurityManager.cs: New Files
* CodeAccessPermission.cs: Add Skeleton code
* IPermission.cs: Make public and inherit from ISecurityEncodable
* ISecurityEncodable.cs: Make interface public
* ISecurityPolicyEncodable.cs: Ditto
* IStackWalk.cs: Ditto
svn path=/trunk/mcs/; revision=1754
* expression.cs (EmitCall): if a method is not virtual, then do
not use callvirt on it.
(ArrayAccess.EmitAssign): storing non-builtin value types (ie,
user defined stuff) requires the use of stobj, which takes an
address on the stack instead of an array and an index. So emit
the Ldelema operation for it.
(EmitStoreOpcode): Use stobj for valuetypes.
(UnaryMutator.EmitCode): Use the right 1 value depending on
whether we are dealing with int64/uint64, float or doubles.
* class.cs (TypeContainer.AddConstructor): Fix the logic to define
constructors that I implemented last night.
(Constructor.IsDefault): Fix to work properly for static
constructors.
* cs-parser.jay (CheckDef): report method signature errors.
Update error number 103 to be 132.
* decl.cs: New AdditionResult enumeration value: MethodExists.
Although we do this check for methods later on in the semantic
analysis, catching repeated default constructors is so easy that
we catch these here.
svn path=/trunk/mcs/; revision=1751
* expression.cs (ParameterReference.EmitAssign, Emit): handle
bools as bytes.
(ArrayAccess.EmitLoadOpcode): Handle bool type here.
(ArrayAccess.EmitStoreOpcode): ditto.
* cs-tokenizer.cs (is_punct): Eliminated empty computation.
* expression.cs (MakeByteBlob): Complete all the missing types
(uint, short, ushort, byte, sbyte)
* class.cs: Only init instance field initializers on instance
constructors.
Rename `constructors' to instance_constructors.
(TypeContainer.AddConstructor): Only add constructors to the list
if it is not static.
Make sure that we handle default_static_constructor independently
everywhere where we handle instance_constructors
svn path=/trunk/mcs/; revision=1744
* class.cs: Do not lookup or create a base initializer for a
static constructor.
(ConstructorInitializer.Resolve): use the proper type to lookup
for constructors.
* cs-parser.jay: Report error 1585 (modifiers between type and name).
* enum.cs, interface.cs: Remove CloseType, this is taken care by
in DeclSpace.
* decl.cs: CloseType is now an virtual method, the default
implementation just closes this type.
svn path=/trunk/mcs/; revision=1741
* attribute.cs (DefinePInvokeMethod): Set the implementation flags
to PreserveSig by default. Also emit HideBySig on such methods.
Basically, set the defaults to standard values.
* expression.cs (Invocation.BetterFunction): We need to make sure that for each
argument, if candidate is better, it can't be worse than the best !
(Invocation): Re-write bits to differentiate between methods being
applicable in their expanded form and their normal form - for params
methods of course.
Get rid of use_standard everywhere as only standard conversions are allowed
in overload resolution.
More spec conformance.
svn path=/trunk/mcs/; revision=1740
* FontUnit.cs -- GetTypeFromString <--- Function name changed from
IndexOf, which looked ugly. The function name is self-explanatory
svn path=/trunk/mcs/; revision=1736
* driver.cs: Add --timestamp, to see where the compiler spends
most of its time.
* ecore.cs (SimpleName.DoResolve): Do not create an implicit
`this' in static code.
(SimpleName.DoResolve): Implement in terms of a helper function
that allows static-references to be passed upstream to
MemberAccess.
(Expression.ResolveWithSimpleName): Resolve specially simple
names when called by MemberAccess to implement the special
semantics.
(Expression.ImplicitReferenceConversion): Handle conversions from
Null to reference types before others, as Null's type is
System.Object.
svn path=/trunk/mcs/; revision=1728
* expression.cs (Invocation.EmitCall): Handle the special case of
calling methods declared on a reference type from a ValueType
(Base classes System.Object and System.Enum)
(MemberAccess.Resolve): Only perform lookups on Enumerations if
the left hand side is a TypeExpr, not on every enumeration.
(Binary.Resolve): If types are reference types, then do a cast to
object on operators != and == of both arguments.
* typemanager.cs (FindMembers): Extract instance and static
members if requested.
* interface.cs (PopulateProperty): Use void_type instead of null
as the return type for the setter method.
(PopulateIndexer): ditto.
svn path=/trunk/mcs/; revision=1727
* support.cs (ReflectionParameters): Fix minor bug where we
were examining the wrong parameter for the ParamArray attribute.
Cope with requests for the type of the parameter at position
greater than the params parameter's. We now return the element
type of the params array as that makes more sense.
* expression.cs (Invocation.IsParamsMethodApplicable): Update
accordingly as we no longer have to extract the element type
ourselves.
(Invocation.OverloadResolve): Update.
svn path=/trunk/mcs/; revision=1726
* statement.cs (Foreach.GetEnumeratorFilter): Do not compare
against IEnumerator, test whether the return value is a descendant
of the IEnumerator interface.
* class.cs (Indexer.Define): Use an auxiliary method to implement
the other bits of the method definition. Begin support for
explicit interface implementation.
(Property.DefineMethod): Use TypeManager.void_type instead of null
for an empty return value.
svn path=/trunk/mcs/; revision=1720
* class.cs (Event.Define): Define the private field only if there
are no accessors defined.
* expression.cs (ResolveMemberAccess): If there is no associated
field with the event, that means we have an event defined with its
own accessors and we should flag error cs0070 since transforming
ourselves into a field is not valid in that case.
* ecore.cs (SimpleName.DoResolve): Same as above.
* attribute.cs (DefinePInvokeMethod): Set the default calling convention
and charset to sane values.
svn path=/trunk/mcs/; revision=1719
* assign.cs (DoResolve): Perform check on events only if they
are being accessed outside the declaring type.
* cs-parser.jay (event_declarations): Update rules to correctly
set the type of the implicit parameter etc.
(add_accessor, remove_accessor): Set current local parameters.
* expression.cs (Binary): For delegate addition and subtraction,
cast the return value from the method into the appropriate delegate
type.
svn path=/trunk/mcs/; revision=1714
* attribute.cs (ApplyAttributes): New method to take care of common tasks
of attaching attributes instead of duplicating code everywhere.
* everywhere : Update code to do attribute emission using the above method.
svn path=/trunk/mcs/; revision=1712
* interp.c: fix ldc.i8.
Mon Dec 24 17:18:10 CET 2001 Paolo Molaro <[email protected]>
* icall.c: fix array init with rank > 1. FindMembers
loops in parent class as well.
* image.c: do not insert nested types in name cache.
* reflection.c: warning fix.
* reflection.h: add override method (for interface impl).
svn path=/trunk/mono/; revision=1711
* typemanager.cs (RegisterDelegateData, GetDelegateData): Get rid
of these as the workaround is unnecessary.
* delegate.cs (NewDelegate.DoResolve): Get rid of bits which registered
delegate data - none of that is needed at all.
Re-write bits to extract the instance expression and the delegate method
correctly.
* expression.cs (Binary.ResolveOperator): Handle the '-' binary operator
on delegates too.
svn path=/trunk/mcs/; revision=1707
* test-19.cs : Augment to exercise tests on delegates
defined in mscorlib.
* test-57.cs : Update to exercise the -= operator
as well.
svn path=/trunk/mcs/; revision=1706
* expression.cs (IsParamsMethodApplicable): if there are not
parameters, return immediately.
* ecore.cs: The 0 literal can be implicity converted to an enum
type.
(SimpleName.DoResolve): First lookup the type, then lookup the
members.
(FieldExpr.Emit): If the InstanceExpression is a ValueType, we
svn path=/trunk/mcs/; revision=1705
* expression.cs (IsParamsMethodApplicable): if there are not
parameters, return immediately.
* ecore.cs: The 0 literal can be implicity converted to an enum
type.
(SimpleName.DoResolve): First lookup the type, then lookup the
members.
(FieldExpr.Emit): If the InstanceExpression is a ValueType, we
want to get its address. If the InstanceExpression is not
addressable, store the result in a temporary variable, then get
the address of it.
* codegen.cs: Only display 219 errors on warning level or above.
* expression.cs (ArrayAccess): Make it implement the
IMemoryLocation interface.
(Binary.DoResolve): handle the operator == (object a, object b)
and operator != (object a, object b) without incurring into a
BoxedCast (because 5 != o should never be performed).
Handle binary enumerator operators.
(EmitLoadOpcode): Use Ldelema if the object we are loading is a
value type, otherwise use Ldelem_ref.
Use precomputed names;
(AddressOf): Implement address of
* cs-parser.jay (labeled_statement): Fix recursive block
addition by reworking the production.
* expression.cs (New.DoEmit): New has a special case:
If we are dealing with a ValueType, we have a few
situations to deal with:
* The target of New is a ValueType variable, that is
easy, we just pass this as the variable reference
* The target of New is being passed as an argument,
to a boxing operation or a function that takes a
ValueType.
In this case, we need to create a temporary variable
that is the argument of New.
svn path=/trunk/mcs/; revision=1701
* typemanager.cs : Use PtrHashtable for Delegate data hashtable etc.
* assign.cs : Get rid of EventIsLocal everywhere.
svn path=/trunk/mcs/; revision=1695
* rootcontext.cs (LookupType): Check that current_type is not null before
going about looking at nested types.
* ecore.cs (EventExpr.EmitAddOrRemove): Rename from EmitAssign as we do
not implement the IAssignMethod interface any more.
* expression.cs (MemberAccess.ResolveMemberAccess): Handle EventExprs specially
where we tranform them into FieldExprs if they are being resolved from within
the declaring type.
* ecore.cs (SimpleName.DoResolve): Do the same here.
* assign.cs (DoResolve, Emit): Clean up code considerably.
* ../errors/bug10.cs : Add.
* ../errors/cs0070.cs : Add.
svn path=/trunk/mcs/; revision=1694
* typemanager.cs (GetAccessors): Make the return value consistent
(ie, 0 is always get, 1 is always set)
* ecore.cs (ConvertIntLiteral): finished the implementation.
* statement.cs (SwitchLabel): Convert the value we are using as a
key before looking up the table.
svn path=/trunk/mcs/; revision=1691
* codegen.cs (EmitTopBlock): Require a Location argument now.
* cs-parser.jay (constructor_declarator): We need to setup
current_local_parameters before we parse the
opt_constructor_initializer, to allow the variables to be bound
to the constructor arguments.
* rootcontext.cs (LookupType): First lookup nested classes in our
class and our parents before we go looking outside our class.
* expression.cs (ConstantFold): Extract/debox the values at the
beginnning.
* rootcontext.cs (EmitCode): Resolve the constants first before we
resolve the types. This is not really needed, but it helps debugging.
svn path=/trunk/mcs/; revision=1690
* expression.cs (CheckIndices): Fix minor bug where the wrong
variable was being referred to ;-)
(DoEmit): Do not call EmitStaticInitializers when the
underlying type is System.Object.
svn path=/trunk/mcs/; revision=1686
* test-19.cs : Augment to exercise code which fixed the bug
where we were not generating a This for the delegate's
instance expression - for the non-static methods ie.
svn path=/trunk/mcs/; revision=1685
* ecore.cs (EventExpr.Resolve): Implement to correctly set the type
and do the usual workaround for SRE.
* class.cs (MyEventBuilder.EventType): New member to get at the type
of the event, quickly.
* expression.cs (Binary.ResolveOperator): Handle delegate addition.
* assign.cs (Assign.DoResolve): Handle the case when the target
is an EventExpr and perform the necessary checks.
* ecore.cs (EventExpr.EmitAssign): Implement the IAssignMethod
interface.
(SimpleName.MemberStaticCheck): Include check for EventExpr.
(EventExpr): Set the type in the constructor itself since we
are meant to be born fully resolved.
(EventExpr.Define): Revert code I wrote earlier.
* delegate.cs (NewDelegate.Resolve): Handle the case when the MethodGroup's
instance expression is null. The instance expression is a This in that case
or a null, depending on whether it is a static method or not.
Also flag an error if the reference to a method is ambiguous i.e the MethodGroupExpr
refers to more than one method.
* assign.cs (DoResolve): Check whether the event belongs to the same Type container
and accordingly flag errors.
svn path=/trunk/mcs/; revision=1684
* Char.cs (Parse): Implement.
* Byte.cs (Parse): Implement a fast parser.
* SByte.cs (Parse): Implement a fast parser.
* UInt16.cs (Parse): Implement a fast parser.
* Int16.cs (Parse): Implement a fast parser.
* UInt32.cs (Parse): Implement a fast parser.
* Int32.cs (Parse): Implement a fast parser.
svn path=/trunk/mcs/; revision=1681
* location.cs (ToString): Provide useful rutine.
2001-12-21 Miguel de Icaza <[email protected]>
* ecore.cs (Expression.ConvertIntLiteral): Do not return Constant
objects, return the actual integral boxed.
* statement.cs (SwitchLabel): define an ILLabel for each
SwitchLabel.
(Switch.CheckSwitch): If the value is a Literal, extract
the underlying literal.
Also in the unused hashtable we had, add the SwitchLabel so we can
quickly look this value up.
* constant.cs: Implement a bunch of new constants. Rewrite
Literal based on this. Made changes everywhere to adapt to this.
* expression.cs (Expression.MakeByteBlob): Optimize routine by
dereferencing array only once, and also copes with enumrations.
bytes are two bytes wide, not one.
(Cast): Perform constant conversions.
* ecore.cs (TryImplicitIntConversion): Return literals instead of
wrappers to the literals here.
* expression.cs (DoNumericPromotions): long literals can converted
to ulong implicity (this is taken care of elsewhere, but I was
missing this spot).
* ecore.cs (Expression.Literalize): Make the return type Literal,
to improve type checking.
* rootcontext.cs: Lookup for nested classes in our class hierarchy.
svn path=/trunk/mcs/; revision=1678
* rawbuffer.cs: Added native Win32 implementation, avoids using
mmap on Cygwin. This patch is from Dan Lewis ([email protected])
svn path=/trunk/mono/; revision=1674
* System.Web/*.cs
* System.Web.Caching/*.cs
* System.Web.UI/*.cs
* System.Web.Utils/*.cs
* System.Web.UI.WebControls/*.cs
-- The ISP was down yesterday and today morning. So many files. See changelog for more details.
svn path=/trunk/mcs/; revision=1666
* literal.cs: Revert code from ravi that checked the bounds. The
bounds are sane by the definition of the type itself.
* typemanager.cs: Fix implementation of ImplementsInterface. We
need to actually look up in our parent hierarchy for interfaces
implemented.
svn path=/trunk/mcs/; revision=1662
* delegate.cs: Compute the basename for the delegate creation,
that should fix the delegate test case, and restore the correct
Type Lookup semantics in rootcontext
* rootcontext.cs: Revert Ravi's last patch. The correct way of
referencing a nested type with the Reflection API is using the "+"
sign.
svn path=/trunk/mcs/; revision=1655
* expression.cs (MemberAccess.ResolveMemberAccess): Add support for
the case when the member is an EventExpr.
* ecore.cs (EventExpr.InstanceExpression): Every event which is not
static has an associated instance expression.
* typemanager.cs (RegisterEvent): The usual workaround, now for events.
(GetAddMethod, GetRemoveMethod): Workarounds, as usual.
* class.cs (Event.Define): Register event and perform appropriate checks
for error #111.
We define the Add and Remove methods even if the use provides none because
in that case, we provide default implementations ourselves.
Define a private field of the type of the event. This is done by the CSC compiler
and we should be doing it too ;-)
* typemanager.cs (delegate_combine_delegate_delegate, delegate_remove_delegate_delegate):
More methods we use in code we generate.
(multicast_delegate_type, delegate_type): Two separate types since the distinction
is important.
(InitCoreTypes): Update accordingly for the above.
* class.cs (Event.Emit): Generate code for default accessors that we provide
(EmitDefaultMethod): Do the job in the above.
* delegate.cs (DefineDelegate): Use TypeManager.multicast_delegate_type in the
appropriate place.
svn path=/trunk/mcs/; revision=1654
* rootcontext.cs (LookupType): Concatenate type names with
a '.' instead of a '+' The test suite passes again.
* enum.cs (Enum.DefineEnum): Set RTSpecialName on the 'value__'
field of the enumeration.
svn path=/trunk/mcs/; revision=1649
* class.cs (Indexer.Define): Fix bug, we were setting both Get/Set
builders even if we were missing one.
* interface.cs, class.cs, enum.cs: When calling DefineNestedType
pass the Basename as our class name instead of the Name. The
basename will be correctly composed for us.
* parameter.cs (Paramters): Now takes a Location argument.
* decl.cs (DeclSpace.LookupType): Removed convenience function and
make all the code call directly LookupType in RootContext and take
this chance to pass the Location information everywhere.
* Everywhere: pass Location information.
2001-12-19 Miguel de Icaza <[email protected]>
* class.cs (Constructor.Define): Updated way of detecting the
length of the parameters.
(TypeContainer.DefineType): Use basename as the type name for
nested types.
(TypeContainer.Define): Do not recursively define types here, as
definition is taken care in order by the RootContext.
svn path=/trunk/mcs/; revision=1648
* tree.cs: Keep track of namespaces in a per-file basis.
* parameter.cs (Parameter.ComputeSignature): Update to use
DeclSpace.
(Parameters.GetSignature): ditto.
* interface.cs (InterfaceMethod.GetSignature): Take a DeclSpace
instead of a TypeContainer.
(Interface.SemanticAnalysis): Use `this' instead of our parent to
resolve names. Because we need to be resolve in our context, not
our parents.
* driver.cs: Implement response files.
* class.cs (TypeContainer.DefineType): If we are defined, do not
redefine ourselves.
(Event.Emit): Emit the code for add/remove handlers.
(Event.Define): Save the MethodBuilders for add/remove.
* typemanager.cs: Use pair here too.
* cs-parser.jay: Replaced use of DictionaryEntry for Pair because
DictionaryEntry requires the first argument to be non-null.
(enum_declaration): Compute full name for registering the
enumeration.
(delegate_declaration): Instead of using
formal_parameter_list, use opt_formal_parameter_list as the list
can be empty.
* cs-tokenizer.cs (PropertyParsing): renamed from `properties'
(EventParsing): New property that controls whether `add' and
`remove' are returned as tokens or identifiers (for events);
svn path=/trunk/mcs/; revision=1645
* class.cs (Event.Define): Revamp use of EventBuilder completely. We now
use MyEventBuilder only and let it wrap the real builder for us.
(MyEventBuilder): Revamp constructor etc.
Implement all operations that we perform on EventBuilder in precisely the same
way here too.
(FindMembers): Update to use the EventBuilder member.
(Event.Emit): Update accordingly.
2001-12-18 Ravi Pratap <[email protected]>
* class.cs (MyEventBuilder.Set*): Chain to the underlying builder
by calling the appropriate methods.
(GetCustomAttributes): Make stubs as they cannot possibly do anything
useful.
(Event.Emit): Use MyEventBuilder everywhere - even to set attributes.
2001-12-17 Ravi Pratap <[email protected]>
* delegate.cs (Delegate.Populate): Check that the return type
and various parameters types are indeed accessible.
* class.cs (Constructor.Define): Same here.
(Field.Define): Ditto.
(Event.Define): Ditto.
(Operator.Define): Check that the underlying Method defined itself
correctly - so it's MethodBuilder should not be null.
* delegate.cs (DelegateInvocation.DoResolve): Bale out if the type of the Instance
expression happens to be null.
* class.cs (MyEventBuilder): Workaround for SRE lameness. Implement various abstract
members but as of now we don't seem to be able to do anything really useful with it.
(FindMembers): Handle events separately by returning the MyEventBuilder of the event,
not the EventBuilder.
svn path=/trunk/mcs/; revision=1642
* UI.WebControls/*.cs
--> Got over 100 erros, 50+ warning (with /nowarn:1595). Trying to remove them for first build. Completing uncompleted. Creating new ones.
svn path=/trunk/mcs/; revision=1640
* cs-tokenizer.cs: Add support for defines.
Add support for #if, #elif, #else, #endif
(eval_var): evaluates a variable.
(eval): stubbed for evaluating functions.
* cs-parser.jay: Pass the defines information
* driver.cs: Add --define command line option.
svn path=/trunk/mcs/; revision=1638
* decl.cs: Move MemberCore here.
Make it the base class for DeclSpace. This allows us to catch and
report 108 and 109 for everything now.
* class.cs (TypeContainer.Define): Extract all the members
before populating and emit the warning 108 (new keyword required
to override) instead of having each member implement this.
(MemberCore.Define): New abstract method, we will be using this in
the warning reporting engine in Populate.
svn path=/trunk/mcs/; revision=1636
* System.Web.UI/*.cs
* System.Web.UI.WebControls/*.cs
--- Still working hard to make build succesfull. Lots of errors. Really, lots and lots. Not it's 6:00AM and I need to sleep :))
svn path=/trunk/mcs/; revision=1634
* class.cs (Method.Define): Allow the entry point to be in a
specific class.
* driver.cs: Rewrite the argument handler to clean it up a bit.
* rootcontext.cs: Made it just an auxiliary namespace feature by
making everything static.
* driver.cs: Adapt code to use RootContext type name instead of
instance variable.
* delegate.cs: Remove RootContext argument.
* class.cs: (Struct, TypeContainer, Class): Remove RootContext
argument.
* class.cs (Event.Define): The lookup can fail.
* cs-tokenizer.cs: Begin implementation of pre-procesor.
* expression.cs: Resolve the this instance before invoking the code.
svn path=/trunk/mcs/; revision=1631
* System.Web.UI/*.cs
* System.Web/*.cs -- Looks like I need to take control of this now. Build is otherwise failing
svn path=/trunk/mcs/; revision=1627
* class.c: fix mono_array_element_size() for objects.
* class.h, class.c: add properties to MonoClass and load them
at init time.
* icall.c: check with isinst() when assigning a value to an array
instead of requiring the classes to match exactly.
Implemented icall for System.Type::GetType().
Implemented icalls to get ParameterInfo, ProprtyInfo and info about
enums. Handle bindingflags when looking for methods and fields.
* metadata.h, metadata.c: implemented mono_metadata_properties_from_typedef()
and mono_metadata_methods_from_property().
* reflection.h, reflection.c: added structures for propreties,
parameters and enums. Implemented mono_property_get_object() and
mono_param_get_objects().
Tue Dec 18 18:48:00 CET 2001 Paolo Molaro <[email protected]>
* main.c: use mono_metadata_methods_from_property() and
mono_metadata_properties_from_typedef() from metadata instead of
custom code.
Tue Dec 18 18:48:50 CET 2001 Paolo Molaro <[email protected]>
* interp.c: make segv_handler static, handle runtime methods in stack
trace.
svn path=/trunk/mono/; revision=1626
* file-io.c: Use mono_string_to_utf16() instead of
mono_string_chars()
* object.c: Added mono_string_to_utf16(), which copies the non
NULL-terminated MonoString into a new double-null-terminated
buffer.
svn path=/trunk/mono/; revision=1622
* cs-tokenizer.cs: Begin implementation of pre-procesor.
* expression.cs: Resolve the this instance before invoking the code.
svn path=/trunk/mcs/; revision=1617
* cs-parser.jay: Add a production in element_access that allows
the thing to become a "type" reference. This way we can parse
things like "(string [])" as a type.
Note that this still does not handle the more complex rules of
casts.
svn path=/trunk/mcs/; revision=1613
* x86.brg, jit.c: Split up the nodes that we used to share on
CONV_OVF. They were sharing the nodes because they are the same
on 32-bit machines, but on 64-bit machines you need different
code for them.
svn path=/trunk/mono/; revision=1608
* emit-x86.c (arch_handle_exception): new code to handle
exceptions inside unmanaged code.
* x86.brg: impl. SAVE_LMF, RESTORE_LMF, pass implizit valuetype
address as first argument.
* x86.brg: pass exceptions on the stack
* jit.h (ISSTRUCT): new macro to check for real value types
(return false for enum types).
* unicode.c (_wapi_unicode_to_utf8): byteswap UTF16 strings before
passing them to iconv
* file-io.c: raise exceptions if handle is invalid.
svn path=/trunk/mono/; revision=1603
* delegate.cs (Delegate.Populate): Register the delegage constructor builder here.
* ecore.cs: (CopyNewMethods): new utility function used to
assemble the list of methods from running FindMembers.
(MemberLookup): Rework FindMembers so that
svn path=/trunk/mcs/; revision=1602
* class.cs (TypeContainer): Remove Delegates who fail to be
defined.
* delegate.cs (Populate): Verify that we dont get null return
values. TODO: Check for AsAccessible.
* cs-parser.jay: Use basename to emit error 574 (destructor should
have the same name as container class), not the full name.
svn path=/trunk/mcs/; revision=1598
* expression.cs (ArrayCreation.DoResolve): We need to do the
argument resolution *always*.
* decl.cs: Make this hold the namespace. Hold the root context as
well.
(LookupType): Move here.
* enum.cs, class.cs, interface.cs: Adapt to new hierarchy.
* location.cs (Row, Name): Fixed the code, it was always returning
references to the first file.
* interface.cs: Register properties defined through interfaces.
* driver.cs: Add support for globbing on the command line
* class.cs (Field): Make it derive from MemberCore as well.
(Event): ditto.
svn path=/trunk/mcs/; revision=1589
* class.cs (Event::Define): Check that the type of the event is a delegate
type else flag error #66.
Also, re-use TypeContainer.MethodModifiersValid here too as the rules are the
same.
* attribute.cs (DefinePInvokeMethod): Handle named arguments and process
values of EntryPoint, CharSet etc etc.
Pass in the values to TypeBuilder.DefinePInvokeMethod; determine Type etc neatly.
* class.cs (FindMembers): If a method is in transit, its MethodBuilder will
be null and we should ignore this. I am not sure if this is really clean. Apparently,
there's no way of avoiding hitting this because the call is coming from SimpleName.DoResolve,
which needs this to do its work.
* ../errors/cs0066.cs : Add.
svn path=/trunk/mcs/; revision=1586
* makefile : Include test-52.cs in the suite, it works fine!
(NO_PASS): It's test-51 which doesn't seem to pass.
* test-50.cs : Augment some more to set named arguments on
the DllImport attribute.
* test-57.cs : Add. This tests support for Events and does not
pass yet.
svn path=/trunk/mcs/; revision=1584
* typemanager.cs: (GetPropertyGetter, GetPropertyGetter): New
helper functions.
* class.cs: (MethodSignature.MethodSignature): Removed hack that
clears out the parameters field.
(MemberSignatureCompare): Cleanup
(MemberCore): New base class used to share code between MethodCore
and Property.
(RegisterRequiredImplementations) BindingFlags.Public requires
either BindingFlags.Instace or Static. Use instance here.
* parameter.cs (GetParameterInfo): Return an empty array instead
of null on error.
svn path=/trunk/mcs/; revision=1576
* parameter.cs (GetParameterInfo): return a zero-sized array.
* class.cs (TypeContainer.MethodModifiersValid): Move all the
method modifier validation to the typecontainer so we can reuse
this on properties.
(MethodCore.ParameterTypes): return an empty sized array of types.
(Property.Define): Test property modifier validity.
Add tests for sealed/override too.
(Method.Emit): abstract or extern methods have no bodies.
svn path=/trunk/mcs/; revision=1572
* class.cs (Method.IsPInvoke): Get rid of it as it is an expensive
thing.
(Method::Define, ::Emit): Modify accordingly.
* expression.cs (Invocation::OverloadResolve): Handle error # 121.
svn path=/trunk/mcs/; revision=1571
* class.cs (TypeContainer.Define): Correctly define explicit
method implementations (they require the full interface name plus
the method name).
* typemanager.cs: Deply the PtrHashtable here and stop using the
lame keys. Things work so much better.
svn path=/trunk/mcs/; revision=1570
* support.cs (PtrHashtable): A hashtable that avoid comparing with
the object stupid Equals method (because, that like fails all over
the place). We still do not use it.
* class.cs (TypeContainer.SetRequiredInterface,
TypeContainer.RequireMethods): Killed these two routines and moved
all the functionality to RegisterRequiredImplementations.
(TypeContainer.RegisterRequiredImplementations): This routine now
registers all the implementations required in an array for the
interfaces and abstract methods. We use an array of structures
which can be computed ahead of time to reduce memory usage and we
also assume that lookups are cheap as most classes will not
implement too many interfaces.
We also avoid creating too many MethodSignatures.
(TypeContainer.IsInterfaceMethod): Update and optionally does not
clear the "pending" bit if we find that there are problems with
the declaration.
(TypeContainer.VerifyPendingMethods): Update to report errors of
methods that look like implementations but are not.
(TypeContainer.Define): Add support for explicit interface method
implementation.
svn path=/trunk/mcs/; revision=1568
* assembly.c: yet another check for mscorlib.
* class.c, class.h: load nesting info for classes.
* icall.c: many new functions to support the Reflection classes.
* metadata.c, metadata.h: mono_metadata_nested_in_typedef() added.
* reflection.h, reflection.c: mono_image_create_token(),
mono_assembly_get_object(), mono_type_get_object(),
mono_method_get_object(), mono_field_get_object(): methods to return
objects that parallel the C representation of assemblies, types,
methods, fields.
Thu Dec 13 20:24:28 CET 2001 Paolo Molaro <[email protected]>
* interp.c: correctly handle exceptions generated in C code.
Install an handler for SIGSEGV. Bare-bones profiler and hook for the
verifier.
svn path=/trunk/mono/; revision=1567
* typemanager.cs: Keep track of the parameters here instead of
being a feature of the TypeContainer.
* class.cs: Drop the registration of parameters here, as
InterfaceMethods are also interface declarations.
* delegate.cs: Register methods with the TypeManager not only with
the TypeContainer. This code was buggy.
* interface.cs: Full registation here.
svn path=/trunk/mcs/; revision=1564
* Linux.cs: IO implemented with file handles with internal calls,
rather than casting file descriptors for C library p/invokes.
Implemented Get/Set Creation/LastAccess/LastWrite TimeFile
functions.
2001-12-11 Dick Porter <[email protected]>
* FileStream.cs: Use handles rather than casting file descriptors.
Added Handle property.
2001-12-11 Dick Porter <[email protected]>
* DateTime.cs: Implemented FromFileTime() and ToFileTime()
* Console.cs: Use handles rather than casting file descriptors
2001-12-11 Dick Porter <[email protected]>
* WaitHandle.cs: Implemented WaitAll(), WaitAny() and WaitOne() as
internal calls.
svn path=/trunk/mcs/; revision=1557
* icall.c:
* file-io.c: Internal calls for file IO.
2001-12-11 Dick Porter <[email protected]>
* io.c: Implement DeleteFile(), GetFileTime(), SetFileTime() and
FileTimeToSystemTime().
* unicode.c (unicode_len): Nasty way of finding length of unicode
string with embedded NULLs (counts until two NULLs together).
svn path=/trunk/mono/; revision=1556
* x86.brg: use position indepentent code if possible.
* x86.brg (EMIT_COND_EXCEPTION): new macro.
* emit-x86.c (mono_emit_cfg): impl. variable code buffer size
* jit.c (mono_analyze_flow): use g_malloc0 o allocate large bcinfo
blocks.
(mono_analyze_flow): use g_malloc0 o allocate large bblocks array.
svn path=/trunk/mono/; revision=1553
* statement.cs (Return.Emit): Report error 157 if the user
attempts to return from a finally block.
(Return.Emit): Instead of emitting a return, jump to the end of
the function.
* codegen.cs (EmitContext): ReturnValue, ReturnLabel: new
LocalBuilder to store the result of the function. ReturnLabel is
the target where we jump.
svn path=/trunk/mcs/; revision=1548
* cs-parser.jay: remember alias in current namespace
* ecore.cs (SimpleName::DoResolve): use aliases for types or
namespaces
* class.cs (LookupAlias): lookup alias in my_namespace
* namespace.cs (UsingAlias): add alias, namespace_or_type pair to
aliases hashtable
(LookupAlias): lookup alias in this and if needed in parent
namespaces
svn path=/trunk/mcs/; revision=1546
* support.cs:
* rootcontext.cs: (ModuleBuilder) Made static, first step into
making things static. I need this to avoid passing the
TypeContainer when calling ParameterType.
* support.cs (InternalParameters.ParameterType): Remove ugly hack
that did string manipulation to compute the type and then call
GetType. Use Parameter.ParameterType instead.
* cs-tokenizer.cs: Consume the suffix for floating values.
* expression.cs (ParameterReference): figure out whether this is a
reference parameter or not. Kill an extra variable by computing
the arg_idx during emission.
* parameter.cs (Parameters.GetParameterInfo): New overloaded
function that returns whether a parameter is an out/ref value or not.
(Parameter.ParameterType): The type of the parameter (base,
without ref/out applied).
(Parameter.Resolve): Perform resolution here.
(Parameter.ExternalType): The full type (with ref/out applied).
* statement.cs (Using.Emit, Using.EmitExpression): Implement
support for expressions on the using statement.
2001-12-07 Miguel de Icaza <[email protected]>
* statement.cs (Using.EmitLocalVariableDecls): Split the
localvariable handling of the using statement.
(Block.EmitMeta): Keep track of variable count across blocks. We
were reusing slots on separate branches of blocks.
(Try.Emit): Emit the general code block, we were not emitting it.
Check the type of the declaration to be an IDisposable or
something that can be implicity converted to it.
Emit conversions if required.
* ecore.cs (EmptyExpression): New utility class.
(Expression.ImplicitConversionExists): New utility function.
svn path=/trunk/mcs/; revision=1544
* ChangeLog: Add the change log to this directory
* System.XML.build: Add dependancy on linux target to test target.
Need to have the dll before we can test it, right? Plus it encourages
others to try 'make test'.
svn path=/trunk/mcs/; revision=1536
* ChangeLog: Add the change log to this directory
* System.build: Add dependancy on linux target to test target. Need to
have the dll before we can test it, right? Plus it encourages others
to try 'make test'.
svn path=/trunk/mcs/; revision=1535
* ChangeLog: Add the change log to this directory
* corlib.build: Add dependancy on linux target to test target. Need to have the dll before we can test it, right? Plus it encourages others to try 'make test'.
svn path=/trunk/mcs/; revision=1534
* statement.cs (Using): Implement.
* expression.cs (LocalVariableReference): Support read only variables.
* statement.cs: Remove the explicit emit for the Leave opcode.
(VariableInfo): Add a readonly field.
svn path=/trunk/mcs/; revision=1532
* makefile: added new target test-jit
* Double.cs: added the parse method from Bob Smith
* DateTime.cs: added an icall to GetNow()
svn path=/trunk/mcs/; revision=1529
* ecore.cs (ConvCast): new class used to encapsulate the various
explicit integer conversions that works in both checked and
unchecked contexts.
(Expression.ConvertNumericExplicit): Use new ConvCast class to
properly generate the overflow opcodes.
2001-12-04 Miguel de Icaza <[email protected]>
* statement.cs: The correct type for the EmptyExpression is the
svn path=/trunk/mcs/; revision=1527
* class.cs (Method::Define): Handle PInvoke methods specially
by using DefinePInvokeMethod instead of the usual one.
* attribute.cs (DefinePInvokeMethod): Implement as this is what is called
above to do the task of extracting information and defining the method.
svn path=/trunk/mcs/; revision=1525
* x86.brg: impl. UNBOX, NEWSTRUCT, removed VTYPE, bug fixes,
removed the locaddr nonterminal, reimplemented value types
* jit.c: reimplemented value type support, better support for
enumeration types.
* object.c (mono_object_allocate): removed static, so that the jit
can allocate value types.
* icall.c (ves_icall_System_DateTime_GetNow): impl.
svn path=/trunk/mono/; revision=1523
* expression.cs (ArrayCreation::EmitStaticInitializers): Get rid
of the condition for string type.
(Emit): Move that here.
(ArrayCreation::CheckIndices): Keep string literals in their expression
form.
(EmitDynamicInitializers): Handle strings appropriately.
svn path=/trunk/mcs/; revision=1522
* codegen.cs (EmitContext): Replace multiple variables with a
single pointer to the current Switch statement.
* statement.cs (GotoDefault, Switch): Adjust to cleaned up
EmitContext.
svn path=/trunk/mcs/; revision=1518
* attribute.cs (CheckAttribute): Handle system attributes by using
Attribute.GetAttributes to examine information we need.
(GetValidPlaces): Same here.
* class.cs (Method::Define): Catch invalid use of extern and abstract together.
* typemanager.cs (dllimport_type): Core type for System.DllImportAttribute.
* class.cs (Method.IsPinvoke): Used to determine if we are a PInvoke method.
(Method::Define): Set appropriate flags if we have a DllImport attribute.
(Method::Emit): Handle the case when we are a PInvoke method.
svn path=/trunk/mcs/; revision=1514
* class.c: init enum types right away and register the
token->MonoClass map in mono_class_create_from_typedef ().
* verify.h, verify.c: first cut of the verifier.
* pedump.c: add --verify switch to verify metadata tables.
* tabledefs.h: add some missing enums.
Mon Dec 3 17:16:36 CET 2001 Paolo Molaro <[email protected]>
* jit.c: call mono_init() after registering internal calls.
Mon Dec 3 17:15:44 CET 2001 Paolo Molaro <[email protected]>
* interp.c: call mono_init() after registering internal calls.
svn path=/trunk/mono/; revision=1509
* constant.cs (EmitConstant): Make sure we resolve the associated expression
before trying to reduce it.
* typemanager.cs (RegisterConstant, LookupConstant): Implement.
* constant.cs (LookupConstantValue): Implement.
(EmitConstant): Use the above in emitting the constant.
* expression.cs (MemberAccess::ResolveMemberAccess): Handle constants
that are user-defined by doing a LookupConstantValue on them.
(SimpleName::DoResolve): When we have a FieldExpr, cope with constants
too, like above.
svn path=/trunk/mcs/; revision=1504
* expression.cs (BaseAccess, BaseIndexer): Also split this out.
(BaseAccess.DoResolve): Implement.
(MemberAccess.DoResolve): Split this routine into a
ResolveMemberAccess routine that can be used independently
2001-11-28 Miguel de Icaza <[email protected]>
* expression.cs (Probe, Is, As): Split Probe in two classes Is and
As that share bits of the implementation. Is returns a boolean,
while As returns the Type that is being probbed.
svn path=/trunk/mcs/; revision=1500
* enum.cs (LookupEnumValue): Re-write various bits, return an object value
instead of a Literal - much easier.
(EnumInTransit): Remove - utterly useless :-)
(Populate): Re-write bits - remove duplicate code etc. The code is much neater now.
* expression.cs (MemberLookup): Cope with user-defined enums when they are in transit.
* enum.cs (LookupEnumValue): Auto-compute next values by going down the dependency
chain when we have no associated expression.
2001-11-30 Ravi Pratap <[email protected]>
* constant.cs (Define): Use Location while reporting the errror.
Also emit a warning when 'new' is used and there is no inherited
member to hide.
* enum.cs (EnumInTransit): Used to tell if an enum type is in the process of being
populated.
(LookupEnumValue): Implement to lookup an enum member's value and define it
if necessary.
(Populate): Re-write accordingly to use the above routine.
svn path=/trunk/mcs/; revision=1498
2001-11-30 Radek Doulik <[email protected]>
* mono-endian.h: reverted last change
added function prototypes
* Makefile.am (libmetadata_a_SOURCES): reverted my last change and
add mono-endian.c back
* mono-endian.c: returned back, as Paolo pointed out, it's needed
for unaligned access, I've mistaked it with endianess. I am
sorry.
(mono_read16): fix reverted endianess
(mono_read64): ditto
(mono_read32): ditto
svn path=/trunk/mono/; revision=1491
* metadata.h, metadata.c: remove params_size and locals_size and their
calculation from the metadata code: they are only usefult to the
interp.
Fri Nov 30 12:02:24 CET 2001 Paolo Molaro <[email protected]>
* x86.brg: rearrange fields to reduce struct size.
* jit.c: use signature->param_count, not signature->params_size.
* debug.c: off-by-one error fix.
Fri Nov 30 12:05:21 CET 2001 Paolo Molaro <[email protected]>
* interp.c: calculate locals and args offsets only once
per method call. Cache trampoline code as well.
svn path=/trunk/mono/; revision=1488
* DataSourceUtils.cs -- Internal class. Does the job of resolving data from the source based on a member element.
----- This function is required during the OnDataBinding(EventArgs) method in several of the UI.*, UI.WebControtrols.* classes
svn path=/trunk/mcs/; revision=1483
* object.c (mono_ldstr): swap bytes here, it's probably not the
best place, but works for me now, I'll redo it once I know mono
better, also note that I add PROT_WRITE and don't reset back, also
note that it's only affects big endians, so x86 should be OK
* mono-endian.h (read16): use just glib macros for both endians
* mono-endian.c: removed as glib macros are used in in
mono-endian.h so we don't need to care about endianess for read
macros as glib does that for us already
svn path=/trunk/mono/; revision=1480
* Makefile.am: build mono only for X86 architecture, compilation
fails for ppc now because of accessing registers in sigcontext
structure
svn path=/trunk/mono/; revision=1479
* class.h, class.h: take minimum alignment into consideration so
that the fields of a class remain aligned also when in an array.
svn path=/trunk/mono/; revision=1469
* debug.c: fix type handling. Position function position at start of
IL code. Output more fine-grained stepping information.
svn path=/trunk/mono/; revision=1465
* expression.cs (This): Fix prototype for DoResolveLValue to
override the base class DoResolveLValue.
* cs-parser.cs: Report errors cs574 and cs575 (destructor
declarations)
* ecore.cs (FieldExpr.EmitAssign): Handle value types specially
(we need to load the address of the field here). This fixes
test-22.
(FieldExpr.DoResolveLValue): Call the DoResolve
function to initialize the Instance expression.
* statement.cs (Foreach.Emit): Fix the bug where we did not invoke
correctly the GetEnumerator operation on a value type.
* cs-parser.jay: Add more simple parsing error catches.
* statement.cs (Switch): Add support for string switches.
Handle null specially.
* literal.cs (NullLiteral): Make NullLiteral objects singletons.
svn path=/trunk/mcs/; revision=1460
* cs-parser.jay (local_constant_declaration): Use declare_local_constant.
(declare_local_constant): New helper function.
* statement.cs (AddConstant): Keep a separate record of constants
(IsConstant): Implement to determine if a variable is a constant.
(GetConstantExpression): Implement.
* expression.cs (LocalVariableReference): Handle the case when it is a constant.
* statement.cs (IsVariableDefined): Re-write.
2001-11-27 Ravi Pratap <[email protected]>
* class.cs (TypeContainer::FindMembers): Look for constants
in the case when we are looking for MemberTypes.Field
* expression.cs (MemberAccess::DoResolve): Check that in the
case we are a FieldExpr and a Literal, we are not being accessed
by an instance reference.
* cs-parser.jay (local_constant_declaration): Implement.
(declaration_statement): Implement for constant declarations.
svn path=/trunk/mcs/; revision=1458
* Int16Test.cs Int32Test.cs SByteTest.cs: Surgically removed tests that
rely on culture of system. These need to be crafted a bit differently.
svn path=/trunk/mcs/; revision=1451
* main.c: output a marker for method (used in debug support).
Tue Nov 27 16:32:41 CET 2001 Paolo Molaro <[email protected]>
* debug.c, debug.h: added support for generating stabs.
Stabs can be compiled with as and the resulting object file can be
loaded in a gdb session with add-symbol-file object.o.
* jit.c, jit.h: add --stabs and --debug command line arguments. Keep track
where locals and arguments are stored in the stack. Add support for
passing command line arguments to CLR programs.
* emit-x86.c: insert a breakpoint at method invocation if needed.
Tue Nov 27 16:39:01 CET 2001 Paolo Molaro <[email protected]>
* loader.h, loader.c: add mono_method_get_param_names().
* class.c: 0-init class fields.
svn path=/trunk/mono/; revision=1449
* jit.c: exception support
* emit-x86.c (arch_emit_epilogue): bug fix: restore the regs in
the right order.
* mono/tests/exception3.cs: modified the test to show a bug in the
current exception handling implementation.
svn path=/trunk/mono/; revision=1446
* Thread.cs: DataSlot uses a single system TLS slot, and a
hashtable per thread. Some minor changes to reflect the new
internal calls using the new IO library, and the newly-supported
bool returns from internal calls.
* Monitor.cs: Use bool returns from internal calls now they are
supported by the runtime. Coalesce enter with the try_enter
internal call.
2001-11-26 Dick Porter <[email protected]>
* LocalDataStoreSlot.cs: No need to delete a system TLS slot in
the finalise routine any more
svn path=/trunk/mcs/; revision=1441
* icall.c:
* threads-types.h:
* threads.c: New file that handles System.Threading on all platforms
* object.c:
* object.h: Remove the synchronisation struct from MonoObject,
replace it with a pointer that gets initialised on demand
* Makefile.am: Replace all the system-specific threading code with
a single file that uses the new wrapper library
2001-11-26 Dick Porter <[email protected]>
* critical-sections.c:
* events.c:
* handles.c:
* io.c:
* mutexes.c:
* semaphores.c:
* threads.c:
* timed-thread.c:
* wait.c: turn off DEBUG messages
2001-11-26 Dick Porter <[email protected]>
* Makefile.am (mono_LDADD): Add io-layer library
svn path=/trunk/mono/; revision=1440
style elsewhere in class libraries. Comments added.
* TcpListener.cs: Same
* Socket.cs: Filled out methods and properties and commented most of
them.
svn path=/trunk/mcs/; revision=1439
* expression.cs (ArrayCreation): Get rid of ArrayExprs : we save
some memory.
(EmitDynamicInitializers): Cope with the above since we extract data
directly from ArrayData now.
(ExpectInitializers): Keep track of whether initializers are mandatory
or not.
(Bounds): Make it a hashtable to prevent the same dimension being
recorded for every element in that dimension.
(EmitDynamicInitializers): Fix bug which prevented the Set array method
from being found.
Also fix bug which was causing the indices to be emitted in the reverse
order.
svn path=/trunk/mcs/; revision=1436
* expression.cs (ArrayCreation): Implement the bits that Ravi left
unfinished. They do not work, because the underlying code is
sloppy.
2001-11-22 Miguel de Icaza <[email protected]>
* cs-parser.jay: Remove bogus fixme.
* statement.cs (Switch, SwitchSection, SwithLabel): Started work
on Switch statement.
svn path=/trunk/mcs/; revision=1434
* expression.cs (ArrayCreation::Emit): Handle string initialization separately.
(MakeByteBlob): Handle types more correctly.
* expression.cs (ArrayCreation:Emit): Write preliminary code to do
initialization from expressions but it is incomplete because I am a complete
Dodo :-|
svn path=/trunk/mcs/; revision=1430
* typemanager.cs (IsDelegateType, IsEnumType): Fix logic to determine
the same.
* expression.cs (ArrayCreation::CheckIndices): Get rid of the require_constant
parameter. Apparently, any expression is allowed.
(ValidateInitializers): Update accordingly.
(CheckIndices): Fix some tricky bugs thanks to recursion.
* delegate.cs (NewDelegate::DoResolve): Re-write large portions as
I was being completely brain-dead.
(VerifyMethod, VerifyApplicability, VerifyDelegate): Make static
and re-write acordingly.
(DelegateInvocation): Re-write accordingly.
svn path=/trunk/mcs/; revision=1428
* statement.cs (If.Emit): Fix a bug that generated incorrect code
on If. Basically, we have to return `true' (ie, we do return to
our caller) only if both branches of the if return.
* expression.cs (Binary.Emit): LogicalOr and LogicalAnd are
short-circuit operators, handle them as short circuit operators.
svn path=/trunk/mcs/; revision=1427
* expression.cs (Cast.DoResolve): Resolve type.
(Cast.Cast): Take an expression as the target type.
* cs-parser.jay (cast_expression): Remove old hack that only
allowed a limited set of types to be handled. Now we take a
unary_expression and we resolve to a type during semantic
analysis.
Use the grammar productions from Rhys to handle casts (this is
not complete like Rhys syntax yet, we fail to handle that corner
case that C# has regarding (-x), but we will get there.
svn path=/trunk/mcs/; revision=1425
* ecore.cs : The error message was correct, it's the variable's names that
were misleading ;-) Make the code more readable.
(MemberAccess::DoResolve): Fix the code which handles Enum literals to set
the correct type etc.
(ConvertExplicit): Handle Enum types by examining the underlying type.
svn path=/trunk/mcs/; revision=1424
* class.cs (EmitFieldInitializer): Take care of the case when we have a
field which is an array type.
* cs-parser.jay (declare_local_variables): Support array initialization too.
svn path=/trunk/mcs/; revision=1419
* expression.cs (Binary.ResolveOperator): Update the values of `l'
and `r' after calling DoNumericPromotions.
* ecore.cs: Fix error message (the types were in the wrong order).
* statement.cs (Foreach.ProbeCollectionType): Need to pass
BindingFlags.Instance as well
svn path=/trunk/mcs/; revision=1417
* ecore.cs (Expression.TryImplicitIntConversion): Wrap the result
implicit int literal conversion in an empty cast so that we
propagate the right type upstream.
svn path=/trunk/mcs/; revision=1413
* ecore.cs (UnboxCast): new class used to unbox value types.
(Expression.ConvertExplicit): Add explicit type conversions done
by unboxing.
(Expression.ImplicitNumericConversion): Oops, forgot to test for
the target type before applying the implicit LongLiterals to ULong
literal cast.
svn path=/trunk/mcs/; revision=1412
* cs-parser.jay (for_statement): Reworked the way For works: now
we declare manually any variables that are introduced in
for_initializer to solve the problem of having out-of-band code
emition (that is what got for broken).
(declaration_statement): Perform the actual variable declaration
that used to be done in local_variable_declaration here.
(local_variable_declaration): Do not declare anything, just pass
the information on a DictionaryEntry
svn path=/trunk/mcs/; revision=1408
* expression.cs (ArrayCreation::CheckIndices): The story continues :-) Complete
re-write of the logic to now make it recursive.
(UpdateIndices): Re-write accordingly.
Store element data in a separate ArrayData list in the above methods.
(MakeByteBlob): Implement to dump the array data into a byte array.
2001-11-19 Ravi Pratap <[email protected]>
* expression.cs (ArrayCreation): Factor out some code from ValidateInitializers
into CheckIndices.
* constant.cs (Define): Implement.
(EmitConstant): Re-write fully.
Pass in location info.
* class.cs (Populate, Emit): Call Constant::Define and Constant::EmitConstant
respectively.
* cs-parser.jay (constant_declarator): Use VariableDeclaration instead of
DictionaryEntry since we need location info too.
(constant_declaration): Update accordingly.
* expression.cs (ArrayCreation): Make ValidateInitializers simpler by factoring
code into another method : UpdateIndices.
svn path=/trunk/mcs/; revision=1395
* AssemblyBuilder.cs: add method to register a string in the "#US"
stream.
* EnumBuilder.cs, SignatureHelper.cs: added stubs.
* ILGenerator.cs: more stuff implemented.
* LocalBuilder.cs: keep track of local var index.
Mon Nov 19 13:56:55 CET 2001 Paolo Molaro <[email protected]>
* MethodBase.cs: add internal get_next_table_index() for use in
Reflection.Emit.
svn path=/trunk/mcs/; revision=1384
* class.c, class.h: add mono_install_trampoline() so that the runtime
can register a function to create a trampoline: removes the ugly
requirement that a runtime needed to export arch_create_jit_trampoline.
* object.h, object.c: added mono_install_handler() so that the runtime
can install an handler for exceptions generated in C code (with
mono_raise_exception()). Added C struct for System.Delegate.
* pedump.c: removed arch_create_jit_trampoline.
* reflection.c: some cleanups to allow registering user strings and
later getting a token for methodrefs and fieldrefs before the assembly
is built.
* row-indexes.h: updates and fixes from the new ECMA specs.
Mon Nov 19 11:36:22 CET 2001 Paolo Molaro <[email protected]>
* jit.c: use mono_install_trampoline (), instead of exporting
a function to a lower-level library.
Mon Nov 19 11:33:00 CET 2001 Paolo Molaro <[email protected]>
* interp.c: start adding support for handling exceptions across
managed/unmanaged boundaries. Cleanup Delegate method invocation.
Pass the correct target object in Delegate::Invoke and use the correct
'this' pointer in ldvirtftn (bugs pointed out by Dietmar).
Mon Nov 19 11:32:28 CET 2001 Paolo Molaro <[email protected]>
* main.c: remove arch_create_jit_trampoline().
svn path=/trunk/mono/; revision=1380
* expression.cs (ArrayCreation::ValidateInitializers): Update to perform
some type checking etc.
2001-11-17 Ravi Pratap <[email protected]>
* expression.cs (ArrayCreation::ValidateInitializers): Implement
bits to provide dimension info is user skips doing that.
Update second constructor to store the rank correctly.
2001-11-16 Ravi Pratap <[email protected]>
* expression.cs (ArrayCreation::ValidateInitializers): Poke around
and try to implement.
* ../errors/cs0150.cs : Add.
* ../errors/cs0178.cs : Add.
svn path=/trunk/mcs/; revision=1377
* statement.cs: Implement foreach on multi-dimensional arrays.
* parameter.cs (Parameters.GetParameterByName): Also lookup the
name of the params argument.
* expression.cs: Use EmitStoreOpcode to get the right opcode while
initializing the array.
(ArrayAccess.EmitStoreOpcode): move the opcode generation here, so
we can use this elsewhere.
* statement.cs: Finish implementation of foreach for single
dimension arrays.
* cs-parser.jay: Use an out-of-band stack to pass information
around, I wonder why I need this.
foreach_block: Make the new foreach_block the current_block.
* parameter.cs (Parameters.GetEmptyReadOnlyParameters): New
function used to return a static Parameters structure. Used for
empty parameters, as those are created very frequently.
* cs-parser.jay, class.cs: Use GetEmptyReadOnlyParameters
2001-11-16 Miguel de Icaza <[email protected]>
* test-34.cs: Improve this test to check if we are actually
walking over the arguments in foreach.
svn path=/trunk/mcs/; revision=1371
* x86.brg (STRING_ARG): impl. a way to marshal strings. This
will be extensible to handle all possible kinds of marshalling
requirements.
* jit.c (map_call_type): added MB_TERM_CALL_VOID
(mono_analyze_stack): impl. LDELEMA, reimplemented CALL
instructions to handle this arguments more effectively.
svn path=/trunk/mono/; revision=1369
* support.cs (ReflectionParameters): Fix logic to determine
whether the last parameter is a params one. Test 9 passes again.
* delegate.cs (Populate): Register the builders we define with
RegisterParameterForBuilder. Test 19 passes again.
* cs-parser.jay (property_declaration): Reference $6 instead
of $$ to get at the location.
(indexer_declaration): Similar stuff.
(attribute): Ditto.
* class.cs (Property): Register parameters for the Get and Set methods
if they exist. Test 23 passes again.
* expression.cs (ArrayCreation::Emit): Pass null for the method in the
call to EmitArguments as we are sure there aren't any params arguments.
Test 32 passes again.
* suppor.cs (ParameterDesc, ParameterModifier): Fix trivial bug causing
IndexOutOfRangeException.
* class.cs (Property::Define): Register property using TypeManager.RegisterProperty
Test 33 now passes again.
svn path=/trunk/mcs/; revision=1366
* cs-parser.jay: Kill horrendous hack ($??? = lexer.Location) that
broke a bunch of things. Will have to come up with a better way
of tracking locations.
svn path=/trunk/mcs/; revision=1364
* Makefile.am (mono_SOURCES): renamed testjit to mono
* x86.brg: added debugging support
* testjit.c: added support for value types, CFG improvements
* emit-x86.c (enter_method): handle value types
(tree_allocate_regs): impl. a better way to handle chain rules
svn path=/trunk/mono/; revision=1363
* enum.cs (Enum.Emit): Delay the lookup of loc until we run into
an error. This removes the lookup from the critical path.
* cs-parser.jay: Removed use of temporary_loc, which is completely
broken.
svn path=/trunk/mcs/; revision=1357
* support.cs (ReflectionParameters.ParameterModifier): Report
whether the argument is a PARAMS argument or not.
* class.cs: Set the attribute `ParamArrayAttribute' on the
parameter argument.
* typemanager.cs: Define param_array_type (ParamArrayAttribute)
and cons_param_array_attribute (ConstructorInfo for
ParamArrayAttribute).,
* codegen.cs: Emit the return using the `Return' statement, that
way we can report the error correctly for missing return values.
* class.cs (Method.Emit): Clean up.
* expression.cs (Argument.Resolve): Take another argument: the
location where this argument is used. Notice that this is not
part of the "Argument" class as to reduce the size of the
structure (we know the approximate location anyways).
Test if the argument is a variable-reference, if not, then
complain with a 206.
(Argument.Emit): Emit addresses of variables.
(Argument.FullDesc): Simplify.
(Invocation.DoResolve): Update for Argument.Resolve.
(ElementAccess.DoResolve): ditto.
svn path=/trunk/mcs/; revision=1356
* delegate.cs (DelegateInvocation.Emit): Invocation of Invoke
method should be virtual, as this method is always virtual.
svn path=/trunk/mcs/; revision=1353
* x86/tramp.c: handle boolean as a return value.
* x96/x86-codegen.c: x86_widen_memindex() added.
Wed Nov 14 19:23:00 CET 2001 Paolo Molaro <[email protected]>
* interp.c: move the stack frame dumping code to a function so it can
be called from the debugger. Fix virtual method lookup for interfaces.
Throw exceptions instead of aborting in more places.
Print also the message in an exception. Updates for field renames in
corlib.
Wed Nov 14 19:26:06 CET 2001 Paolo Molaro <[email protected]>
* class.h, class.c: add a max_interface_id to MonoClass.
* icall.c: rename my_mono_new_object() to my_mono_new_mono_type()
since it's used to do that. Added mono_type_type_from_obj().
Make GetType() return NULL instead of segfaulting if the type was not
found. Handle simple arrays in assQualifiedName.
* object.h: add a struct to represent an Exception.
* reflection.c: output call convention in method signature.
Add code to support P/Invoke methods and fixed offsets for fields.
svn path=/trunk/mono/; revision=1352
* statement.cs (Foreach.Emit): Use EmitAssign instead of Store.
* expression.cs (ParameterReference): Drop IStackStorage and implement
IAssignMethod instead.
(LocalVariableReference): ditto.
* ecore.cs (FieldExpr): Drop IStackStorage and implement
IAssignMethod instead.
2001-11-13 Miguel de Icaza <[email protected]>
* parameter.cs, expression.cs, class.cs, ecore.cs: Made all
enumerations that are used in heavily used structures derive from
byte in a laughable and pathetic attempt to reduce memory usage.
This is the kind of pre-optimzations that you should not do at
home without adult supervision.
* expression.cs (UnaryMutator): New class, used to handle ++ and
-- separatedly from the other unary operators. Cleans up the
code, and kills the ExpressionStatement dependency in Unary.
(Unary): Removed `method' and `Arguments' from this class, making
it smaller, and moving it all to SimpleCall, so I can reuse this
code in other locations and avoid creating a lot of transient data
strucutres when not required.
* cs-parser.jay: Adjust for new changes.
2001-11-11 Miguel de Icaza <[email protected]>
* enum.cs (Enum.Populate): If there is a failure during
definition, return
* cs-parser.jay (opt_enum_base): we used to catch type errors
here, but this is really incorrect. The type error should be
catched during semantic analysis.
svn path=/trunk/mcs/; revision=1347
* cs-parser.jay (operator_declarator, conversion_operator_declarator): Set
current_local_parameters as expected since I, in my stupidity, had forgotten
to do this :-)
* attribute.cs (GetValidPlaces): Fix stupid bug.
* class.cs (Method::Emit): Perform check on applicability of attributes.
(Constructor::Emit): Ditto.
(Field::Emit): Ditto.
(Field.Location): Store location information.
(Property, Event, Indexer, Operator): Ditto.
* cs-parser.jay (field_declaration): Pass in location for each field.
* ../errors/cs0592.cs : Add.
2001-11-12 Ravi Pratap <[email protected]>
* typemanager.cs (attribute_usage_type): New static member for System.AttributeUsage.
(InitCoreTypes): Update accordingly.
(RegisterAttrType, LookupAttr): Implement.
* attribute.cs (Attribute.Targets, AllowMultiple, Inherited): New fields to hold
info about the same.
(Resolve): Update to populate the above as necessary.
(Error592): Helper.
(GetValidPlaces): Helper to the above.
(CheckAttribute): Implement to perform validity of attributes on declarative elements.
* class.cs (TypeContainer::Emit): Update attribute emission code to perform checking etc.
svn path=/trunk/mcs/; revision=1343
* threads.c: Implement TLS. Implement GetCurrentThreadId(), and
GetCurrentThread() by maintaining a hash of thread handles.
* threads.h: Define thread and process creation flags
svn path=/trunk/mono/; revision=1340
* configure.in: Some more tests for pthread features
(specifically, glibc 2.1 doesnt define pthread_mutex_timedlock but
still needs _GNU_SOURCE for PTHREAD_MUTEX_RECURSIVE)
svn path=/trunk/mono/; revision=1339
* semaphores.c: Implement semaphores
* wait.c (wait_for_item): Maintain a wait count rather than count
signalled booleans.
* threads.c (thread_wait_multiple): Don't lock the wait item, that
will block other wait threads
2001-11-11 Dick Porter <[email protected]>
* Makefile.am: Rename some automake variables
(from Nick Drochak <[email protected]>)
svn path=/trunk/mono/; revision=1329
* decimal.c, decimal.h: mono_double2decimal() get the sign bit from
the value.
* icall.c: use mono_array_addr instead of array->vector: fixes the
reflection image writing.
* reflection.c: init call convention byte to 0 in method signature.
Encode the property signature. Don't output property-related methods
twice. Really process the properties for a type (don't cast a field to
a property, my mom always told me that).
Fix 64 bit issues in pointer alignment in a different and more
readable way.
svn path=/trunk/mono/; revision=1328
* CLSCompliant.cs: Marked with AttributeUsage attribute.
* Decimal.cs: Fixed CLSCompliant attributes.
* Type.cs: changed _impl to internal (needs to be accessable by
subclasses).
(TypeHandle): Marked as abstract, implementation removed.
(IsNotPublic, IsPublic, GetMethods, GetPropery, GetConstructor,
GetMethod): Added stub implementations so NUnit would link against
corlib
* FileNotFoundException.cs: Added some constructors
* Path.cs (GetFullPath): Fixed implementation
* Assembly.cs: Filled in some stub implementations
* ConstructorInfo.cs: Added some stub functions for NUnit
* TypeBuilder.cs: Added implementation for TypeHandle.
svn path=/trunk/mcs/; revision=1326
* loader.c: Loaded MonoType, removed loading of Type
* icall.c (my_mono_new_object): Now returns a System.MonoType,
and fills in System.Type._impl with a RuntimeTypeHandle rather
than the actual MonoClass *
(ves_icall_type_from_handle): change from type_class to
monotype_class
(ves_icall_System_Runtime_InteropServices_Marshal_ReadIntPtr):
implemented
(ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAuto):
implemented
(ves_icall_System_Reflection_Assembly_LoadFrom): implemented
(ves_icall_System_Reflection_Assembly_GetType): implemented
(ves_icall_System_MonoType_assQualifiedName): implemented
(ves_icall_System_PAL_OpSys_GetCurrentDirecotry): implemented
svn path=/trunk/mono/; revision=1325
* enum.cs (Emit): Rename to Populate to be more consistent with what
we expect it to do and when exactly it is called.
* class.cs, rootcontext.cs : Update accordingly.
* typemanager.cs (RegisterField, GetValue): Workarounds for the fact that
FieldInfo.GetValue does not work on dynamic types ! S.R.E lameness strikes again !
* enum.cs (Populate): Register fields with TypeManager.RegisterField.
* expression.cs (MemberAccess.DoResolve): Adjust code to obtain the value
of a fieldinfo using the above, when dealing with a FieldBuilder.
2001-11-10 Ravi Pratap <[email protected]>
* ../errors/cs0031.cs : Add.
* ../errors/cs1008.cs : Add.
* ../errrors/cs0543.cs : Add.
* enum.cs (DefineEnum): Check the underlying type and report an error if not a valid
enum type.
(FindMembers): Implement.
* typemanager.cs (FindMembers): Re-write to call the appropriate methods for
enums and delegates too.
(enum_types): Rename to builder_to_enum.
(delegate_types): Rename to builder_to_delegate.
* delegate.cs (FindMembers): Implement.
svn path=/trunk/mcs/; revision=1324
* Calendar.cs Added some functions, provided skeleton to some more
* BaseCompareValidator.cs Still wondering how to implement this
svn path=/trunk/mcs/; revision=1321
* main.c, dump, dump.c: decode the customattr table.
* dump.c: handle also field signature when dumping the memberref
table.
svn path=/trunk/mono/; revision=1318
* pthread-compat.c: added some include files to make it compile on
linux.
* x86.brg (INITOBJ): bug fix: initialize data before use,
simplified the code.
svn path=/trunk/mono/; revision=1316
* testjit.c (mono_analyze_stack): Remove compiler warning by
testing against NULL.
2001-11-09 Miguel de Icaza <[email protected]>
* assembly.c (mono_assembly_open): Implement a cache for the
assemblies.
(mono_assembly_close): only destroy the assembly when the last
reference is gone.
svn path=/trunk/mono/; revision=1312
* typemanager.cs (IsEnumType): Implement.
* enum.cs (Emit): Re-write parts to account for the underlying type
better and perform checking etc.
(GetNextDefaultValue): Helper to ensure we don't overshoot max value
of the underlying type.
* literal.cs (GetValue methods everywhere): Perform bounds checking and return
value
* enum.cs (error31): Helper to report error #31.
* cs-parser.jay (enum_declaration): Store location of each member too.
* enum.cs (member_to_location): New hashtable.
(AddEnumMember): Update location hashtable.
(Emit): Use the location of each member while reporting errors.
svn path=/trunk/mcs/; revision=1311
* configure.in: Try and get large file support, but it's not fatal
if it's not there (the io-layer just ignores the high word in that
case.)
Check for windows builds, and only bother to look for pthreads and
large files if we're not building for cygwin or native win32. Not
having pthread support on Posix systems is now a fatal error.
* autogen.sh: Fix ACLOCAL_FLAGS - it wasn't being passed to
aclocal
2001-11-08 Dick Porter <[email protected]>
* Initial checkin.
This is a library emulating the win32 threading and IO API.
2001-11-09 Dick Porter <[email protected]>
* Makefile.am (mint_LDADD): Don't need THREAD_LIBS any more
2001-11-09 Dick Porter <[email protected]>
* Makefile.am (testjit_LDADD): Don't need THREAD_LIBS any more
2001-11-09 Dick Porter <[email protected]>
* Makefile.am (pedump_LDADD): Don't need THREAD_LIBS any more
svn path=/trunk/mono/; revision=1310
* testjit.c (mono_analyze_stack): finished array support
2001-11-08 Dietmar Maurer <[email protected]>
* testjit.c (MAKE_STELEM, MAKE_LDELEM): we build a tree which
represents the address of the element. This way we can emit highly
optimized x86 instructions to access elements (using base+index+offset
adressing mode)
svn path=/trunk/mono/; revision=1305
* cs-parser.jay: A for_initializer if is a
local_variable_declaration really ammount to have an implicit
block with the variable declaration and no initializer for for.
* statement.cs (For.Emit): Cope with null initializers.
This fixes the infinite loop on for initializers.
svn path=/trunk/mcs/; revision=1303
* UrlUtils.cs Added the following functions:
GetProtocol(string) -> Returns the protocol used (before ://)
IsRootUrl(string) -> Is the url supplied is RootUrl
IsValidProtocol(string)
-> Can the protocol represent a valid protocol
RegionMatches(...) -> Matches an inner part of a string
svn path=/trunk/mcs/; revision=1302
* x86/tramp.c: Include stdlib to kill warning.
2001-11-07 Miguel de Icaza <[email protected]>
* main.c (dis_property_methods): Added missing colon which avoided
setting loc.t
2001-11-07 Miguel de Icaza <[email protected]>
* interp.c: Include stdlib to kill warning.
(check_corlib): Adjust format encodings to remove warnings.
2001-11-07 Miguel de Icaza <[email protected]>
* reflection.c (build_compressed_metadata): Eliminates warnings
and uses 64-bit clean code.
* metadata.c (mono_type_hash): Change signature to eliminate warnings.
(mono_type_equal): Change signature to eliminate warnings.
2001-11-07 Miguel de Icaza <[email protected]>
* monoburg.y: Include string.h, stdlib.h to kill warnings.
* sample.brg: Include string.h to remove warnings.
svn path=/trunk/mono/; revision=1298
* class.cs (Property): Emit attributes.
(Field): Ditto.
(Event): Ditto.
(Indexer): Ditto.
(Operator): Ditto.
* enum.cs (Emit): Ditto.
* rootcontext.cs (ResolveTree, EmitCode, CloseTypes): Do the same for
Enums too.
* class.cs (Field, Event, etc.): Move attribute generation into the
Emit method everywhere.
* enum.cs (Enum): Revamp to use the same definition semantics as delegates so
we have a DefineEnum, CloseEnum etc. The previous way of doing things was not right
as we had no way of defining nested enums !
* rootcontext.cs : Adjust code accordingly.
* typemanager.cs (AddEnumType): To keep track of enum types separately.
2001-11-07 Ravi Pratap <[email protected]>
* expression.cs (EvalConstantExpression): Move into ecore.cs
* enum.cs (Enum): Rename some members and make them public and readonly
according to our convention.
* modifiers.cs (EnumAttr): Implement as we need to set only visibility flags,
nothing else.
* enum.cs (Enum::Define): Use the above instead of TypeAttr.
(Enum::Emit): Write a simple version for now which doesn't try to compute
expressions. I shall modify this to be more robust in just a while.
* class.cs (TypeContainer::Emit): Make sure we include Enums too.
(TypeContainer::CloseType): Create the Enum types too.
* attribute.cs (Resolve): Use the new Reduce method instead of EvalConstantExpression.
* expression.cs (EvalConstantExpression): Get rid of completely.
* enum.cs (Enum::Emit): Use the new expression reducer. Implement assigning
user-defined values and other cases.
(IsValidEnumLiteral): Helper function.
* expression.cs (ExprClassfromMemberInfo): Modify to not do any literalizing
out there in the case we had a literal FieldExpr.
(MemberAccess:DoResolve): Do the literalizing of the FieldExpr here.
(Literalize): Revamp a bit to take two arguments.
(EnumLiteral): New class which derives from Literal to wrap enum literals.
2001-11-06 Ravi Pratap <[email protected]>
* cs-parser.jay (compilation_unit): Remove extra opt_attributes for now.
* expression.cs (ArrayCreation::ValidateInitializers): Implement.
(Resolve): Use the above to ensure we have proper initializers.
2001-11-05 Ravi Pratap <[email protected]>
* expression.cs (Expression::EvalConstantExpression): New method to
evaluate constant expressions.
* attribute.cs (Attribute::Resolve): Modify bits to use the above function.
svn path=/trunk/mcs/; revision=1293
* makefile(s): add 'test' target, so now you can do 'make test'
and something useful will happen.
* *.build: link NUnit test dll's with the mono assembly they are
supposed to test, and suppress 1595 warnings.
svn path=/trunk/mcs/; revision=1291
* corlib.build: put /norwarn in for 0169 and 0649 since most of the
classes have unused fields, but it's really an problem right now
because we know the class isn't finished. 'make' should be a lot
quieter now!
svn path=/trunk/mcs/; revision=1288
* expression.cs (ArrayCreation.Emit): Some bits to initialize data
in an array.
(Binary.ResolveOperator): Handle operator != (object a, object b)
and operator == (object a, object b);
(Binary.DoNumericPromotions): Indicate whether the numeric
promotion was possible.
(ArrayAccess.DoResolve, ArrayAccess.Emit, ArrayAccess.EmitAssign):
Implement.
Made the ArrayAccess implement interface IAssignMethod instead of
IStackStore as the order in which arguments are passed reflects
this.
svn path=/trunk/mcs/; revision=1284
* corlib.build: build a corlib that can be linked against the nunit
test dll's when linux is the target (just like windows).
Added /nowarn 0649 and 0169 to cut down on the compiler noise for
all the unused fields we have in the stubs.
svn path=/trunk/mcs/; revision=1283
* icall.c, loader.c: remove the internalcall array constructors.
Changes to match the new MonoArray structure.
* object.h, object.c: an array object doesn't allocate an extra
vector. Add mono_array_new_full () to create jagged arrays easily.
Mon Nov 5 19:51:06 CET 2001 Paolo Molaro <[email protected]>
* metadata.h, metadata.c: add mono_metadata_field_info () to
retreive all the info about a field from vairous tables.
* icall.c: implement S.Runtime.CServices::InitializeArray () icall.
* class.h, class.c: augment MonoClassField with more info.
Implemented mono_ldtoken for fields. Implemented ExplicitLayout
policy and load a field's RVA if needed.
Wed Nov 7 15:47:36 CET 2001 Paolo Molaro <[email protected]>
* interp.c: updates for changes in array code.
Fri Nov 2 19:06:54 CET 2001 Paolo Molaro <[email protected]>
* interp.c: hanlde field refs. Throw an exception on NULL references.
Check consistency of corlib types with the C struct representation.
svn path=/trunk/mono/; revision=1280
* emit-x86.c (enter_method): print out all method arguments
(x86_magic_trampoline): impl.
(arch_create_simple_jit_trampoline): we use different trampolines
for static methods (no need to write the address back into to
vtable).
svn path=/trunk/mono/; revision=1278
* expression.cs (ArrayCreation.Emit): Some bits to initialize data
in an array.
* typemanager.cs: Load InitializeArray definition.
* rootcontext.cs (RootContext.MakeStaticData): Used to define
static data that can be used to initialize arrays.
svn path=/trunk/mcs/; revision=1277
* expression.cs: Handle operator== and operator!= for booleans.
(Conditioal.Reduce): Implement reducer for the ?: operator.
(Conditional.Resolve): Implement dead code elimination.
(Binary.Resolve): Catch string literals and return a new
concatenated string.
(Unary.Reduce): Implement reduction of unary expressions.
* ecore.cs: Split out the expression core handling here.
(Expression.Reduce): New method used to perform constant folding
and CSE. This is needed to support constant-expressions.
* statement.cs (Statement.EmitBoolExpression): Pass true and false
targets, and optimize for !x.
svn path=/trunk/mcs/; revision=1274
Tue Nov 6 09:11:43 CET 2001 Paolo Molaro <[email protected]>
* AppDomain.cs: use an internal constructor for AssemblyBuilder.
Tue Nov 6 09:13:45 CET 2001 Paolo Molaro <[email protected]>
* AssemblyBuilder.cs: define an internal constructor.
svn path=/trunk/mcs/; revision=1272
* interp.c: hanlde field refs. Throw an exception on NULL references.
Check consistency of corlib types with the C struct representation.
Fri Nov 2 19:37:51 CET 2001 Paolo Molaro <[email protected]>
* class.h, class.c: include name in MonoClassField.
* class.c: fix fundamental type of System.Object and System.String.
Set the right fundamental type for SZARRAY, too. Handle TypeSpec
tokens in ldtoken.
* icall.c: remove internalcalls for the Reflection stuff that is now
done in C# code.
* loader.c: mono_field_from_memberref () implementation.
* mono-endian.c: thinko (s/struct/union/g).
* object.c, object.h: make the mono_string_* prototypes actually use
MonoString instead of MonoObject.
* reflection.c, reflection.h: updates for changes in the reflection
code in corlib: we use C structures that map to the actual C# classes.
Handle SZARRAYs when encoding types. Handle locals in methods. Use a
fat method header if needed and use the info from the ILGenerator for
methods. Handle fields in types. Misc fixes.
svn path=/trunk/mono/; revision=1262
* String.cs: fix a couple of bugs.
* AppDomain.cs: use new AppBuilder constructor.
* Buffer.cs, GC.cs, NonSerializedAttribute.cs,
NotImplementedException.cs, ObjectDisposedException.cs,
UnauthorizedAccessException.cs: add implementation.
* OverflowException.cs: fix class name.
Fri Nov 2 18:29:36 CET 2001 Paolo Molaro <[email protected]>
* AmbiguousMatchException.cs,
* Assembly.cs, Module.cs: updates.
* FieldInfo.cs: better compliance to the spec.
* MethodBase.cs: move call_conv out of the way.
* AssemblyBuilder.cs: don't use internalcalls, more stuff supported.
* FieldBuilder.cs: implemented.
* ILGenerator.cs: implemented some opcode handling.
* Label.cs: add constructor.
* LocalBuilder.cs: implemented.
* MethodBuilder.cs: don't use internalcalls, more implemented stuff.
* ModuleBuilder.cs: don't use internalcalls, more meat here, too.
* ParameterBuilder.cs: implemented.
* PropertyBuilder.cs: implemented.
* TypeBuilder.cs: don't use internalcalls, more stuff working.
Fri Nov 2 18:27:58 CET 2001 Paolo Molaro <[email protected]>
* DirectoryNotFoundException.cs: implemented.
svn path=/trunk/mcs/; revision=1260
* attribute.cs (Attribute::Resolve): Implement guts. Note that resolution
of an attribute gives us a CustomAttributeBuilder which we use accordingly to
set custom atttributes.
* literal.cs (Literal::GetValue): New abstract method to return the actual
value of the literal, cast as an object.
(*Literal): Implement GetValue method.
* cs-parser.jay (positional_argument_list, named_argument_list): Add not just plain
expressions to the arraylist but objects of type Argument.
* class.cs (TypeContainer::Emit): Emit our attributes too.
(Method::Emit, Constructor::Emit): Ditto.
* cs-parser.jay (constructor_declaration): Set attributes too, which we seemed
to be ignoring earlier.
2001-11-03 Ravi Pratap <[email protected]>
* attribute.cs (AttributeSection::Define): Implement to do the business
of constructing a CustomAttributeBuilder.
(Attribute): New trivial class. Increases readability of code.
* cs-parser.jay : Update accordingly.
(positional_argument_list, named_argument_list, named_argument): New rules
(attribute_arguments): Use the above so that we are more correct.
2001-11-02 Ravi Pratap <[email protected]>
* expression.cs (Invocation::IsParamsMethodApplicable): Implement
to perform all checks for a method with a params parameter.
(Invocation::OverloadResolve): Update to use the above method and therefore
cope correctly with params method invocations.
* support.cs (InternalParameters::ParameterDesc): Provide a desc for
params too.
* class.cs (ConstructorInitializer::Resolve): Make sure we look for Non-public
constructors in our parent too because we can't afford to miss out on
protected ones ;-)
* attribute.cs (AttributeSection): New name for the class Attribute
Other trivial changes to improve readability.
* cs-parser.jay (opt_attributes, attribute_section etc.): Modify to
use the new class names.
2001-11-01 Ravi Pratap <[email protected]>
* class.cs (Method::Define): Complete definition for params types too
(Indexer::Define): Ditto.
* support.cs (InternalParameters::ParameterType, ParameterDesc, ParameterModifier):
Cope everywhere with a request for info about the array parameter.
svn path=/trunk/mcs/; revision=1257
* Queue.cs: Fixed small syntax errors that were preventing the compile.
I changed the build file to include Queue.cs as well.
svn path=/trunk/mcs/; revision=1251
* RandomTest.cs: Add message to Assert() in TestDouble.
Double.ToString() is not implemented yet, so this doesn't
help.
svn path=/trunk/mcs/; revision=1250
* ArrayList.cs: Fixed "off by one" error when shifting left the array when
items are removed.
* CollectionBase.cs: Added OnValidate(), OnRemove() and OnRemoveComplete()
hook methods to the RemoveAt() method.
svn path=/trunk/mcs/; revision=1248
* emit-x86.c (enter_method): new debugging code
(leave_method): new debbuging code, this functions are called
when you use the new option --trace-calls
svn path=/trunk/mono/; revision=1246
* tree.cs (RecordNamespace): Fix up to check for the correct key.
* cs-parser.jay (GetQualifiedIdentifier): New Helper method used in
local_variable_type to extract the string corresponding to the type.
(local_variable_type): Fixup the action to use the new helper method.
* codegen.cs : Get rid of RefOrOutParameter, it's not the right way to
go.
* expression.cs : Clean out code which uses the above.
svn path=/trunk/mcs/; revision=1239
* typemanager.cs (RegisterMethod): Check if we already have an existing key
and bale out if necessary by returning a false.
(RegisterProperty): Ditto.
* class.cs (everywhere): Check the return value from TypeManager.RegisterMethod
and print out appropriate error messages.
* interface.cs (everywhere): Ditto.
* cs-parser.jay (property_declaration, event_declaration, indexer_declaration): Pass
location to constructor.
* class.cs (Property, Event, Indexer): Update accordingly.
* ../errors/cs111.cs : Added.
* expression.cs (Invocation::IsApplicable): New static method to determine applicability
of a method, as laid down by the spec.
(Invocation::OverloadResolve): Use the above method.
svn path=/trunk/mcs/; revision=1234
* support.cs (InternalParameters): Get rid of crap taking in duplicate info. We
now take a TypeContainer and a Parameters object.
(ParameterData): Modify return type of ParameterModifier method to be
Parameter.Modifier and not a string.
(ReflectionParameters, InternalParameters): Update accordingly.
* expression.cs (Argument::GetParameterModifier): Same here.
* support.cs (InternalParameters::ParameterType): Find a better way of determining
if we are a ref/out parameter. Actually, the type shouldn't be holding the '&'
symbol in it at all so maybe this is only for now.
svn path=/trunk/mcs/; revision=1232
* support.cs (InternalParameters): Constructor now takes an extra argument
which is the actual Parameters class.
(ParameterDesc): Update to provide info on ref/out modifiers.
* class.cs (everywhere): Update call to InternalParameters to pass in
the second argument too.
* support.cs (ParameterData): Add ParameterModifier, which is a method
to return the modifier info [ref/out etc]
(InternalParameters, ReflectionParameters): Implement the above.
* expression.cs (Argument::ParameterModifier): Similar function to return
info about the argument's modifiers.
(Invocation::OverloadResolve): Update to take into account matching modifiers
too.
* class.cs (Indexer::Define): Actually define a Parameter object and put it onto
a new SetFormalParameters object which we pass to InternalParameters.
svn path=/trunk/mcs/; revision=1230
* expression.cs (NewArray): Merge into the ArrayCreation class.
2001-10-29 Ravi Pratap <[email protected]>
* expression.cs (NewArray): Merge classes NewBuiltinArray and
NewUserdefinedArray into one as there wasn't much of a use in having
two separate ones.
* expression.cs (Argument): Change field's name to ArgType from Type.
(Type): New readonly property which returns the proper type, taking into
account ref/out modifiers.
(everywhere): Adjust code accordingly for the above.
* codegen.cs (EmitContext.RefOrOutParameter): New field to determine
whether we are emitting for a ref or out parameter.
* expression.cs (Argument::Emit): Use the above field to set the state.
(LocalVariableReference::Emit): Update to honour the flag and emit the
right stuff.
* parameter.cs (Attributes): Set the correct flags for ref parameters.
* expression.cs (Argument::FullDesc): New function to provide a full desc.
* support.cs (ParameterData): Add method ParameterDesc to the interface.
(ReflectionParameters, InternalParameters): Implement the above method.
* expression.cs (Invocation::OverloadResolve): Use the new desc methods in
reporting errors.
(Invocation::FullMethodDesc): Ditto.
svn path=/trunk/mcs/; revision=1229
* cs-parser.jay: Add extra production for the second form of array
creation.
* expression.cs (ArrayCreation): Update to reflect the above
change.
svn path=/trunk/mcs/; revision=1228
* StringBuilder.cs: Throw exceptions when constructor paramter(s) are
invalid. Just like MS does (as best as I can tell).
Tests for these exceptions are now added to the unit tests as well.
svn path=/trunk/mcs/; revision=1225
* typemanager.cs (ImplementsInterface): interface might be null;
Deal with this problem;
Also, we do store negative hits on the cache (null values), so use
this instead of calling t.GetInterfaces on the type everytime.
svn path=/trunk/mcs/; revision=1222
* typemanager.cs (IsBuiltinType): New method to help determine the same.
* expression.cs (New::DoResolve): Get rid of array creation code and instead
split functionality out into different classes.
(New::FormArrayType): Move into NewBuiltinArray.
(Invocation::EmitArguments): Get rid of the MethodBase argument. Appears
quite useless.
(NewBuiltinArray): New class to handle creation of built-in arrays.
(NewBuiltinArray::DoResolve): Implement guts of array creation. Also take into
account creation of one-dimensional arrays.
(::Emit): Implement to use Newarr and Newobj opcodes accordingly.
(NewUserdefinedArray::DoResolve): Implement.
* cs-parser.jay (local_variable_type): Fix up to add the rank to the variable too.
* typemanager.cs (AddModule): Used to add a ModuleBuilder to the list of modules
we maintain inside the TypeManager. This is necessary to perform lookups on the
module builder.
(LookupType): Update to perform GetType on the module builders too.
* driver.cs (Driver): Add the ModuleBuilder to the list maintained by the TypeManager.
* exprssion.cs (NewUserdefinedArray::Emit): Implement.
svn path=/trunk/mcs/; revision=1221
* Delegate.cs (Delegate.CombineImpl): Implement.
(Delegate.Combine): Implement.
* MulticastDelegate.cs (MulticastDelegate.Equals): Implement.
(MulticastDelegate.CombineImpl): This was not as trivial as I
thought.
* ContextStaticAttribute.cs: Added AttributeUsage to
ContextStaticAttribute.
* FlagsAttribute.cs: Add AttributeUsage to FlagsAttribute
svn path=/trunk/mcs/; revision=1216
* expression.cs:
(Expression.Resolve): Report a 246 error (can not resolve name)
if we find a SimpleName in the stream.
(Expression.ResolveLValue): Ditto.
(Expression.ResolveWithSimpleName): This function is a variant of
ResolveName, this one allows SimpleNames to be returned without a
warning. The only consumer of SimpleNames is MemberAccess
svn path=/trunk/mcs/; revision=1213
* expression.cs (Invocation::DoResolve): Catch SimpleNames that
might arrive here. I have my doubts that this is correct.
* statement.cs (Lock): Implement lock statement.
* cs-parser.jay: Small fixes to support `lock' and `using'
* cs-tokenizer.cs: Remove extra space
* driver.cs: New flag --checked, allows to turn on integer math
checking.
* typemanger.cs: Load methodinfos for Threading.Monitor.Enter and
Threading.Monitor.Exit
svn path=/trunk/mcs/; revision=1207
interpreter (although new warning are now there, we need to get the
Decimal internalcalls in place).
Implement some bits of CultureInfo, but it is yet far from finished.
svn path=/trunk/mcs/; revision=1205
* StringBuilder.cs: Throw exception if they try to make a StringBuilder
whose capacity is greater than the MaxCapacity.
I added some tests for the constructors and the above exception. More
coming soon.
svn path=/trunk/mcs/; revision=1198
* StringBuilder.cs: Refactored constructor code into just one
constructor. All the other construtors call it. Also supplied missing
constructors so the class has all those in the spec.
Added the MaxCapacity property as well, however this needs to be
completed to return a value is related to the available system memory.
svn path=/trunk/mcs/; revision=1197
* typemanager.cs (ImplementsInterface): New method to determine if a type
implements a given interface. Provides a nice cache too.
* expression.cs (ImplicitReferenceConversion): Update checks to use the above
method.
(ConvertReferenceExplicit): Ditto.
* delegate.cs (Delegate::Populate): Update to define the parameters on the
various methods, with correct names etc.
* class.cs (Operator::OpType): New members Operator.UnaryPlus and
Operator.UnaryNegation.
* cs-parser.jay (operator_declarator): Be a little clever in the case where
we have a unary plus or minus operator.
* expression.cs (Unary): Rename memebers of Operator enum to UnaryPlus and
UnaryMinus.
* everywhere : update accordingly.
* everywhere : Change Negate and BitComplement to LogicalNot and OnesComplement
respectively.
* class.cs (Method::Define): For the case where we are implementing a method
inherited from an interface, we need to set the MethodAttributes.Final flag too.
Also set MethodAttributes.NewSlot and MethodAttributes.HideBySig.
svn path=/trunk/mcs/; revision=1194
* makefile : New target 'verify' which uses the verifier to check
that executables produced by us are identical to the MS' produced ones.
* test-7.cs : Update to exercise more overloadable operators.
svn path=/trunk/mcs/; revision=1193
* interface.cs (FindMembers): Implement to work around S.R.E
lameness.
* typemanager.cs (IsInterfaceType): Implement.
(FindMembers): Update to handle interface types too.
* expression.cs (ImplicitReferenceConversion): Re-write bits which
use IsAssignableFrom as that is not correct - it doesn't work.
* delegate.cs (DelegateInvocation): Derive from ExpressionStatement
and accordingly override EmitStatement.
* expression.cs (ConvertReferenceExplicit): Re-write similary, this time
using the correct logic :-)
svn path=/trunk/mcs/; revision=1188
* assign.cs (Assign::Resolve): Resolve right hand side first, and
then pass this as a hint to ResolveLValue.
* expression.cs (FieldExpr): Add Location information
(FieldExpr::LValueResolve): Report assignment to readonly
variable.
(Expression::ExprClassFromMemberInfo): Pass location information.
(Expression::ResolveLValue): Add new method that resolves an
LValue.
(Expression::DoResolveLValue): Default invocation calls
DoResolve.
(Indexers): New class used to keep track of indexers in a given
Type.
(IStackStore): Renamed from LValue, as it did not really describe
what this did. Also ResolveLValue is gone from this interface and
now is part of Expression.
(ElementAccess): Depending on the element access type
* typemanager.cs: Add `indexer_name_type' as a Core type
(System.Runtime.CompilerServices.IndexerNameAttribute)
* statement.cs (Goto): Take a location.
svn path=/trunk/mcs/; revision=1185
System.build: Fixed clean target
System.XML.build: Output changed to System.Xml.dll not from System.XML
corlib.build: More things excluded from testing corlib
HashtableTest.cs: Don't print extra debug info during tests
Windows.cs: Added code to read/write/open/close files
svn path=/trunk/mcs/; revision=1181
* delegate.cs (Delegate::VerifyDelegate): New method to verify
if two delegates are compatible.
(NewDelegate::DoResolve): Update to take care of the case when
we instantiate a delegate from another delegate.
* typemanager.cs (FindMembers): Don't even try to look up members
of Delegate types for now.
svn path=/trunk/mcs/; revision=1180
* delegate.cs (NewDelegate): New class to take care of delegate
instantiation.
* expression.cs (New): Split the delegate related code out into
the NewDelegate class.
* delegate.cs (DelegateInvocation): New class to handle delegate
invocation.
* expression.cs (Invocation): Split out delegate related code into
the DelegateInvocation class.
svn path=/trunk/mcs/; revision=1178
* expression.cs (New::DoResolve): Implement delegate creation fully
and according to the spec.
(New::DoEmit): Update to handle delegates differently.
(Invocation::FullMethodDesc): Fix major stupid bug thanks to me
because of which we were printing out arguments in reverse order !
* delegate.cs (VerifyMethod): Implement to check if the given method
matches the delegate.
(FullDelegateDesc): Implement.
(VerifyApplicability): Implement.
* expression.cs (Invocation::DoResolve): Update to accordingly handle
delegate invocations too.
(Invocation::Emit): Ditto.
* ../errors/cs1593.cs : Added.
* ../errors/cs1594.cs : Added.
* delegate.cs (InstanceExpression, TargetMethod): New properties.
2001-10-16 Ravi Pratap <[email protected]>
* typemanager.cs (intptr_type): Core type for System.IntPtr
(InitCoreTypes): Update for the same.
(iasyncresult_type, asynccallback_type): Ditto.
* delegate.cs (Populate): Fix to use System.Intptr as it is indeed
correct.
* typemanager.cs (AddDelegateType): Store a pointer to the Delegate class
too.
* delegate.cs (ConstructorBuilder, InvokeBuilder, ...): New members to hold
the builders for the 4 members of a delegate type :-)
(Populate): Define the BeginInvoke and EndInvoke methods on the delegate
type.
* expression.cs (New::DoResolve): Implement guts for delegate creation.
* ../errors/errors.txt : Update for an error (-11) which only we catch :-)
svn path=/trunk/mcs/; revision=1175
* statement.cs (Break::Emit): Implement.
(Continue::Emit): Implement.
(For::Emit): Track old being/end loops; Set Begin loop, ack end loop
(While::Emit): Track old being/end loops; Set Begin loop, ack end loop
(Do::Emit): Track old being/end loops; Set Begin loop, ack end loop
(Foreach::Emit): Track old being/end loops; Set Begin loop, ack
end loop
* codegen.cs (EmitContext::LoopEnd, EmitContext::LoopBegin): New
properties that track the label for the current loop (begin of the
loop and end of the loop).
svn path=/trunk/mcs/; revision=1169
* delegate.cs (Emit): Get rid of it as there doesn't seem to be any ostensible
use of emitting anything at all.
* class.cs, rootcontext.cs : Get rid of calls to the same.
* delegate.cs (DefineDelegate): Make sure the class we define is also sealed.
(Populate): Define the constructor correctly and set the implementation
attributes.
* typemanager.cs (delegate_types): New hashtable to hold delegates that
have been defined.
(AddDelegateType): Implement.
(IsDelegateType): Implement helper method.
* delegate.cs (DefineDelegate): Use AddDelegateType instead of AddUserType.
* expression.cs (New::DoResolve): Check if we are trying to instantiate a delegate type
and accordingly handle it.
* delegate.cs (Populate): Take TypeContainer argument.
Implement bits to define the Invoke method. However, I still haven't figured out
how to take care of the native int bit :-(
* cs-parser.jay (delegate_declaration): Fixed the bug that I had introduced :-)
Qualify the name of the delegate, not its return type !
* expression.cs (ImplicitReferenceConversion): Implement guts of implicit array
conversion.
(StandardConversionExists): Checking for array types turns out to be recursive.
(ConvertReferenceExplicit): Implement array conversion.
(ExplicitReferenceConversionExists): New method to determine precisely that :-)
2001-10-12 Ravi Pratap <[email protected]>
* cs-parser.jay (delegate_declaration): Store the fully qualified
name as it is a type declaration.
* delegate.cs (ReturnType, Name): Rename members to these. Make them
readonly.
(DefineDelegate): Renamed from Define. Does the same thing essentially,
as TypeContainer::DefineType.
(Populate): Method in which all the definition of the various methods (Invoke)
etc is done.
(Emit): Emit any code, if necessary. I am not sure about this really, but let's
see.
(CloseDelegate): Finally creates the delegate.
* class.cs (TypeContainer::DefineType): Update to define delegates.
(Populate, Emit and CloseType): Do the same thing here too.
* rootcontext.cs (ResolveTree, PopulateTypes, EmitCode, CloseTypes): Include
delegates in all these operations.
svn path=/trunk/mcs/; revision=1167
* class.c (mono_class_metadata_init): interface offset table now
contains pointers into the vtable - this is more efficient for the jit
* class.c (mono_class_metadata_init): use a temporary vtable (the
old algorithm only worked for the interpreter, but not for the jit)
* loader.c (method_from_memberref): use mono_class_get to get the
class of an array instead of using System.Array directly.
(mono_get_method): also add MEMBERREF methods to the method cache
which usefull for arrays.
* pedump.c (arch_compile_method): added to compute vtable entry
* interp.c: removed newobj()
* interp.c (get_virtual_method): use the vtable
(arch_compile_method): added to compute vtable entry
* x86.brg: added some experimental code for CALL
instructions - still not found the optimal way to do it.
* testjit.c (map_stind_type): add support for value types with
a size of 1, 2 or 4 bytes, implemented CEE_UNBOX, CEE_LDOBJ,
CEE_LDSTR, CEE_LDFLD, CEE_LDFLDA, CEE_STFLD, CEE_NEWOBJ, CEE_CEQ
(ctree_create_newobj): impl.
* emit-x86.c (tree_allocate_regs): removed allocation code for
addr nonterminal.
(get_address): use a simple, but bug free search instead of the
buggy binary search.
* testjit.c: support virtual functions
svn path=/trunk/mono/; revision=1166
* expression.cs: LocalTemporary: a new expression used to
reference a temporary that has been created.
* assign.cs: Handle PropertyAccess back here, so that we can
provide the proper semantic access to properties.
svn path=/trunk/mcs/; revision=1165
* expression.cs (Expression::ConvertReferenceExplicit): Implement
a few more explicit conversions.
* modifiers.cs: `NEW' modifier maps to HideBySig.
* expression.cs (PropertyExpr): Make this into an
ExpressionStatement, and support the EmitStatement code path.
Perform get/set error checking, clean up the interface.
* assign.cs: recognize PropertyExprs as targets, and if so, turn
them into toplevel access objects.
svn path=/trunk/mcs/; revision=1164
* expression.cs: PropertyExpr::PropertyExpr: use work around the
SRE.
* typemanager.cs: Keep track here of our PropertyBuilders again to
work around lameness in SRE.
svn path=/trunk/mcs/; revision=1158
* expression.cs (LValue::LValueResolve): New method in the
interface, used to perform a second resolution pass for LValues.
(This::DoResolve): Catch the use of this in static methods.
(This::LValueResolve): Implement.
(This::Store): Remove warning, assigning to `this' in structures
is
svn path=/trunk/mcs/; revision=1157
* expression.cs (Invocation::Emit): Deal with invocation of
methods on value types. We need to pass the address to structure
methods rather than the object itself. (The equivalent code to
emit "this" for structures leaves the entire structure on the
stack instead of a pointer to it).
(ParameterReference::DoResolve): Compute the real index for the
argument based on whether the method takes or not a `this' pointer
(ie, the method is static).
* codegen.cs (EmitContext::GetTemporaryStorage): Used to store
value types returned from functions when we need to invoke a
method on the sturcture.
svn path=/trunk/mcs/; revision=1147
* class.cs (TypeContainer::DefineType): Method to actually do the business of
defining the type in the Modulebuilder or Typebuilder. This is to take
care of nested types which need to be defined on the TypeBuilder using
DefineNestedMethod.
(TypeContainer::GetClassBases): Implement. Essentially the code from the
methods in RootContext, only ported to be part of TypeContainer.
(TypeContainer::GetInterfaceOrClass): Ditto.
(TypeContainer::LookupInterfaceOrClass, ::MakeFQN): Ditto.
* interface.cs (Interface::DefineInterface): New method. Does exactly
what RootContext.CreateInterface did earlier, only it takes care of nested types
too.
(Interface::GetInterfaces): Move from RootContext here and port.
(Interface::GetInterfaceByName): Same here.
* rootcontext.cs (ResolveTree): Re-write.
(PopulateTypes): Re-write.
* class.cs (TypeContainer::Populate): Populate nested types too.
(TypeContainer::Emit): Emit nested members too.
* typemanager.cs (AddUserType): Do not make use of the FullName property,
instead just use the name argument passed in as it is already fully
qualified.
(FindMembers): Check in the Builders to TypeContainer mapping instead of the name
to TypeContainer mapping to see if a type is user-defined.
* class.cs (TypeContainer::CloseType): Implement.
(TypeContainer::DefineDefaultConstructor): Use Basename, not Name while creating
the default constructor.
(TypeContainer::Populate): Fix minor bug which led to creating default constructors
twice.
(Constructor::IsDefault): Fix up logic to determine if it is the default constructor
* interface.cs (CloseType): Create the type here.
* rootcontext.cs (CloseTypes): Re-write to recursively close types by running through
the hierarchy.
Remove all the methods which are now in TypeContainer.
2001-10-10 Ravi Pratap <[email protected]>
* delegate.cs (Define): Re-write bits to define the delegate
correctly.
svn path=/trunk/mcs/; revision=1145
* interp.c (get_virtual_method): use the vtable
* metadata.c (mono_metadata_interfaces_from_typedef): also return the
number of interfaces.
* class.h: merged MonoArrayClass into MonoClass
* class.c (mono_class_create_from_typedef): compute the vtable size and
allocate space to include the vtable inside MonoClass
(mono_class_metadata_init): initialize the vtable
svn path=/trunk/mono/; revision=1128
* makefile: Renamed the compiler to `mcs.exe' instead of compiler.exe
* expression.cs (ImplicitReferenceConversion): handle null as well
as a source to convert to any reference type.
* statement.cs (Return): Perform any implicit conversions to
expected return type.
Validate use of return statement.
* codegen.cs (EmitContext): Pass the expected return type here.
* class.cs (Method, Constructor, Property): Pass expected return
type to EmitContext.
2001-10-09 Miguel de Icaza <[email protected]>
* expression.cs: Make DoResolve take an EmitContext instead of a
TypeContainer.
Replaced `l' and `location' for `loc', for consistency.
(Error, Warning): Remove unneeded Tc argument.
* assign.cs, literal.cs, constant.cs: Update to new calling
convention.
* codegen.cs: EmitContext now contains a flag indicating whether
code is being generated in a static method or not.
* cs-parser.jay: DecomposeQI, new function that replaces the old
QualifiedIdentifier. Now we always decompose the assembled
strings from qualified_identifier productions into a group of
memberaccesses.
2001-10-08 Miguel de Icaza <[email protected]>
* rootcontext.cs: Deal with field-less struct types correctly now
by passing the size option to Define Type.
* class.cs: Removed hack that created one static field.
2001-10-07 Miguel de Icaza <[email protected]>
* statement.cs: Moved most of the code generation here.
svn path=/trunk/mcs/; revision=1126
* expression.cs (New::DoResolve): Revert changes for array creation, doesn't
seem very right.
(ElementAccess): Remove useless bits for now - keep checks as the spec
says.
svn path=/trunk/mcs/; revision=1123
* configure.in: define NO_UNALIGNED_ACCESS for platforms that
can't read on unaligned boundaries
Mon Oct 8 16:12:38 CEST 2001 Paolo Molaro <[email protected]>
* metadata.c, metadata.h: use MonoArrayType to describe the shape of an array.
Guard against calling bsearch with a NULL pointer (pointed out by Laurent Rioux, smoux).
* image.c: endian fixes by Laurent Rioux.
* object.h, object.c: rename MonoStringObject to MonoString and
MonoArrayObject to MonoArray. Change some function names to conform to
the style mono_<object>_<action>. mono_string_new_utf16 () takes a
guint16* as first argument, so don't use char*.
Provide macros to do the interesting things on arrays in a portable way.
* threads-pthread.c: updates for the API changes and #include <sched.h>
(required for sched_yield()).
* icall.c: updates for the API changes above.
* Makefile.am, mono-endian.c. mono-endian.h: include unaligned read routines for
platforms that need them.
Mon Oct 8 16:13:55 CEST 2001 Paolo Molaro <[email protected]>
* get.c, get.h: MonoArray changed in MonoArrayType.
* main.c: guard against calling bsearch with a NULL pointer
(pointed out by Laurent Rioux, smoux).
Mon Oct 8 16:13:07 CEST 2001 Paolo Molaro <[email protected]>
* x86/tramp.c: remove mono_get_ansi_string () and use
mono_string_to_utf8 () instead.
Mon Oct 8 16:14:40 CEST 2001 Paolo Molaro <[email protected]>
* interp.c: use the accessors provided in object.h to deal with
MonoArrays. Updates for API renames in metadata. Throw exception
in ldelema if index is out of bounds.
svn path=/trunk/mono/; revision=1122
* cs-parser.jay (type_suffix*): Remove - they are redundant. Use
rank_specifiers instead.
(rank_specifiers): Change the order in which the rank specifiers are stored
(local_variable_declaration): Use opt_rank_specifier instead of type_suffixes.
* expression.cs (ElementAccess): Implement the LValue interface too.
2001-10-06 Ravi Pratap <[email protected]>
* expression.cs (ConvertExplicitStandard): Add. Same as ConvertExplicit
except that user defined conversions are not included.
(UserDefinedConversion): Update to use the ConvertExplicitStandard to
perform the conversion of the return type, if necessary.
(New::DoResolve): Check whether we are creating an array or an object
and accordingly do the needful.
(New::Emit): Same here.
(New::DoResolve): Implement guts of array creation.
(New::FormLookupType): Helper function.
svn path=/trunk/mcs/; revision=1121
* class.c: set the correct type for all the fundamental
type when loading the class.
Mon Oct 8 10:44:25 CEST 2001 Paolo Molaro <[email protected]>
* interp.c: fixes for changes in metadata.
svn path=/trunk/mono/; revision=1118
* codegen.cs: Added support for try/catch/finalize and throw.
* cs-parser.jay: Added support for try/catch/finalize.
svn path=/trunk/mcs/; revision=1117
2001-10-07 Miguel de Icaza <[email protected]>
* Exception.cs: Implement bits of serialization.
* RuntimeFieldHandle.cs: Implement Serialization features.
* Type.cs: Implement TypeHandle property.
2001-10-07 Miguel de Icaza <[email protected]>
* AssemblyBuilder.cs: Reformatted.
Added override keywords to those that needed them.
Removed methods that we do not override, but just inherit
2001-10-07 Miguel de Icaza <[email protected]>
* Encoding.cs, UTF8Encoding.cs, UTF7Encoding.cs, ASCIIEncoding.cs,
UnicodeEncoding.cs: Corrected API.
* UTF8Encoding.cs: Checked in changes from Rafael.
svn path=/trunk/mcs/; revision=1113
* expression.cs (UserCast): This user cast was not really doing
what it was supposed to do. Which is to be born in fully resolved
state. Parts of the resolution were being performed at Emit time!
Fixed this code.
svn path=/trunk/mcs/; revision=1109
* expression.cs: Implicity convert the result from UserCast.
Include the test from Ravi that exhibits the bug.
New classes from Toelen.
svn path=/trunk/mcs/; revision=1102
* expression.cs (Expression::FindMostEncompassingType): Fix bug which
prevented it from working correctly.
(ConvertExplicit): Make the first try, a call to ConvertImplicitStandard, not
merely ConvertImplicit.
svn path=/trunk/mcs/; revision=1100
* test-16.cs : Update to exercise the code which selects the best
conversion operator based on "most encompassing/encompassed type"
* test-7.cs : Update here too.
svn path=/trunk/mcs/; revision=1099
* expression.cs (Expression::ImplicitUserConversion): Rename to
UserDefinedConversion.
(Expression::UserDefinedConversion): Take an extra argument specifying
whether we look for explicit user conversions too.
(Expression::ImplicitUserConversion): Make it a call to UserDefinedConversion.
(UserDefinedConversion): Incorporate support for user defined explicit conversions.
(ExplicitUserConversion): Make it a call to UserDefinedConversion
with the appropriate arguments.
* cs-parser.jay (cast_expression): Record location too.
* expression.cs (Cast): Record location info.
(Expression::ConvertExplicit): Take location argument.
(UserImplicitCast): Change name to UserCast. Take an extra constructor argument
to determine if we are doing explicit conversions.
(UserCast::Emit): Update accordingly.
(Expression::ConvertExplicit): Report an error if everything fails.
* ../errors/cs0030.cs : Add.
svn path=/trunk/mcs/; revision=1091
* class.cs (TypeContainer::RegisterRequiredImplementations):
Record methods we need.
(TypeContainer::MakeKey): Helper function to make keys for
MethodBases, since the Methodbase key is useless.
(TypeContainer::Populate): Call RegisterRequiredImplementations
before defining the methods.
Create a mapping for method_builders_to_methods ahead of time
instead of inside a tight loop.
(::RequireMethods): Accept an object as the data to set into the
hashtable so we can report interface vs abstract method mismatch.
svn path=/trunk/mcs/; revision=1080
* class.c: MonoTypes stored in MonoClass are stored as
fundamental MonoTypes when the class represents a
fundamental type (System.Int32, ...).
The TypeHandle return by ldtoken is a MonoType*.
* icall.c: ves_icall_get_data_chunk () write out all the
PE/COFF stuff. Implement ves_icall_define_method (),
ves_icall_set_method_body (), ves_icall_type_from_handle ().
* image.c: properly skip unknown streams.
* loader.h, loader.c: add type_class to mono_defaults.
* metadata.c, metadata.h: export compute_size () as
mono_metadata_compute_size () with a better interface.
Typo and C&P fixes.
* pedump.c: don't try to print the entry point RVA if there is no entry point.
* reflection.c, reflection.h: many cleanups, fixes, output method
signatures and headers, typedef and typeref info, compress the metadata
tables, output all the heap streams, cli header etc.
* row-indexes.h: typo fixes.
Thu Oct 4 19:09:13 CEST 2001 Paolo Molaro <[email protected]>
* x86/tramp.c: allow marshalling valuetypes if they are
4 bytes long.
Thu Oct 4 19:05:56 CEST 2001 Paolo Molaro <[email protected]>
* dis-cil.c: fix printing of exception stuff.
* dump.c: display some more info in the typedef table dump.
* main.c: typo fix and method list fix.
svn path=/trunk/mono/; revision=1071
* configure.in: Do some deeper checks on pthreads for some of the
more interesting functions
2001-10-04 Dick Porter <[email protected]>
* object.h: Add a synchronisation mutex struct to MonoObject
* object.c (mono_new_object): Initialise the object
synchronisation mutexes
* icall.c: System.Threading.Monitor internal calls
* threads-pthread.h:
* threads-pthread.c: System.Threading.Monitor internal calls
* threads-types.h: New file, includes the system-specific thread
structures
* threads-pthread-types.h:
* threads-pthread-types.c: New files, handle pthread-specific
synchronisation types
* threads-dummy-types.h:
* threads-dummy-types.c: New files of dummy support for
thread-specific types
* metadata.c:
* image.c:
* pedump.c: include mono-endian.h not endian.h
* Makefile.am: More threads files.
Name mono-endian.h not endian.h
2001-10-04 Dick Porter <[email protected]>
* meta.h: include mono-endian.h not endian.h
2001-10-04 Dick Porter <[email protected]>
* interp.c (ves_runtime_method): init_class() the
mono_defaults.delegate_class
Include mono-endian.h not endian.h
2001-10-04 Dick Porter <[email protected]>
* testjit.c:
* emit-x86.c: include mono-endian.h not endian.h
svn path=/trunk/mono/; revision=1069
* expression.cs (Binary::DoNumericPromotions): Fix the case when
we do a forcible conversion regardless of type, to check if
ForceConversion returns a null.
(Binary::error19): Use location to report error.
(Unary::error23): Use location here too.
* ../errors/cs0019.cs : Check in.
* ../errors/cs0023.cs : Check in.
* expression.cs (Expression.MemberLookup): Return null for a rather esoteric
case of a non-null MethodInfo object with a length of 0 !
(Binary::ResolveOperator): Flag error if overload resolution fails to find
an applicable member - according to the spec :-)
Also fix logic to find members in base types.
(Unary::ResolveOperator): Same here.
(Unary::report23): Change name to error23 and make first argument a TypeContainer
as I was getting thoroughly confused between this and error19 :-)
* expression.cs (Expression::ImplicitUserConversion): Re-write fully
(::FindMostEncompassedType): Implement.
(::FindMostEncompassingType): Implement.
(::StandardConversionExists): Implement.
(UserImplicitCast): Re-vamp. We now need info about most specific
source and target types so that we can do the necessary conversions.
(Invocation::MakeUnionSet): Completely re-write to make sure we form a proper
mathematical union with no duplicates.
svn path=/trunk/mcs/; revision=1065
* Makefile.am, reflection.h, reflection.c: move here the reflection related
stuff and implement a few more bits.
* icall.c: a field needs to be dereferenced twice. Do not use the same
name for two variables in the same scope.
* image.c, image.h: cleanups.
svn path=/trunk/mono/; revision=1059
* testjit.c (ctree_create_dup): really duplicate the tree.
attach the arguments to the CALL node. Added a neiw macro to
make argument order configurable (ARCH_ARGS_RIGHT_TO_LEFT).
svn path=/trunk/mono/; revision=1053
* expression.cs (Unary::ResolveOperator): Find operators on base type
too - we now conform exactly to the spec.
(Binary::ResolveOperator): Same here.
* class.cs (Operator::Define): Fix minor quirk in the tests.
* ../errors/cs0215.cs : Added.
* ../errors/cs0556.cs : Added.
* ../errors/cs0555.cs : Added.
svn path=/trunk/mcs/; revision=1050
* icall.c: implemented some of the Reflection internalcalls.
* image.c, image.h: start writing out the PE/COFF image.
* metadata.h, metadata.c: implement mono_metadata_encode_value ()
that does the reverse than decode_blob_size ().
* object.c: use mono_metadata_encode_value (). Move here
temporary implementation of mono_string_to_utf8 ().
* rawbuffer.c: make malloc_map static.
svn path=/trunk/mono/; revision=1045
needs a _file_ handle).
Idem, avoid corruption calling fseek on a file handle (use lseek instead).
This file should be reworked to be 64 bits clean.
svn path=/trunk/mcs/; revision=1043
* expression.cs (Expression::ImplicitUserConversion): Use location
even in the case when we are examining True operators.
* class.cs (Operator::Define): Perform extensive checks to conform
with the rules for operator overloading in the spec.
* expression.cs (Expression::ImplicitReferenceConversion): Implement
some of the other conversions mentioned in the spec.
* typemanager.cs (array_type): New static member for the System.Array built-in
type.
(cloneable_interface): For System.ICloneable interface.
* driver.cs (Driver::Driver): Initialize TypeManager's core types even before
we start resolving the tree and populating types.
* ../errors/errors.txt : Update for error numbers -7, -8, -9, -10
svn path=/trunk/mcs/; revision=1041
* expression.cs (Expression::ExprClassFromMemberInfo,
Expression::Literalize): Create literal expressions from
FieldInfos which are literals.
(ConvertNumericExplicit, ImplicitNumericConversion): Fix a few
type casts, because they were wrong. The test suite in tests
caught these ones.
(ImplicitNumericConversion): ushort to ulong requires a widening
cast.
Int32 constant to long requires widening cast as well.
* literal.cs (LongLiteral::EmitLong): Do not generate i4 constants
for integers because the type on the stack is not i4.
svn path=/trunk/mcs/; revision=1038
* expression.cs (report118): require location argument.
* parameter.cs: Do not dereference potential null value.
* class.cs: Catch methods that lack the `new' keyword when
overriding a name. Report warnings when `new' is used without
anything being there to override.
* modifiers.cs: Handle `NEW' as MethodAttributes.NewSlot.
svn path=/trunk/mcs/; revision=1036
* class.cs: Only add constructor to hashtable if it is non-null
(as now constructors can fail on define).
(TypeManager, Class, Struct): Take location arguments.
Catch field instance initialization in structs as errors.
accepting_filter: a new filter for FindMembers that is static so
that we dont create an instance per invocation.
(Constructor::Define): Catch errors where a struct constructor is
parameterless
* cs-parser.jay: Pass location information for various new
constructs.
* delegate.cs (Delegate): take a location argument.
* driver.cs: Do not call EmitCode if there were problesm in the
Definition of the types, as many Builders wont be there.
* decl.cs (Decl::Decl): Require a location argument.
* cs-tokenizer.cs: Handle properly hex constants that can not fit
into integers, and find the most appropiate integer for it.
* literal.cs: Implement ULongLiteral.
* rootcontext.cs: Provide better information about the location of
failure when CreateType fails.
2001-09-29 Miguel de Icaza <[email protected]>
* rootcontext.cs (RootContext::PopulateTypes): Populates structs
as well.
* expression.cs (Binary::CheckShiftArguments): Add missing type
computation.
(Binary::ResolveOperator): Add type to the logical and and logical
or, Bitwise And/Or and Exclusive Or code paths, it was missing
before.
(Binary::DoNumericPromotions): In the case where either argument
is ulong (and most signed types combined with ulong cause an
error) perform implicit integer constant conversions as well.
svn path=/trunk/mcs/; revision=1035
* expression.cs (UserImplicitCast): Method should always be
non-null.
(Invocation::BetterConversion): Simplified test for IntLiteral.
(Expression::ImplicitNumericConversion): Split this routine out.
Put the code that performs implicit constant integer conversions
here.
(Expression::Resolve): Become a wrapper around DoResolve so we can
check eclass and type being set after resolve.
(Invocation::Badness): Remove this dead function
(Binary::ResolveOperator): Do not compute the expensive argumnets
unless we have a union for it.
svn path=/trunk/mcs/; revision=1031
* expression.cs (Probe::Emit): Is needs to do an isinst and then
compare against null.
(::CanConvert): Added Location argument. If the Location argument
is null (Location.Null), then we do not report errors. This is
used by the `probe' mechanism of the Explicit conversion. We do
not want to generate an error for something that the user
explicitly requested to be casted. But the pipeline for an
explicit cast first tests for potential implicit casts.
So for now, if the Location is null, it means `Probe only' to
avoid adding another argument. Might have to revise this
strategy later.
(ClassCast): New class used to type cast objects into arbitrary
classes (used in Explicit Reference Conversions).
Implement `as' as well.
Reverted all the patches from Ravi below: they were broken:
* The use of `level' as a mechanism to stop recursive
invocations is wrong. That was there just to catch the
bug with a strack trace but not as a way of addressing
the problem.
To fix the problem we have to *understand* what is going
on and the interactions and come up with a plan, not
just get things going.
* The use of the type conversion cache that I proposed
last night had an open topic: How does this work across
protection domains. A user defined conversion might not
be public in the location where we are applying the
conversion, a different conversion might be selected
(ie, private A->B (better) but public B->A (worse),
inside A, A->B applies, but outside it, B->A will
apply).
* On top of that (ie, even if the above is solved),
conversions in a cache need to be abstract. Ie, `To
convert from an Int to a Short use an OpcodeCast', not
`To convert from an Int to a Short use the OpcodeCast on
the variable 5' (which is what this patch was doing).
svn path=/trunk/mcs/; revision=1029
* metadata.c: fix type comparison for arrays.
* loader.h, loader.c: half-assed fix to get more tests work in cygwin.
Added a couple of new classes to monodefaults.
* icall.c: added a couple of Reflection-related internalcalls.
* class.h, class.c: implemented mono_ldtoken () for RuntimeTypeHandles.
Added a byval_arg MonoType to MonoClass.
Fri Sep 28 19:43:12 CEST 2001 Paolo Molaro <[email protected]>
* x86/tramp.c: marshal valuetypes that are enums.
Fri Sep 28 19:37:46 CEST 2001 Paolo Molaro <[email protected]>
* interp.c: Implemented ldtoken, conv.ovf.i. Use MonoClass->byval_arg
(and remove related kludges). Don't choke on access to arrays of
references. Throw an exception when an internalcall or P/Invoke
function don't have an implementation. Throw and EngineException
for unimplemented opcodes.
svn path=/trunk/mono/; revision=1027
* icall.c:
* threads-pthread.h:
* threads-pthread.c: Implemented internal calls for
LocalDataStoreSlot operations. Applied mutexes around all shared
data. Reworked the thread creation and Start() operations to
avoid a race condition.
* threads-dummy.h:
* threads-dummy.c: Dummy calls for the LocalDataStoreSlot operations
svn path=/trunk/mono/; revision=1026
* expression.cs (Invocation::ConversionExists): Re-write to use
the conversion cache
(Expression::ConvertImplicit): Automatic bailing out if level != 0. Also
cache all conversions done, not just user-defined ones.
(Invocation::BetterConversion): The real culprit. Use ConversionExists
to determine if a conversion exists instead of acutually trying to
perform the conversion. It's faster too.
(Expression::ConvertExplicit): Modify to use ConversionExists to check
and only then attempt the implicit conversion.
svn path=/trunk/mcs/; revision=1023
* typemanager.cs (string_concat_string_string, string_concat_object_object):
Export standard methods that we expect for string operations.
* statement.cs (Block::UsageWarning): Track usage of variables and
report the errors for not used variables.
* expression.cs (Conditional::Resolve, ::Emit): Implement ?:
operator.
svn path=/trunk/mcs/; revision=1018
* expression.cs: Fix the order in which implicit conversions are
done.
The previous fixed dropped support for boxed conversions (adding a
test to the test suite now)
(UserImplicitCast::CanConvert): Remove test for source being null,
that code is broken. We should not feed a null to begin with, if
we do, then we should track the bug where the problem originates
and not try to cover it up here.
Return a resolved expression of type UserImplicitCast on success
rather than true/false. Ravi: this is what I was talking about,
the pattern is to use a static method as a "constructor" for
objects.
Also, do not create arguments until the very last minute,
otherwise we always create the arguments even for lookups that
will never be performed.
(UserImplicitCast::Resolve): Eliminate, objects of type
UserImplicitCast are born in a fully resolved state.
svn path=/trunk/mcs/; revision=1013
* expression.cs (LValue): Add new method AddressOf to be used by
the `&' operator.
Change the argument of Store to take an EmitContext instead of an
ILGenerator, because things like FieldExpr need to be able to call
their children expression to generate the instance code.
(Expression::Error, Expression::Warning): Sugar functions for
reporting errors.
(Expression::MemberLookup): Accept a TypeContainer instead of a
Report as the first argument.
(Expression::ResolvePrimary): Killed. I still want to improve
this as currently the code is just not right.
(Expression::ResolveMemberAccess): Simplify, but it is still
wrong.
(Unary::Resolve): Catch errors in AddressOf operators.
(LocalVariableReference::Emit, ::Store, ::AddressOf): typecast
index to a byte for the short-version, or the compiler will choose
the wrong Emit call, which generates the wrong data.
(ParameterReference::Emit, ::Store): same.
(FieldExpr::AddressOf): Implement.
* typemanager.cs: TypeManager: made public variable instead of
property.
* driver.cs: document --fatal.
* report.cs (ErrorMessage, WarningMessage): new names for the old
Error and Warning classes.
* cs-parser.jay (member_access): Turn built-in access to types
into a normal simplename
svn path=/trunk/mcs/; revision=1009
* class.c, loader.c: warn and return NULL instead of erroring out.
* icall.c: added System.AppDomain::getCurDomain().
* loader.c: we don't need to lookup the typedef again for p/invoke calls.
svn path=/trunk/mono/; revision=1004
* testjit.c: impl. LDIND/STIND/LDLOCA, use g_malloc to alloc static
data.
(map_stind_type): support enum types
(map_ldind_type): support enum types
* emit-x86.c (tree_allocate_regs): added code to support
register allocation for addressing modes trees.
(tree_emit): bug fix: we have to emit all mono_burg_functins. The
previous impl. did not work for chain rules.
(compute_branches): support for SWITCH statements
* x86.brg: added rules to model x86 addressing modes
svn path=/trunk/mono/; revision=997
* class.cs (TypeContainer::AddConstructor): Fix a stupid bug
I had introduced long ago (what's new ?).
* expression.cs (UserImplicitCast::CanConvert): Static method to do
the work of all the checking.
(ConvertImplicit): Call CanConvert and only then create object if necessary.
(UserImplicitCast::CanConvert, ::Resolve): Re-write.
(Unary::Operator): Rename Add and Subtract to Addition and Subtraction because
that is the right way.
(Invocation::MakeUnionSet): Convenience function to make unions of sets for
overloading resolution. Use everywhere instead of cutting and pasting code.
(Binary::ResolveOperator): Use MakeUnionSet.
(UserImplicitCast::CanConvert, ::Resolve): Update to take care of the case when
we have to convert to bool types. Not complete yet.
svn path=/trunk/mcs/; revision=994
* typemanager.cs (TypeManager::CSharpName): support ushort.
* expression.cs (Expression::TryImplicitIntConversion): Attempts
to provide an expression that performsn an implicit constant int
conversion (section 6.1.6).
(Expression::ConvertImplicitRequired): Reworked to include
implicit constant expression conversions.
(Expression::ConvertNumericExplicit): Finished.
(Invocation::Emit): If InstanceExpression is null, then it means
that we perform a call on this.
svn path=/trunk/mcs/; revision=992
* cs-parser.jay: Update operator constants.
* parameter.cs (Parameters::GetParameterInfo): Hook up VerifyArgs
(Parameters::GetSignature): Hook up VerifyArgs here.
(Parameters::VerifyArgs): Verifies that no two arguments have the
same name.
* class.cs (Operator): Update the operator names to reflect the
ones that the spec expects (as we are just stringizing the
operator names).
* expression.cs (Unary::ResolveOperator): Fix bug: Use
MethodInfo's ReturnType instead of LookupMethodByBuilder as the
previous usage did only work for our methods.
(Expression::ConvertImplicit): Handle decimal implicit numeric
conversions as well.
(Expression::InternalTypeConstructor): Used to invoke constructors
on internal types for default promotions.
(Unary::Emit): Implement special handling for the pre/post
increment/decrement for overloaded operators, as they need to have
the same semantics as the other operators.
(Binary::ResolveOperator): ditto.
(Invocation::ConversionExists): ditto.
(UserImplicitCast::Resolve): ditto.
svn path=/trunk/mcs/; revision=988
* expression.cs (Unary::Emit and Binary::Emit): If we have an overloaded
operator, return after emitting body. Regression tests pass again !
* expression.cs (ConvertImplicit): Take TypeContainer as first argument
(Unary::ForceConversion, Binary::ForceConversion): Ditto.
(Invocation::OverloadResolve): Ditto.
(Invocation::BetterFunction, BetterConversion, ConversionExists): Ditto.
* everywhere : update calls to the above methods accordingly.
svn path=/trunk/mcs/; revision=968
* emit-x86.c (arch_compile_method): more documentation.
* testjit.c: moved the architecture specific things to emit-x86.c
and x86.brg. Added more documentation. code cleanup.
svn path=/trunk/mono/; revision=966
* x86.brg: we now have different types of addresses: ADDR_L for local
values, ADDR_A for arguments and ADDR_G for global addresses. We
also use LDIND_XX token to load values from a specific address
instead of LDLOC/STLOC.
* testjit.c: use the new adressing scheme everywhere:
LDIND _XX (ADDR_X), and STIND_XX (ADDR_X, tree)
svn path=/trunk/mono/; revision=957
* expression.cs (Binary::ResolveOperator): Had forgottten to set
the type of the expression to the return type of the method if
we have an overloaded operator match ! The regression tests pass again !
(Unary::ResolveOperator): Ditto.
* expression.cs (Invocation::ConversionExists): Correct the member lookup
to find "op_Implicit", not "implicit" ;-)
(UserImplicitCast): New class to take care of user-defined implicit conversions.
(ConvertImplicit, ForceConversion): Take TypeContainer argument
* everywhere : Correct calls to the above accordingly.
* expression.cs (UserImplicitCast::Resolve, ::Emit): Implement.
(ConvertImplicit): Do user-defined conversion if it exists.
svn path=/trunk/mcs/; revision=952
* String.cs: don't access the string array out of bounds in LastIndexOf.
* Type.cs: fix return type of the Assembly property.
svn path=/trunk/mcs/; revision=951
* assign.cs: track location.
(Resolve): Use implicit conversions on assignment.
* literal.cs: Oops. Not good, Emit of short access values should
pass (Bytes) or the wrong argument will be selected.
* expression.cs (Unary::Emit): Emit code for -expr.
(Unary::ResolveOperator): Handle `Substract' for non-constants
(substract from zero from the non-constants).
Deal with Doubles as well.
(Expression::ConvertImplicitRequired): New routine that reports an
error if no implicit conversion exists.
(Invocation::OverloadResolve): Store the converted implicit
expressions if we make them
svn path=/trunk/mcs/; revision=945
* x86/tramp.c: don't change a MONO_TYPE_STRING to a char*
when it's an argument to an internalcall.
Mon Sep 24 18:56:59 CEST 2001 Paolo Molaro <[email protected]>
* object.c, object.h: added mono_ldstr (), mono_string_is_interned () and
mono_string_intern () to implement the semantics of the ldstr opcode
and the interning of System.Strings.
* icall.c: provide hooks to make String::IsIntern and String::Intern
internalcalls.
Mon Sep 24 18:50:25 CEST 2001 Paolo Molaro <[email protected]>
* interp.c: catch a few more error conditions with exceptions instead of
erroring out.
Don't use g_print() in stack traces because it doesn't work with
some float values.
When we call an instance method of a valuetype class, unbox the 'this'
argument if it is an object.
Use mono_ldstr () to implement the ldstr opcode: it takes care of
interning the string if necessary.
Implemented new opcodes: ckfinite, cgt.un, clt.un, ldvirtftn, ldarga.
Fixes to handle NaNs when comparing doubles.
Make sure the loaded assembly has an entry point defined.
Fixed portability bugs in neg and not opcodes.
svn path=/trunk/mono/; revision=943
* class.cs (ConstructorInitializer): Take a Location argument.
(ConstructorBaseInitializer): Same here.
(ConstructorThisInitializer): Same here.
* cs-parser.jay : Update all calls accordingly.
* expression.cs (Unary, Binary, New): Take location argument.
Update accordingly everywhere.
* cs-parser.jay : Update all calls to the above to take a location
argument.
* class.cs : Ditto.
svn path=/trunk/mcs/; revision=939
* threads-dummy.c:
* threads-dummy.h: New files of dummy threading routines
* Makefile.am (THREAD_SOURCE): Arrange to compile different thread
support code based on system specifics
Rename PTHREAD_LIBS to THREAD_LIBS
2001-09-23 Dick Porter <[email protected]>
* configure.in: Arrange to compile dummy thread support routines
if pthread isnt available
2001-09-23 Dick Porter <[email protected]>
* Makefile.am (testjit_LDADD): rename PTHREAD_LIBS to THREAD_LIBS
2001-09-23 Dick Porter <[email protected]>
* Makefile.am (mint_LDADD): rename PTHREAD_LIBS to THREAD_LIBS
svn path=/trunk/mono/; revision=934
* threads-pthread.c: Implement the System.Threading.Thread::Sleep,
Schedule (called when asked to Sleep for 0 ms) and CurrentThread
internal calls.
(mono_thread_init): Set up a Thread object instance to return when
the main thread calls Thread.CurrentThread
(mono_thread_cleanup): Wait for all subthreads to exit
* icall.c: New internal calls for System.Threading.Thread::Sleep
(including Schedule) and CurrentThread
* threads.h: New file, to insulate thread-specific stuff from the
rest of the code
2001-09-23 Dick Porter <[email protected]>
* interp.c (main): Do some thread setup and cleanup around the
call to ves_exec()
2001-09-23 Dick Porter <[email protected]>
* configure.in: Check for pthread.h, so that we can check for the
HAVE_PTHREAD_H define in config.h
svn path=/trunk/mono/; revision=933
* testjit.c: use the memory pool to avoid memory leaks
monoburg.c: add a macro MBALLOC_STATE to define the allocation
function for MBState. Added an additional user data argument to
mono_burg_label - the data can be used in the cost functions. The
type can be defined with MBCOST_DATA macro.
(emit_cost_func): inline cost functions
svn path=/trunk/mono/; revision=928
* expression.cs (OverloadResolve): Improve some more to catch errors 1502 and 1503
Also take an additional TypeContainer argument.
* All over : Pass in TypeContainer as argument to OverloadResolve.
* typemanager.cs (CSharpName): Update to check for the string type and return
that too.
* expression.cs (Invocation::FullMethodDesc): New static method to return a string fully describing
a given method.
svn path=/trunk/mcs/; revision=925
* threads-pthread.h:
* threads-pthread.c: New file, for handling pthreads-style
threading support. Start() now starts a new thread and executes
the ThreadStart delegate instance.
* icall.c: Added the internalcall for
System.Threading.Thread::Start_internal
* Makefile.am: Added new files, and PTHREADS_LIBS to the link line
2001-09-21 Dick Porter <[email protected]>
* Makefile.am (testjit_LDADD): Added PTHREAD_LIBS to the link line
2001-09-21 Dick Porter <[email protected]>
* Makefile.am (mint_LDADD): Added PTHREAD_LIBS to the link line
2001-09-21 Dick Porter <[email protected]>
* configure.in: Check for libpthread
svn path=/trunk/mono/; revision=914
* expression.cs (Invocation::OverloadResolve): Re-write to conform more to the spec.
(Invocation::BetterFunction): Implement.
(Invocation::BetterConversion): Implement.
(Invocation::ConversionExists): Skeleton, no implementation yet.
Okay, things work fine !
svn path=/trunk/mcs/; revision=912
* x86.brg: implemented long MUL/DIV
* testjit.c (tree_allocate_regs): added a way to prevent EDX usage
for operations like idiv. it is also possible to assign specific registers.
svn path=/trunk/mono/; revision=907
* typemanager.cs: declare and load enum_type, delegate_type and
void_type.
* expression.cs (Expression::Emit): Now emit returns a value that
tells whether a value is left on the stack or not. This strategy
might be reveted tomorrow with a mechanism that would address
multiple assignments.
(Expression::report118): Utility routine to report mismatches on
the ExprClass.
(Unary::Report23): Report impossible type/operator combination
utility function.
(Unary::IsIncrementableNumber): Whether the type can be
incremented or decremented with add.
(Unary::ResolveOperator): Also allow enumerations to be bitwise
complemented.
(Unary::ResolveOperator): Implement ++, !, ~, ++ and --.
(Unvocation::Emit): Deal with new Emit convetion.
* All Expression derivatives: Updated their Emit method to return
whether they leave values on the stack or not.
* codegen.cs (CodeGen::EmitStatement): Pop values left on the
stack for expressions that are statements.
2001-09-20 Miguel de Icaza <[email protected]>
* expression.cs (LValue): New interface. Must be implemented by
LValue objects.
(LocalVariableReference, ParameterReference, FieldExpr): Implement
LValue interface.
* assign.cs (Assign::Emit, Assign::Resolve): Use new LValue
interface for generating code, simplifies the code.
svn path=/trunk/mcs/; revision=906
* interp.c: implemented some more opcodes: calli, rem.un,
shr.un, conv.u, cpobj, stobj, conv.r.un, conv.ovf.i1.un,
conv.ovf.i2.un, conv.ovf.i4.un, conv.ovf.i8.un, conv.ovf.i.un,
conv.ovf.u1.un, conv.ovf.u2.un, conv.ovf.u4.un, conv.ovf.u8.un,
conv.ovf.u.un.
Fix some 64 bit issues in the array element access code and a small bug.
Throw an exception on index out of range instead of asserting.
Throw an exception on a NULL array instead of dying.
Stomped a memory corruption bug (.cctor methods were freed after
executing them, but they are stores in MonoClass now...).
Added a simple facility to invoke the debugger when a named
function is entered (use the cmdline option --debug method_name).
* interp.h: fix 64 bit issue.
svn path=/trunk/mono/; revision=904
* loader.c: work around the different signatures for delegates
constructors csc generates in compiled code vs the ones compiled in mscorlib.
svn path=/trunk/mono/; revision=902
* driver.cs (parse): Report error 2001 if we can not open the
source file.
* expression.cs (SimpleName::ResolveSimpleName): Error if we can
not resolve it.
svn path=/trunk/mcs/; revision=893
* statement.cs (Block::EmitMeta): Reuse the count across all the variables,
otherwise nested blocks end up with the same index.
* codegen.cs (CodeGen::EmitTopBlock): Pass initial sequence
svn path=/trunk/mcs/; revision=891
* expression.cs: Instead of having FIXMEs in the Resolve
functions, throw exceptions so it is obvious that we are facing a
bug.
* cs-parser.jay (invocation_expression): Pass Location information.
* codegen.cs (CodeGen::Save, CodeGen::CodeGen, CodeGen::Basename):
Use a basename for those routines because .NET does not like paths
on them.
* class.cs (TypeContainer::AddMethod): Do not call DefineName if the name was
already defined.
2001-09-19 Miguel de Icaza <[email protected]>
* typemanager.cs (TypeManager::CoreLookupType): A function to make sure that we
are loading the correct data types (throws an exception if not).
(TypeManager::InitCoreTypes): Use CoreLookupType
* expression.cs (Unary::ResolveOperator): return the child
expression for expressions which are just +expr.
(Unary::ResolveOperator): Return negative literals for -LITERAL
expressions (otherwise they are Unary {Literal}).
(Invocation::Badness): Take into account `Implicit constant
expression conversions'.
* literal.cs (LongLiteral): Implement long literal class.
(IntLiteral): export the `Value' of the intliteral.
svn path=/trunk/mcs/; revision=890
* x86.brg: added more floating point grammar
* testjit.c (mono_compile_method): make local offsets negative
* mono/tests/test-ops.cs: added more tests
svn path=/trunk/mono/; revision=883
* expression.cs (Binary::Emit): Finally get the emission right ! Woo!
* class.cs (Operator::Define): Change the methodname prefix to 'op_'
instead of 'Operator'
* expression.cs (Binary::ResolveOperator): Update accordingly.
(Unary::Operator): Change names to 'Add' and 'Subtract' instead 'Plus'
and 'Minus'
* cs-parser.jay (unary_expression): Update to use the new names.
* gen-treedump.cs (GetUnary): Same here.
* expression.cs (Unary::Resolve): Implement.
(Binary::ResolveOperator): Re-write bits to quietly continue if no overloaded
operators are found instead of making noise ;-)
(Unary::ResolveOperator): New method to do precisely the same thing which
Binary::ResolveOperator does for Binary expressions.
(Unary.method, .Arguments): Add.
(Unary::OperName): Implement.
(Unary::ForceConversion): Copy and Paste !
* class.cs (Operator::Define): Fix a small bug for the case when we have
a unary operator.
* expression.cs (Unary::Emit): Implement. Need to find the right Opcodes
for the inbuilt operators. Only overloading works for now ;-)
svn path=/trunk/mcs/; revision=882
* testjit.c (mono_compile_method): arguments on the runtime
stack are at least 4 bytes
* x86.brg: partly implemented 8,16 bit integers
* testjit.c (get_address): mark basic blocks
svn path=/trunk/mono/; revision=880
echo"This is a list of pending classes, and links to their documentation on MSDN.Microsoft.com<p><p>" > pending-classes
for i in `cat pending-classes.in`;dox=`echo$$i | sed s/\\\.//g`;link=`echo http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrf@@@ClassTopic.asp | sed "s/@@@/$$x/"`;echo" <a href=\"$$link\">$$i</a><br>" >> pending-classes;done
To start developing classes or to contribute to the compiler,
you only need Windows and the .NET Beta 2 SDK. Please notice
you only need Windows and the .NET Framework 1.0 SDK. Please notice
that you do not need Visual Studio (although you can use it if
you want).
You can get it <a href="http://msdn.microsoft.com/downloads/default.asp?url=/downloads/sample.asp?url=/msdn-files/027/000/976/msdncompositedoc.xml&frame=true">here</a>
Alternatively you can use the <a
href="#compile-service">compilation service</a> that was setup by
Derek.
** Bug reporting
If you find bugs in Mono, please make sure you enter a bug
@@ -44,32 +40,21 @@
A few smaller tasks are here, dropped in no particular order:
<ul>
* <b>MCS compilation process:</b> Currently MCS does
not build with a single `make' command. This should
be fixed (this being part of the `Joel Test' that
software has to pass).
* <b>Mono/doc and web site:</b> They need to be
packaged up in the official `distribution'
* Adding serialization support to all the classes.
We have many classes, but we have not implemented in
many cases the serialization and re-incarnation support in
them (this is pretty straight forward code, and simple,
but there is a lot to be done here).
</ul>
<a name="compile-service">
* C# Compilation Service
* Emacs support
If you are working on a class for the Mono project, but do not
have a C# compiler available or a Windows machine to run the
.NET SDK, you can use the compilation service that Derek
The <a href="http://msdn.microsoft.com/net">Microsoft.NET site.
The Microsoft .NET Framework 1.0 can be downloaded <a href="http://msdn.microsoft.com/downloads/default.asp?url=/downloads/sample.asp?url=/msdn-files/027/000/976/msdncompositedoc.xml&frame=true">here</a>
New methods that are not documented in 1.0, are documented <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndotnet/html/framewrkaddend.asp">here</a>
** IRC
Various Mono contributors get together on channel #mono on
* <a href="http://research.microsoft.com/copyright/accept.asp?path=http://www.research.microsoft.com/~drh/pubs/iburg.pdf&pub=ACM">Engineering efficient code generators using tree matching and dynamic programming.</a>
* VCODE.
</ul>
** Garbage Collection
We have decided to implement a generational tracing garbage
collector, which is very similar to the one being used by
.NET. For an introduction to the garbage collection system
used by Microsoft's CLR implementation, you can read this book
/// Represents a SQL statement that is executed while connected to a data source, and is implemented by .NET data providers that access relational databases.
/// Provides a means of reading one or more forward-only streams of result sets obtained by executing a command at a data source, and is implemented by .NET data providers that access relational databases.
/// Represents a SQL statement that is executed while connected to a data source, and is implemented by .NET data providers that access relational databases.
/// Specifies the type of SQL query to be used by the OleDbRowUpdatedEventArgs, OleDbRowUpdatingEventArgs, SqlRowUpdatedEventArgs, or SqlRowUpdatingEventArgs class.
Loaded 100 of 1648 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.