root/trunk/demangle.d

// Demangles a mangled D identifier
// by James Dunne
// Jan. 5 2005

module  demangle;

import  std.ctype;
import  std.string;

// 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 ~= ".";
        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)
char[] extracttypeinfo(char[] id, inout int i) {
    if (i >= id.length) return null;
    // Extract the type info:
    switch (id[i]) {
        // array, static array, dynamic array:
        case 'A', 'G', 'H': ++i; return extracttypeinfo(id, i) ~ "[]";
        // pointer:
        case 'P': ++i; return extracttypeinfo(id, i) ~ "*";
        // reference:
        case 'R': ++i; return extracttypeinfo(id, i) ~ "&";
        // return value:
        case 'Z': ++i; return extracttypeinfo(id, i);
        // out:
        case 'J': ++i; return "out " ~ extracttypeinfo(id, i);
        // inout:
        case 'K': ++i; return "inout " ~ extracttypeinfo(id, i);

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

        // basic types:
        case 'n': ++i; return "none";       // ever used?
        case 'v': ++i; return "void";
        case 'g': ++i; return "byte";
        case 'h': ++i; return "ubyte";
        case 's': ++i; return "short";
        case 't': ++i; return "ushort";
        case 'i': ++i; return "int";
        case 'k': ++i; return "uint";
        case 'l': ++i; return "long";
        case 'm': ++i; return "ulong";
        case 'f': ++i; return "float";
        case 'd': ++i; return "double";
        case 'e': ++i; return "real";

        // imaginary and complex:
        case 'o': ++i; return "ifloat";
        case 'p': ++i; return "idouble";
        case 'j': ++i; return "ireal";
        case 'q': ++i; return "cfloat";
        case 'r': ++i; return "cdouble";
        case 'c': ++i; return "creal";

        // other types:
        case 'b': ++i; return "bit";
        case 'a': ++i; return "char";
        case 'u': ++i; return "wchar";
        case 'w': ++i; return "dchar";

        // typeinfo, error, instance:
        case '@': ++i; return extractidentifiers(id, i);    // BUG: is this right?

        default: return "unknown";
    }
}

// Returns true if it's an identifier (should be modified to return the string)
bool demangle(char[] id) {
    char[]  name;
    int i;

    // D linkage function:
    if (id[0] == '_') {
        if (id[1] == 'D') {
            // is it main?
            if (id[2 .. 7] == "main") {
                // aww that's easy:
                printf("int main(char[][])\n");
                return true;
            }
    
            // Parse the collection of identifiers:
            i = 2;
            name = extractidentifiers(id, i);
            // function:
            if (id[i] == 'F') {
                char[]  params;
                bool    first = true;
    
                // extract all the parameters:
                ++i;
                while (i < id.length) {
                    if (id[i] == 'Z') break;
                    if (!first) params ~= ", ";
                    params ~= extracttypeinfo(id, i);
                    first = false;
                }
    
                // extract the return type:
                char[] rettype = extracttypeinfo(id, i);
    
                // print the function definition:
                printf("%.*s %.*s(%.*s)\n\n", rettype, name, params);
                return true;
            } else {
                // should always be a function with _D linkage?!?!
                printf("wtf?!\n\n");
                return false;
            }
            // Check the type:
        } else if (id[1 .. 6] == "Class") {
            i = 7;
            printf("class %.*s\n", extractidentifiers(id, i));
        } else if (id[1 .. 5] == "init") {
            i = 6;
            printf("init %.*s\n", extractidentifiers(id, i));
        } else if (id[1 .. 5] == "vtbl") {
            i = 6;
            printf("vtbl %.*s\n", extractidentifiers(id, i));
        } else if (id[1 .. 8] == "modctor") {
            i = 9;
            printf("ctor %.*s\n", extractidentifiers(id, i));
        } else if (id[1 .. 8] == "moddtor") {
            i = 9;
            printf("dtor %.*s\n", extractidentifiers(id, i));
        } else if (id[1 .. 11] == "ModuleInfo") {
            i = 12;
            printf("module %.*s\n", extractidentifiers(id, i));
        } else {
            return false;
        }
        printf("\n");
        return true;
    }

    return false;
}

// should be a unittest:
int main(char[][] args) {
    // these were taken from phobos.lib:
    demangle("_D3std6stream4File5_ctorFT3std1c7windows7windows6HANDLEE8FileModeZC3std6stream4File");
    demangle("_Class_3std6socket9UdpSocket");
    demangle("_D3std6stream4File6handleFZT3std1c7windows7windows6HANDLE");
    demangle("_D3std6stream12BufferedFile6createFAaE8FileModeZv");
    demangle("_D3std5math24polyFeAeZe");
    demangle("_D3std3uri15decodeComponentFAaZAa");
    demangle("_D3std7windows8registry17Reg_CreateKeyExA_FT3std7windows8registry4HKEYAakE6REGSAMPvJT3std7windows8registry4HKEYJkZi");
    demangle("_D3std6string5ifindFAawZi");
    demangle("_D3std6stream12EndianStream4readFJqZv");
    // these were taken from the compiled EXE of this module:
    demangle("_D8demangle18extractidentifiersFAaKiZAa");
    demangle("_D8demangle15extracttypeinfoFAaKiZAa");
    return 0;
}

//
// Demangling algorithm:
//
// 1. check the prefix of the mangled name.
//    a. if _D then D-linkage function
//    b. if __Class_ then class definition
//    c. if __init_ then init-table for class
//    d. if __vtbl_ then inherited class/interface for class
//    e. if __modctor_ then constructor for class
//    f. if __moddtor_ then destructor for class
//    g. if __ModuleInfo_ then module definition
// 2. To parse an identifier:
//    1. read digits until non-digit character
//    2. convert that collection of digits to integer
//    3. use integer as length to extract identifier
//    4. suffix identifier with .
//    5. repeat steps 1-4 until no initial digit character found.
// 3. To parse the parameter list of a function definition:
//    1. make sure function starts with '_D', has an identifier, and then an 'F'
//    2. check demangling type table function "extracttypeinfo" to appropriate action.
//    3. all lower-case letters are basic types
//    4. all upper-case letters are complex types (like arrays, structs, classes, etc)
//    5. upper-case letters are either followed by lower-case letters (basic types) or
//       identifiers.
//