xnu-1228.tar.gz

[apple/xnu.git] / libsa / c++rem3.c

// 45678901234567890123456789012345678901234567890123456789012345678901234567890
/*

Rules specification by
Stan Shebs of Apple Computer, Inc 2002

Parse and remangle implemented by
Godfrey van der Linden of Apple Computer, Inc 2002

Rules for demangling IOKit symbols

In Darwin versions 1.0 through at least 5.2, IOKit is compiled using
GCC version 2.  GCC 2's C++ symbol mangling algorithm ultimately
derives from the basic scheme described in the Annotated C++ Reference
Manual (ARM), section 7.2.1c, with a number of changes, mostly due to
the expansion of the language since the ARM was published in 1990.

This description is not complete.  It omits RTTI, thunks, and
templates, since they are not allowed in IOKit.  The description also
mentions mangled name constructs that are not disallowed in IOKit, but
that as of Jan 2002, did actually appear in any symbol in the base
system.

A mangled name basically consists of a function name followed
by two underscores, optionally followed by a signature computed
from the function's argument types.  (Note that in Darwin, the
compiler adds an additional underscore to all C and C++ symbols.
The description assumes this has been removed.)

<special_or_name> ::= <gnu_special>
                    | <mangled_name>

<mangled_name> ::= <prefix> [ <signature> ]

<prefix> ::= [ "_GLOBAL_" [ID] "__" ] <function_name> "__" [ <opinfo> ]

<function_name> ::= <char> <char>*
                  | NULL

Questions for Stan (@@@Stan@@@)
1> A valid <opinfo> implies a null function name.
2> I wonder if an <opinfo> is mutually exclusive with a <function_name> perhaps something like :-
<prefix> ::= [ "_GLOBAL_" ("I"|"D") "__" ] ((<function_name> "__") | <opinfo>)
3> Do constructors turn up as an opinfo or a NULL function name?

The optional "_GLOBAL_"("I"|"D")"__" sequence indicates global constructors
and destructors, but in practice these do not appear with the mach-o Apple 2.95

A Null <function_name> indicates a constructor or an operator.

Since <function_name> may include trailing underscores, the demangler
should scan forward until a non-underscore is seen, and then take the
last two as the separator between name and signature.

<function_name> may also include any number of leading underscores, so
the demangler needs to add those to <function_name> and look for the
"__" following the name.

<gnu_special> ::= ("_._"|"_$_" ) <class_name>	; destructor
                | "__vt_" <class_name>		; virtual table
                | "_" <class_name> ("."|"$") <varname> ; Variable

<class_name> ::= <counted_class_name>
               | "Q" <qualified_name>
               | "K" <qualified_name>	; ignored and illegal

<counted_class_name> ::= <count> <name>

<qualified_name> ::= <q_count> <counted_class_name> <counted_class_name>*

<opinfo> ::= "type" <type>
           | "__op" <type>
           | <opname> "__"
           | "a"

<opname> ::= "aa"	# &&
           | "aad"	# &=
           | "ad"	# &
           | "adv"	# /=
           | "aer"	# ^=
           | "als"	# <<=
           | "amd"	# %=
           | "ami"	# -=
           | "aml"	# *=
           | "aor"	# |=
           | "apl"	# +=
           | "ars"	# >>=
           | "as"	# =
           | "cl"	# ()
           | "cm"	# ,
           | "cn"	# ?:
           | "co"	# ~
           | "dl"	# delete
           | "dv"	# /
           | "eq"	# ==
           | "er"	# ^
           | "ge"	# >=
           | "gt"	# >
           | "le"	# <=
           | "ls"	# <<
           | "lt"	# <
           | "md"	# %
           | "mi"	# -
           | "ml"	# *
           | "mm"	# --
           | "mn"	# <?
           | "mx"	# >?
           | "ne"	# !=
           | "nt"	# !
           | "nw"	# new
           | "oo"	# ||
           | "or"	# |
           | "pl"	# +
           | "pp"	# ++
           | "rf"	# ->
           | "rm"	# ->*
           | "rs"	# >>
           | "sz"	# sizeof
           | "vc"	# []
           | "vd"	# delete[]
           | "vn"	# new[]

Questions for Stan (@@@Stan@@@)
1> What the hell is The "type" & "__op" stuff?

IOKit has so far only been observed to use operations new ("nw") and
delete ("dl").

The signature is a concatenated list of elements, which are usually
argument types, but may include other sorts of things.

<signature> ::= <qualifier>* <s_element> <argument_types>

<s_element> ::= <class_name>
              | "S"
              | "F" <argument_types> [ "_" <return_type> ] 

Questions for Stan (@@@Stan@@@)
1> I think the 'B' phrase should probably read '| "B" <index>'?
2> Ambiguous productions for signature
   OSObject::func(struct timeval fred) => _func__8OSObject7timeval
   signature could be parsed as
        <s_element> <s_element> or <s_element> <argument_types>
    I believe the second one must be the valid production.

<count> ::= <digit> <digit>*

<varname> :: <name>

<name> ::= <char> <char>*

The <count> is the number of characters in <name>.

Argument types are a concatenated sequence of types.

<argument_types> ::= # Empty
                   | <arg_type>+
<arg_type> ::= <type>  [ "n" <index> ]
	     | "N" <count> <pos>
             | "T" <index>

The "N" repeats and "T" references to already-seen typescan only
appear if -fno-squangle (no squashed mangling), and in practice aren't
seen in IOKit symbols.

<index> ::= <digit> | <digit> <digit> <digit>* "_"

Return types are just like any other sort of type.

<return_type> ::= <type>

Types consist of a variable number of declarators in front of a basic
type.

<type> ::= <declarator>* <base_type>

<declarator> ::= "P"            ; pointer
               | "p"            ; pointer (but never occurs?)
               | "R"            ; reference (&)
               | "A" <count>    ; array
               | "T" <index>
               | "O" <count>
               | <qualifier>

The "A" <count> production can produce an ambigous output if it is followed by a counted class name or structure name.

The "T" reference to a type does not appear in IOKit symbols, nor do
the "M" and "O" declarators.

<base_type> ::= <function_type>	; function
              | <method_type>	; method
              | <type_qualifier>* <fund_type_id>

<function_type> ::= "F" <argument_types> "_" <type>

<method_type> ::= "M" <class_name> <function_type>

A qualified name consists of a count of types, followed by all the
types concatenated together.  For instance, Namespace::Class is
Q29Namespace5Class.  For more than 9 types (which has not yet occurred
in IOKit), the multi-digit count is surrounded by underscores.

Questions for Stan (@@@Stan@@@)
1> Can the types in a qualified name really be generic types or can the set be restricted to just counted class names?

<q_count> ::= <digit> | "_" <digit> <digit>* "_"

Fundamental types are single letters representing standard built-in
types, optionally preceded by type qualifiers for properties like
signedness and constness.  For instance, CUi is a const unsigned int.

<type_qualifier> ::= "S"        ; signed (chars only)
                   | "U"        ; unsigned (any integral type)
                   | "J"        ; __complex
                   | <qualifier>

<fund_type_id> ::= <class_name>
                 | "b"          ; bool
                 | "c"          ; char
                 | "d"          ; double
                 | "f"          ; float
                 | "i"          ; int
                 | "l"          ; long
                 | "r"          ; long double
                 | "s"          ; short
                 | "v"          ; void
                 | "w"          ; wchar_t
                 | "x"          ; long long
                 | "G" <count>  ; ?????
                 | "e"		; ellipsis

"G" does not appear in IOKit symbols in this context.

<qualifier> ::= "C"             ; const
              | "V"             ; volatile
              | "u"             ; restrict (C99)
              | "G"             ; struct/union/enum unused by gcc3

The restrict qualifier has not appeared in IOKit symbols.

*/
#if KERNEL

#include <stdarg.h>
#include <string.h>

#include <sys/systm.h>

#include <libkern/OSTypes.h>

#include <libsa/stdlib.h>

enum { false = 0, true = 1 };

