/*
    Copyright 2017-2020 Katy Coe - http://www.djkaty.com - https://github.com/djkaty
    Copyright 2020 Robert Xiao - https://robertxiao.ca

    All rights reserved.
*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using Il2CppInspector.Cpp.UnityHeaders;
using Il2CppInspector.Reflection;

namespace Il2CppInspector.Cpp
{
    // Class for generating C header declarations from Reflection objects (TypeInfo, etc.)
    public class CppDeclarationGenerator
    {
        private readonly Il2CppModel model;

        // Version number and header file to generate structures for
        public UnityVersion UnityVersion { get; }
        public UnityHeader UnityHeader { get; }

        // How inheritance of type structs should be represented.
        // Different C++ compilers lay out C++ class structures differently,
        // meaning that the compiler must be known in order to generate class type structures
        // with the correct layout.
        public CppCompiler.Type InheritanceStyle;

        public CppDeclarationGenerator(Il2CppModel model, UnityVersion version) {
            this.model = model;
            if (version == null) {
                UnityHeader = UnityHeader.GuessHeadersForModel(model)[0];
                UnityVersion = UnityHeader.MinVersion;
            } else {
                UnityVersion = version;
                UnityHeader = UnityHeader.GetHeaderForVersion(version);
                if (UnityHeader.MetadataVersion != model.Package.BinaryImage.Version) {
                    /* this can only happen in the CLI frontend with a manually-supplied version number */
                    Console.WriteLine($"Warning: selected version {UnityVersion} (metadata version {UnityHeader.MetadataVersion})" +
                        $" does not match metadata version {model.Package.BinaryImage.Version}.");
                }
            }

            InitializeNaming();
            InitializeConcreteImplementations();

            // Configure inheritance style based on binary type; this can be overridden by setting InheritanceStyle in the object initializer
            InheritanceStyle = CppCompiler.GuessFromImage(model.Package.BinaryImage);
        }
        
        // C type declaration used to name variables of the given C# type
        public string AsCType(TypeInfo ti) {
            // IsArray case handled by TypeNamer.GetName
            if (ti.IsByRef || ti.IsPointer) {
                return $"{AsCType(ti.ElementType)} *";
            } else if (ti.IsValueType) {
                if (ti.IsPrimitive) {
                    switch (ti.Name) {
                        case "Boolean": return "bool";
                        case "Byte": return "uint8_t";
                        case "SByte": return "int8_t";
                        case "Int16": return "int16_t";
                        case "UInt16": return "uint16_t";
                        case "Int32": return "int32_t";
                        case "UInt32": return "uint32_t";
                        case "Int64": return "int64_t";
                        case "UInt64": return "uint64_t";
                        case "IntPtr": return "void *";
                        case "UIntPtr": return "void *";
                        case "Char": return "uint16_t";
                        case "Double": return "double";
                        case "Single": return "float";
                    }
                }
                return $"struct {TypeNamer.GetName(ti)}";
            } else if (ti.IsEnum) {
                return $"enum {TypeNamer.GetName(ti)}";
            }
            return $"struct {TypeNamer.GetName(ti)} *";
        }

        // Resets the cache of visited types and pending types to output, but preserve any names we have already generated
        public void Reset() {
            VisitedFieldStructs.Clear();
            VisitedTypes.Clear();
            TodoFieldStructs.Clear();
            TodoTypeStructs.Clear();
        }

        #region Field Struct Generation
        /* Generating field structures (structures for the fields of a given type) occurs in two passes.
         * In the first pass (VisitFieldStructs), we walk over a type and all of the types that the resulting structure would depend on.
         * In the second pass (GenerateVisitedFieldStructs), we generate all type structures in the necessary order.
         * (For example: structures for value types must precede any usage of those value types for layout reasons).
         */

        // A cache of field structures that have already been generated, to eliminate duplicate definitions
        private readonly HashSet<TypeInfo> VisitedFieldStructs = new HashSet<TypeInfo>();

        // A queue of field structures that need to be generated.
        private readonly List<TypeInfo> TodoFieldStructs = new List<TypeInfo>();

        // Walk over dependencies of the given type, to figure out what field structures it depends on
        private void VisitFieldStructs(TypeInfo ti) {
            if (VisitedFieldStructs.Contains(ti))
                return;
            if (ti.IsByRef || ti.IsPointer || ti.ContainsGenericParameters)
                return;
            VisitedFieldStructs.Add(ti);

            if (ti.BaseType != null)
                VisitFieldStructs(ti.BaseType);

            if (ti.IsArray)
                VisitFieldStructs(ti.ElementType);

            if (ti.IsEnum)
                VisitFieldStructs(ti.GetEnumUnderlyingType());

            foreach (var fi in ti.DeclaredFields)
                if (!fi.IsStatic && !fi.IsLiteral && (fi.FieldType.IsEnum || fi.FieldType.IsValueType))
                    VisitFieldStructs(fi.FieldType);

            TodoFieldStructs.Add(ti);
        }

        // Generate the fields for the base class of all objects (Il2CppObject)
        // The two fields are inlined so that we can specialize the klass member for each type object
        private void GenerateObjectFields(StringBuilder csrc, TypeInfo ti) {
            csrc.Append(
                $"  struct {TypeNamer.GetName(ti)}__Class *klass;\n" +
                $"  struct MonitorData *monitor;\n");
        }

        // Generate structure fields for each field of a given type
        private void GenerateFieldList(StringBuilder csrc, CppNamespace ns, TypeInfo ti) {
            var namer = ns.MakeNamer<FieldInfo>((field) => field.Name.ToCIdentifier());
            foreach (var field in ti.DeclaredFields) {
                if (field.IsLiteral || field.IsStatic)
                    continue;
                csrc.Append($"  {AsCType(field.FieldType)} {namer.GetName(field)};\n");
            }
        }

        // Generate the C structure for a value type, such as an enum or struct
        private void GenerateValueFieldStruct(StringBuilder csrc, TypeInfo ti) {
            string name = TypeNamer.GetName(ti);
            if (ti.IsEnum) {
                // Enums should be represented using enum syntax
                // They otherwise behave like value types
                csrc.Append($"enum {name} : {AsCType(ti.GetEnumUnderlyingType())} {{\n");
                foreach (var field in ti.DeclaredFields) {
                    if (field.Name != "value__")
                        csrc.Append($"  {EnumNamer.GetName(field)} = {field.DefaultValue},\n");
                }
                csrc.Append($"}};\n");

                // Use System.Enum base type as klass
                csrc.Append($"struct {name}__Boxed {{\n");
                GenerateObjectFields(csrc, ti.BaseType);
                csrc.Append($"  {AsCType(ti)} value;\n");
                csrc.Append($"}};\n");
            } else {
                // This structure is passed by value, so it doesn't include Il2CppObject fields.
                csrc.Append($"struct {name} {{\n");
                GenerateFieldList(csrc, CreateNamespace(), ti);
                csrc.Append($"}};\n");

                // Also generate the boxed form of the structure which includes the Il2CppObject header.
                csrc.Append($"struct {name}__Boxed {{\n");
                GenerateObjectFields(csrc, ti);
                csrc.Append($"  {AsCType(ti)} fields;\n");
                csrc.Append($"}};\n");
            }
        }

        // Generate the C structure for a reference type, such as a class or array
        private void GenerateRefFieldStruct(StringBuilder csrc, TypeInfo ti) {
            var name = TypeNamer.GetName(ti);
            if (ti.IsArray || ti.FullName == "System.Array") {
                var klassType = ti.IsArray ? ti : ti.BaseType;
                var elementType = ti.IsArray ? AsCType(ti.ElementType) : "void *";
                csrc.Append($"struct {name} {{\n");
                GenerateObjectFields(csrc, klassType);
                csrc.Append(
                    $"  struct Il2CppArrayBounds *bounds;\n" +
                    $"  il2cpp_array_size_t max_length;\n" +
                    $"  {elementType} vector[32];\n");
                csrc.Append($"}};\n");
                return;
            }

            /* Generate a list of all base classes starting from the root */
            List<TypeInfo> baseClasses = new List<TypeInfo>();
            for (var bti = ti; bti != null; bti = bti.BaseType)
                baseClasses.Add(bti);
            baseClasses.Reverse();

            var ns = CreateNamespace();

            if (InheritanceStyle == CppCompiler.Type.MSVC) {
                /* MSVC style: classes directly contain their base class as the first member.
                 * This causes all classes to be aligned to the alignment of their base class. */
                TypeInfo firstNonEmpty = null;
                foreach (var bti in baseClasses) {
                    if (bti.DeclaredFields.Any(field => !field.IsStatic && !field.IsLiteral)) {
                        firstNonEmpty = bti;
                        break;
                    }
                }
                if (firstNonEmpty == null) {
                    /* This struct is completely empty. Omit __Fields entirely. */
                    csrc.Append($"struct {name} {{\n");
                    GenerateObjectFields(csrc, ti);
                    csrc.Append($"}};\n");
                } else {
                    if (firstNonEmpty == ti) {
                        /* All base classes are empty, so this class forms the root of a new hierarchy.
                         * We have to be a little careful: the rootmost class needs to have its alignment
                         * set to that of Il2CppObject, but we can't explicitly include Il2CppObject
                         * in the hierarchy because we want to customize the type of the klass parameter. */
                        var align = model.Package.BinaryImage.Bits == 32 ? 4 : 8;
                        csrc.Append($"struct __declspec(align({align})) {name}__Fields {{\n");
                        GenerateFieldList(csrc, ns, ti);
                        csrc.Append($"}};\n");
                    } else {
                        /* Include the base class fields. Alignment will be dictated by the hierarchy. */
                        ns.ReserveName("_");
                        csrc.Append($"struct {name}__Fields {{\n");
                        csrc.Append($"  struct {TypeNamer.GetName(ti.BaseType)}__Fields _;\n");
                        GenerateFieldList(csrc, ns, ti);
                        csrc.Append($"}};\n");
                    }
                    csrc.Append($"struct {name} {{\n");
                    GenerateObjectFields(csrc, ti);
                    csrc.Append($"  struct {name}__Fields fields;\n");
                    csrc.Append($"}};\n");
                }
            } else if (InheritanceStyle == CppCompiler.Type.GCC) {
                /* GCC style: after the base class, all fields in the hierarchy are concatenated.
                 * This saves space (fields are "packed") but requires us to repeat fields from
                 * base classes. */
                ns.ReserveName("klass");
                ns.ReserveName("monitor");

                csrc.Append($"struct {name} {{\n");
                GenerateObjectFields(csrc, ti);
                foreach (var bti in baseClasses)
                    GenerateFieldList(csrc, ns, bti);
                csrc.Append($"}};\n");
            }
        }

        // "Flush" the list of visited types, generating C structures for each one
        private void GenerateVisitedFieldStructs(StringBuilder csrc) {
            foreach (var ti in TodoFieldStructs) {
                if (ti.IsEnum || ti.IsValueType)
                    GenerateValueFieldStruct(csrc, ti);
                else
                    GenerateRefFieldStruct(csrc, ti);
            }
            TodoFieldStructs.Clear();
        }
        #endregion

        #region Class Struct Generation

        // Concrete implementations for abstract classes, for use in looking up VTable signatures and names
        private readonly Dictionary<TypeInfo, TypeInfo> ConcreteImplementations = new Dictionary<TypeInfo, TypeInfo>();
        /// <summary>
        /// VTables for abstract types have "null" in place of abstract functions.
        /// This function searches for concrete implementations so that we can properly
        /// populate the abstract class VTables.
        /// </summary>
        private void InitializeConcreteImplementations() {
            foreach (var ti in model.Types) {
                if (ti.HasElementType || ti.IsAbstract || ti.IsGenericParameter)
                    continue;
                var baseType = ti.BaseType;
                while (baseType != null) {
                    if (baseType.IsAbstract && !ConcreteImplementations.ContainsKey(baseType))
                        ConcreteImplementations[baseType] = ti;
                    baseType = baseType.BaseType;
                }
            }
        }

        /// <summary>
        /// Obtain the vtables for a given type, with implementations of abstract methods filled in.
        /// </summary>
        /// <param name="ti"></param>
        /// <returns></returns>
        private MethodBase[] GetFilledVTable(TypeInfo ti) {
            MethodBase[] res = ti.GetVTable();
            /* An abstract type will have null in the vtable for abstract methods.
             * In order to recover the correct method signature for such abstract
             * methods, we replace the corresponding vtable slot with an
             * implementation from a concrete subclass, as the name and signature
             * must match.
             * Note that, for the purposes of creating type structures, we don't
             * care which concrete implementation we put in this table! The name
             * and signature will always match that of the abstract type.
             */
            if (ti.IsAbstract && ConcreteImplementations.ContainsKey(ti)) {
                res = (MethodBase[])res.Clone();
                MethodBase[] impl = ConcreteImplementations[ti].GetVTable();
                for (int i = 0; i < res.Length; i++) {
                    if (res[i] == null)
                        res[i] = impl[i];
                }
            }
            return res;
        }

        private readonly HashSet<TypeInfo> VisitedTypes = new HashSet<TypeInfo>();
        private readonly List<TypeInfo> TodoTypeStructs = new List<TypeInfo>();

        /// <summary>
        /// Include the given type into this generator. This will add the given type and all types it depends on.
        /// Call GenerateRemainingTypeDeclarations to produce the actual type declarations afterwards.
        /// </summary>
        /// <param name="ti"></param>
        public void IncludeType(TypeInfo ti) {
            if (VisitedTypes.Contains(ti))
                return;
            if (ti.ContainsGenericParameters)
                return;
            VisitedTypes.Add(ti);

            if (ti.IsArray) {
                VisitFieldStructs(ti);
                IncludeType(ti.ElementType);
                IncludeType(ti.BaseType);
                return;
            } else if (ti.HasElementType) {
                IncludeType(ti.ElementType);
                return;
            } else if (ti.IsEnum) {
                VisitFieldStructs(ti);
                IncludeType(ti.GetEnumUnderlyingType());
                return;
            }

            // Visit all fields first, considering only value types,
            // so that we can get the layout correct.
            VisitFieldStructs(ti);

            if (ti.BaseType != null)
                IncludeType(ti.BaseType);

            TypeNamer.GetName(ti);

            foreach (var fi in ti.DeclaredFields)
                IncludeType(fi.FieldType);

            foreach (var mi in GetFilledVTable(ti))
                if (mi != null && !mi.ContainsGenericParameters)
                    IncludeMethod(mi);

            TodoTypeStructs.Add(ti);
        }

        // Generate the C structure for virtual function calls in a given type (the VTable)
        private void GenerateVTableStruct(StringBuilder csrc, TypeInfo ti) {
            MethodBase[] vtable;
            if (ti.IsInterface) {
                /* Interface vtables are just all of the interface methods.
                   You might have to type a local variable manually as an
                   interface vtable during an interface call, but the result
                   should display the correct method name (with a computed
                   InterfaceOffset added).
                */
                vtable = ti.DeclaredMethods.ToArray();
            } else {
                vtable = ti.GetVTable();
            }
            var name = TypeNamer.GetName(ti);
            var namer = CreateNamespace().MakeNamer<int>((i) => vtable[i]?.Name?.ToCIdentifier() ?? "__unknown");

            // Il2Cpp switched to `VirtualInvokeData *vtable` in Unity 5.3.6.
            // Previous versions used `MethodInfo **vtable`.
            // TODO: Consider adding function types. This considerably increases the script size
            // but can significantly help with reverse-engineering certain binaries.
            csrc.Append($"struct {name}__VTable {{\n");
            if (UnityVersion.CompareTo("5.3.6") < 0) {
                for (int i = 0; i < vtable.Length; i++) {
                    csrc.Append($"  MethodInfo *{namer.GetName(i)};\n");
                }
            } else {
                for (int i = 0; i < vtable.Length; i++) {
                    csrc.Append($"  VirtualInvokeData {namer.GetName(i)};\n");
                }
            }
            csrc.Append($"}};\n");
        }

        // Generate the overall Il2CppClass-shaped structure for the given type
        private void GenerateTypeStruct(StringBuilder csrc, TypeInfo ti) {
            var name = TypeNamer.GetName(ti);
            GenerateVTableStruct(csrc, ti);

            csrc.Append($"struct {name}__StaticFields {{\n");
            var namer = CreateNamespace().MakeNamer<FieldInfo>((field) => field.Name.ToCIdentifier());
            foreach (var field in ti.DeclaredFields) {
                if (field.IsLiteral || !field.IsStatic)
                    continue;
                csrc.Append($"  {AsCType(field.FieldType)} {namer.GetName(field)};\n");
            }
            csrc.Append($"}};\n");

            /* TODO: type the rgctx_data */
            if (UnityVersion.CompareTo("5.5.0") < 0) {
                csrc.Append(
                    $"struct {name}__Class {{\n" +
                    $"  struct Il2CppClass_0 _0;\n" +
                    $"  struct {name}__VTable *vtable;\n" +
                    $"  Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;\n" +
                    $"  struct {name}__StaticFields *static_fields;\n" +
                    $"  const Il2CppRGCTXData *rgctx_data;\n" +
                    $"  struct Il2CppClass_1 _1;\n" +
                    $"}};\n");
            } else {
                csrc.Append(
                    $"struct {name}__Class {{\n" +
                    $"  struct Il2CppClass_0 _0;\n" +
                    $"  Il2CppRuntimeInterfaceOffsetPair *interfaceOffsets;\n" +
                    $"  struct {name}__StaticFields *static_fields;\n" +
                    $"  const Il2CppRGCTXData *rgctx_data;\n" +
                    $"  struct Il2CppClass_1 _1;\n" +
                    $"  struct {name}__VTable vtable;\n" +
                    $"}};\n");
            }
        }

        /// <summary>
        /// Output type declarations for every type that was included since the last call to GenerateRemainingTypeDeclarations
        /// Type declarations that have previously been generated by this instance of CppDeclarationGenerator will not be generated again.
        /// </summary>
        /// <returns>A string containing C type declarations</returns>
        public string GenerateRemainingTypeDeclarations() {
            var csrc = new StringBuilder();
            GenerateVisitedFieldStructs(csrc);

            foreach (var ti in TodoTypeStructs)
                GenerateTypeStruct(csrc, ti);
            TodoTypeStructs.Clear();

            return csrc.ToString();
        }
        #endregion

        #region Method Generation

        /// <summary>
        /// Analyze a method and include all types that it takes and returns.
        /// Must call this before generating the method's declaration with GenerateMethodDeclaration or GenerateFunctionPointer.
        /// </summary>
        /// <param name="mi"></param>
        public void IncludeMethod(MethodBase method, TypeInfo declaringType = null) {
            if (!method.IsStatic)
                IncludeType(declaringType ?? method.DeclaringType);

            if (method is MethodInfo mi)
                IncludeType(mi.ReturnType);

            foreach (var pi in method.DeclaredParameters) {
                IncludeType(pi.ParameterType);
            }
        }

        // Generate a C declaration for a method
        private string GenerateMethodDeclaration(MethodBase method, string name, TypeInfo declaringType) {
            string retType;
            if (method is MethodInfo mi) {
                retType = mi.ReturnType.FullName == "System.Void" ? "void" : AsCType(mi.ReturnType);
            } else {
                retType = "void";
            }

            var paramNs = CreateNamespace();
            paramNs.ReserveName("method");
            var paramNamer = paramNs.MakeNamer<ParameterInfo>((pi) => pi.Name == "" ? "arg" : pi.Name.ToCIdentifier());

            var paramList = new List<string>();
            // Figure out the "this" param
            if (method.IsStatic) {
                // In older versions, static methods took a dummy this parameter
                if (UnityVersion.CompareTo("2018.3.0") < 0)
                    paramList.Add("void *this");
            } else {
                if (declaringType.IsValueType) {
                    // Methods for structs take the boxed object as the this param
                    paramList.Add($"struct {TypeNamer.GetName(declaringType)}__Boxed * this");
                } else {
                    paramList.Add($"{AsCType(declaringType)} this");
                }
            }

            foreach (var pi in method.DeclaredParameters) {
                paramList.Add($"{AsCType(pi.ParameterType)} {paramNamer.GetName(pi)}");
            }

            paramList.Add($"struct MethodInfo *method");

            return $"{retType} {name}({string.Join(", ", paramList)})";
        }

        /// <summary>
        /// Generate a declaration of the form "retType methName(argTypes argNames...)"
        /// You must first visit the method using VisitMethod and then call
        /// GenerateVisitedTypes in order to generate any dependent types.
        /// </summary>
        /// <param name="mi"></param>
        /// <returns></returns>
        public string GenerateMethodDeclaration(MethodBase method) {
            return GenerateMethodDeclaration(method, GlobalNamer.GetName(method), method.DeclaringType);
        }

        /// <summary>
        /// Generate a declaration of the form "retType (*name)(argTypes...)"
        /// You must first visit the method using VisitMethod and then call
        /// GenerateVisitedTypes in order to generate any dependent types.
        /// </summary>
        /// <param name="mi">Method to generate (only the signature will be used)</param>
        /// <param name="name">Name of the function pointer</param>
        /// <returns></returns>
        public string GenerateFunctionPointer(MethodBase method, string name, TypeInfo declaringType = null) {
            return GenerateMethodDeclaration(method, $"(*{name})", declaringType ?? method.DeclaringType);
        }
        #endregion

        #region Naming
        // We try decently hard to avoid creating clashing names, and also sanitize any invalid names.
        // You can customize how naming works by modifying this function.
        private void InitializeNaming() {
            TypeNamespace = CreateNamespace();
            // Type names that may appear in the header
            foreach (var typeName in new string[] { "CustomAttributesCache", "CustomAttributeTypeCache", "EventInfo", "FieldInfo", "Hash16", "MemberInfo", "MethodInfo", "MethodVariableKind", "MonitorData", "ParameterInfo", "PInvokeArguments", "PropertyInfo", "SequencePointKind", "StackFrameType", "VirtualInvokeData" }) {
                TypeNamespace.ReserveName(typeName);
            }
            TypeNamer = TypeNamespace.MakeNamer<TypeInfo>((ti) => {
                if (ti.IsArray)
                    return TypeNamer.GetName(ti.ElementType) + "__Array";
                var name = ti.Name.ToCIdentifier();
                if (name.StartsWith("Il2Cpp"))
                    name = "_" + name;
                name = Regex.Replace(name, "__+", "_");
                // Work around a dumb IDA bug: enums can't be named the same as certain "built-in" types
                // like KeyCode, Position, ErrorType. This only applies to enums, not structs.
                if (ti.IsEnum)
                    name += "__Enum";
                return name;
            });

            GlobalsNamespace = CreateNamespace();
            GlobalNamer = GlobalsNamespace.MakeNamer<MethodBase>((method) => $"{TypeNamer.GetName(method.DeclaringType)}_{method.Name.ToCIdentifier()}");
            EnumNamer = GlobalsNamespace.MakeNamer<FieldInfo>((field) => $"{TypeNamer.GetName(field.DeclaringType)}_{field.Name.ToCIdentifier()}");
        }

        // Reserve C/C++ keywords and built-in names
        private static CppNamespace CreateNamespace() {
            var ns = new CppNamespace();
            /* Reserve C/C++ keywords */
            foreach (var keyword in new [] { "_Alignas", "_Alignof", "_Atomic", "_Bool", "_Complex", "_Generic", "_Imaginary", "_Noreturn", "_Static_assert", "_Thread_local", "alignas", "alignof", "and", "and_eq", "asm", "auto", "bitand", "bitor", "bool", "break", "case", "catch", "char", "char16_t", "char32_t", "char8_t", "class", "co_await", "co_return", "co_yield", "compl", "concept", "const", "const_cast", "consteval", "constexpr", "constinit", "continue", "decltype", "default", "delete", "do", "double", "dynamic_cast", "else", "enum", "explicit", "export", "extern", "false", "final", "float", "for", "friend", "goto", "if", "inline", "int", "long", "mutable", "namespace", "new", "noexcept", "not", "not_eq", "nullptr", "operator", "or", "or_eq", "private", "protected", "public", "reflexpr", "register", "reinterpret_cast", "requires", "restrict", "return", "short", "signed", "sizeof", "static", "static_assert", "static_cast", "struct", "switch", "synchronized", "template", "this", "thread_local", "throw", "true", "try", "typedef", "typeid", "typename", "union", "unsigned", "using", "virtual", "void", "volatile", "wchar_t", "while", "xor", "xor_eq" }) {
                ns.ReserveName(keyword);
            }
            /* Reserve commonly defined C++ symbols for MSVC DLL projects */
            /* This is not an exhaustive list! (windows.h etc.) */
            foreach (var symbol in new[] {"_int32", "DEFAULT_CHARSET", "FILETIME", "NULL", "SYSTEMTIME", "stderr", "stdin", "stdout"}) {
                ns.ReserveName(symbol);
            }
            /* Reserve builtin keywords in IDA */
            foreach (var keyword in new [] { "_BYTE", "_DWORD", "_OWORD", "_QWORD", "_UNKNOWN", "_WORD", "__cdecl", "__declspec", "__export", "__far", "__fastcall", "__huge", "__import", "__int128", "__int16", "__int32", "__int64", "__int8", "__interrupt", "__near", "__pascal", "__spoils", "__stdcall", "__thiscall", "__thread", "__unaligned", "__usercall", "__userpurge", "_cs", "_ds", "_es", "_ss", "flat" }) {
                ns.ReserveName(keyword);
            }
            return ns;
        }

        /// <summary>
        /// Namespace for all types and typedefs
        /// </summary>
        public CppNamespace TypeNamespace { get; private set; }

        public CppNamespace.Namer<TypeInfo> TypeNamer { get; private set; }

        /// <summary>
        /// Namespace for global variables, enum values and methods
        /// </summary>
        public CppNamespace GlobalsNamespace { get; private set; }
        public CppNamespace.Namer<MethodBase> GlobalNamer { get; private set; }
        public CppNamespace.Namer<FieldInfo> EnumNamer { get; private set; }
        #endregion
    }
}