/*
 * Copyright 2008-2009, Axel Dörfler, axeld@pinc-software.de.
 * This file may be used under the terms of the MIT License.
 */


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

#include <TypeConstants.h>

#ifdef _KERNEL_MODE
#       include <debug.h>
#endif

#include "demangle.h"


//#define TRACE_GCC2_DEMANGLER
#ifdef TRACE_GCC2_DEMANGLER
#       include <stdio.h>
#       define TRACE(x...) printf(x)
#else
#       define TRACE(x...) ;
#endif


class Input {
public:
        Input(const char* string, size_t length)
                :
                fString(string),
                fLength(length)
        {
        }

        const char* String() const
        {
                return fString;
        }

        int CharsRemaining() const
        {
                return fLength;
        }

        void Skip(size_t count)
        {
                if (count > fLength) {
                        TRACE("Input::Skip(): fOffset > fLength\n");
                        fString += fLength;
                        fLength = 0;
                        return;
                }

                fString += count;
                fLength -= count;
        }

        Input& operator++()
        {
                Skip(1);
                return *this;
        }
        Input operator++(int)
        {
                Input result(*this);
                ++(*this);
                return result;
        }

        char operator[](size_t index) const
        {
                if (index >= fLength) {
                        TRACE("Input::operator[](): fOffset + index >= fLength\n");
                        return '\0';
                }

                return fString[index];
        }

private:
        const char*     fString;
        size_t          fLength;
};


enum {
        TYPE_FUNCTION,
        TYPE_METHOD,
};


static void
ignore_qualifiers(Input& _arg)
{
        while (isupper(_arg[0])) {
                if (_arg[0] == 'Q') {
                        // argument has namespaces
                        break;
                }
                if (_arg[0] == 'F') {
                        // skip function declaration
                        while (_arg.CharsRemaining() && _arg[0] != '_')
                                _arg++;

                        if (!_arg.CharsRemaining())
                                break;
                }

                _arg++;
        }
}


static uint32
argument_type(Input arg, size_t& length)
{
        length = sizeof(int);

        switch (char type = arg[0]) {
                case 'P':       // pointer
                case 'R':       // reference
                        length = sizeof(void*);
                        ignore_qualifiers(arg);
                        if (arg[0] == 'c')
                                return B_STRING_TYPE;
                        if (arg[0] == 't') {
                                // TODO: templates are not yet supported
                                return 0;
                        }

                        return type == 'P' ? B_POINTER_TYPE : B_REF_TYPE;
                case 'x':
                        length = sizeof(long long);
                        return B_INT64_TYPE;
                case 'l':
                        if (sizeof(long) == 4)
                                return B_INT32_TYPE;
                        return B_INT64_TYPE;
                case 'i':
                        return B_INT32_TYPE;
                case 's':
                        return B_INT16_TYPE;
                case 'c':
                        return B_INT8_TYPE;
                case 'b':
                        return B_BOOL_TYPE;
                case 'U':
                        switch (arg[1]) {
                                case 'x':
                                        length = sizeof(long long);
                                        return B_UINT64_TYPE;
                                case 'l':
                                        if (sizeof(long) == 4)
                                                return B_UINT32_TYPE;
                                        return B_UINT64_TYPE;
                                case 'i':
                                        return B_UINT32_TYPE;
                                case 's':
                                        return B_UINT16_TYPE;
                                case 'c':
                                        return B_UINT8_TYPE;
                                default:
                                        return B_UINT32_TYPE;
                        }
                        break;

                case 'f':
                        return B_FLOAT_TYPE;
                case 'd':
                        length = sizeof(double);
                        return B_DOUBLE_TYPE;
                case 'r':
                        // TODO: is "long double" supported under Haiku at all?
                        return 0;

                case 't':
                        // TODO: templates are not yet supported
                        return 0;

                default:
                        return B_ANY_TYPE;
        }
}


static uint32
parse_number(Input& _arg, bool numberLeft)
{
        Input arg = _arg;

        while (isdigit(arg[0]))
                arg++;

        uint32 value;

        if (arg[0] == '_' && (!numberLeft || isdigit(arg[1]))) {
                // long value
                const char* tmp_arg = _arg.String();
                value = strtoul(tmp_arg, (char**)&tmp_arg, 10);
                _arg.Skip(tmp_arg - _arg.String());
                if (_arg[0] == '_')
                        _arg++;
        } else {
                value = _arg[0] - '0';
                _arg++;
        }

        return value;
}


