root/trunk/dsymextract.d

// Demangles a mangled D identifier and produces the result in
// inherited container classes such as DType and DSymbol.

// Ideally used to extract code-completion info from a compiled D library
// using the library's symbol table.

// by James Dunne
// Jan. 6 2005

module  dsymextract;

import  std.ctype;
import  std.string;

//version = destructors;                    // include destructor code (for explicit memory management)
version = error_extrachars;             // check for extra characters after end of mangled string
version(linux) {
    version = ansi_color;               // use ANSI color strings for cheap syntax highlighting
}
//debug = destruct;                     // dump destructor calls

// A D symbol (inherited usually)
class DSymbol {
    public:
        char[]  name;       // name for the symbol
        DType   type;       // type of the symbol

        this() {
            
        }

        char[] toANSIString() {
            return "\033[0;37m" ~ name;
        }

        char[] toString() {
            return name;
        }
}

// A D function definition
class DFunction : DSymbol {
    public:
        //char[]    name;       // name for the function
        //DType     type;       // return type for the function
        DType[]     params;     // parameters for the function

        this() {
        }

        version (destructors) ~this() {
            foreach (inout DType t; params)
                if (cast(DReservedType)t is null)
                    delete t;
        }

        char[] toANSIString() {
            char[] s;
            bool first = true;

            if (type is null) return name;

            s = type.toANSIString() ~ " \033[0;37m" ~ name ~ "\033[0;36m" ~ "(";
            foreach (DType dt; params) {
                if (!first) s ~= "\033[0;36m" ~ ", ";
                s ~= dt.toANSIString();
                first = false;
            }
            s ~= "\033[0;36m)\033[37m";

            return s;
        }

        char[] toString() {
            char[] s;
            bool first = true;

            if (type is null) return name;

            s = type.toString() ~ " " ~ name ~ "(";
            foreach (DType dt; params) {
                if (!first) s ~= ", ";
                s ~= dt.toString();
                first = false;
            }
            s ~= ")";

            return s;
        }
}

// A D class definition:
class DClass : DSymbol {
    public:
        // Doesn't have much.
        // Should expand to contain functions and other symbols.

        this(char[] name) {
            this.name = name;
        }

        char[] toANSIString() {
            return "\033[0;37mclass " ~ name;
        }

        char[] toString() {
            return "class " ~ name;
        }
}

// A D module definition:
class DModule : DSymbol {
    public:
        // Doesn't have much.
        // Should expand to contain class definitions, functions, and other symbols.

        this(char[] name) {
            this.name = name;
        }

        char[] toANSIString() {
            return "\033[0;37mmodule " ~ name;
        }

        char[] toString() {
            return "module " ~ name;
        }
}


// A reserved type:
class DReservedType : DType {
    public:
        this() {
            
        }

        // Initialize a DType with a string representation:
        this(char[] chars) {
            asString = chars;
        }

        version (destructors) ~this() {
            debug (destruct) printf("DReservedType.~this()\n");
        }
}

// A D type:
class DType {
    private:
        char[]  asString;       // what this type is as a string

    public:
        // Some static basic types:
        static DReservedType None;      // ever used?
        static DReservedType Void;
        static DReservedType Byte;
        static DReservedType UByte;
        static DReservedType Short;
        static DReservedType UShort;
        static DReservedType Int;
        static DReservedType UInt;
        static DReservedType Long;
        static DReservedType ULong;
        static DReservedType Float;
        static DReservedType Double;
        static DReservedType Real;

        // imaginary and complex:
        static DReservedType IFloat;
        static DReservedType IDouble;
        static DReservedType IReal;
        static DReservedType CFloat;
        static DReservedType CDouble;
        static DReservedType CReal;

        // other types:
        static DReservedType Bit;
        static DReservedType Char;
        static DReservedType WChar;
        static DReservedType DChar;

        // Initialize the basic types:
        static this() {
            // basic types:
            None = new DReservedType("none");       // ever used?
            Void = new DReservedType("void");
            Byte = new DReservedType("byte");
            UByte = new DReservedType("ubyte");
            Short = new DReservedType("short");
            UShort = new DReservedType("ushort");
            Int = new DReservedType("int");
            UInt = new DReservedType("uint");
            Long = new DReservedType("long");
            ULong = new DReservedType("ulong");
            Float = new DReservedType("float");
            Double = new DReservedType("double");
            Real = new DReservedType("real");

            // imaginary and complex:
            IFloat = new DReservedType("ifloat");
            IDouble = new DReservedType("idouble");
            IReal = new DReservedType("ireal");
            CFloat = new DReservedType("cfloat");
            CDouble = new DReservedType("cdouble");
            CReal = new DReservedType("creal");

            // other types:
            Bit = new DReservedType("bit");
            Char = new DReservedType("char");
            WChar = new DReservedType("wchar");
            DChar = new DReservedType("dchar");
        }