#else /* !KERNEL */

#include <unistd.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <CoreFoundation/CoreFoundation.h>
 
#endif /* KERNEL */

#include "c++rem3.h"

#define STRLEN(s) (sizeof(s)-1)
#define APPENDSTR(c, str) do { appendNStr(c, str, STRLEN(str)); } while (0)

#define MAX_COMPOUND_TYPES	128
#define MAX_ENTRIES		256
#define MAX_SDICT_ENTRIES	256
#define MAX_BDICT_ENTRIES	 64
#define MAX_RETURN_BUFFER	256

// Can't be bigger that 16 entries
typedef enum NameTypes {
    kNTUndefined,	kNTClass,	kNTFunction,	kNTFuncEnd,
    kNTMethod,		kNTBuiltIn,	kNTDeclarator,	kNTArray,
    kNTKName,		kNTSubstitute,  kNTSubQualClass
} NameTypes;

typedef struct TypeData {
    short fStartEntry, fNumEntries;
} TypeData;

typedef struct BaseTypeData {
    const char *fFundTypeID;	// May contain the type itself for kNTBuiltIt
    unsigned int fLen:16;
    unsigned int fType:4;	// Must fit a NameType
    unsigned int fVolatile:1;
    unsigned int fConst:1;
    unsigned int fSigned:1;
    unsigned int fUnsigned:1;
    unsigned int fPseudo:1;
    unsigned int fQualified:1;
} BaseTypeData;

typedef struct CheckPoint {
    const char *fInChar;
    unsigned char fNumI, fNumO, fNumT, fNumB, fNumS;
} CheckPoint;

typedef struct ParseContext {
    CheckPoint fP;
    BaseTypeData fInEntries[MAX_ENTRIES];	// Input parsed elements
    BaseTypeData fOutEntries[MAX_ENTRIES];	// Output parsed elements
    TypeData fTypeList[MAX_COMPOUND_TYPES];	// Table of types
    TypeData fSubDict[MAX_SDICT_ENTRIES];
    TypeData fBDict[MAX_BDICT_ENTRIES];		// B dictionary types
    BaseTypeData *fCurBaseP;
    const char *fInStr;
    char *fOutStrEnd;
    char *fOutChar;
    int fInSize;
    Rem3Return fRetCode;
} ParseContext;

//
// The only forward declaration necessary
//
static Boolean parse_type(ParseContext *c);

// Helper functions for walking through the string
static __inline__ char getNext(ParseContext *c)
{
    return *c->fP.fInChar++;
}

static __inline__ CheckPoint *checkPoint(ParseContext *c)
{
    return &c->fP;
}

static __inline__ void resetTo(ParseContext *c, CheckPoint *chk)
{
    c->fP = *chk;
}

static __inline__ const char *inCharFromCheck(CheckPoint *chk)
{
    return chk->fInChar;
}

static __inline__ void advance(ParseContext *c, int len)
{
    c->fP.fInChar += len;
}

static __inline__ Boolean retard(ParseContext *c, int len)
{
    const char *cp = c->fP.fInChar - len;
    if (cp < c->fInStr)
        return false;

    c->fP.fInChar = cp;
    return true;
}

static __inline__ char peekAt(ParseContext *c, int index)
{
    return c->fP.fInChar[index];
}

static __inline__ char peekNext(ParseContext *c)
{
    return peekAt(c, 0);
}

static __inline__ Boolean atEnd(ParseContext *c)
{
    return '\0' == peekNext(c);
}

static __inline__ Boolean hasRemain(ParseContext *c, int len)
{
    return (c->fP.fInChar - c->fInStr + len <= c->fInSize);
}

//
// Routines for allocating entries in the various
//
static __inline__ BaseTypeData *newIn(ParseContext *c)
{
    BaseTypeData *iP;

    if (c->fP.fNumI < MAX_ENTRIES) {
        iP = &c->fInEntries[c->fP.fNumI++];
        bzero(iP, sizeof(*iP));
        c->fCurBaseP = iP;
        return iP;
    }
    else {
        c->fRetCode = kR3InternalNotRemangled;
        return NULL;
    }
}

static __inline__ BaseTypeData *newOut(ParseContext *c)
{
    BaseTypeData *oP;

    if (c->fP.fNumO < MAX_ENTRIES) {
        oP = &c->fOutEntries[c->fP.fNumO++];
        return oP;
    }
    else {
        c->fRetCode = kR3InternalNotRemangled;
        return NULL;
    }
}

static __inline__ TypeData *
newSub(ParseContext *c, int start, int num)
{
    TypeData *sP;

    if (c->fP.fNumS < MAX_SDICT_ENTRIES) {
        sP = &c->fSubDict[c->fP.fNumS++];
        sP->fStartEntry = start;
        sP->fNumEntries = num;
        return sP;
    }
    else {
        c->fRetCode = kR3InternalNotRemangled;
        return NULL;
    }
}

static __inline__ TypeData *
newBDict(ParseContext *c, int start, int num)
{
    TypeData *bP;

    if (c->fP.fNumB < MAX_BDICT_ENTRIES) {
        bP = &c->fBDict[c->fP.fNumB++];
        bP->fStartEntry = start;
        bP->fNumEntries = num;
        return bP;
    }
    else {
        c->fRetCode = kR3InternalNotRemangled;
        return NULL;
    }
}

static __inline__ TypeData *
newType(ParseContext *c, int start)
{
    TypeData *tP;

    if (c->fP.fNumT < MAX_COMPOUND_TYPES) {
        tP = &c->fTypeList[c->fP.fNumT++];
        tP->fStartEntry = start;
        return tP;
    }
    else
        return NULL;
}

static __inline__ TypeData *
dupType(ParseContext *c, TypeData *iTP, int offset)
{
    TypeData *tP = newType(c, iTP->fStartEntry + offset);
    if (tP)
        tP->fNumEntries = iTP->fNumEntries;

    return tP;
}

//
// Identifier character recognition helpers, can be optimised
//
static __inline__ Boolean isValidFirstAlphabetic(char c)
{
    if ('a' <= c && c <= 'z')
        return true;
    else if ('A' <= c && c <= 'Z')
        return true;
    else
        return false;
}

static __inline__ Boolean isValidFirstChar(char c)
{
    if (isValidFirstAlphabetic(c))
        return true;
    else if (c == '_')
        return true;
    else
        return false;
}

static __inline__ Boolean isValidChar(char c)
{
    if (isValidFirstChar(c))
        return true;
    else if ('0' <= c && c <= '9')
        return true;
    else
        return false;
}

//
// Helper function for recognising characters and strings
//

// Check the current input is the given character
static __inline__ Boolean isNext(ParseContext *c, char ch)
{
    if (peekNext(c) == ch) {
        advance(c, 1);
        return true;
    }
    else
        return false;
}

// Check the current input is ONE of the characters in str
static Boolean charNext(ParseContext *c, const char *str)
{
    if (hasRemain(c, 1)) {
        char ch = peekNext(c);
        char next;

        while ( (next = *str++) )
            if (next == ch) {
                advance(c, 1);
                return true;
            }
    }

    return false;
}

// Check the current input for 'str'
static Boolean strNext(ParseContext *c, const char *str)
{
    const char *cp = c->fP.fInChar;

    do {
        if (!*str) {
            c->fP.fInChar = (const char *) cp;
            return true;
        }
        else if (!*cp)
            return false;

    } while (*cp++ == *str++);

    return false;
}

//
// Qualifier re-encoding
//
static void
decodeQual(BaseTypeData *typeP, int *qualLenP, const char **qualP)
{
    const char *qual;
    int qualLen;

    if (typeP->fConst && typeP->fVolatile)
        { qual = "VK"; qualLen = 2; }
    else if (typeP->fConst)
        { qual = "K";  qualLen = 1; }
    else if (typeP->fVolatile)
        { qual = "V";  qualLen = 1; }
    else
        { qual = NULL; qualLen = 0; }

    *qualLenP = qualLen;
    *qualP = qual;
}


//
// Output functions
//

