/// <summary> /// Internal! This is used by the Installer to create new classes. /// </summary> /// <param name="runtime">Smalltalk runtime this class is part of.</param> /// <param name="name">Name of the class.</param> /// <param name="superclass">Optional binding to the class' superclass.</param> /// <param name="instanceState">State of the class' instances (named, object-indexable, byte-indexable).</param> /// <param name="instanceVariables">Instance variables bindings. Those are initially not initialized.</param> /// <param name="classVariables">Class variable binding.</param> /// <param name="classInstanceVariables">Class-instance variables bindings. Those are initially not initialized.</param> /// <param name="importedPools">Collection of pools that are imported by the class.</param> /// <param name="instanceMethods">Collection with the methods defining the instance behaviors.</param> /// <param name="classMethods">Collection with the methods defining the class behaviors.</param> public SmalltalkClass(SmalltalkRuntime runtime, Symbol name, ClassBinding superclass, InstanceStateEnum instanceState, BindingDictionary <InstanceVariableBinding> instanceVariables, DiscreteBindingDictionary <ClassVariableBinding> classVariables, BindingDictionary <ClassInstanceVariableBinding> classInstanceVariables, DiscreteBindingDictionary <PoolBinding> importedPools, InstanceMethodDictionary instanceMethods, ClassMethodDictionary classMethods) { if (runtime == null) { throw new ArgumentNullException("runtime"); } if ((name == null) || (name.Value.Length == 0)) { throw new ArgumentNullException("name"); } if (!SmalltalkClass.ValidateIdentifiers <InstanceVariableBinding>(instanceVariables)) { throw new ArgumentException("Invalid or duplicate instance variable name found", "instanceVariables"); } if (!SmalltalkClass.ValidateIdentifiers <ClassVariableBinding>(classVariables)) { throw new ArgumentException("Invalid or duplicate class variable name found", "classVariables"); } if (!SmalltalkClass.ValidateIdentifiers <ClassInstanceVariableBinding>(classInstanceVariables)) { throw new ArgumentException("Invalid or duplicate class instance variable name found", "classInstanceVariables"); } if (!SmalltalkClass.ValidateIdentifiers <PoolBinding>(importedPools)) { throw new ArgumentException("Invalid or duplicate imported pool name found", "importedPools"); } if (!SmalltalkClass.CheckDuplicates <InstanceVariableBinding, ClassVariableBinding>(instanceVariables, classVariables)) { throw new ArgumentException("Duplicate instance or class variable name. Instance and class variable names must be unique."); } if (!SmalltalkClass.CheckDuplicates <ClassInstanceVariableBinding, ClassVariableBinding>(classInstanceVariables, classVariables)) { throw new ArgumentException("Duplicate class-instance or class variable name. Class-instance and class variable names must be unique."); } this.Runtime = runtime; this.ClassInstanceVariableBindings = classInstanceVariables ?? new BindingDictionary <ClassInstanceVariableBinding>(this.Runtime, 1); this.ClassBehavior = classMethods ?? new ClassMethodDictionary(this.Runtime); this.ClassVariableBindings = classVariables ?? new DiscreteBindingDictionary <ClassVariableBinding>(this.Runtime, 1); this.ImportedPoolBindings = importedPools ?? new DiscreteBindingDictionary <PoolBinding>(this.Runtime, 1); this.InstanceBehavior = instanceMethods ?? new InstanceMethodDictionary(this.Runtime); this.InstanceState = instanceState; this.InstanceVariableBindings = instanceVariables ?? new BindingDictionary <InstanceVariableBinding>(this.Runtime, 1); this.Name = name; this.SuperclassBinding = superclass; // Null is OK .... Object has null this.InstanceSize = 0; this.ClassInstanceSize = 0; this.ClassInstanceVariables = new object[0]; }
public static void CreateClass(SmalltalkRuntime runtime, SmalltalkNameScope scope, ClassBinding binding, string superclassName, SmalltalkClass.InstanceStateEnum instanceState, string[] classVarNames, string[] instVarNames, string[] classInstVarNames, string[] importedPools, Func <SmalltalkClass, Dictionary <Symbol, CompiledMethod> > classMethodDicInitializer, Func <SmalltalkClass, Dictionary <Symbol, CompiledMethod> > instanceMethodDicInitializer) { if (runtime == null) { throw new ArgumentNullException("runtime"); } if (scope == null) { throw new ArgumentNullException("scope"); } if (binding == null) { throw new ArgumentNullException("binding"); } if (classMethodDicInitializer == null) { throw new ArgumentNullException("classMethodDicInitializer"); } if (instanceMethodDicInitializer == null) { throw new ArgumentNullException("instanceMethodDicInitializer"); } // 3. Prepare stuff .... ClassBinding superclass; if (String.IsNullOrWhiteSpace(superclassName)) { superclass = null; // Object has no superclass } else { superclass = scope.GetClassBinding(superclassName); if (superclass == null) { throw new InvalidOperationException("Should have found a binding for the superclass"); } } // Create the collection of class, class-instance, instance variables and imported pools BindingDictionary <InstanceVariableBinding> instVars = new BindingDictionary <InstanceVariableBinding>(runtime); DiscreteBindingDictionary <ClassVariableBinding> classVars = new DiscreteBindingDictionary <ClassVariableBinding>(runtime, ((classVarNames == null) ? 0 : classVarNames.Length)); BindingDictionary <ClassInstanceVariableBinding> classInstVars = new BindingDictionary <ClassInstanceVariableBinding>(runtime); DiscreteBindingDictionary <PoolBinding> pools = new DiscreteBindingDictionary <PoolBinding>(runtime); // Add class variable names ... if (classVarNames != null) { foreach (string identifier in classVarNames) { Symbol varName = runtime.GetSymbol(identifier); classVars.Add(new ClassVariableBinding(varName)); } } // Add instance variable names ... if (instVarNames != null) { foreach (string identifier in instVarNames) { Symbol varName = runtime.GetSymbol(identifier); instVars.Add(new InstanceVariableBinding(varName)); } } // Add class instance variable names ... if (classInstVarNames != null) { foreach (string identifier in classInstVarNames) { Symbol varName = runtime.GetSymbol(identifier); classInstVars.Add(new ClassInstanceVariableBinding(varName)); } } // Add imported pool names ... if (importedPools != null) { foreach (string identifier in importedPools) { Symbol varName = runtime.GetSymbol(identifier); PoolBinding pool = scope.GetPoolBinding(varName); if (pool == null) { throw new InvalidOperationException(String.Format("Should have found a binding for pool {0}", identifier)); } pools.Add(pool); } } // Create method dictionaries MethodDictionaryInitializer clsMthInitializer = new MethodDictionaryInitializer(classMethodDicInitializer); MethodDictionaryInitializer instMthInitializer = new MethodDictionaryInitializer(instanceMethodDicInitializer); ClassMethodDictionary classMethods = new ClassMethodDictionary(runtime, clsMthInitializer.Initialize); InstanceMethodDictionary instanceMethods = new InstanceMethodDictionary(runtime, instMthInitializer.Initialize); // 4. Finally, create the behavior object SmalltalkClass cls = new SmalltalkClass(runtime, binding.Name, superclass, instanceState, instVars, classVars, classInstVars, pools, instanceMethods, classMethods); clsMthInitializer.Class = cls; instMthInitializer.Class = cls; binding.SetValue(cls); }