        version (destructors) static ~this() {
            debug (destruct) printf("static DType::~this()\n");
            // basic types:
            delete None;        // ever used?
            delete Void;
            delete Byte;
            delete UByte;
            delete Short;
            delete UShort;
            delete Int;
            delete UInt;
            delete Long;
            delete ULong;
            delete Float;
            delete Double;
            delete Real;

            // imaginary and complex:
            delete IFloat;
            delete IDouble;
            delete IReal;
            delete CFloat;
            delete CDouble;
            delete CReal;

            // other types:
            delete Bit;
            delete Char;
            delete WChar;
            delete DChar;
            debug (destruct) printf("static DType::~this() deleted\n");
        }

    public:
        // Not sure why, but the compiler complains without it:
        this() {
            
        }

        version (destructors) ~this() {
            
        }

        // Convert the type to its string representation:
        char[] toANSIString() {
            return "\033[34m" ~ asString;
        }

        char[] toString() {
            return asString;
        }
}

// This exception is thrown on parsing errors and type errors:
class DTypeException : Exception {
    public:
        this(char[] msg) {
            super("DTypeException: " ~ msg);
        }
}

// Simple D types:

// Array:
class DTypeArray : DType {
    private:
        DType   internalType;       // the type of the array

    public:
        this(DType singleType) {
            this.internalType = singleType;
        }

        version (destructors) ~this() {
            debug (destruct) printf("DTypeArray.~this()\n");
            if (cast(DReservedType)internalType is null)
                delete internalType;
        }

        // append a [] to the end of the type:
        char[] toANSIString() {
            return internalType.toANSIString() ~ "\033[1;31m[]\033[0;37m";
        }

        char[] toString() {
            return internalType.toString() ~ "[]";
        }
}

// Static array:
class DTypeSArray : DType {
    private:
        DType   internalType;       // the type of the array

    public:
        this(DType singleType) {
            this.internalType = singleType;
        }

        version (destructors) ~this() {
            debug (destruct) printf("DTypeSArray.~this()\n");
            if (cast(DReservedType)internalType is null)
                delete internalType;
        }

        // append a [] to the end of the type:
        char[] toANSIString() {
            return internalType.toANSIString() ~ "\033[1;31m[]\033[0;37m";
        }

        char[] toString() {
            return internalType.toString() ~ "[]";
        }
}

// Dynamic array:
class DTypeDArray : DType {
    private:
        DType   internalType;       // the type of the array

    public:
        this(DType singleType) {
            this.internalType = singleType;
        }

        version (destructors) ~this() {
            debug (destruct) printf("DTypeDArray.~this()\n");
            if (cast(DReservedType)internalType is null)
                delete internalType;
        }

        // append a [] to the end of the type:
        char[] toANSIString() {
            return internalType.toANSIString() ~ "\033[1;31m[]\033[0;37m";
        }

        char[] toString() {
            return internalType.toString() ~ "[]";
        }
}

// Pointer:
class DTypePointer : DType {
    private:
        DType   internalType;       // the type of pointer

    public:
        this(DType singleType) {
            this.internalType = singleType;
        }

        version (destructors) ~this() {
            debug (destruct) ("DTypePointer.~this()\n");
            if (cast(DReservedType)internalType is null)
                delete internalType;
        }

        char[] toANSIString() {
            return internalType.toANSIString() ~ "\033[1;33m*\033[0;37m";
        }

        char[] toString() {
            return internalType.toString() ~ "*";
        }
}

// Reference:
class DTypeReference : DType {
    private:
        DType   internalType;       // the type of reference

    public:
        this(DType singleType) {
            this.internalType = singleType;
        }

        version (destructors) ~this() {
            debug (destruct) printf("DTypeReference.~this()\n");
            if (cast(DReservedType)internalType is null)
                delete internalType;
        }

        char[] toANSIString() {
            return internalType.toANSIString() ~ "\033[1;33m&\033[0;37m";
        }
        
        char[] toString() {
            return internalType.toString() ~ "&";
        }
}

// out parameter:
// (in is default)
class DTypeOut : DType {
    private:
        DType   internalType;       // an out parameter

    public:
        this(DType singleType) {
            if (!(cast(DTypeInOut)singleType is null))
                throw new DTypeException("inout cannot be followed by out!");
            if (!(cast(DTypeOut)singleType is null))
                throw new DTypeException("out cannot be followed by out!");

            this.internalType = singleType;
        }

        version (destructors) ~this() {
            debug (destruct) printf("DTypeOut.~this()\n");
            if (cast(DReservedType)internalType is null)
                delete internalType;
        }

        char[] toANSIString() {
            return "\033[34mout " ~ internalType.toANSIString();
        }

        char[] toString() {
            return "out " ~ internalType.toString();
        }
}

// inout parameter:
class DTypeInOut : DType {
    private:
        DType   internalType;       // an inout parameter

    public:
        this(DType singleType) {
            if (!(cast(DTypeInOut)singleType is null))
                throw new DTypeException("inout cannot be followed by inout!");
            if (!(cast(DTypeOut)singleType is null))
                throw new DTypeException("out cannot be followed by inout!");

            this.internalType = singleType;
        }