static void appendChar(ParseContext *c, char ch)
{
    char *outAddr = c->fOutChar++;
    if (outAddr < c->fOutStrEnd)
        *outAddr = ch;
}

static void appendNStr(ParseContext *c, const char *str, int len)
{
    char *outAddr = c->fOutChar;

    c->fOutChar += len;
    if (c->fOutChar < c->fOutStrEnd)
        bcopy(str, outAddr, len);
}

static __inline__ void appendStr(ParseContext *c, const char *str)
{
    appendNStr(c, str, strlen(str));
}

static void appendSub(ParseContext *c, int ls)
{
    appendChar(c, 'S');
    if (ls) {
        if (--ls >= 36) {
            int ms;
    
            ms = ls / 36;
            appendChar(c, (ms < 10)? '0' + ms : 'A' + ms - 10);
            ls -= (ms * 36);
        }
        appendChar(c, (ls < 10)? '0' + ls : 'A' + ls - 10);
    }
    appendChar(c, '_');
}

static Boolean compareTypes(ParseContext *c, int sub, int entry, int numEntries)
{
    TypeData *subP = &c->fSubDict[sub];
    BaseTypeData *bSP, *bIP;
    int i;

    if (subP->fNumEntries != numEntries)
        return false;

    bSP = &c->fInEntries[subP->fStartEntry];
    bIP = &c->fInEntries[entry];

    for (i = 0; i < numEntries; i++, bSP++, bIP++) {
        if (bSP->fType != bIP->fType)
            return false;

        switch (bSP->fType) {
        case kNTClass:
            if (bSP->fLen != bIP->fLen)
                return false;
            else if (strncmp(bSP->fFundTypeID, bIP->fFundTypeID, bSP->fLen))
                return false;
            break;

        case kNTArray:
        case kNTBuiltIn:
        case kNTDeclarator:
            if (bSP->fFundTypeID != bIP->fFundTypeID)
                return false;
            break;

        case kNTMethod:
        case kNTFunction:
        case kNTUndefined:
        case kNTKName:
            break;		// OK so far

        default:
            return false;	// Fatal errors 
        }
    }

    return true;
}

static int searchDict(ParseContext *c, int entry, int numE)
{
    int sub, numSubs = c->fP.fNumS;

        // don't try to substitute the last builtin 
    if (numE == 1 && kNTBuiltIn == c->fInEntries[entry].fType)
        return -1;
        
    for (sub = 0; sub < numSubs; sub++)
        if (compareTypes(c, sub, entry, numE))
            return sub;

    return -1;
}

static int searchDictClass(ParseContext *c, const char *qname, int len)
{
    TypeData *subP;
    int sub, numSubs = c->fP.fNumS;

    for (sub = 0, subP = c->fSubDict; sub < numSubs; sub++, subP++) {
        BaseTypeData *iP = &c->fInEntries[subP->fStartEntry];

        if (kNTClass != iP->fType || iP->fLen != len)
            continue;
        if (!strncmp(iP->fFundTypeID, qname, len))
            return sub;
    }

    return -1;
}

static Boolean
appendQualifiedClass(ParseContext *c, int entry)
{
    BaseTypeData *iP, *oP, *sP, *endSP;
    const char *cp, *typeID;
    char *cp_new;
    int sub, subEntry, prefixLen;
    int q_count;

    int decodeStart = c->fP.fNumI;

    // Scan through the incom
    iP = &c->fInEntries[entry];
    endSP = &c->fInEntries[MAX_ENTRIES];
    sP = &c->fInEntries[decodeStart];

    prefixLen = iP->fLen;
    typeID = cp = iP->fFundTypeID;
    for (q_count = 0; sP < endSP && (cp-typeID) < prefixLen; q_count++, sP++) {
        int count;

        count = strtoul(cp, &cp_new, 10);
	cp = cp_new + count;

        sP->fType = kNTClass;
        sP->fFundTypeID = typeID;
        sP->fLen = cp - typeID;
    }
    if (sP >= endSP)
        return false;
    
    // Search backwards until I find the first substitution
    sub = -1;
    for (subEntry = q_count, sP--; subEntry > 0; subEntry--, sP--) {
        sub = searchDictClass(c, sP->fFundTypeID, sP->fLen);
        if (-1 != sub)
            break;
    }

    // Now drop the symbol into the output buffer
    oP = newOut(c);
    if (!oP)
        return false;

    if (sub < 0)
        *oP = *iP;	// No sub copy original
    else {
        // Substitution found
        prefixLen = sP->fLen;		// Length of substitution

        oP->fType = kNTSubstitute;	// Assume complete substitution
        oP->fLen = sub;
        oP->fFundTypeID = NULL;

        // We have a partial substitution so tag on the unmatched bit
        if (prefixLen != iP->fLen) {
            oP->fType = kNTSubQualClass; // Re-characterise as 2 part sub
    
            oP = newOut(c);
            if (!oP)
                return false;

            *oP = *iP;			// Duplicate the original
            oP->fType = kNTSubQualClass;
            oP->fFundTypeID += prefixLen; // Skip leading substituted text
            oP->fLen -= prefixLen;
        }
    }

    // Finally insert the qualified class names into the dictionary
    for (subEntry++, sP++; subEntry < q_count; subEntry++, decodeStart++) {
        c->fInEntries[decodeStart] = *sP++;
        if (!newSub(c, decodeStart, 1))
            return false;
    }
    c->fP.fNumI = decodeStart;

    if (!newSub(c, entry, 1))
        return false;
    
    return true;
}

static int
appendType(ParseContext *c, int type)
{
    BaseTypeData *iP, *oP;
    TypeData *tP;
    int i, sub;
    int entry, numE, lastEntry;
    Boolean found;

    if (type >= c->fP.fNumT)
        return -1;

    tP = &c->fTypeList[type++];
    entry = tP->fStartEntry;
    numE  = tP->fNumEntries;
    lastEntry = entry + numE;
    iP = NULL;
    for (i = 0, found = false, sub = -1; i < numE; i++) {
        iP = &c->fInEntries[entry + i];
        switch (iP->fType) {

	// Function & Builtin can't be compressed alone
        case kNTFunction:
        case kNTBuiltIn:
            i++;		// Copy the current entry
            found = true;
            break;

        case kNTClass:
        case kNTMethod:
            sub = searchDict(c, entry + i, numE - i);
            if (sub < 0 && !iP->fQualified)
                i++;
            found = true;
            break;

        case kNTDeclarator:
        case kNTArray:
            sub = searchDict(c, entry + i, numE - i);
            found = (sub >= 0);
            break;

        // Internal error's should never occur
        case kNTKName:
        case kNTSubstitute:
        case kNTSubQualClass:
        case kNTUndefined:
        default:
            return -1;
        }
        if (found)
            break;
    }

    if (!found)
        return -1;	// Internal error: no terminal symbol?

    // Copy the already input buffer to the output
    oP = &c->fOutEntries[c->fP.fNumO];
    if (i) {  
        if (c->fP.fNumO + i >= MAX_ENTRIES)
            return -1;

        bcopy(&c->fInEntries[entry], oP, i * sizeof(*oP));
        c->fP.fNumO += i;
        oP += i;
    }

    if (sub >= 0) {
        // We found a substitution
        oP->fType = kNTSubstitute;
        oP->fLen = sub;
        c->fP.fNumO++;		// Increment output for the substitution

        // Walk over types that have been substituted
        while (type < c->fP.fNumT 
           &&  c->fTypeList[type].fStartEntry < lastEntry)
                type++;
    }
    else switch (iP->fType)
    {
    case kNTMethod:
        type = appendType(c, type);	// Class Name
        if (type < 0)
            return type;
        type = appendType(c, type);	// Pointer to function
        if (type < 0)
            return type;
        break;

    case kNTFunction:
        type = appendType(c, type);	// Return type
        if (type < 0)
            return type;

        // process the argument list
        do {
            tP = &c->fTypeList[type];
            if (tP->fStartEntry < lastEntry) {
                type = appendType(c, type);
                if (type < 0)
                    return type;
            }
            else
                break;
        } while (type < c->fP.fNumT);
        oP = newOut(c);
        if (!oP)
            return -1;
        oP->fType = kNTFuncEnd;
        break;

    case kNTBuiltIn:
        i--;		// Do not store the buildit in the dictionary
        break;

    case kNTClass:	// Nothing more to do
        if (!iP->fQualified)
            break;
        else if (appendQualifiedClass(c, entry + i))
            break;
        else
            return -1;
    }
    
    // No further substititions to be had update the dictionary
    for (i += entry; --i >= entry; ) {
        if (!newSub(c, i, lastEntry - i))
            return -1;
    }
    
    return type;
}

