/*
 * Copyright 2004-2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "gensyscalls.h"

#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <string>
#include <string.h>
#include <vector>

#include "gensyscalls_common.h"

using std::vector;


// print_usage
static void
print_usage(bool error)
{
        fprintf(error ? stderr : stdout,
                "Usage: gensyscalls [ -c <calls> ] [ -d <dispatcher> ] [ -n <numbers> "
                        "]\n"
                "                   [ -t <table> ] [ -s <strace> ]\n"
                "\n"
                "The command is able to generate several syscalls related source "
                        "files.\n"
                "\n"
                "  <calls>                - Output: The assembly source file "
                        "implementing the\n"
                "                           actual syscalls.\n"
                "  <dispatcher>           - Output: The C source file to be included by "
                        "the\n"
                "                           syscall dispatcher source file.\n"
                "  <numbers>              - Output: The C/assembly include files "
                        "defining the\n"
                "                           syscall numbers.\n"
                "  <table>                - Output: A C source file containing an array "
                        "with\n"
                "                           infos about the syscalls\n"
                "  <strace>               - Output: A C source file for strace "
                        "support.\n");
}


// #pragma mark - Type


Type::Type(const char* name, int size, int usedSize,
        const char* alignmentTypeName)
        :
        fName(name),
        fSize(size),
        fUsedSize(usedSize),
        fAlignmentType(alignmentTypeName)
{
}


// #pragma mark - Parameter


Parameter::Parameter(const char* typeName, const char* parameterName,
        int size, int usedSize, int offset, const char* alignmentTypeName)
        :
        Type(typeName, size, usedSize, alignmentTypeName),
        fParameterName(parameterName),
        fOffset(offset)
{
}


// #pragma mark - Syscall


struct Syscall::ParameterVector : public vector<Parameter*> {
};


Syscall::Syscall(const char* name, const char* kernelName)
        :
        fName(name),
        fKernelName(kernelName),
        fReturnType(NULL),
        fParameters(new ParameterVector)
{
}


Syscall::~Syscall()
{
        delete fReturnType;

        int count = CountParameters();
        for (int i = 0; i < count; i++)
                delete ParameterAt(i);
        delete fParameters;
}


int
Syscall::CountParameters() const
{
        return fParameters->size();
}


Parameter*
Syscall::ParameterAt(int index) const
{
        if (index < 0 || index >= CountParameters())
                return NULL;

        return (*fParameters)[index];
}


Parameter*
Syscall::LastParameter() const
{
        return ParameterAt(CountParameters() - 1);
}


void
Syscall::SetReturnType(int size, const char* name)
{
        int usedSize = (size + kReturnTypeAlignmentSize - 1)
                / kReturnTypeAlignmentSize * kReturnTypeAlignmentSize;
        const char* alignmentType
                = size != usedSize && size < kReturnTypeAlignmentSize
                        ? kReturnTypeAlignmentType : 0;

        SetReturnType(name, size, usedSize, alignmentType);
}


Type*
Syscall::SetReturnType(const char* name, int size, int usedSize,
        const char* alignmentTypeName)
{
        delete fReturnType;
        return fReturnType = new Type(name, size, usedSize, alignmentTypeName);
}


Parameter*
Syscall::AddParameter(const char* typeName, const char* parameterName,
        int size, int usedSize, int offset, const char* alignmentTypeName)
{
        Parameter* parameter = new Parameter(typeName, parameterName, size,
                usedSize, offset, alignmentTypeName);
        fParameters->push_back(parameter);
        return parameter;
}

void
Syscall::AddParameter(int size, const char* typeName, const char* parameterName)
{
        // compute offset
        int offset = 0;
        if (Parameter* previous = LastParameter())
                offset = previous->Offset() + previous->UsedSize();

        // take care of extra alignment for long parameters
        // this is needed to sort out parameter offsets on ARM
        if (size >= kLongParameterAlignmentSize) {
                if ((offset % kLongParameterAlignmentSize) != 0) {
                        offset += kLongParameterAlignmentSize
                                - offset % kLongParameterAlignmentSize;
                }
        }

        int usedSize = (size + kParameterAlignmentSize - 1)
                / kParameterAlignmentSize * kParameterAlignmentSize;
        const char* alignmentType
                = size != usedSize && size < kParameterAlignmentSize
                        ? kParameterAlignmentType : 0;

        AddParameter(typeName, parameterName, size, usedSize, offset,
                alignmentType);
}


// #pragma mark - SyscallVector


struct SyscallVector::_SyscallVector : public vector<Syscall*> {
};



SyscallVector::SyscallVector()
        :
        fSyscalls(new _SyscallVector)
{
}


SyscallVector::~SyscallVector()
{
        int count = CountSyscalls();
        for (int i = 0; i < count; i++)
                delete SyscallAt(i);
        delete fSyscalls;
}


SyscallVector*
SyscallVector::Create()
{
        return new SyscallVector;
}


int
SyscallVector::CountSyscalls() const
{
        return fSyscalls->size();
}


Syscall*
SyscallVector::SyscallAt(int index) const
{
        if (index < 0 || index >= CountSyscalls())
                return NULL;

        return (*fSyscalls)[index];
}


Syscall*
SyscallVector::CreateSyscall(const char* name, const char* kernelName)
{
        Syscall* syscall = new Syscall(name, kernelName);
        fSyscalls->push_back(syscall);
        return syscall;
}


// #pragma mark -


class Main {
public:
        int Run(int argc, char** argv)
        {
                // parse arguments
                const char* syscallsFile = NULL;
                const char* dispatcherFile = NULL;
                const char* numbersFile = NULL;
                const char* tableFile = NULL;
                const char* straceFile = NULL;

                for (int argi = 1; argi < argc; argi++) {
                        string arg(argv[argi]);
                        if (arg == "-h" || arg == "--help") {
                                print_usage(false);
                                return 0;
                        } else if (arg == "-c") {
                                if (argi + 1 >= argc) {
                                        print_usage(true);
                                        return 1;
                                }
                                syscallsFile = argv[++argi];
                        } else if (arg == "-d") {
                                if (argi + 1 >= argc) {
                                        print_usage(true);
                                        return 1;
                                }
                                dispatcherFile = argv[++argi];
                        } else if (arg == "-n") {
                                if (argi + 1 >= argc) {
                                        print_usage(true);
                                        return 1;
                                }
                                numbersFile = argv[++argi];
                        } else if (arg == "-t") {
                                if (argi + 1 >= argc) {
                                        print_usage(true);
                                        return 1;
                                }
                                tableFile = argv[++argi];
                        } else if (arg == "-s") {
                                if (argi + 1 >= argc) {
                                        print_usage(true);
                                        return 1;
                                }
                                straceFile = argv[++argi];
                        } else {
                                print_usage(true);
                                return 1;
                        }
                }
                fSyscallVector = create_syscall_vector();
                fSyscallCount = fSyscallVector->CountSyscalls();
                if (!syscallsFile && !dispatcherFile && !numbersFile && !tableFile
                        && !straceFile) {
                        printf("Found %d syscalls.\n", fSyscallCount);
                        return 0;
                }
                // generate the output
                if (syscallsFile)
                        _WriteSyscallsFile(syscallsFile);
                if (dispatcherFile)
                        _WriteDispatcherFile(dispatcherFile);
                if (numbersFile)
                        _WriteNumbersFile(numbersFile);
                if (tableFile)
                        _WriteTableFile(tableFile);
                if (straceFile)
                        _WriteSTraceFile(straceFile);
                return 0;
        }

        void _WriteSyscallsFile(const char* filename)
        {
                // open the syscalls output file
                ofstream file(filename, ofstream::out | ofstream::trunc);
                if (!file.is_open())
                        throw IOException(string("Failed to open `") + filename + "'.");

                // output the syscalls definitions
                for (int i = 0; i < fSyscallCount; i++) {
                        const Syscall* syscall = fSyscallVector->SyscallAt(i);
                        int paramCount = syscall->CountParameters();
                        int paramSize = 0;
                        // XXX: Currently the SYSCALL macros support 4 byte aligned
                        // parameters only. This has to change, of course.
                        for (int k = 0; k < paramCount; k++) {
                                const Parameter* parameter = syscall->ParameterAt(k);
                                int size = parameter->UsedSize();
                                paramSize += (size + 3) / 4 * 4;
                        }
                        file << "SYSCALL" << (paramSize / 4) << "("
                                << syscall->Name() << ", " << i << ")" << endl;
                }
        }

        void _WriteDispatcherFile(const char* filename)
        {
                // open the dispatcher output file
                ofstream file(filename, ofstream::out | ofstream::trunc);
                if (!file.is_open())
                        throw IOException(string("Failed to open `") + filename + "'.");

                // output the case statements
                for (int i = 0; i < fSyscallCount; i++) {
                        const Syscall* syscall = fSyscallVector->SyscallAt(i);
                        file << "case " << i << ":" << endl;
                        file << "\t";
                        if (string(syscall->ReturnType()->TypeName()) != "void")
                                file << "*_returnValue = ";
                        file << syscall->KernelName() << "(";
                        int paramCount = syscall->CountParameters();
                        if (paramCount > 0) {
                                Parameter* parameter = syscall->ParameterAt(0);
                                if (parameter->AlignmentTypeName()) {
                                        file << "(" << parameter->TypeName() << ")*("
                                                 << parameter->AlignmentTypeName()
                                                 << "*)args";
                                } else {
                                        file << "*(" << _GetPointerType(parameter->TypeName())
                                                << ")args";
                                }
                                for (int k = 1; k < paramCount; k++) {
                                        parameter = syscall->ParameterAt(k);
                                        if (parameter->AlignmentTypeName()) {
                                                file << ", (" << parameter->TypeName() << ")*("
                                                        << parameter->AlignmentTypeName()
                                                        << "*)((char*)args + " << parameter->Offset()
                                                        << ")";
                                        } else {
                                                file << ", *(" << _GetPointerType(parameter->TypeName())
                                                        << ")((char*)args + " << parameter->Offset()
                                                        << ")";
                                        }
                                }
                        }
                        file << ");" << endl;
                        file << "\tbreak;" << endl;
                }
        }

        void _WriteNumbersFile(const char* filename)
        {
                // open the syscall numbers output file
                ofstream file(filename, ofstream::out | ofstream::trunc);
                if (!file.is_open())
                        throw IOException(string("Failed to open `") + filename + "'.");

                // output the defines
                const char* prefix = "_user_";
                size_t prefixLen = strlen(prefix);
                for (int i = 0; i < fSyscallCount; i++) {
                        const Syscall* syscall = fSyscallVector->SyscallAt(i);
                        string name(syscall->KernelName());

                        // drop the leading "_user_" prefix
                        if (name.find(prefix) != 0)
                                throw Exception(string("Bad kernel name: `") + name + "'.");
                        name = string(name, prefixLen);

                        // convert to upper case (is there no function for that?)
                        string defineName;
                        for (int k = 0; k < (int)name.length(); k++)
                                defineName += toupper(name[k]);
                        file << "#define SYSCALL_" << defineName << " " << i << endl;
                }
        }

        void _WriteTableFile(const char* filename)
        {
                // open the syscall table output file
                ofstream file(filename, ofstream::out | ofstream::trunc);
                if (!file.is_open())
                        throw IOException(string("Failed to open `") + filename + "'.");

                // output syscall count macro
                file << "#define SYSCALL_COUNT " << fSyscallCount << endl;
                file << endl;

                // assembler guard
                file << "#ifndef _ASSEMBLER" << endl;
                file << endl;

                // includes
                file << "#include <TypeConstants.h>" << endl;
                file << endl;

                // output syscall count
                file << "const int kSyscallCount = SYSCALL_COUNT;" << endl;
                file << endl;

                // syscall infos array preamble
                file << "const syscall_info kSyscallInfos[] = {" << endl;

                // the syscall infos
                for (int i = 0; i < fSyscallCount; i++) {
                        const Syscall* syscall = fSyscallVector->SyscallAt(i);

                        // get the parameter size
                        int paramSize = 0;
                        if (Parameter* parameter = syscall->LastParameter())
                                paramSize = parameter->Offset() + parameter->UsedSize();

                        // output the info for the syscall
                        file << "\t{ (void *)" << syscall->KernelName() << ", "
                                << paramSize << " }," << endl;
                }

                // syscall infos array end
                file << "};" << endl;
                file << endl;

                // syscall parameters infos array preamble
                file << "const extended_syscall_info kExtendedSyscallInfos[] = {"
                        << endl;

                // the syscall parameters infos
                for (int i = 0; i < fSyscallCount; i++) {
                        const Syscall* syscall = fSyscallVector->SyscallAt(i);
                        int paramCount = syscall->CountParameters();

                        file << "\t{" << endl;
                        file << "\t\t\"" << syscall->Name() << "\", " << paramCount << ","
                                << endl;

                        // return type
                        Type* returnType = syscall->ReturnType();
                        file << "\t\t{ " << returnType->Size() << ", "
                                << returnType->UsedSize() << ", "
                                << _GetTypeCode(returnType) << " }," << endl;

                        // parameters
                        file << "\t\t{" << endl;

                        for (int k = 0; k < paramCount; k++) {
                                const Parameter* parameter = syscall->ParameterAt(k);
                                file << "\t\t\t{ " << parameter->Offset() << ", "
                                        << parameter->Size() << ", "
                                        << parameter->UsedSize() << ", "
                                        << _GetTypeCode(parameter) << " }," << endl;
                        }

                        file << "\t\t}" << endl;
                        file << "\t}," << endl;
                }

                // syscall parameters infos array end
                file << "};" << endl;

                // assembler guard end
                file << "#endif // _ASSEMBLER" << endl;
        }

        void _WriteSTraceFile(const char* filename)
        {
                // open the syscall table output file
                ofstream file(filename, ofstream::out | ofstream::trunc);
                if (!file.is_open())
                        throw IOException(string("Failed to open `") + filename + "'.");

                // the file defines a single function get_syscalls
                file << "void" << endl
                        << "GET_SYSCALLS(vector<Syscall*> &syscalls)" << endl
                        << "{" << endl
                        << "\tSyscall *syscall;" << endl
                        << "\tTypeHandler *handler;" << endl
                        << "(void)syscall;" << endl
                        << "(void)handler;" << endl;

                int chunkSize = (fSyscallCount + 19) / 20;

                // iterate through the syscalls
                for (int i = 0; i < fSyscallCount; i++) {
                        const Syscall* syscall = fSyscallVector->SyscallAt(i);

                        if (i % chunkSize == 0) {
                                // chunk end
                                file << endl;
                                if (i > 0)
                                        file << "#endif" << endl;
                                // chunk begin
                                file << "#ifdef SYSCALLS_CHUNK_" << (i / chunkSize) << endl;
                        }

                        // spacing, comment
                        file << endl;
                        file << "\t// " << syscall->Name() << endl;

                        // create the return type handler
                        const char* returnType = syscall->ReturnType()->TypeName();
                        file << "\thandler = TypeHandlerFactory<"
                                << returnType
                                << ">::Create();" << endl;

                        // create the syscall
                        file << "\tsyscall = new Syscall(\"" << syscall->Name() << "\", "
                                << "\"" << returnType << "\", "<< "handler);" << endl;
                        file << "\tsyscalls.push_back(syscall);" << endl;

                        // add the parameters
                        int paramCount = syscall->CountParameters();
                        for (int k = 0; k < paramCount; k++) {
                                const Parameter* parameter = syscall->ParameterAt(k);

                                // create the parameter type handler
                                file << "\thandler = TypeHandlerFactory<"
                                        << parameter->TypeName() << ">::Create();" << endl;

                                // add the parameter
                                file << "\tsyscall->AddParameter(\""
                                        << parameter->ParameterName() << "\", "
                                        << parameter->Offset() << ", \"" << parameter->TypeName()
                                        << "\", handler);" << endl;
                        }
                }

                // last syscall chunk end
                file << "#endif" << endl;

                // function end
                file << "}" << endl;
        }

        static string _GetPointerType(const char* type)
        {
                const char* parenthesis = strchr(type, ')');
                if (!parenthesis)
                        return string(type) + "*";
                // function pointer type
                return string(type, parenthesis - type) + "*" + parenthesis;
        }

        static string _GetTypeCode(const Type* type)
        {
                const char* typeName = type->TypeName();
                if (strchr(typeName, '*')) {
                        // pointer type
                        // check, if it is a string constant ("const char *" or
                        // "char const *")
                        if ((_GetTypeCodeTokenize(typeName) == "const"
                                        && _GetTypeCodeTokenize(typeName) == "char"
                                        && _GetTypeCodeTokenize(typeName) == "*"
                                        && _GetTypeCodeTokenize(typeName) == "")
                                || (_GetTypeCodeTokenize(typeName) == "char"
                                        && _GetTypeCodeTokenize(typeName) == "const"
                                        && _GetTypeCodeTokenize(typeName) == "*"
                                        && _GetTypeCodeTokenize(typeName) == "")) {
                                return "B_STRING_TYPE";
                        }

                        // not a string constant
                        return "B_POINTER_TYPE";
                } else {
                        // non-pointer type
                        switch (type->Size()) {
                                case 1:
                                        return "B_INT8_TYPE";
                                case 2:
                                        return "B_INT16_TYPE";
                                case 4:
                                        return "B_INT32_TYPE";
                                case 8:
                                        return "B_INT64_TYPE";
                                default:
                                        return "B_RAW_TYPE";
                        }
                }
        }

        static string _GetTypeCodeTokenize(const char*& type)
        {
                // skip whitespace
                while (*type != '\0' && isspace(*type))
                        type++;

                switch (*type) {
                        case '\0':
                                return "";

                        case '*':
                        case '(':
                        case ')':
                        case '&':
                                return string(type++, 1);

                        default:
                        {
                                if (*type != '_' && !isalpha(*type)) {
                                        // probably invalid, just return something
                                        return string(type++, 1);
                                }

                                // an identifier
                                const char* start = type;
                                while (*type == '_' || isalnum(*type))
                                        type++;
                                return string(start, type - start);
                        }
                }
        }

private:
        SyscallVector*  fSyscallVector;
        int                             fSyscallCount;
};


int
main(int argc, char** argv)
{
        try {
                return Main().Run(argc, argv);
        } catch (Exception &exception) {
                fprintf(stderr, "%s\n", exception.what());
                return 1;
        }
}