        version (destructors) ~this() {
            debug (destruct) printf("DTypeInOut.~this()\n");
            if (cast(DReservedType)internalType is null)
                delete internalType;
        }

        char[] toANSIString() {
            return "\033[34minout " ~ internalType.toANSIString();
        }

        char[] toString() {
            return "inout " ~ internalType.toString();
        }
}

// enum:
class DTypeEnumeration : DType {
    private:
        char[]  identifier;         // the name of the enum type

    public:
        this(char[] ident) {
            this.identifier = ident;
        }

        version (destructors) ~this() {
            debug (destruct) printf("DTypeEnumeration.~this()\n");
        }

        char[] toANSIString() {
            return "\033[0;37m" ~ identifier;
        }

        char[] toString() {
            return identifier;
        }
}

// typedef:
class DTypeTypedef : DType {
    private:
        char[]  identifier;         // the name of the typedef type

    public:
        this(char[] ident) {
            this.identifier = ident;
        }

        version (destructors) ~this() {
            debug (destruct) printf("DTypeTypedef.~this()\n");
        }

        char[] toANSIString() {
            return "\033[0;37m" ~ identifier;
        }

        char[] toString() {
            return identifier;
        }
}

// delegate:
class DTypeDelegate : DType {
    private:
        char[]  identifier;         // the name of the delegate type

    public:
        this(char[] ident) {
            this.identifier = ident;
        }

        version (destructors) ~this() {
            debug (destruct) printf("DTypeDelegate.~this()\n");
        }

        char[] toANSIString() {
            return "\033[0;37m" ~ identifier;
        }

        char[] toString() {
            return identifier;
        }
}

// class instance:
class DTypeClass : DType {
    private:
        char[]  identifier;         // the name of the class type

    public:
        this(char[] ident) {
            this.identifier = ident;
        }

        version (destructors) ~this() {
            debug (destruct) printf("DTypeClass.~this()\n");
        }

        char[] toANSIString() {
            return "\033[0;37m" ~ identifier;
        }

        char[] toString() {
            return identifier;
        }
}

// struct instance:
class DTypeStruct : DType {
    private:
        char[]  identifier;         // the name of the struct type

    public:
        this(char[] ident) {
            this.identifier = ident;
        }

        version (destructors) ~this() {
            debug (destruct) printf("DTypeStruct.~this()\n");
        }

        char[] toANSIString() {
            return "\033[0;37m" ~ identifier;
        }

        char[] toString() {
            return identifier;
        }
}

// identifier:
class DTypeIdentifier : DType {
    private:
        char[]  identifier;

    public:
        this(char[] ident) {
            this.identifier = ident;
        }

        version (destructors) ~this() {
            debug (destruct) printf("DTypeIdentifier.~this()\n");
        }

        char[] toANSIString() {
            return "\033[0;37m" ~ identifier;
        }

        char[] toString() {
            return identifier;
        }
}

// The extractor class:
class DSymbolExtractor {
    private:

        // extracts a series of dot-separated identifiers:
        char[] extractidentifiers(char[] id, inout int i) {
            char[]  s;
            bool first = true;

            for (;;) {
                int num = i;

                // Parse numeric length:
                while (i < id.length) {
                    if (!isdigit(id[i])) break;
                    ++i;
                }
                if (num == i) break;

                // Get the length as an integer:
                int len = atoi(id[num .. i]);
                // Extract the identifier
                if (!first) s ~= ".";

                if (i+len > id.length)
                    throw new DTypeException("length of identifier would exceed length of mangled string!");

                s ~= id[i .. i+len];
                i += len;

                // Dot-separate after this:
                first = false;
            }

            // Return the identifier string:
            return s;
        }

        // extracts a single definition (like a parameter)
        DType extracttypeinfo(char[] id, inout int i) {
            if (i >= id.length)
                throw new DTypeException("unexpected end of identifier!");

            // Extract the type info:
            switch (id[i]) {
                // array, static array, dynamic array:
                case 'A': ++i; return new DTypeArray(extracttypeinfo(id, i));
                case 'G': ++i; return new DTypeSArray(extracttypeinfo(id, i));
                case 'H': ++i; return new DTypeDArray(extracttypeinfo(id, i));
                // pointer:
                case 'P': ++i; return new DTypePointer(extracttypeinfo(id, i));
                // reference:
                case 'R': ++i; return new DTypeReference(extracttypeinfo(id, i));
                // out:
                case 'J': ++i; return new DTypeOut(extracttypeinfo(id, i));
                // inout:
                case 'K': ++i; return new DTypeInOut(extracttypeinfo(id, i));

                // enum:
                case 'E': ++i; return new DTypeEnumeration(extractidentifiers(id, i));
                // typedef:
                case 'T': ++i; return new DTypeTypedef(extractidentifiers(id, i));
                // delegate:
                case 'D': ++i; return new DTypeDelegate(extractidentifiers(id, i));
                // class:
                case 'C': ++i; return new DTypeClass(extractidentifiers(id, i));
                // struct:
                case 'S': ++i; return new DTypeStruct(extractidentifiers(id, i));
                // identifier:
                case 'I': ++i