static Boolean appendArgumentList(ParseContext *c)
{
    int i, num;

    c->fRetCode = kR3InternalNotRemangled;
    // Setup the output entry array
    num = c->fP.fNumT;
    for (i = 0; i < num; ) {
        i = appendType(c, i);
        if (i < 0)
            return false;
    }

    // First pass output uncompressed types
    for (i = 0, num = c->fP.fNumO; i < num; i++) {
        BaseTypeData *bP;

        bP = &c->fOutEntries[i];

        if (bP->fPseudo)
            continue;	// Pseudo entry do not output;

        switch (bP->fType) {

        case kNTSubstitute: appendSub(c, bP->fLen); break;

        case kNTSubQualClass:
            appendChar(c, 'N');
            appendSub(c, bP->fLen);
            i++; bP = &c->fOutEntries[i];
            appendNStr(c, bP->fFundTypeID, bP->fLen);
            appendChar(c, 'E');
            break;

        case kNTClass:
            if (bP->fQualified) {
                appendChar(c, 'N');
                appendNStr(c, bP->fFundTypeID, bP->fLen);
                appendChar(c, 'E');
            }
            else
                appendNStr(c, bP->fFundTypeID, bP->fLen);
            break;

        case kNTArray: {
            char numbuf[16];	// Bigger than MAX_LONG + 3
            int len;
            len = snprintf(numbuf, sizeof(numbuf),
                           "A%lu_", (unsigned long) bP->fFundTypeID);
            appendNStr(c, numbuf, len);
            break;
        }

        case kNTBuiltIn:
        case kNTDeclarator:	appendChar(c, (int) bP->fFundTypeID); break;
        case kNTMethod:		appendChar(c, 'M'); break;
        case kNTFunction:	appendChar(c, 'F'); break;
        case kNTFuncEnd:	appendChar(c, 'E'); break;

        case kNTUndefined:
        case kNTKName:
        default:
            return false;	// Fatal errors 
        }
    }

    // Successful remangle
    c->fRetCode = kR3Remangled;
    return true;
}

//
// Parse routines
//

// <count> ::= <digit> <digit>*
static Boolean parse_count(ParseContext *c, int *countP)
{
    int count = 0;
    char ch;
    char *newp;

    ch = peekNext(c);
    if (ch < '1' || ch > '9')
        return false;

    count = strtol(c->fP.fInChar, &newp, 10);
    c->fP.fInChar = newp;
    if (countP)
        *countP = count;

    return true;
}


// "n" <index> can cause the following type to be ambiguous as
// n23_Pc... can be
//	  "n" <digit> <counted_class_name> ...
//	| "n" <digit> <digit> '_' <declarator> <fund_type_id> ...
// However as the class '_Pc' is probably going to be unlikely a quick
// check to see if the next field is a valid type would probably clear
// up the abiguity for the majority of cases.
// 
// <index> ::= <digit> | <digit> <digit> <digit>* "_"
static Boolean parse_index(ParseContext *c, int *indexP)
{
    CheckPoint chk = *checkPoint(c);
    char ch0, ch1;
    int index;

    ch0 = peekAt(c, 0);
    ch1 = peekAt(c, 1);

    if ( !('0' <= ch0 && ch0 <= '9') )
        goto abandonParse;
    if ('0' <= ch1 && ch1 <= '9') {
        if (!parse_count(c, &index))
            goto abandonParse;
        if (isNext(c, '_')) {
            // @@@ gvdl: Ambiguity check one day
            if (indexP)
                *indexP = index;
            return true;
        }
        else
            resetTo(c, &chk);	// Must be the one digit case
    }

    // One digit case
    advance(c, 1);
    index = ch0 - '0';

    if (indexP)
        *indexP = index;
    return true;

abandonParse:
    return false;
}


// <qualifier> ::= "C"	; const
//               | "V"	; volatile
//               | "u"	; restrict (C99) unsupported
//               | "G"	; struct/union/enum ; unused in gcc3
static Boolean parse_qualifiers(ParseContext *c)
{
    BaseTypeData *bP = c->fCurBaseP;

    for (;;) {
        if (isNext(c, 'C'))
            bP->fConst = true;		// "C"	; const
        else if (isNext(c, 'V'))
            bP->fVolatile = true;	// "V"	; volatile
        else if (isNext(c, 'u'))
            return false;		// "u"	; restrict (C99)
        else if (isNext(c, 'G'))
            continue;			// "G"	; struct/union/enum ; unused
        else
            break;
    }

    return true;
}

// Assumes we have an open fInEntry in fCurBaseP
static Boolean duplicateEntries(ParseContext *c, int start, int numE)
{
    BaseTypeData *bIP = &c->fInEntries[start];	// First duplicate entry
    BaseTypeData *bP = c->fCurBaseP;
    int i;

    // Duplicating a method
    if (kNTMethod == bIP->fType) {
        bP--;			// Strip leading 'P' declarator
        c->fP.fNumI--;
    }

    numE--;

    // do we have room available for duplication
    if (c->fP.fNumI + numE >= MAX_ENTRIES)
        return false;

    // Copy the parse entries over
    bcopy(bIP, bP, (numE + 1) * sizeof(*bP));

    // Now we have to duplicate the types for the new entry
    for (i = 0; i < c->fP.fNumT; i++) {
        TypeData *tP = &c->fTypeList[i];
        if (tP->fStartEntry < start)
            continue;
        else if (tP->fStartEntry <= start + numE)
            dupType(c, tP, bP - bIP);
        else
            break;
    } 

    c->fP.fNumI += numE;
    bP += numE;
    c->fCurBaseP = bP;

    return true;
}

// Must have a valid c->fCurBaseP pointer on entry
// <class_name> ::= <counted_class_name>	; plain class name
//                | "Q" <qualified_name>	; qualified name
//                | "B" <index>			; compressed name
//                | "K" <qualified_name>	; ignored and illegal
// <qualified_name> ::= <q_count> <counted_class_name>+
// <q_count> ::= <digit> | "_" <digit> <digit>* "_"
// <counted_class_name> ::= <count> <name>
// <name> ::= <char> <char>*
static Boolean
parse_class_name(ParseContext *c)
{
    BaseTypeData *bP = c->fCurBaseP;
    const char *typeId = c->fP.fInChar;
    char ch;
    int count;

    if (parse_count(c, &count)) {

        // <counted_class_name> ::= <count> <name>
        if (!hasRemain(c, count))
            goto abandonParse;

        bP->fType = kNTClass;
        advance(c, count);

        bP->fFundTypeID = typeId;
        bP->fLen = c->fP.fInChar - typeId;
    }
    else {
        switch (peekNext(c)) {

        case 'Q': {
            int i, q_count;

            advance(c, 1);

            //                | "Q" <qualified_name>	; qualified name
            // <qualified_name> ::= <q_count> <counted_class_name>+
            // <q_count> ::= <digit> | "_" <digit> <digit>* "_"
            if ('_' == (ch = getNext(c))) {
                advance(c, 1);
                if (!parse_count(c, &q_count) || !isNext(c, '_'))
                    goto abandonParse;
            }
            else if ('1' <= ch && ch <= '9')
                q_count = ch - '0';

            if (!q_count)
                goto abandonParse;

            typeId = c->fP.fInChar;
            bP->fType = kNTClass;
            bP->fQualified = true;
            i = 0;
            for (i = 0; i < q_count; i++) {
                if (parse_count(c, &count))
                    advance(c, count);
                else
                    goto abandonParse;
            }
            bP->fLen = c->fP.fInChar - typeId;
            bP->fFundTypeID = typeId;
            break;
        }

        case 'B':
            //               | "B" <index>
            advance(c, 1);

            if (!parse_index(c, &count) || count >= c->fP.fNumB)
                goto abandonParse;

            if (!duplicateEntries(c, c->fBDict[count].fStartEntry,
                                     c->fBDict[count].fNumEntries))
                goto abandonParse;
            return true;

        case 'K': default:
            goto abandonParse;
        }
    }

    if (newBDict(c, bP - c->fInEntries, 1))
        return true;

abandonParse:
    return false;
}

