Esempio n. 1
0
        private void FinalizeTypeIdentifiers(CompilerDTO dto)
        {
            // Add TypeDescriptors to Program
            foreach (var td in dto.UserDefinedTypeInfoList)
                dto.Program.Program.AddUserDefinedType(td.Type.UserDefinedType);

            // Finalize Global variables TypeIdentifiers
            foreach (var global in dto.GlobalVariableInfoList)
            {
                if (global.Type.TypeEnum == TypeEnum.UserDefinedType)
                {
                    ITypeDescriptor td = dto.GetUserTypeDescriptor(global.Type.TypeName);
                    if (td == null)
                    {
                        dto.AddError(CompilerErrorCode.UndefinedType,
                            string.Format("Undefined type \"{0}\"!", global.Type.TypeName),
                            global.NodeValueInfo, global.FileName);

                        // Set Type to undefined !
                        global.Type.TypeEnum = TypeEnum.Undefined;
                    }
                    else
                    {
                        global.Type.UserDefinedType = td;
                    }
                }
            }

            // Finalize Function parameter and return TypeIdentifiers
            foreach (var func in dto.UserDefinedFunctionInfoList)
            {
                // Return Type
                if (func.Function.ReturnValueType.Type.TypeEnum == TypeEnum.UserDefinedType)
                {
                    ITypeDescriptor td = dto.GetUserTypeDescriptor(func.Function.ReturnValueType.Type.TypeName);
                    if (td == null)
                    {
                        dto.AddError(CompilerErrorCode.UndefinedType,
                            string.Format("Undefined type \"{0}\"!", func.Function.ReturnValueType.Type.TypeName),
                            func.NodeValueInfo, func.FileName);

                        // Set Type to undefined !
                        func.Function.ReturnValueType.Type.TypeEnum = TypeEnum.Undefined;
                    }
                    else
                    {
                        func.Function.ReturnValueType.Type.UserDefinedType = td;
                    }
                }

                // Parameter Types
                foreach (var param in func.Function.Parameters)
                {
                    if (param.Type.TypeEnum == TypeEnum.UserDefinedType)
                    {
                        ITypeDescriptor td = dto.GetUserTypeDescriptor(param.Type.TypeName);
                        if (td == null)
                        {
                            dto.AddError(CompilerErrorCode.UndefinedType, string.Format(
                                "Undefined type \"{0}\" in function \"{1}\" at the \"{2}\" parameter!",
                                param.Type.TypeName, func.Name, param.Name),
                                func.NodeValueInfo, func.FileName);

                            // Set Type to undefined !
                            param.Type.TypeEnum = TypeEnum.Undefined;
                        }
                        else
                        {
                            param.Type.UserDefinedType = td;
                        }
                    }
                }
            }

            // Finalize User defined type memeber TypeIdentifiers
            // If this will be allowed !
            // UDT in UDT not allowed yet !
            foreach (var type in dto.UserDefinedTypeInfoList)
            {
                var udtd = type.Type.UserDefinedType as UserDefinedTypeDescriptor;
                if (udtd == null)
                {
                    // Error ! Not an user defined type.
                }
                else
                {
                    foreach (var attr in udtd.Attributes)
                    {
                        if (attr.Descriptor.Type.TypeEnum == TypeEnum.UserDefinedType)
                        {
                            ITypeDescriptor td = dto.GetUserTypeDescriptor(attr.Descriptor.Type.TypeName);
                            if (td == null)
                            {
                                dto.AddError(CompilerErrorCode.UndefinedType, string.Format(
                                    "Undefined type \"{0}\" in User Defined Type \"{1}\" at Memeber \"{2}\"!",
                                    attr.Descriptor.Type.TypeName, type.Name, attr.Descriptor.Name),
                                    type.NodeValueInfo, type.FileName);

                                // Set Type to undefined !
                                attr.Descriptor.Type.TypeEnum = TypeEnum.Undefined;
                            }
                            else
                            {
                                attr.Descriptor.Type.UserDefinedType = td;
                            }
                        }
                    }
                }
            }
        }