2001-09-27 Ravi Pratap * expression.cs (UserImplicitCast::Resolve): Fix bug. 2001-09-27 Ravi Pratap * 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. 2001-09-27 Miguel de Icaza * 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. 2001-09-26 Miguel de Icaza * expression.cs (Unary::Emit): Remove some dead code. (Probe): Implement Resolve and Emit for `is'. (Expression::ConvertImplicitRequired): Attempt to do constant expression conversions here. Maybe should be moved to ConvertImplicit, but I am not sure. (Expression::ImplicitLongConstantConversionPossible, Expression::ImplicitIntConstantConversionPossible): New functions that tell whether is it possible to apply an implicit constant expression conversion. (ConvertNumericExplicit): Started work on explicit numeric conversions. * 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. 2001-09-26 Ravi Pratap * 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. 2001-09-26 Miguel de Icaza * assign.cs (Assign): Make it inherit from ExpressionStatement. * expression.cs (ExpressionStatement): New base class used for expressions that can appear in statements, so that we can provide an alternate path to generate expression that do not leave a value on the stack. (Expression::Emit, and all the derivatives): We no longer return whether a value is left on the stack or not. Every expression after being emitted leaves a single value on the stack. * codegen.cs (EmitContext::EmitStatementExpression): Use the facilties of ExpressionStatement if possible. * cs-parser.jay: Update statement_expression. 2001-09-25 Miguel de Icaza * driver.cs: Change the wording of message 2001-09-25 Ravi Pratap * 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. 2001-09-24 Miguel de Icaza * 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 2001-09-24 Ravi Pratap * 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. 2001-09-24 Ravi Pratap * expression.cs (Invocation::BetterFunction): Take TypeContainer argument (Invocation::BetterConversion): Same here (Invocation::ConversionExists): Ditto. (Invocation::ConversionExists): Implement. 2001-09-22 Ravi Pratap * 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. 2001-09-21 Ravi Pratap * 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 ! 2001-09-21 Miguel de Icaza * 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 --. (Invocation::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 * 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. 2001-09-20 Ravi Pratap * expression.cs (everywhere): Comment out return statements in ::Resolve methods to avoid the warnings. 2001-09-20 Miguel de Icaza * 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. * cs-parser.jay (QualifierIdentifier): Pass location to SimpleName object. * 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 * 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 * 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. 2001-09-19 Ravi Pratap * 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 ;-) 2001-09-18 Miguel de Icaza * expression.cs (CheckedExpr::Resolve, CheckedExpr::Emit, UnCheckedExpr::Resolve, UnCheckedExpr::Emit): Implement. * expression.cs (This::Emit): Implement. (This::Resolve): Implement. (TypeOf:Resolve): Implement. (Expression::ResolveSimpleName): Add an implicit this to instance field references. (MemberAccess::Resolve): Deal with Parameters and Fields. Bind instance variable to Field expressions. (FieldExpr::Instance): New field used to track the expression that represents the object instance. (FieldExpr::Resolve): Track potential errors from MemberLookup not binding (FieldExpr::Emit): Implement. * codegen.cs (EmitIf, EmitStatement, EmitBlock): Propagate whether the last instruction contains a return opcode to avoid generating the last `ret' instruction (this generates correct code, and it is nice to pass the peverify output). * class.cs (TypeContainer::EmitFieldInitializers): Implement field initializer for static and instance variables. (Constructor::Emit): Allow initializer to be null in the case of static constructors. Only emit initializer for instance constructors. (TypeContainer::FindMembers): Return a null array if there are no matches. Also fix the code for the MemberTypes.Method branch, as it was not scanning that for operators (or tried to access null variables before). * assign.cs (Assign::Emit): Handle instance and static fields. * TODO: Updated. * driver.cs: Stop compilation if there are parse errors. * cs-parser.jay (constructor_declaration): Provide default base initializer for non-static constructors. (constructor_declarator): Do not provide a default base initializers if none was specified. Catch the fact that constructors should not have parameters. * class.cs: Do not emit parent class initializers for static constructors, that should be flagged as an error. 2001-09-18 Ravi Pratap * class.cs (RegisterMethodBuilder): Remove : it's unnecessary. Move back code into TypeContainer::Populate. 2001-09-18 Ravi Pratap * class.cs (TypeContainer::AddConstructor): Fix the check to compare against Name, not Basename. (Operator::OpType): Change Plus and Minus to Add and Subtract. * cs-parser.jay : Update accordingly. * class.cs (TypeContainer::FindMembers): For the case where we are searching for methods, don't forget to look into the operators too. (RegisterMethodBuilder): Helper method to take care of this for methods, constructors and operators. (Operator::Define): Completely revamp. (Operator.OperatorMethod, MethodName): New fields. (TypeContainer::Populate): Move the registering of builders into RegisterMethodBuilder. (Operator::Emit): Re-write. * expression.cs (Binary::Emit): Comment out code path to emit method invocation stuff for the case when we have a user defined operator. I am just not able to get it right ! 2001-09-17 Miguel de Icaza * expression.cs (Expression::OverloadResolve): Drop TypeContainer argument. (Expression::MemberLookup): Provide a version that allows to specify the MemberTypes and BindingFlags. * statement.cs (Block::GetVariableInfo): Forgot to recurse here, so it was not fetching variable information from outer blocks. * modifiers.cs: (Modifiers::TypeAttr): Invert condition on Beforefieldinit as it was buggy. * rootcontext.cs (::LookupInterfaceOrClass): Removed an Error -200 that Ravi put here. * class.cs (Constructor::Emit): Only emit if block is not null. (TypeContainer::EmitDefaultConstructor): Removed routine, now we deal with this by semantically definining it as if the user had done it. (TypeContainer::FindMembers): Removed ad-hoc hack to deal with constructors as we now "emit" them at a higher level. (TypeContainer::DefineDefaultConstructor): Used to define the default constructors if none was provided. (ConstructorInitializer): Add methods Resolve and Emit. * expression.cs: Cast to ConstructorInfo instead of MethodInfo 2001-09-17 Ravi Pratap * class.cs (TypeContainer::EmitDefaultConstructor): Register the default constructor builder with our hashtable for methodbuilders to methodcores. * expression.cs (Invocation::OverloadResolve): Add a check for pd == null and argument_count is 0 in which case we have a match. (Binary::ResolveOperator): More null checking and miscellaneous coding style cleanup. 2001-09-17 Ravi Pratap * rootcontext.cs (IsNameSpace): Compare against null. * everywhere : Correct spelling to 'Greater' and to 'Subtract' * class.cs (Operator::OpType): Change names to match the ones in Binary::Operator and Unary::Operator. * cs-parser.jay (operator_declaration, CheckBinaryOperator, CheckUnaryOperator): Update accordingly. * expression.cs (Binary::method): New member to hold the MethodBase for the case when we have overloaded operators. (Binary::ResolveOperator): Implement the part which does the operator overload resolution. * class.cs (Operator::Emit): Implement. (TypeContainer::Emit): Emit the operators we have too. * expression.cs (Binary::Emit): Update to emit the appropriate code for the case when we have a user-defined operator. 2001-09-17 Miguel de Icaza * rootcontext.cs: Fix bug: tree.Namespaces might be null. 2001-09-16 Ravi Pratap * class.cs (EmitStaticFieldInitializers, EmitFieldInitializers): Make public. (TypeContainer::EmitConstructor): Remove and move code into Contructor::Emit. (Constructor::Emit): Implement. (EmitStaticFieldInitializers, EmitFieldInitializers): Ensure we return immediately if we have no work to do. (TypeContainer::Emit): Pass in TypeContainer as argument to the constructor's Emit method. * interface.cs (Interface::InterfaceAttr): Re-write to be more correct and complete. (Interface::IsTopLevel): Add. Same as TypeContainer::IsTopLevel. * class.cs (TypeContainer::IsTopLevel): Modify to use parent.Parent instead of parent.parent. 2001-09-15 Ravi Pratap * tree.cs (Tree::namespaces): New hashtable to keep track of namespaces in the source. (Tree::RecordNamespace): Method to do what the name says ;-) (Tree::Namespaces): Property to get at the namespaces hashtable. * cs-parser.jay (namespace_declaration): Call RecordNamespace to keep track. * rootcontext.cs (IsNamespace): Fixed it :-) 2001-09-14 Miguel de Icaza * class.cs (TypeContainer::FindMembers): Add support for constructors. (MethodCore): New class that encapsulates both the shared aspects of a Constructor and a Method. (Method, Constructor): Factored pieces into MethodCore. * driver.cs: Added --fatal which makes errors throw exceptions. Load System assembly as well as part of the standard library. * report.cs: Allow throwing exceptions on errors for debugging. * modifiers.cs: Do not use `parent', instead use the real type container to evaluate permission settings. * class.cs: Put Ravi's patch back in. He is right, and we will have to cope with the 2001-09-14 Ravi Pratap * modifiers.cs (TypeAttr, MethodAttr, FieldAttr): Map protected internal to FamORAssem, not FamANDAssem. 2001-09-14 Miguel de Icaza * driver.cs: Added --parse option that only parses its input files and terminates. * class.cs: Reverted last change from Ravi to IsTopLevel. That is incorrect. IsTopLevel is not used to tell whether an object is root_types or not (that can be achieved by testing this == root_types). But to see if this is a top-level *class* (not necessarly our "toplevel" container). 2001-09-14 Ravi Pratap * enum.cs (Enum::Define): Modify to call the Lookup method on the parent instead of a direct call to GetType. 2001-09-14 Ravi Pratap * class.cs (TypeContainer::TypeAttr): Remove property code and move it into Modifiers.TypeAttr. This should just be a call to that method. * modifiers.cs (TypeAttr): Re-write and take an extra argument, the TypeContainer object so that we can determine if we are top-level or not. * delegate.cs (Delegate::Define): Update call to TypeAttr method to pass in the TypeContainer too. * enum.cs (Enum::Define): Ditto. * modifiers.cs (FieldAttr): Re-write. * class.cs (TypeContainer::IsTopLevel): Change accessibility to public. (TypeContainer::HaveStaticConstructor): New property to provide access to precisely that info. * modifiers.cs (MethodAttr): Re-write. (EventAttr): Remove altogether as there seems to be no ostensible use for it. * class.cs (TypeContainer::IsTopLevel): Re-write. root_types doesn't seem to be the parent of top-level types as claimed. 2001-09-13 Miguel de Icaza * expression.cs (MemberLookup): Fruitless attempt to lookup constructors. Maybe I need to emit default constructors? That might be it (currently .NET emits this for me automatically). (Invocation::OverloadResolve): Cope with Arguments == null. (Invocation::EmitArguments): new function, shared by the new constructor and us. (Invocation::Emit): Handle static and instance methods. Emit proper call instruction for virtual or non-virtual invocations. (New::Emit): Implement. (New::Resolve): Implement. (MemberAccess:Resolve): Implement. (MethodGroupExpr::InstanceExpression): used conforming to the spec to track instances. (FieldExpr::Resolve): Set type. * support.cs: Handle empty arguments. * cs-parser.jay (CompositeLookup, QualifierIdentifier, SimpleLookup): Auxiliary routines to help parse a qualifier identifier. Update qualifier_identifier rule. * codegen.cs: Removed debugging messages. * class.cs: Make this a global thing, this acts just as a "key" to objects that we might have around. (Populate): Only initialize method_builders_to_methods once. * expression.cs (PropertyExpr): Initialize type from the PropertyType. * codegen.cs (EmitContext::EmitBoolExpression): Use propper Resolve pattern. Attempt to implicitly convert value to boolean. Emit code. * expression.cs: Set the type for the int32/int32 argument case. (Binary::ResolveOperator): Set the return type to boolean for comparission operators * typemanager.cs: Remove debugging print code. (Invocation::Resolve): resolve type. * class.cs: Allocate a MemberInfo of the correct size, as the code elsewhere depends on the test to reflect the correct contents. (Method::) Keep track of parameters, due to System.Reflection holes (TypeContainer::Populate): Keep track of MethodBuilders to Method mapping here. (TypeContainer::FindMembers): Use ArrayList and then copy an array of the exact size and return that. (Class::LookupMethodByBuilder): New function that maps MethodBuilders to its methods. Required to locate the information on methods because System.Reflection bit us again. * support.cs: New file, contains an interface ParameterData and two implementations: ReflectionParameters and InternalParameters used to access Parameter information. We will need to grow this as required. * expression.cs (Invocation::GetParameterData): implement a cache and a wrapper around the ParameterData creation for methods. (Invocation::OverloadResolve): Use new code. 2001-09-13 Ravi Pratap * class.cs (TypeContainer::EmitField): Remove and move into (Field::Define): here and modify accordingly. (Field.FieldBuilder): New member. (TypeContainer::Populate): Update accordingly. (TypeContainer::FindMembers): Implement. 2001-09-13 Miguel de Icaza * statement.cs: (VariableInfo::VariableType): New field to be initialized with the full type once it is resolved. 2001-09-12 Miguel de Icaza * parameter.cs (GetParameterInfo): Use a type cache to compute things only once, and to reuse this information * expression.cs (LocalVariableReference::Emit): Implement. (OpcodeCast::Emit): fix. (ParameterReference::Resolve): Implement. (ParameterReference::Emit): Implement. * cs-parser.jay: Fix bug introduced by Ravi, variable initializers that are expressions need to stay as Expressions. * typemanager.cs (CSharpName): Returns the C# name of a type if possible. * expression.cs (Expression::ConvertImplicit): New function that implements implicit type conversions. (Expression::ImplicitReferenceConversion): Implements implicit reference conversions. (EmptyCast): New type for transparent casts. (OpcodeCast): New type for casts of types that are performed with a sequence of bytecodes. (BoxedCast): New type used for casting value types into reference types. Emits a box opcode. (Binary::DoNumericPromotions): Implements numeric promotions of and computation of the Binary::Type. (Binary::EmitBranchable): Optimization. (Binary::Emit): Implement code emission for expressions. * typemanager.cs (TypeManager): Added two new core types: sbyte and byte. 2001-09-12 Ravi Pratap * class.cs (TypeContainer::FindMembers): Method which does exactly what Type.FindMembers does, only we don't have to use reflection. No implementation yet. * typemanager.cs (typecontainers): New hashtable to hold the corresponding typecontainer objects as we need to get at them. (TypeManager::AddUserType): Overload to take an extra argument, the TypeContainer. * rootcontext.cs : Correspondingly modify called to AddUserType to pass the typecontainer object. * expression.cs (MemberLookup): Modify signature to take a RootContext object instead of just a Report object. 2001-09-11 Ravi Pratap * class.cs (Event::Define): Go back to using the prefixes "add_" and "remove_" (TypeContainer::Populate): Now define the delegates of the type too. (TypeContainer.Delegates): Property to access the list of delegates defined in the type. * delegates.cs (Delegate::Define): Implement partially. * modifiers.cs (TypeAttr): Handle more flags. 2001-09-11 Ravi Pratap * class.cs (Indexer::Define): Fix for loop iteration condition to be just < and not <= (Operator::Define): Re-write logic to get types by using the LookupType method instead of blindly doing a Type.GetType ! How stupid can I get ;-) ? (Indexer::Define): Ditto. (Event::Define): Ditto. (Property::Define): Ditto. 2001-09-10 Ravi Pratap * class.cs (TypeContainer::Populate): Now define operators too. (TypeContainer.Operators): New property to access the list of operators in a type. (Operator.OperatorMethodBuilder): New member to hold the method builder for the operator we are defining. (Operator::Define): Implement. 2001-09-10 Ravi Pratap * class.cs (Event::Define): Make the prefixes of the accessor methods addOn_ and removeOn_ * genericparser.cs (GenericParser::error): Overloaded method to handle the case of the location being passed in too. Ideally, this should go later since all error reporting should be done through the Report object. * class.cs (TypeContainer.Indexers): New property to access the list of indexers. (Populate): Iterate thru the indexers we have and define them too. (Indexer.GetMethodBuilder, .SetMethodBuilder): New members to hold the method builders for the get and set accessors. (Indexer::Define): Implement. 2001-09-09 Miguel de Icaza * expression.cs (Binary::Resolve): Beginning of it. I scratched my previous implementation, did not work. * typemanager.cs: Add a couple of missing types (the longs). * literal.cs: Use TypeManager.bool_type instead of getting it. * expression.cs (EventExpr): New kind of expressions. (Expressio::ExprClassFromMemberInfo): finish 2001-09-08 Miguel de Icaza * assign.cs: Emit stores to static fields differently. 2001-09-08 Ravi Pratap * Merge in changes and adjust code to tackle conflicts. Backed out my code in Assign::Resolve ;-) 2001-09-08 Ravi Pratap * cs-parser.jay (CheckAttributeTarget): Modify call to error to use instead Report.Error and also pass in the location. (CSharpParser::Lexer): New readonly property to return the reference to the Tokenizer object. (declare_local_variables): Use Report.Error with location instead of plain old error. (CheckDef): Ditto. * class.cs (Operator::CheckUnaryOperator): Move into cs-parser.jay. (Operator.CheckBinaryOperator): Ditto. * cs-parser.jay (operator_declarator): Update accordingly. * cs-parser.jay (CheckUnaryOperator): Modify to use Report.Error (CheckBinaryOperator): Same here. * rootcontext.cs (LookupType): Add an extra lookup which simply does a lookup on the name without any prefixes of namespace names etc. This is because we already might have something already fully qualified like 'System.Console.WriteLine' * assign.cs (Resolve): Begin implementation. Stuck ;-) 2001-09-07 Ravi Pratap * cs-tokenizer.cs (location): Return a string which also contains the file name. * expression.cs (ElementAccess): New class for expressions of the type 'element access.' (BaseAccess): New class for expressions of the type 'base access.' (CheckedExpr, UnCheckedExpr): New classes for Checked and Unchecked expressions respectively. * cs-parser.jay (element_access): Implement action. (base_access): Implement actions. (checked_expression, unchecked_expression): Implement. * cs-parser.jay (local_variable_type): Correct and implement. (type_suffixes, type_suffix_list, type_suffix): Implement actions. * cs-tokenizer.cs (real_type_suffix): Comment out the extra getchar. * cs-parser.jay (rank_specifiers): Remove space while concatenating the type's name and the specifiers. * interface.cs (InterfaceAttr): New property to return the corresponding TypeAttributes * rootcontext.cs (CreateInterface): Use the InterfaceAttr property instead of making them all public ;-) * cs-parser.jay (error): Remove entirely as we have an implementation in the base class anyways. 2001-09-07 Miguel de Icaza * expression.cs (ExprClassFromMemberInfo): Return FieldExpr and PropertyExprs. (FieldExpr, PropertyExprs): New resolved expressions. (SimpleName::MemberStaticCheck): Perform static checks for access to non-static fields on static methods. Maybe this should be generalized for MemberAccesses. (SimpleName::ResolveSimpleName): More work on simple name resolution. * cs-parser.jay (primary_expression/qualified_identifier): track the parameter index. * codegen.cs (CodeGen::Save): Catch save exception, report error. (EmitContext::EmitBoolExpression): Chain to expression generation instead of temporary hack. (::EmitStatementExpression): Put generic expression code generation. * assign.cs (Assign::Emit): Implement variable assignments to local variables, parameters and fields. 2001-09-06 Miguel de Icaza * statement.cs (Block::GetVariableInfo): New method, returns the VariableInfo for a variable name in a block. (Block::GetVariableType): Implement in terms of GetVariableInfo * literal.cs (IntLiteral::Emit, FloatLiteral::Emit, DoubleLiteral::Emit, CharLiteral::Emit, BoolLiteral::Emit): Implement 2001-09-06 Ravi Pratap * cs-parser.jay (operator_declaration): Continue on my quest : update to take attributes argument. (event_declaration): Ditto. (enum_declaration): Ditto. (indexer_declaration): Ditto. * class.cs (Operator::Operator): Update constructor accordingly. (Event::Event): Ditto. * delegate.cs (Delegate::Delegate): Same here. * enum.cs (Enum::Enum): Same here. 2001-09-05 Ravi Pratap * cs-parser.jay (CheckAttributeTarget): Update to use the right error number. * ../tests/cs0658.cs : New file to demonstrate error 0658. * attribute.cs (Attributes): New class to encapsulate all attributes which were being passed around as an arraylist. (Attributes::AddAttribute): Method to add attribute sections. * cs-parser.jay (opt_attributes): Modify actions to use the new Attributes class. (struct_declaration): Update accordingly. (constant_declaration): Update. (field_declaration): Update. (method_header): Update. (fixed_parameter): Update. (parameter_array): Ditto. (property_declaration): Ditto. (destructor_declaration): Ditto. * class.cs (Struct::Struct): Update constructors accordingly. (Class::Class): Ditto. (Field::Field): Ditto. (Method::Method): Ditto. (Property::Property): Ditto. (TypeContainer::OptAttribute): update property's return type. * interface.cs (Interface.opt_attributes): New member. (Interface::Interface): Update to take the extra Attributes argument. * parameter.cs (Parameter::Parameter): Ditto. * constant.cs (Constant::Constant): Ditto. * interface.cs (InterfaceMemberBase): New OptAttributes field. (InterfaceMemberBase::InterfaceMemberBase): Update constructor to take the attributes as a parameter. (InterfaceProperty): Update constructor call. (InterfaceEvent): Ditto. (InterfaceMethod): Ditto. (InterfaceIndexer): Ditto. * cs-parser.jay (interface_indexer_declaration): Update call to constructor to pass the attributes too. (interface_event_declaration): Ditto. (interface_property_declaration): Ditto. (interface_method_declaration): Ditto. (interface_declaration): Ditto. 2001-09-05 Miguel de Icaza * class.cs (Method::Define): Track the "static Main" definition to create an entry point. * rootcontext.cs (RootContext::EntryPoint): MethodInfo that holds the EntryPoint if we find it. * codegen.cs (EmitContext::EmitInvocation): Emit invocations. (EmitContext::ig): Make this variable public. * driver.cs: Make the default output file be the first file name with the .exe extension. Detect empty compilations Handle various kinds of output targets. Handle --target and rename -t to --dumper. * expression.cs, literal.cs, assign.cs, constant.cs: All `Resolve' methods inherited from Expression return now an Expression. This will is used during the tree rewriting as we resolve them during semantic analysis. (Expression::MemberLookup): Implements the MemberLookup (7.3) from the spec. Missing entirely is the information about accessability of elements of it. (Expression::ExprClassFromMemberInfo): New constructor for Expressions that creates a fully initialized Expression based on a MemberInfo that is one of Eventinfo, FieldINfo, PropertyInfo or a Type. (Invocation::Resolve): Begin implementing resolution of invocations. * literal.cs (StringLiteral): Implement Emit. 2001-09-05 Ravi Pratap * cs-parser.jay (error): Add new modifier because we are hiding an inherited member. 2001-09-04 Ravi Pratap * cs-parser.jay (attribute_arguments): Implement actions. (attribute): Fix bug in production. Implement action. (attribute_list): Implement. (attribute_target): Implement. (attribute_target_specifier, opt_target_specifier): Implement (CheckAttributeTarget): New method to check if the attribute target is valid. (attribute_section): Implement. (opt_attributes): Implement. * attribute.cs : New file to handle attributes. (Attribute): Class to hold attribute info. * cs-parser.jay (opt_attribute_target_specifier): Remove production (attribute_section): Modify production to use 2 different rules to achieve the same thing. 1 s/r conflict down ! Clean out commented, useless, non-reducing dimension_separator rules. * class.cs (TypeContainer.attributes): New member to hold list of attributes for a type. (Struct::Struct): Modify to take one more argument, the attribute list. (Class::Class): Ditto. (Field::Field): Ditto. (Method::Method): Ditto. (Property::Property): Ditto. * cs-parser.jay (struct_declaration): Update constructor call to pass in the attributes too. (class_declaration): Ditto. (constant_declaration): Ditto. (field_declaration): Ditto. (method_header): Ditto. (fixed_parameter): Ditto. (parameter_array): Ditto. (property_declaration): Ditto. * constant.cs (Constant::Constant): Update constructor similarly. Use System.Collections. * parameter.cs (Parameter::Parameter): Update as above. 2001-09-02 Ravi Pratap * class.cs (TypeContainer::AddDelegate): New method to add a delegate. (TypeContainer.delegates): New member to hold list of delegates. * cs-parser.jay (delegate_declaration): Implement the action correctly this time as I seem to be on crack ;-) 2001-09-02 Miguel de Icaza * rootcontext.cs (RootContext::IsNamespace): new function, used to tell whether an identifier represents a namespace. * expression.cs (NamespaceExpr): A namespace expression, used only temporarly during expression resolution. (Expression::ResolveSimpleName, ::ResolvePrimary, ::ResolveName): utility functions to resolve names on expressions. 2001-09-01 Miguel de Icaza * codegen.cs: Add hook for StatementExpressions. * class.cs: Fix inverted test for static flag in methods. 2001-09-02 Ravi Pratap * class.cs (Operator::CheckUnaryOperator): Correct error number used to make it coincide with MS' number. (Operator::CheckBinaryOperator): Ditto. * ../errors/errors.txt : Remove error numbers added earlier. * ../errors/cs1019.cs : Test case for error # 1019 * ../errros/cs1020.cs : Test case for error # 1020 * cs-parser.jay : Clean out commented cruft. (dimension_separators, dimension_separator): Comment out. Ostensibly not used anywhere - non-reducing rule. (namespace_declarations): Non-reducing rule - comment out. * enum.cs (Enum::AddEnum): Rename to AddEnumMember as I was getting confused with TypeContainer::AddEnum. * delegate.cs : New file for delegate handling classes. (Delegate): Class for declaring delegates. * makefile : Update. * cs-parser.jay (delegate_declaration): Implement. 2001-09-01 Ravi Pratap * class.cs (Event::Define): Implement. (Event.EventBuilder): New member. * class.cs (TypeContainer::Populate): Update to define all enums and events we have. (Events): New property for the events arraylist we hold. Shouldn't we move to using readonly fields for all these cases ? 2001-08-31 Ravi Pratap * class.cs (Property): Revamp to use the convention of making fields readonly. Accordingly modify code elsewhere. * class.cs : Apply patch from Mr. Mandar for implementing the Define method of the Property class. * class.cs : Clean up applied patch and update references to variables etc. Fix trivial bug. (TypeContainer::Populate): Update to define all the properties we have. Also define all enumerations. * enum.cs (Define): Implement. 2001-08-31 Ravi Pratap * cs-parser.jay (overloadable_operator): The semantic value is an enum of the Operator class. (operator_declarator): Implement actions. (operator_declaration): Implement. * class.cs (Operator::CheckUnaryOperator): New static method to help in checking validity of definitions. (Operator::CheckBinaryOperator): Static method to check for binary operators (TypeContainer::AddOperator): New method to add an operator to a type. * cs-parser.jay (indexer_declaration): Added line to actually call the AddIndexer method so it gets added ;-) * ../errors/errors.txt : Update to include new error numbers. Are these numbers already taken care of by the MS compiler ? 2001-08-29 Ravi Pratap * class.cs (Operator): New class for operator declarations. (Operator::OpType): Enum for the various operators. 2001-08-29 Ravi Pratap * class.cs (TypeContainer::AddIndexer): Remove FIXME comment. We ostensibly handle this in semantic analysis. * cs-parser.jay (general_catch_clause): Comment out (specific_catch_clauses, specific_catch_clause): Ditto. (opt_general_catch_clause, opt_specific_catch_clauses): Ditto (catch_args, opt_catch_args): New productions. (catch_clause): Rewrite to use the new productions above (catch_clauses): Modify accordingly. (opt_catch_clauses): New production to use in try_statement (try_statement): Revamp. Basically, we get rid of one unnecessary rule and re-write the code in the actions to extract the specific and general catch clauses by being a little smart ;-) * ../tests/try.cs : Fix. It's not 'finalize' my friend, it's 'finally' ! Hooray, try and catch statements parse fine ! 2001-08-28 Ravi Pratap * statement.cs (Block::GetVariableType): Fix logic to extract the type string from the hashtable of variables. * cs-parser.jay (event_accessor_declarations): Trivial fix. Man, how did I end up making that mistake ;-) (catch_clauses): Fixed gross error which made Key and Value of the DictionaryEntry the same : $1 !! 2001-08-28 Ravi Pratap * cs-tokenizer.cs (initTokens): Add keywords 'add' and 'remove' * cs-parser.jay (event_declaration): Correct to remove the semicolon when the add and remove accessors are specified. 2001-08-28 Ravi Pratap * cs-parser.jay (IndexerDeclaration): New helper class to hold information about indexer_declarator. (indexer_declarator): Implement actions. (parsing_indexer): New local boolean used to keep track of whether we are parsing indexers or properties. This is necessary because implicit_parameters come into picture even for the get accessor in the case of an indexer. (get_accessor_declaration, set_accessor_declaration): Correspondingly modified. * class.cs (Indexer): New class for indexer declarations. (TypeContainer::AddIndexer): New method to add an indexer to a type. (TypeContainer::indexers): New member to hold list of indexers for the type. 2001-08-27 Ravi Pratap * cs-parser.jay (add_accessor_declaration): Implement action. (remove_accessor_declaration): Implement action. (event_accessors_declaration): Implement (variable_declarators): swap statements for first rule - trivial. * class.cs (Event): New class to hold information about event declarations. (TypeContainer::AddEvent): New method to add an event to a type (TypeContainer::events): New member to hold list of events. * cs-parser.jay (event_declaration): Implement actions. 2001-08-27 Ravi Pratap * cs-parser.jay (dim_separators): Implement. Make it a string concatenating all the commas together, just as they appear. (opt_dim_separators): Modify accordingly (rank_specifiers): Update accordingly. Basically do the same thing - instead, collect the brackets here. (opt_rank_sepcifiers): Modify accordingly. (array_type): Modify to actually return the complete type string instead of ignoring the rank_specifiers. (expression_list): Implement to collect the expressions (variable_initializer): Implement. We make it a list of expressions essentially so that we can handle the array_initializer case neatly too. (variable_initializer_list): Implement. (array_initializer): Make it a list of variable_initializers (opt_array_initializer): Modify accordingly. * expression.cs (New::NType): Add enumeration to help us keep track of whether we have an object/delegate creation or an array creation. (New:NewType, New::Rank, New::Indices, New::Initializers): New members to hold data about array creation. (New:New): Modify to update NewType (New:New): New Overloaded contructor for the array creation case. * cs-parser.jay (array_creation_expression): Implement to call the overloaded New constructor. 2001-08-26 Ravi Pratap * class.cs (TypeContainer::Constructors): Return member constructors instead of returning null. 2001-08-26 Miguel de Icaza * typemanager.cs (InitCoreTypes): Initialize the various core types after we have populated the type manager with the user defined types (this distinction will be important later while compiling corlib.dll) * expression.cs, literal.cs, assign.cs, constant.cs: Started work on Expression Classification. Now all expressions have a method `Resolve' and a method `Emit'. * codegen.cs, cs-parser.jay: Fixed the bug that stopped code generation from working. Also add some temporary debugging code. 2001-08-24 Miguel de Icaza * codegen.cs: Lots of code generation pieces. This is only the beginning, will continue tomorrow with more touches of polish. We handle the fundamentals of if, while, do, for, return. Others are trickier and I need to start working on invocations soon. * gen-treedump.cs: Bug fix, use s.Increment here instead of s.InitStatement. * codegen.cs (EmitContext): New struct, used during code emission to keep a context. Most of the code generation will be here. * cs-parser.jay: Add embedded blocks to the list of statements of this block. So code generation proceeds in a top down fashion. 2001-08-23 Miguel de Icaza * statement.cs: Add support for multiple child blocks. 2001-08-22 Miguel de Icaza * codegen.cs (EmitCode): New function, will emit the code for a Block of code given a TypeContainer and its ILGenerator. * statement.cs (Block): Standard public readonly optimization. (Block::Block constructors): Link children. (Block::Child): Child Linker. (Block::EmitVariables): Emits IL variable declarations. * class.cs: Drop support for MethodGroups here, delay until Semantic Analysis. (Method::): Applied the same simplification that I did before, and move from Properties to public readonly fields. (Method::ParameterTypes): Returns the parameter types for the function, and implements a cache that will be useful later when I do error checking and the semantic analysis on the methods is performed. (Constructor::GetCallingConvention): Renamed from CallingConvetion and made a method, optional argument tells whether this is a class or a structure to apply the `has-this' bit. (Method::GetCallingConvention): Implement, returns the calling convention. (Method::Define): Defines the type, a second pass is performed later to populate the methods. (Constructor::ParameterTypes): implement a cache similar to the one on Method::ParameterTypes, useful later when we do semantic analysis. (TypeContainer::EmitMethod): New method. Emits methods. * expression.cs: Removed MethodGroup class from here. * parameter.cs (Parameters::GetCallingConvention): new method. 2001-08-21 Miguel de Icaza * class.cs (TypeContainer::Populate): Drop RootContext from the argument. (Constructor::CallingConvention): Returns the calling convention. (Constructor::ParameterTypes): Returns the constructor parameter types. (TypeContainer::AddConstructor): Keep track of default constructor and the default static constructor. (Constructor::) Another class that starts using `public readonly' instead of properties. (Constructor::IsDefault): Whether this is a default constructor. (Field::) use readonly public fields instead of properties also. (TypeContainer::TypeAttr, TypeContainer::AddConstructor): Keep track of static constructors; If none is used, turn on BeforeFieldInit in the TypeAttributes. * cs-parser.jay (opt_argument_list): now the return can be null for the cases where there are no arguments. (constructor_declarator): If there is no implicit `base' or `this', then invoke the default parent constructor. * modifiers.cs (MethodAttr): New static function maps a set of modifiers flags into a MethodAttributes enum (FieldAttr): renamed from `Map'. So now we have FieldAttr, MethodAttr, TypeAttr to represent the various mappings where the modifiers are used. (FieldAttr): Map also `readonly' to `FieldAttributes.InitOnly' 2001-08-19 Miguel de Icaza * parameter.cs (GetParameterInfo): Fix bug where there would be no method arguments. * interface.cs (PopulateIndexer): Implemented the code generator for interface indexers. 2001-08-17 Miguel de Icaza * interface.cs (InterfaceMemberBase): Now we track the new status here. (PopulateProperty): Implement property population. Woohoo! Got Methods and Properties going today. Removed all the properties for interfaces, and replaced them with `public readonly' fields. 2001-08-16 Miguel de Icaza * interface.cs (AddEvent, AddMethod, AddIndexer, AddProperty): initialize their hashtables/arraylists only when they are needed instead of doing this always. * parameter.cs: Handle refs and out parameters. * cs-parser.jay: Use an ArrayList to construct the arguments instead of the ParameterCollection, and then cast that to a Parameter[] array. * parameter.cs: Drop the use of ParameterCollection and use instead arrays of Parameters. (GetParameterInfo): Use the Type, not the Name when resolving types. 2001-08-13 Miguel de Icaza * parameter.cs: Eliminate the properties Name, Type and ModFlags, and instead use public readonly fields. * class.cs: Put back walking code for type containers. 2001-08-11 Miguel de Icaza * class.cs (MakeConstant): Code to define constants. * rootcontext.cs (LookupType): New function. Used to locate types 2001-08-08 Miguel de Icaza * rootcontext.cs: OH MY! My trick works! It is amazing how nice this System.Reflection code is. Kudos to Microsoft * typemanager.cs: Implement a type cache and avoid loading all types at boot time. Wrap in LookupType the internals. This made the compiler so much faster. Wow. I rule! * driver.cs: Make sure we always load mscorlib first (for debugging purposes, nothing really important). * Renamespaced things that were on `CSC' to `CIR'. Maybe I should have moved to `CSC' rather than `CIR'. Oh man! The confussion! * rootcontext.cs: Lookup types on their namespace; Lookup types on namespaces that have been imported using the `using' keyword. * class.cs (TypeContainer::TypeAttr): Virtualize. (Class::TypeAttr): Return attributes suitable for this bad boy. (Struct::TypeAttr): ditto. Handle nested classes. (TypeContainer::) Remove all the type visiting code, it is now replaced with the rootcontext.cs code * rootcontext.cs (GetClassBases): Added support for structs. 2001-08-06 Miguel de Icaza * interface.cs, statement.cs, class.cs, parameter.cs, rootcontext.cs, gen-treedump.cs, enum.cs, cs-parse.jay: Drop use of TypeRefs, and use strings instead. 2001-08-04 Miguel de Icaza * rootcontext.cs: * class.cs (Struct::Struct): set the SEALED flags after checking the modifiers. (TypeContainer::TypeAttr): new property, returns the TypeAttributes for a class. * cs-parser.jay (type_list): Oops, list production was creating a new list of base types. * rootcontext.cs (StdLib): New property. (GetInterfaceTypeByName): returns an interface by type name, and encapsulates error handling here. (GetInterfaces): simplified. (ResolveTree): Encapsulated all the tree resolution here. (CreateClass, GetClassBases, GetInterfaceOrClass): Create class types. * driver.cs: Add support for --nostdlib, to avoid loading the default assemblies. (Main): Do not put tree resolution here. * rootcontext.cs: Beginning of the class resolution. 2001-08-03 Miguel de Icaza * rootcontext.cs: Provide better error reporting. * cs-parser.jay (interface_base): set our $$ to be interfaces. * rootcontext.cs (CreateInterface): Handle the case where there are no parent interfaces. (CloseTypes): Routine to flush types at the end. (CreateInterface): Track types. (GetInterfaces): Returns an array of Types from the list of defined interfaces. * typemanager.c (AddUserType): Mechanism to track user types (puts the type on the global type hash, and allows us to close it at the end). 2001-08-02 Miguel de Icaza * tree.cs: Removed RecordType, added RecordClass, RecordStruct and RecordInterface instead. * cs-parser.jay: Updated to reflect changes above. * decl.cs (Definition): Keep track of the TypeBuilder type that represents this type here. Not sure we will use it in the long run, but wont hurt for now. * driver.cs: Smaller changes to accomodate the new code. Call ResolveInterfaceBases, Call ResolveClassBases, Save assembly when done. * rootcontext.cs (CreateInterface): New method, used to create the System.TypeBuilder type for interfaces. (ResolveInterfaces): new entry point to resolve the interface hierarchy. (CodeGen): Property, used to keep track of the code generator. 2001-07-26 Miguel de Icaza * cs-parser.jay: Add a second production for delegate_declaration with `VOID'. (enum_body): Put an opt_comma here instead of putting it on enum_body or enum_member_declarations so we can handle trailing commas on enumeration members. Gets rid of a shift/reduce. (type_list): Need a COMMA in the middle. (indexer_declaration): Tell tokenizer to recognize get/set * Remove old targets. * Re-add the parser target. 2001-07-13 Simon Cozens * cs-parser.jay: Add precendence rules for a number of operators ot reduce the number of shift/reduce conflicts in the grammar. 2001-07-17 Miguel de Icaza * tree.cs: moved IGenerator interface and renamed it to ITreeDump and put it here. Get rid of old crufty code. * rootcontext.cs: Use this to keep track of the parsed representation and the defined types available to the program. * gen-treedump.cs: adjust for new convention. * type.cs: Split out the type manager, and the assembly builder from here. * typemanager.cs: the type manager will live here now. * cil-codegen.cs: And the code generator here. 2001-07-14 Sean MacIsaac * makefile: Fixed up for easy making. 2001-07-13 Simon Cozens * cs-parser.jay (rank_specifier): Remove a conflict by reordering the (unary_expression): Expand pre_increment_expression and post_decrement_expression to reduce a shift/reduce. 2001-07-11 Simon Cozens * cs-tokenizer.cs: Hex numbers should begin with a 0. Improve allow_keyword_as_indent name. 2001-06-19 Miguel de Icaza * Adjustments for Beta2. 2001-06-13 Miguel de Icaza * decl.cs: Added `Define' abstract method. (InTransit): new property, used to catch recursive definitions. * interface.cs: Implement `Define'. * modifiers.cs: Map Modifiers.constants to System.Reflection.TypeAttribute flags. * class.cs: Keep track of types and user-defined types. (BuilderInit): New method for creating an assembly (ResolveType): New function to launch the resolution process, only used by interfaces for now. * cs-parser.jay: Keep track of Classes, Structs and Interfaces that are inserted into the name space. 2001-06-08 Miguel de Icaza * ARGH. I have screwed up my tree so many times due to the use of rsync rather than using CVS. Going to fix this at once. * driver.cs: Objetify driver. Load assemblies, use assemblies to load types. 2001-06-07 Miguel de Icaza * Experiment successful: Use System.Type rather that our own version of Type. 2001-05-25 Miguel de Icaza * cs-parser.jay: Removed nsAliases from here. Use new namespaces, handle `using XXX;' * namespace.cs: Reimplemented namespace handling, use a recursive definition of the class. Now we can keep track of using clauses and catch invalid using clauses. 2001-05-24 Miguel de Icaza * gen-treedump.cs: Adapted for all the renaming. * expression.cs (Expression): this class now has a Type property which returns an expression Type. (Probe::, New::, TypeOf::, SizeOf::, Constant::): renamed from `Type', as this has a different meaning now in the base 2001-05-22 Miguel de Icaza * interface.cs, class.cs: Removed from all the sources the references to signature computation, as we can not do method signature computation during the parsing time, as we are not trying to solve at that point distinguishing: class X { void a (Blah x) {} void a (NS.Blah x) {} } Which depending on the context might be valid or not, as we do not know if Blah is the same thing as NS.Blah at that point. * Redid everything so the code uses TypeRefs now instead of Types. TypeRefs are just temporary type placeholders, that need to be resolved. They initially have a pointer to a string and the current scope in which they are used. This is used later by the compiler to resolve the reference to an actual Type. * DeclSpace is no longer a CIR.Type, and neither are TypeContainers (Class and Struct) nor Interfaces nor Enums. They are all DeclSpaces, but no Types. * type.cs (TypeRefManager): This implements the TypeRef manager, which keeps track of all the types that need to be resolved after the parsing has finished. 2001-05-13 Miguel de Icaza * ARGH. We are going to have to store `foreach' as a class rather than resolving it, as we need to verify error 1579 after name resolution. *OR* we could keep a flag that says `This request to IEnumerator comes from a foreach statement' which we can then use to generate the error. 2001-05-10 Miguel de Icaza * class.cs (TypeContainer.AddMethod): we now add methods to the MethodGroup instead of the method hashtable. * expression.cs: Add MethodGroup abstraction, which gets us one step closer to the specification in the way we handle method declarations. * cs-parser.jay (primary_expression): qualified_identifier now tried to match up an identifier to a local variable reference or to a parameter reference. current_local_parameters is now a parser global variable that points to the current parameters for the block, used during name lookup. (property_declaration): Now creates an implicit `value' argument to the set accessor. 2001-05-09 Miguel de Icaza * parameter.cs: Do not use `param' arguments as part of the signature, per the spec. 2001-05-08 Miguel de Icaza * decl.cs: Base class for classes, structs and interfaces. This is the "Declaration Space" * cs-parser.jay: Use CheckDef for checking declaration errors instead of having one on each function. * class.cs: Factor out some code for handling error handling in accordance to the "Declarations" section in the "Basic Concepts" chapter in the ECMA C# spec. * interface.cs: Make all interface member classes derive from InterfaceMemberBase. 2001-05-07 Miguel de Icaza * Many things: all interfaces are parsed and generated in gen-treedump. Support for member variables, constructors, destructors, properties, constants is there. Beginning of the IL backend, but very little done, just there for testing purposes. 2001-04-29 Miguel de Icaza * cs-parser.jay: Fix labeled statement. * cs-tokenizer.cs (escape): Escape " and ' always. ref_line, ref_name: keep track of the line/filename as instructed by #line by the compiler. Parse #line. 2001-04-27 Miguel de Icaza * System.CodeDOM/CodeBinaryOperatorExpression.cs: Rearrange enum to match the values in System.CodeDOM. Divid renamed to Divide. * System.CodeDOM/CodeForLoopStatement.cs: Always have valid statements. (Statements.set): remove. * System.CodeDOM/CodeCatchClause.cs: always have a valid statements. * System.CodeDOM/CodeIfStatement.cs: trueStatements and falseStatements always have valid values. * cs-parser.jay: Use System.CodeDOM now.