Example #1
0
        /// <summary>
        /// Create the class object (and sets the value of the binding).
        /// </summary>
        /// <param name="installer">Context within which the class is to be created.</param>
        /// <returns>Returns true if successful, otherwise false.</returns>
        protected internal override bool CreateGlobalObject(IInstallerContext installer)
        {
            if (installer == null)
                throw new ArgumentNullException();
            // 1. Get the binding to the global
            Symbol name = installer.Runtime.GetSymbol(this.Name.Value);
            ClassBinding binding = installer.GetLocalClassBinding(name);
            // 2. Check consistency that we didn't mess up in the implementation.
            if (binding == null)
                throw new InvalidOperationException("Should have found a binding, because CreateGlobalBinding() created it!");
            if (binding.Value != null)
                throw new InvalidOperationException("Should be an empty binding, because CreateGlobalBinding() complained if one already existed!");

            // 3. Prepare stuff ....
            SmalltalkClass.InstanceStateEnum instanceState = this.InstanceState.Value;
            ClassBinding superclass;
            if (this.SuperclassName.Value.Length == 0)
            {
                superclass = null; // Object has no superclass
            }
            else
            {
                superclass = installer.GetClassBinding(this.SuperclassName.Value);
                if (superclass == null)
                    return installer.ReportError(this.SuperclassName, InstallerErrors.ClassInvalidSuperclass);
            }

            // Create the collection of class, class-instance, instance variables and imported pools
            BindingDictionary<InstanceVariableBinding> instVars = new BindingDictionary<InstanceVariableBinding>(installer.Runtime);
            DiscreteBindingDictionary<ClassVariableBinding> classVars = new DiscreteBindingDictionary<ClassVariableBinding>(installer.Runtime, this.ClassVariableNames.Count());
            BindingDictionary<ClassInstanceVariableBinding> classInstVars = new BindingDictionary<ClassInstanceVariableBinding>(installer.Runtime);
            DiscreteBindingDictionary<PoolBinding> pools = new DiscreteBindingDictionary<PoolBinding>(installer.Runtime);
            // Validate class variable names ...
            foreach (SourceReference<string> identifier in this.ClassVariableNames)
            {
                Symbol varName = installer.Runtime.GetSymbol(identifier.Value);
                if (!IronSmalltalk.Common.Utilities.ValidateIdentifier(identifier.Value))
                    return installer.ReportError(identifier, InstallerErrors.ClassClassVariableNotIdentifier);
                if (classVars.Any<ClassVariableBinding>(varBinding => varBinding.Name == varName))
                    return installer.ReportError(identifier, InstallerErrors.ClassClassVariableNotUnique);
                classVars.Add(new ClassVariableBinding(varName));
            }
            // Validate instance variable names ...
            foreach (SourceReference<string> identifier in this.InstanceVariableNames)
            {
                Symbol varName = installer.Runtime.GetSymbol(identifier.Value);
                if (!IronSmalltalk.Common.Utilities.ValidateIdentifier(identifier.Value))
                    return installer.ReportError(identifier, InstallerErrors.ClassInstanceVariableNotIdentifier);
                if (((IEnumerable<InstanceVariableBinding>) instVars).Any(varBinding => varBinding.Name == varName))
                    return installer.ReportError(identifier, InstallerErrors.ClassInstanceVariableNotUnique);
                if (classVars.Any<ClassVariableBinding>(varBinding => varBinding.Name == varName))
                    return installer.ReportError(identifier, InstallerErrors.ClassInstanceOrClassVariableNotUnique);
                instVars.Add(new InstanceVariableBinding(varName));
            }
            // Validate class instance variable names ...
            foreach (SourceReference<string> identifier in this.ClassInstanceVariableNames)
            {
                Symbol varName = installer.Runtime.GetSymbol(identifier.Value);
                if (!IronSmalltalk.Common.Utilities.ValidateIdentifier(identifier.Value))
                    return installer.ReportError(identifier, InstallerErrors.ClassClassInstanceVariableNotIdentifier);
                if (classInstVars.Any<ClassInstanceVariableBinding>(varBinding => varBinding.Name == varName))
                    return installer.ReportError(identifier, InstallerErrors.ClassClassInstanceVariableNotUnique);
                if (classVars.Any<ClassVariableBinding>(varBinding => varBinding.Name == varName))
                    return installer.ReportError(identifier, InstallerErrors.ClassClassInstanceOrClassVariableNotUnique);
                classInstVars.Add(new ClassInstanceVariableBinding(varName));
            }
            // Validate imported pool names ...
            foreach (SourceReference<string> identifier in this.ImportedPoolNames)
            {
                Symbol varName = installer.Runtime.GetSymbol(identifier.Value);
                if (!IronSmalltalk.Common.Utilities.ValidateIdentifier(identifier.Value))
                    return installer.ReportError(identifier, InstallerErrors.ClassImportedPoolNotIdentifier);
                if (pools.Any<PoolBinding>(varBinding => varBinding.Name == varName))
                    return installer.ReportError(identifier, InstallerErrors.ClassImportedPoolNotUnique);
                PoolBinding pool = installer.GetPoolBinding(varName);
                if (pool == null)
                    return installer.ReportError(identifier, InstallerErrors.ClassImportedPoolNotDefined);
                pools.Add(pool);
            }

            // 4. Finally, create the behavior object
            binding.SetValue(new SmalltalkClass(
                installer.Runtime, binding.Name, superclass, instanceState, instVars, classVars, classInstVars, pools));
            return true;
        }