// <fund_type_id> ::= <class_name>
//                  | "b"          ; bool
//                  | "c"          ; char
//                  | "d"          ; double
//                  | "e"          ; ellipsis
//                  | "f"          ; float
//                  | "i"          ; int
//                  | "l"          ; long
//                  | "r"          ; long double
//                  | "s"          ; short
//                  | "v"          ; void
//                  | "w"          ; wchar_t
//                  | "x"          ; long long
//                  | "G" <count>  ; ???
static Boolean parse_fund_type_id(ParseContext *c)
{
    BaseTypeData *bP = c->fCurBaseP;

    if (!parse_class_name(c)) {
        // Use the TypeID pointer as a 4 character buffer
        char ch = peekNext(c);

        if (bP->fSigned && 'c' != ch)
            goto abandonParse;	// illegal only chars can be signed

        switch (ch) {

        case 'b': case 'd': case 'f': case 'v': case 'w':	// No map types
            break;

        case 'c':			// character
            if (bP->fSigned)		ch = 'a';
            else if (bP->fUnsigned)	ch = 'h';
            break;
        case 'e':			// ellipsis
                                        ch = 'z';
            break;
        case 'i':			// int
            if (bP->fUnsigned)		ch = 'j';
            break;
        case 'l':			// long
            if (bP->fUnsigned)		ch = 'm';
            break;
        case 'r':			// long double
                                        ch = 'e';
            break;
        case 's':			// short
            if (bP->fUnsigned)		ch = 't';
            break;
        case 'x':			// long long
            if (bP->fUnsigned)		ch = 'y';
            break;

        case 'G':			// Don't understand "G"
        default:
            goto abandonParse;
        }

        advance(c, 1);	// Consume the input character
        bP->fFundTypeID = (void *) (int) ch;
        bP->fLen = 0;
        bP->fType = kNTBuiltIn;
    }

    return true;

abandonParse:
    return false;
}

// <arg_type> ::= <type>  [ "n" <index> ]
//	       | "N" <count> <pos>	; Not implemented
//             | "T" <index>		; Not implemented
static Boolean parse_arg_type(ParseContext *c)
{
    // Don't bother to check point as parse_argument_types does it for us

    TypeData *typeP;
    int repeat = 0;

    typeP = &c->fTypeList[c->fP.fNumT];	// Cache type for later repeat
    if (!parse_type(c))
        return false;

    // Now check for a repeat count on this type
    if (isNext(c, 'n')) {
        if (!parse_index(c, &repeat))
            return false;

        do {
            c->fCurBaseP = newIn(c);	// Duplicate requires a fresh type
            if (!c->fCurBaseP)
                return false;
            if (!duplicateEntries(c, typeP->fStartEntry, typeP->fNumEntries))
                return false;
        } while (--repeat);
    }

    return true;
}

// <argument_types> ::= # Empty
//                    | <arg_type>+
static Boolean parse_argument_types(ParseContext *c)
{
    if (atEnd(c))
        return true;

    if (!parse_arg_type(c))
        goto abandonParse;

    while (!atEnd(c) && parse_arg_type(c))
        ;

    return true;

    // Not a counted class name so reset to checkPoint
abandonParse:
    return false;
}

// leaf function so the copy aside buffer isn't on the primary
// recursion stack.
static Boolean
rotateFunction(ParseContext *c, int argStart, int retStart)
{
    char returnTypeBuffer[MAX_RETURN_BUFFER];
    unsigned int numArg, numRet;
    unsigned int lenArg, lenRet;
    char *sArgP, *sRetP;
    unsigned int i;

    TypeData *argTP = &c->fTypeList[argStart];
    TypeData *retTP = &c->fTypeList[retStart];

    // Rotate around the entries first
    numArg = retTP->fStartEntry - argTP->fStartEntry;
    numRet = retTP->fNumEntries;
    lenArg = numArg * sizeof(BaseTypeData);
    lenRet = numRet * sizeof(BaseTypeData);

    // Copy the return type into a buffer
    if (lenRet > sizeof(returnTypeBuffer))
        return false;

    sArgP = (char *) (&c->fInEntries[argTP->fStartEntry]);
    sRetP = (char *) (&c->fInEntries[retTP->fStartEntry]);
    
    bcopy(sRetP, returnTypeBuffer, lenRet);
    bcopy(sArgP, sArgP + lenRet, lenArg);
    bcopy(returnTypeBuffer, sArgP, lenRet);

    // Retarget the argument and return types for the new entry positions
    lenArg = numArg;
    lenRet = numRet;
    numArg = retStart - argStart;
    numRet = c->fP.fNumT - retStart;
    for (i = 0; i < numArg; i++)
        c->fTypeList[argStart+i].fStartEntry += lenRet;
    for (i = 0; i < numRet; i++)
        c->fTypeList[retStart+i].fStartEntry -= lenArg;

    // Rotate the BDictionary
    for (i = 0; i < c->fP.fNumB; i++) {
        TypeData *bDP = &c->fBDict[i];
        int start = bDP->fStartEntry;

        if (start >= argTP->fStartEntry)
            bDP->fStartEntry = start + lenRet;
        else if (start >= retTP->fStartEntry)
            bDP->fStartEntry = start - lenArg;
    }

    // Finally rotate the retargeted type structures.
    lenArg = numArg * sizeof(TypeData);
    lenRet = numRet * sizeof(TypeData);

    sArgP = (char *) (&c->fTypeList[argStart]);
    sRetP = (char *) (&c->fTypeList[retStart]);

    bcopy(sRetP, returnTypeBuffer, lenRet);
    bcopy(sArgP, sArgP + lenRet, lenArg);
    bcopy(returnTypeBuffer, sArgP, lenRet);

    return true;
}

// <function_type> ::= "F" <argument_types> "_" <type>
static Boolean parse_function_type(ParseContext *c, Boolean forMethod)
{
    TypeData *bDictP = NULL;
    BaseTypeData *bP = c->fCurBaseP;

    int argTypeStart, retTypeStart;

    if (!forMethod) {
        bDictP = newBDict(c, c->fP.fNumI-1, 0);
        if (!bDictP)
            goto abandonParse;
    }

    if (!isNext(c, 'F'))
        goto abandonParse;

    bP->fType = kNTFunction;

    // Note that the argument types will advance the Entry list
    argTypeStart = c->fP.fNumT;
    if (!parse_argument_types(c))
        goto abandonParse;

    if (!isNext(c, '_'))
        goto abandonParse;

    // Parse the return type
    retTypeStart = c->fP.fNumT;
    if (!parse_type(c))
        goto abandonParse;

    // gcc3 puts the return code just after the 'F' declaration
    // as this impacts the order of the compression I need to rotate
    // the return type and the argument types.
    if (!rotateFunction(c, argTypeStart, retTypeStart))
        goto abandonParse;

    if (!forMethod)
        bDictP->fNumEntries = c->fP.fNumI - bDictP->fStartEntry;

    return true;

abandonParse:
    return false;
}