static uint32
parse_repeats(Input& _arg, uint32& index)
{
        if (_arg[0] != 'N')
                return 0;

        _arg++;

        uint32 count = parse_number(_arg, true);
        index = parse_number(_arg, false);

        return count;
}


static void
skip_numbers(Input& _arg, int32 count)
{
        // skip leading character
        _arg++;

        while (count-- > 0) {
                parse_number(_arg, count != 0);
        }
}


static uint32
count_namespaces(Input& _mangled)
{
        Input mangled = _mangled;

        int32 namespaces = 0;
        if (mangled[0] == 'Q') {
                // more than one namespace
                if (mangled[1] == '_') {
                        // more than 9 namespaces
                        const char* mangled_str = mangled.String();
                        namespaces = strtoul(mangled_str + 2, (char**)&mangled_str, 10);
                        mangled.Skip(mangled_str - mangled.String());
                        if (mangled[0] != '_')
                                namespaces = 0;

                        mangled++;
                } else {
                        namespaces = mangled[1] - '0';
                        mangled.Skip(2);
                }
        } else if (isdigit(mangled[0]))
                namespaces = 1;

        _mangled = mangled;
        return namespaces;
}


static void
skip_namespaces(Input& mangled)
{
        int32 namespaces = count_namespaces(mangled);

        while (namespaces-- > 0) {
                if (!isdigit(mangled[0]))
                        break;

                const char* mangled_str = mangled.String();
                mangled_str += strtoul(mangled_str, (char**)&mangled_str, 10);
                mangled.Skip(mangled_str - mangled.String());
        }
}


static bool
has_named_argument(Input& arg)
{
        ignore_qualifiers(arg);

        // See if it's a built-in type
        return arg[0] == 'Q' || isdigit(arg[0]);
}


static uint32
argument_length(Input& _arg)
{
        if (_arg[0] == 'N') {
                // skip repeats
                skip_numbers(_arg, 2);
                return 0;
        } else if (_arg[0] == 'T') {
                // skip reference
                skip_numbers(_arg, 1);
                return 0;
        }

        ignore_qualifiers(_arg);

        if (!_arg.CharsRemaining())
                return 0;

        // See if it's a built-in type
        if (_arg[0] != 'Q' && !isdigit(_arg[0]))
                return 1;

        Input mangled = _arg;
        skip_namespaces(mangled);

        return mangled.String() - _arg.String();
}


static Input
next_argument(Input arg)
{
        if (!arg.CharsRemaining() || !arg[0])
                return arg;

        uint32 length = argument_length(arg);
        arg.Skip(length);

        return arg;
}


static Input
first_argument(Input mangled)
{
        skip_namespaces(mangled);

        return mangled;
}


static bool
mangled_start(Input& name, size_t* _symbolLength, int32* _symbolType)
{
        // search '__' starting from the end, don't accept them at the start
        size_t pos = name.CharsRemaining() - 1;
        bool foundStart = false;

        while (pos > 1) {
                if (name[pos] == '_') {
                        if (name[pos - 1] == '_') {
                                foundStart = true;
                                name.Skip(pos + 1);
                                break;
                        } else
                                pos--;
                }
                pos--;
        }

        if (!foundStart)
                return false;

        if (name[0] == 'H') {
                // TODO: we don't support templates yet
                return false;
        }

        if (_symbolLength != NULL)
                *_symbolLength = pos - 1;

        if (name[0] == 'F') {
                if (_symbolType != NULL)
                        *_symbolType = TYPE_FUNCTION;
                name.Skip(1);
                return true;
        }

        if (_symbolType != NULL)
                *_symbolType = TYPE_METHOD;
        return true;
}