Example #2
0
        /// <summary>
        /// Create the class object (and sets the value of the binding).
        /// </summary>
        /// <param name="installer">Context within which the class is to be created.</param>
        /// <returns>Returns true if successful, otherwise false.</returns>
        protected internal override bool CreateGlobalObject(IDefinitionInstallerContext installer)
        {
            if (installer == null)
            {
                throw new ArgumentNullException();
            }
            // 1. Get the binding to the global
            Symbol       name    = installer.Runtime.GetSymbol(this.Name.Value);
            ClassBinding binding = installer.GetLocalClassBinding(name);

            // 2. Check consistency that we didn't mess up in the implementation.
            if (binding == null)
            {
                throw new InvalidOperationException("Should have found a binding, because CreateGlobalBinding() created it!");
            }
            if (binding.Value != null)
            {
                throw new InvalidOperationException("Should be an empty binding, because CreateGlobalBinding() complained if one already existed!");
            }

            // 3. Prepare stuff ....
            SmalltalkClass.InstanceStateEnum instanceState = this.InstanceState.Value;
            ClassBinding superclass;

            if (this.SuperclassName.Value.Length == 0)
            {
                superclass = null; // Object has no superclass
            }
            else
            {
                superclass = installer.GetClassBinding(this.SuperclassName.Value);
                if (superclass == null)
                {
                    return(installer.ReportError(this.SuperclassName, InstallerErrors.ClassInvalidSuperclass));
                }
            }

            // Create the collection of class, class-instance, instance variables and imported pools
            BindingDictionary <InstanceVariableBinding>      instVars      = new BindingDictionary <InstanceVariableBinding>(installer.Runtime);
            DiscreteBindingDictionary <ClassVariableBinding> classVars     = new DiscreteBindingDictionary <ClassVariableBinding>(installer.Runtime, this.ClassVariableNames.Count());
            BindingDictionary <ClassInstanceVariableBinding> classInstVars = new BindingDictionary <ClassInstanceVariableBinding>(installer.Runtime);
            DiscreteBindingDictionary <PoolBinding>          pools         = new DiscreteBindingDictionary <PoolBinding>(installer.Runtime);

            // Validate class variable names ...
            foreach (SourceReference <string> identifier in this.ClassVariableNames)
            {
                Symbol varName = installer.Runtime.GetSymbol(identifier.Value);
                if (!IronSmalltalk.Common.Utilities.ValidateIdentifier(identifier.Value))
                {
                    return(installer.ReportError(identifier, InstallerErrors.ClassClassVariableNotIdentifier));
                }
                if (classVars.Any <ClassVariableBinding>(varBinding => varBinding.Name == varName))
                {
                    return(installer.ReportError(identifier, InstallerErrors.ClassClassVariableNotUnique));
                }
                classVars.Add(new ClassVariableBinding(varName));
            }
            // Validate instance variable names ...
            foreach (SourceReference <string> identifier in this.InstanceVariableNames)
            {
                Symbol varName = installer.Runtime.GetSymbol(identifier.Value);
                if (!IronSmalltalk.Common.Utilities.ValidateIdentifier(identifier.Value))
                {
                    return(installer.ReportError(identifier, InstallerErrors.ClassInstanceVariableNotIdentifier));
                }
                if (((IEnumerable <InstanceVariableBinding>)instVars).Any(varBinding => varBinding.Name == varName))
                {
                    return(installer.ReportError(identifier, InstallerErrors.ClassInstanceVariableNotUnique));
                }
                if (classVars.Any <ClassVariableBinding>(varBinding => varBinding.Name == varName))
                {
                    return(installer.ReportError(identifier, InstallerErrors.ClassInstanceOrClassVariableNotUnique));
                }
                instVars.Add(new InstanceVariableBinding(varName));
            }
            // Validate class instance variable names ...
            foreach (SourceReference <string> identifier in this.ClassInstanceVariableNames)
            {
                Symbol varName = installer.Runtime.GetSymbol(identifier.Value);
                if (!IronSmalltalk.Common.Utilities.ValidateIdentifier(identifier.Value))
                {
                    return(installer.ReportError(identifier, InstallerErrors.ClassClassInstanceVariableNotIdentifier));
                }
                if (classInstVars.Any <ClassInstanceVariableBinding>(varBinding => varBinding.Name == varName))
                {
                    return(installer.ReportError(identifier, InstallerErrors.ClassClassInstanceVariableNotUnique));
                }
                if (classVars.Any <ClassVariableBinding>(varBinding => varBinding.Name == varName))
                {
                    return(installer.ReportError(identifier, InstallerErrors.ClassClassInstanceOrClassVariableNotUnique));
                }
                classInstVars.Add(new ClassInstanceVariableBinding(varName));
            }
            // Validate imported pool names ...
            foreach (SourceReference <string> identifier in this.ImportedPoolNames)
            {
                Symbol varName = installer.Runtime.GetSymbol(identifier.Value);
                if (!IronSmalltalk.Common.Utilities.ValidateIdentifier(identifier.Value))
                {
                    return(installer.ReportError(identifier, InstallerErrors.ClassImportedPoolNotIdentifier));
                }
                if (pools.Any <PoolBinding>(varBinding => varBinding.Name == varName))
                {
                    return(installer.ReportError(identifier, InstallerErrors.ClassImportedPoolNotUnique));
                }
                PoolBinding pool = installer.GetPoolBinding(varName);
                if (pool == null)
                {
                    return(installer.ReportError(identifier, InstallerErrors.ClassImportedPoolNotDefined));
                }
                pools.Add(pool);
            }

            // 4. Finally, create the behavior object
            binding.SetValue(new SmalltalkClass(
                                 installer.Runtime, binding.Name, superclass, instanceState, instVars, classVars, classInstVars, pools));
            return(true);
        }
Example #3
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);
        }