// To convert 2.95 method to a 3.0 method I need to prune the
// first argument of the function type out of the parse tree.
static Boolean cleanMethodFunction(ParseContext *c, int type)
{
    TypeData *typeP, *startTP, *endTP;            
    BaseTypeData *bP;
    int i, thisStart, thisEnd, thisLen, funcRemain;

    // Get pointer for the return value's type.
    startTP = &c->fTypeList[type+1];
    endTP = &c->fTypeList[c->fP.fNumT];

    // Now look for the first type that starts after the return type
    thisEnd = startTP->fStartEntry + startTP->fNumEntries;
    for (startTP++; startTP < endTP; startTP++)
        if (startTP->fStartEntry >= thisEnd)
            break;

    if (startTP >= endTP) {
        c->fRetCode = kR3InternalNotRemangled;
        return false;	// Internal error: should never happen
    }

    // We now have a pointer to the 1st argument in the input list
    // we will need to excise the entries from the input list and don't forget
    // to remove the associated types from the type list.

    thisLen = startTP->fNumEntries;
    thisStart = startTP->fStartEntry;
    thisEnd = thisStart + thisLen;
    funcRemain = c->fP.fNumI - thisEnd;
    bP = &c->fInEntries[thisStart];

    // If we have no arguments then replace the pointer with a void
    if (!funcRemain) {
        c->fP.fNumI -= (thisLen - 1);

        bP->fFundTypeID = (void *) (int) 'v';	// Void arg list
        bP->fLen = 0;
        bP->fType = kNTBuiltIn;

        // Update the type entry for the void argument list
        startTP->fNumEntries = 1;
        return true;
    }

    // Move the argument list down to replace the 'this' pointer
    bcopy(bP + thisLen, bP, funcRemain * sizeof(*bP));
    c->fP.fNumI -= thisLen;

    // And remove the 'this' pointers type
    
    // First walk over all of the types that have to be removed
    for (typeP = startTP + 1; typeP < endTP; typeP++)
        if (typeP->fStartEntry >= thisEnd)
            break;

    if (typeP >= endTP) {
        c->fRetCode = kR3InternalNotRemangled;
        return false;	// Internal error Can't be a void argument list.
    }

    bcopy(typeP, startTP, (char *) endTP - (char *) typeP);
    
    c->fP.fNumT -= typeP - startTP;
    endTP = &c->fTypeList[c->fP.fNumT];
    for (typeP = startTP ; typeP < endTP; typeP++)
        typeP->fStartEntry -= thisLen;

    // Finally we can retarget the BDictionary lists
    for (i = 0; i < c->fP.fNumB; i++) {
        TypeData *bDP = &c->fBDict[i];
        int start = bDP->fStartEntry;

        if (start < thisStart)
            continue;
        if (start >= thisEnd)
            break;

        bDP->fStartEntry = start - thisLen;
    }

    return true;
}

// <method_type> ::= "M" <class_name> <function_type>
//
// Note this is a very bad function.  Gcc3 doesn't doesn't use pointer that
// is immediately before this entry.  We will have to delete the 'P' declarator
// that is before the method declaration.
// We will also have to prune the first type in the argument list as Gcc3
// doesn't register the 'this' pointer within the function list.
static Boolean parse_method_type(ParseContext *c)
{
    TypeData *bDictP;
    TypeData *typeP;            
    BaseTypeData *bP;

    bDictP = newBDict(c, c->fP.fNumI-2, 0);
    if (!bDictP)
        goto abandonParse;

    // Replace 'P' declarator
    c->fP.fNumI--;
    bP = c->fCurBaseP - 1;

    if (!isNext(c, 'M'))
        goto abandonParse;

    if (bP->fFundTypeID != (void *) (int) 'P')
        goto abandonParse;

    // Replace the previous 'Pointer' declarator
    bP->fType = kNTMethod;
    bP->fFundTypeID = NULL;
    bP->fLen = 0;

    // Grab the method's 'this' type specification
    typeP = newType(c, c->fP.fNumI);
    if (!newIn(c) || !typeP)
        goto abandonParse;

    if (!parse_class_name(c))
        goto abandonParse;
    typeP->fNumEntries = c->fP.fNumI - typeP->fStartEntry;

    // Grab the <function_type> specifier
    typeP = newType(c, c->fP.fNumI);
    if (!newIn(c) || !typeP)
        goto abandonParse;

    if (!parse_function_type(c, /* forMethod */ true))
        goto abandonParse;

    if (!cleanMethodFunction(c, typeP - c->fTypeList))
        goto abandonParse;
    typeP->fNumEntries = c->fP.fNumI - typeP->fStartEntry;

    // Finally update the dictionary with the M & 'this'
    bDictP->fNumEntries = c->fP.fNumI - bDictP->fStartEntry;

    return true;

abandonParse:
    return false;
}

static Boolean emitQualifiers(ParseContext *c)
{
    BaseTypeData *bP = c->fCurBaseP;

    if (bP->fVolatile || bP->fConst) {
        Boolean isConst, isVolatile, isSigned, isUnsigned;
    
        isVolatile = bP->fVolatile;
        isConst = bP->fConst;
        isSigned = bP->fSigned;
        isUnsigned = bP->fUnsigned;
        bP->fConst = bP->fVolatile = bP->fSigned = bP->fUnsigned = 0;
    
        if (isVolatile) {
            bP->fType = kNTDeclarator;
            bP->fFundTypeID = (void *) (int) 'V';
            bP->fLen = 0;
            bP = newIn(c);
            if (!bP)
                return false;
        }
        if (isConst) {
            bP->fType = kNTDeclarator;
            bP->fFundTypeID = (void *) (int) 'K';
            bP->fLen = 0;
            bP = newIn(c);
            if (!bP)
                return false;
        }
        bP->fSigned = isSigned;
        bP->fUnsigned = isUnsigned;
    }

    return true;
}


// <base_type> ::= <function_type>	; function
//               | <method_type>	; method
//               | <type_qualifier>* <fund_type_id>
// <type_qualifier> ::= "S"        ; signed (chars only)
//                    | "U"        ; unsigned (any integral type)
//                    | "J"        ; __complex
//                    | <qualifier>
static Boolean parse_base_type(ParseContext *c)
{
    if ('F' == peekNext(c)) {
        if (!parse_function_type(c, /* forMethod */ false))
            goto abandonParse;
    }
    else if ('M' == peekNext(c)) {
        if (!parse_method_type(c))
            goto abandonParse;
    }
    else {
        //               | <type_qualifier>* <fund_type_id>
        BaseTypeData *bP = c->fCurBaseP;
        for (;;) {
            if (isNext(c, 'S'))
                // <type_qualifier> ::= "S"	; signed (chars only)
                { bP->fSigned = true; continue; }
            else if (isNext(c, 'U'))
                //                    | "U"	; unsigned (any integral type)
                { bP->fUnsigned = true; continue; }
            else if (isNext(c, 'C'))
                //                    | <qualifier>
                // <qualifier> ::= "C"		; const
                { bP->fConst = true; continue; }
            else if (isNext(c, 'V'))
                //               | "V"		; volatile
                { bP->fVolatile = true; continue; }
            else if (charNext(c, "Ju"))
                goto abandonParse;	// Don't support these qualifiers
                //                    | "J"	; __complex
                //               | "u"		; restrict (C99)
            else
                break;
        }

        if (!emitQualifiers(c))
            goto abandonParse;

        if (!parse_fund_type_id(c))
            goto abandonParse;
    }
    return true;

abandonParse:
    return false;
}