static status_t
get_next_argument_internal(uint32* _cookie, const char* symbol, char* name,
        size_t nameSize, int32* _type, size_t* _argumentLength, bool repeating)
{
        Input mangled(symbol, strlen(symbol));
        if (!mangled_start(mangled, NULL, NULL))
                return B_BAD_VALUE;

        Input arg = first_argument(mangled);

        // (void) is not an argument
        if (arg[0] == 'v')
                return B_ENTRY_NOT_FOUND;

        uint32 current = *_cookie;
        if (current > 32)
                return B_TOO_MANY_ARGS;

        for (uint32 i = 0; i < current; i++) {
                arg = next_argument(arg);
                if (arg.CharsRemaining() && arg[0] == 'N') {
                        // repeat argument 'count' times
                        uint32 index;
                        uint32 count = parse_repeats(arg, index);
                        if (current <= i + count) {
                                if (repeating)
                                        return B_LINK_LIMIT;

                                // it's a repeat case
                                status_t status = get_next_argument_internal(&index, symbol,
                                        name, nameSize, _type, _argumentLength, true);
                                if (status == B_OK)
                                        (*_cookie)++;
                                return status;
                        }

                        i += count - 1;
                }
        }

        if (arg[0] == '\0' || !arg.CharsRemaining())
                return B_ENTRY_NOT_FOUND;

        TRACE("\n\targ %ld: %s\n", current, arg.String());

        if (arg[0] == 'T') {
                // duplicate argument
                if (repeating)
                        return B_LINK_LIMIT;

                arg++;
                uint32 index = parse_number(arg, false);
                status_t status = get_next_argument_internal(&index, symbol, name,
                        nameSize, _type, _argumentLength, true);
                if (status == B_OK)
                        (*_cookie)++;
                return status;
        }

        (*_cookie)++;

        size_t argumentLength;
        int32 type = argument_type(arg, argumentLength);
        if (type == 0)
                return B_NOT_SUPPORTED;

        if (_type != NULL)
                *_type = type;
        if (_argumentLength != NULL)
                *_argumentLength = argumentLength;

        name[0] = '\0';
        if (!has_named_argument(arg))
                return B_OK;

        Input namespaceStart = arg;
        int32 namespaces = count_namespaces(namespaceStart);

        while (namespaces-- > 0) {
                if (namespaceStart[0] == 't') {
                        // It's a template class after all
                        return B_BAD_TYPE;
                }
                if (!isdigit(namespaceStart[0]))
                        break;

                const char* ns_str = namespaceStart.String();
                uint32 length = strtoul(ns_str, (char**)&ns_str, 10);
                namespaceStart.Skip(ns_str - namespaceStart.String());

                uint32 max = strlen(name) + length + 1;
                strlcat(name, namespaceStart.String(), min_c(max, nameSize));
                if (namespaces > 0)
                        strlcat(name, "::", nameSize);
                namespaceStart.Skip(length);
        }

        return B_OK;
}


//      #pragma mark -


const char*
demangle_symbol_gcc2(const char* name, char* buffer, size_t bufferSize,
        bool* _isObjectMethod)
{
        if (name == NULL)
                return NULL;

        size_t nameLength;
        int32 type;
        Input mangled(name, strlen(name));
        if (!mangled_start(mangled, &nameLength, &type))
                return NULL;

        if (mangled[0] == 'C') {
                // ignore const method
                type = TYPE_METHOD;
                mangled++;
        }

        if (_isObjectMethod != NULL) {
                // we can only guess with GCC2 mangling
                *_isObjectMethod = type == TYPE_METHOD;
        }

        Input namespaceStart = mangled;
        int32 namespaces = count_namespaces(namespaceStart);

        buffer[0] = '\0';

        while (namespaces-- > 0) {
                if (namespaceStart[0] == 't') {
                        // It's a template class after all
                        return NULL;
                }
                if (!isdigit(namespaceStart[0]))
                        break;

                const char* ns_str = namespaceStart.String();
                uint32 length = strtoul(ns_str, (char**)&ns_str, 10);
                namespaceStart.Skip(ns_str - namespaceStart.String());

                uint32 max = strlen(buffer) + length + 1;
                strlcat(buffer, namespaceStart.String(), min_c(max, bufferSize));
                strlcat(buffer, "::", bufferSize);
                namespaceStart.Skip(length);
        }

        size_t max = strlen(buffer) + nameLength + 1;
        strlcat(buffer, name, min_c(max, bufferSize));
        return buffer;
}


status_t
get_next_argument_gcc2(uint32* _cookie, const char* symbol, char* name,
        size_t nameSize, int32* _type, size_t* _argumentLength)
{
        status_t error = get_next_argument_internal(_cookie, symbol, name, nameSize,
                _type, _argumentLength, false);
        if (error != B_OK)
                return error;

        // append the missing '*'/'&' for pointer/ref types
        if (name[0] != '\0' && (*_type == B_POINTER_TYPE || *_type == B_REF_TYPE))
                strlcat(name, *_type == B_POINTER_TYPE ? "*" : "&", nameSize);

        return B_OK;
}