// Use the top SDict as a stack of declarators.
// parses <declarator>*
// <declarator> ::= "P"            ; pointer
//                | "p"            ; pointer (but never occurs?)
//                | "R"            ; reference (&)
//                | "A" <count>    ; array
//                | "T" <index>
//                | "O" <count>
//                | <qualifier>
//
// As a side-effect the fCurBaseP is setup with any qualifiers on exit
static Boolean parse_declarators(ParseContext *c)
{
    int count;
    unsigned long l;
    BaseTypeData *dP;
    char *newp;

    // Note we MUST go through the for loop at least once
    for (count = 0; ; count++) {
        const char *curDecl;
        char ch;

        if (!newIn(c))
            goto abandonParse;

        // <declarator> ::= <qualifier> production
        if (!parse_qualifiers(c) || !emitQualifiers(c))
            goto abandonParse;

        dP = c->fCurBaseP;	// Find the current base type pointer

        curDecl = c->fP.fInChar;

        switch (peekNext(c)) {

        case 'P': case 'p': case 'R':
            // <declarator> ::= "P"            ; pointer
            //                | "p"            ; pointer (but never occurs?)
            //                | "R"            ; reference (&)

            dP->fType = kNTDeclarator;
            advance(c, 1);

            ch = *curDecl;
            if ('p' == ch) ch = 'P';
            dP->fFundTypeID = (void *) (int) ch;
            dP->fLen = 0;
            continue;	// Go around again

        case 'A':
            //                | "A" <count>    ; array
            dP->fType = kNTArray;

            advance(c, 1); curDecl++;
            l = strtoul(curDecl, &newp, 10);
            c->fP.fInChar = newp;
            curDecl = (const char *)l;
            if (!curDecl)
                goto abandonParse;
            dP->fFundTypeID = curDecl;
            dP->fLen = 0;
            continue;	// Go around again

        case 'T': case 'O':
            //                | "T" <index>	Unsupported
            //                | "O" <count>	Unsupported
            goto abandonParse;

        default:
            break;
        }

        break;
    }

    dP->fLen = 0;
    return true;

abandonParse:
    return false;
}

// <type> ::= <declarator>* <base_type>
static Boolean parse_type(ParseContext *c)
{
    CheckPoint chk = *checkPoint(c);
    TypeData *typeP = newType(c, c->fP.fNumI);
    if (!typeP)
        goto abandonParse;

    // As a side-effect the fCurBaseP is setup with any qualifiers on exit
    if (!parse_declarators(c))
        goto abandonParse;

    // Merge the last qualifiers into the base type
    if (!parse_base_type(c) || kNTUndefined == c->fCurBaseP->fType)
        goto abandonParse;

    typeP->fNumEntries = c->fP.fNumI - typeP->fStartEntry;
    return true;

abandonParse:
    resetTo(c, &chk);
    return false;
}

// <function_name> ::= <char> <char>*
// No need to check point as an invalid function name is fatal
// Consumes trailing "__".
static Boolean
parse_function_name(ParseContext *c)
{
    char ch;

    while ( (ch = peekNext(c)) )
    {
        advance(c, 1);
        if ('_' == ch && '_' == peekNext(c)) {
            do {
                advance(c, 1);
            } while ('_' == peekNext(c));
            return true;
        }
    }

    return false;
}

// <opinfo> ::= "type" <type>
//            | "__op" <type>
//            | <opname> "__"	; Implies null function name
//            | "a"
// <opname> ::= "aa"	# &&	==> "aa"
//            | "aad"	# &=	==> "aN"
//            | "ad"	# &	==> "ad"
//            | "adv"	# /=	==> "dV"
//            | "aer"	# ^=	==> "eO"
//            | "als"	# <<=	==> "lS"
//            | "amd"	# %=	==> "rM"
//            | "ami"	# -=	==> "mI"
//            | "aml"	# *=	==> "mL
//            | "aor"	# |=	==> "oR
//            | "apl"	# +=	==> "pL
//            | "ars"	# >>=	==> "rS
//            | "as"	# =	==> "aS
//            | "cl"	# ()	==> "cl
//            | "cm"	# ,	==> "cm
//            | "cn"	# ?:	==> "qu
//            | "co"	# ~	==> "co
//            | "dl"	# delete ==> "dl
//            | "dv"	# /	==> "dv
//            | "eq"	# ==	==> "eq
//            | "er"	# ^	==> "eo
//            | "ge"	# >=	==> "ge
//            | "gt"	# >	==> "gt
//            | "le"	# <=	==> "le
//            | "ls"	# <<	==> "ls
//            | "lt"	# <	==> "lt
//            | "md"	# %	==> "rm
//            | "mi"	# -	==> "mi
//            | "ml"	# *	==> "ml
//            | "mm"	# --	==> "mm
//            | "mn"	# <?	==> "????????????????
//            | "mx"	# >?	==> "????????????????
//            | "ne"	# !=	==> "ne
//            | "nt"	# !	==> "nt
//            | "nw"	# new	==> "nw
//            | "oo"	# ||	==> "oo"
//            | "or"	# |	==> "or
//            | "pl"	# +	==> "pl
//            | "pp"	# ++	==> "pp
//            | "rf"	# ->	==> "pt
//            | "rm"	# ->*	==> "pm
//            | "rs"	# >>	==> "rs
//            | "sz"	# sizeof ==> "sz
//            | "vc"	# []	==> "ix
//            | "vd"	# delete[] ==> "da
//            | "vn"	# new[]	==> "na
static struct opMap { 
    const char *op295, *op3;
} opMapTable[] = {  
    {"aad", "aN" }, {"adv", "dV" }, {"aer", "eO" }, {"als", "lS" },
    {"amd", "rM" }, {"ami", "mI" }, {"aml", "mL" }, {"aor", "oR" },
    {"apl", "pL" }, {"ars", "rS" }, {"aa",  "aa" }, {"ad",  "ad" },
    {"as",  "aS" }, {"cl",  "cl" }, {"cm",  "cm" }, {"cn",  "qu" },
    {"co",  "co" }, {"dl",  "dl" }, {"dv",  "dv" }, {"eq",  "eq" },
    {"er",  "eo" }, {"ge",  "ge" }, {"gt",  "gt" }, {"le",  "le" },
    {"ls",  "ls" }, {"lt",  "lt" }, {"md",  "rm" }, {"mi",  "mi" },
    {"ml",  "ml" }, {"mm",  "mm" }, {"mn",  NULL }, {"mx",  NULL },
    {"ne",  "ne" }, {"nt",  "nt" }, {"nw",  "nw" }, {"oo",  "oo" },
    {"or",  "or" }, {"pl",  "pl" }, {"pp",  "pp" }, {"rf",  "pt" },
    {"rm",  "pm" }, {"rs",  "rs" }, {"sz",  "sz" }, {"vc",  "ix" },
    {"vd",  "da" }, {"vn",  "na" },
};

static Boolean parse_opinfo(ParseContext *c, const char **opInfoP)
{
    CheckPoint chk = *checkPoint(c);
    const char *op;
    char ch;
    unsigned int i;

    if ('a' == (ch = peekNext(c))) {
        goto abandonParse;
    }
    else if (strNext(c, "type")) {
        goto abandonParse;
    }
    else if (retard(c, 4) && strNext(c, "____op")) {
        // @@@ gvdl: check this out it may change
        // <opinfo> ::= "__op" <type>
        goto abandonParse;
    }

    // Failed till now so reset and see if we have an operator
    resetTo(c, &chk);

    // quick check to see if we may have an operator
    if (!strrchr("acdeglmnoprsv", peekNext(c)))
        goto abandonParse;

    op = NULL;
    for (i = 0; i < sizeof(opMapTable)/sizeof(opMapTable[0]); i++) {
        if (strNext(c, opMapTable[i].op295)) {
            op = opMapTable[i].op3;
            break;
        }
    }
    if (!op)
        goto abandonParse;

    if (!strNext(c, "__"))		// Trailing underbars
        goto abandonParse;

    if (opInfoP)
        *opInfoP = op;
    return true;

abandonParse:
    return false;
}

// <signature> ::= <qualifier>* <s_element> <argument_types>
// <s_element> ::= <class_name>
//               | "K" <qualified_name>
//               | "S"
//               | "F" <argument_types> [ "_" <return_type> ] 
// <return_type> ::= <type>
// Treat the prefix's s_element as a full type
static Boolean
parse_signature(ParseContext *c,
                const char *func, int funcLen, const char *op)
{
    BaseTypeData *bP;
    TypeData *tP;

    Boolean isFunction = false;

    if (isNext(c, 'F')) {
        //               | "F" <argument_types> [ "_" <return_type> ] 

        char numbuf[16];	// Bigger than MAX_INT + 4
        int len;
        isFunction = true;
        if (!funcLen)
            goto abandonParse;

        len = snprintf(numbuf, sizeof(numbuf), "__Z%d", funcLen);

        appendNStr(c, numbuf, len);
        appendNStr(c, func, funcLen);
    }
    else if (isNext(c, 'S')) {
        //         | "S"	; Ignored
        goto abandonParse;
    }
    else {
        const char *qual;
        int qualLen;

        // See if we can find a qualified class reference
        tP = newType(c, c->fP.fNumI);
        if (!tP)
            goto abandonParse;
    
        bP = newIn(c);
        if (!bP)
            goto abandonParse;
    
        // Parse any qualifiers, store results in *fCurBaseP
        bP->fPseudo = true;
        if (!parse_qualifiers(c))
            goto abandonParse;
    
        if (!parse_class_name(c))
            goto abandonParse;

        bP = c->fCurBaseP;	// class name may have redifined current
        tP->fNumEntries = c->fP.fNumI - tP->fStartEntry;

        APPENDSTR(c, "__ZN");
        decodeQual(bP, &qualLen, &qual);
        if (qualLen)
            appendNStr(c, qual, qualLen);
        appendNStr(c, bP->fFundTypeID, bP->fLen);

        if (funcLen) {
            char numbuf[16];	// Bigger than MAX_INT + 1
            int len;

            len = snprintf(numbuf, sizeof(numbuf), "%d", funcLen);
            appendNStr(c, numbuf, len);
            appendNStr(c, func, funcLen);
        }
        else if (op)
            appendStr(c, op);
        else {
            // No function & no op means constructor choose one of C1 & C2
            APPENDSTR(c, "C2");
        }
        appendChar(c, 'E');
    }

    if (atEnd(c)) {
        appendChar(c, 'v');	// void argument list
        c->fRetCode = kR3Remangled;
        return true;
    }

    c->fCurBaseP = NULL;
    if (!parse_argument_types(c))
        goto abandonParse;

    if (isFunction) {
        if (isNext(c, '_')) {
            // && !parse_type(c)	@@@ gvdl: Unsupported return
            c->fRetCode = kR3InternalNotRemangled;
            goto abandonParse;
        }
    }

    if (!atEnd(c))
        goto abandonParse;

    // OK we have a complete and successful parse now output the
    // argument list
    return appendArgumentList(c);

abandonParse:
    return false;
}

// <mangled_name> ::= <prefix> [ <signature> ]
// <prefix> ::= [ "_GLOBAL_" [ID] "__" ] <function_name> "__" [ <opinfo> ]
static Boolean parse_mangled_name(ParseContext *c)
{
    CheckPoint chk;
    CheckPoint dubBarChk;
    const char *func;

    // <prefix> parse
    if (strNext(c, "_GLOBAL_")) {	// Is this GLOBAL static constructor?
        // gvdl: can't deal with _GLOBAL_
        c->fRetCode = kR3InternalNotRemangled;
        return false;	// Can't deal with these
    }

    func = c->fP.fInChar;
    for (chk = *checkPoint(c); ; resetTo(c, &dubBarChk)) {
        int funcLen;
        const char *op = NULL;

        if (!parse_function_name(c))
            goto abandonParse;
        dubBarChk = *checkPoint(c);

        // Note that the opInfo may be earlier than the curDoubleBar
        // in which case the function name may need to be shrunk later on.
        (void) parse_opinfo(c, &op);

        if (atEnd(c))
            goto abandonParse;	// No Signature?

        funcLen = inCharFromCheck(&dubBarChk) - func - 2;
        if (parse_signature(c, func, funcLen, op))
            return true;

        if (kR3NotRemangled != c->fRetCode)
            goto abandonParse;

        // If no error then try again maybe another '__' exists
    }

abandonParse:
    resetTo(c, &chk);
    return false;
}

// <gnu_special> ::= ("_._" | "_$_" ) <class_name>	; destructor
//                 | "__vt_" <class_name>		; virtual table
//                 | "_" <class_name> ("."|"$") <varname>
static Boolean parse_gnu_special(ParseContext *c)
{
    CheckPoint chk = *checkPoint(c);
    BaseTypeData *bP = newIn(c);

    if (!bP)
        return false;

    // What do the intel desctructors look like
    if (strNext(c, "_._") || strNext(c, "_$_") )	// Is this a destructor
    {
        if (!parse_class_name(c) || !atEnd(c))
            goto abandonParse;
        APPENDSTR(c, "__ZN");
        appendNStr(c, bP->fFundTypeID, bP->fLen);
        APPENDSTR(c, "D2Ev");
        c->fRetCode = kR3Remangled;
        return true;
    }
    else if (strNext(c, "__vt_"))	// Is it's a vtable?
    {
        if (!parse_class_name(c) || !atEnd(c))
            goto abandonParse;

        APPENDSTR(c, "__ZTV");
        if (kNTClass != bP->fType)
            goto abandonParse;
        else if (bP->fQualified) {
            appendChar(c, 'N');
            appendNStr(c, bP->fFundTypeID, bP->fLen);
            appendChar(c, 'E');
        }
        else
            appendNStr(c, bP->fFundTypeID, bP->fLen);

        c->fRetCode = kR3Remangled;
        return true;
    }
    else if (isNext(c, '_'))		// Maybe it's a variable
    {
        const char *varname;
        int varlen, len;
        char numbuf[16];	// Bigger than MAX_INT + 1

        if (!parse_class_name(c))	// Loads up the bP structure
            goto abandonParse;

        if (!isNext(c, '.') && !isNext(c, '$'))
            goto abandonParse;

        // Parse the variable name now.
        varname = c->fP.fInChar;
        if (atEnd(c) || !isValidFirstChar(getNext(c)))
            goto abandonParse;

        while ( !atEnd(c) )
            if (!isValidChar(getNext(c)))
                goto abandonParse;

        varlen = c->fP.fInChar - varname;
        len = snprintf(numbuf, sizeof(numbuf), "%d", varlen);

        APPENDSTR(c, "__ZN");
        appendNStr(c, bP->fFundTypeID, bP->fLen);

        appendNStr(c, numbuf, len);
        appendNStr(c, varname, varlen);
        appendChar(c, 'E');

        c->fRetCode = kR3Remangled;
        return true;
    }

    // Oh well it is none of those so give up but reset scan
abandonParse:
    resetTo(c, &chk);
    return false;
}

// <special_or_name> ::= <gnu_special>
//                     | <mangled_name>
static Boolean parse_special_or_name(ParseContext *c)
{
    Boolean res;

    
    res = (parse_gnu_special(c) || parse_mangled_name(c));
    appendChar(c, '\0');

    return res;
}

Rem3Return rem3_remangle_name(char *gcc3, int *gcc3size, const char *gcc295)
{
    ParseContext *c;
    Rem3Return result;
    int size;

    if (!gcc295 || !gcc3 || !gcc3size)
        return kR3BadArgument;

    size = strlen(gcc295);
    if (size < 2)
        return kR3NotRemangled;	// Not a valid C++ symbol
    else if (*gcc295 != '_')
        return kR3NotRemangled;	// no leading '_', not valid

    c = (ParseContext *) malloc(sizeof(*c));
    if (!c)
        return kR3InternalNotRemangled;
    bzero(c, sizeof(*c));

    c->fInSize = size;
    c->fInStr = gcc295 + 1;	// Strip leading '_'
    c->fP.fInChar = c->fInStr;

    c->fOutStrEnd = gcc3 + *gcc3size;
    c->fOutChar = gcc3;

    c->fRetCode = kR3NotRemangled;
    (void) parse_special_or_name(c);

    result = c->fRetCode;
    if (kR3Remangled == result) {
        if (c->fOutChar > c->fOutStrEnd)
            result = kR3BufferTooSmallRemangled;
        *gcc3size = c->fOutChar - gcc3 - 1;	// Remove nul from len
    }

    free(c);

    return result;
}