/*

 * Copyright (C) 2012 David Anderson

 *

 * This file is part of SourcePawn.

 *

 * SourcePawn is free software: you can redistribute it and/or modify it under

 * the terms of the GNU General Public License as published by the Free

 * Software Foundation, either version 3 of the License, or (at your option)

 * any later version.

 * 

 * SourcePawn is distributed in the hope that it will be useful, but WITHOUT ANY

 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * SourcePawn. If not, see http://www.gnu.org/licenses/.

 */

#include <stdio.h>

#include <string.h>

#include "../Zone.h"

#include "../Interpreter.h"

#include "../Packages.h"

#include "../FileSystem.h"

#include "../FixedArray.h"

#include "../Vector.h"

#include "Scanner.h"

#include "CompileContext.h"

#include "Parser.h"

#include "NameBinding.h"

#include "SemanticAnalysis.h"

#include "../Spaces-inl.h"

#include "../Heap-inl.h"

using namespace ke;

CompileContext::CompileContext(Zone *zone)

  : zone_(zone),

    active_(NULL)

{

}

CompileContext::~CompileContext()

{

    for (size_t i = 0; i < units_.length(); i++)

        units_[i]->destroy();

}

bool

CompileContext::initialize(Handle<Package> package, const char *name)

{

    size_t len = strlen(name);

    AutoFree<char> path((char *)zone_->malloc(len + 1));

    if (!*path)

        return false;

    strcpy(*path, name);

    if (len > 3 && strcmp(&name[len - 3], ".sp") == 0)

        (*path)[len - 3] = '\0';

    Local<String> strname(zone_, zone_->makeSymbol(*path));

    if (!strname)

        return false;

    PathComponent p(new (zone_->pool()) ScopedRoot<String>(strname), NULL);

    Local<Importable> importable(zone_);

    if (!zone_->packages()->findOrAdd(package, &p, importable.address()))

        return false;

    // If we couldn't find anything on the filesystem to match, we error out

    // early.

    if (!importable) {

        zone_->reportError(Message_CannotImportPath, *path);

        return false;

    }

    if (importable->isModule()) {

        Local<Module> module(zone_, Module::cast(importable));

        if (!add(module))

            return true;

    } else {

        // nyi

        assert(false);

    }

    return true;

}

char *

CompileContext::loadSource(Handle<Module> module, size_t *lengthp)

{

    char *bytes = NULL;

    size_t length;

    FILE *fp = fopen(module->path()->chars(), "rb");

    if (!fp) {

        reportError(SourcePosition(), Message_CantOpenFile);

        return NULL;

    }

    if (fseek(fp, 0, SEEK_END)) {

        reportError(SourcePosition(), Message_ErrorSeekingFile);

        fclose(fp);

        return NULL;

    }

    long size = ftell(fp);

    if (size < 0) {

        reportError(SourcePosition(), Message_ErrorSeekingFile);

        fclose(fp);

        return NULL;

    }

    rewind(fp);

    length = size_t(size);

    bytes = new char[length + 1];

    if (fread(bytes, 1, length, fp) != length) {

        reportError(SourcePosition(), Message_ErrorReadingFile);

        fclose(fp);

        delete [] bytes;

        return NULL;

    }

    fclose(fp);

    *lengthp = length;

    return bytes;

}

bool

CompileContext::parse(TranslationUnit *unit)

{

    assert(!unit->tree_);

    size_t length;

    char *source = loadSource(unit->module(), &length);

    if (!source)

        return false;

    Parser parser(ZONE(), *this, source, length);

    if ((unit->tree_ = parser.parse()) == NULL)

        return false;

    return true;

}

bool

CompileContext::evaluateImports(TranslationUnit *unit)

{

    PoolList<ImportStatement *> *imports = unit->tree()->imports();

    if (!imports->length())

        return true;

    // We're allowed to use Handle<> here instead of ScopedRoot<> because

    // we get the handle from ImportStatement which has a ScopedRoot<>.

    Vector<Handle<Importable> > vec;

    for (size_t i = 0; i < imports->length(); i++) {

        ImportStatement *import = imports->at(i);

        // Crawl the path until we find a valid file to load.

        Local<Importable> obj(zone_);

        Local<Package> package(zone_, unit->module()->parent());

        if (!zone_->packages()->findOrAdd(package, import->path(), obj.address()))

            return false;

        if (!obj) {

            PathComponent *path = import->path();

            while (path->next)

                path = path->next;

            reportError(import->pos(), Message_CannotImportPath, path->name->chars());

            return false;

        }

        // If the object is a package, we will attempt to execute it

        // immediately after resolving imports.

        if (obj->isPackage()) {

            assert(false);

        } else {

            Local<Module> module(zone_, Module::cast(obj));

            if (!add(module))

                return false;

        }

        import->setSource(obj);

        // See if there are any duplicates. This is O(n^2), but we expect

        // |n| to be small.

        unsigned index = 0;

        for (; index < vec.length(); index++) {

            if (vec[index] == obj)

                break;

        }

        if (index == vec.length() && !vec.append(import->source()))

            return false;

        import->setImportIndex(index);

    }

    if (!IsUint32MultiplySafe(vec.length(), 2)) {

        zone_->reportAllocationOverflow();

        return false;

    }

    // Create an array of the import and paths.

    Local<FixedArray> importables(zone_, FixedArray::New(zone_, vec.length() * 2, Heap::Tenure_Default));

    if (!importables)

        return false;

    for (unsigned i = 0; i < vec.length(); i++) {

        importables->set(zone_, i * 2, vec[i]);

        unsigned count = 0;

        PathComponent *path = imports->at(i)->path();

        for (PathComponent *iter = path; iter; iter = iter->next)

            count++;

        Local<FixedArray> list(zone_, FixedArray::New(zone_, count, Heap::Tenure_Default));

        if (!list)

            return false;

        count = 0;

        for (PathComponent *iter = path; iter; iter = iter->next, count++)

            list->set(zone_, count, iter->name);

        importables->set(zone_, i * 2 + 1, list);

    }

    unit->module()->setImports(importables);

    return true;

}

bool

CompileContext::add(Handle<Module> module)

{

    if (module->compiled() || module->translationUnit())

        return true;

    TranslationUnit *tu = new (zone_->pool()) TranslationUnit(module);

    if (!unparsed_.append(tu) || !units_.append(tu))

        return false;

    module->setTranslationUnit(tu);

    return true;

}

bool

CompileContext::propagateFailure()

{

    Vector<TranslationUnit *> worklist;

    for (size_t i = 0; i < units_.length(); i++) {

        if (units_[i]->failed() && !worklist.append(units_[i]))

            return false;

    }

    while (!worklist.empty()) {

        TranslationUnit *unit = worklist.popCopy();

        for (size_t i = 0; i < unit->dependents().length(); i++) {

            TranslationUnit *other = unit->dependents().at(i);

            if (other->failed())

                continue;

            other->setDependencyFailed();

            if (!worklist.append(other))

                return false;

        }

    }

    return true;

}

bool

CompileContext::compile()

{

    // Phase 1. Parse all modules we're importing. This process may load new

    // modules off disk and add them to the parse queue.

    while (!unparsed_.empty()) {

        TranslationUnit *unit = unparsed_.popCopy();

        AutoEnterCompileContext enter(*this, unit);

        if (!parse(unit))

            continue;

        evaluateImports(unit);

    }

    // Phase 2. Create scopes and symbol tables for every lexical region with

    // a declaration. This phase excludes declarations created via imports.

    for (size_t i = 0; i < units_.length(); i++) {

        TranslationUnit *unit = units_[i];

        if (unit->failed())

            continue;

        PopulateNamesAndTypes(zone_, *this, unit);

    }

    // Phase 3. Complete imports and bind all names.

    for (size_t i = 0; i < units_.length(); i++) {

        TranslationUnit *unit = units_[i];

        if (unit->failed())

            continue;

        BindGlobals(zone_, *this, unit);

        if (unit->failed())

            continue;

        BindNamesAndTypes(zone_, *this, unit);

    }

    // Phase 4. Now we can finally perform SemA+bytecode compilation.

    for (size_t i = 0; i < units_.length(); i++) {

        TranslationUnit *unit = units_[i];

        if (unit->failed())

            continue;

        AutoEnterCompileContext enter(*this, unit);

        SemanticAnalysis sema(zone_, *this, unit);

        sema.analyze();

    }

    // Phase 5. Run modules.

    for (size_t i = 0; i < units_.length(); i++) {

        TranslationUnit *unit = units_[i];

        // Mark the unit as no longer being translated.

        unit->module()->setTranslationUnit(NULL);

        if (unit->failed())

            break;

        InvokeArgs args;

        if (!zone_->stack().pushModuleFrame(unit->module_, args))

            assert(false);

        ke::LocalSlot slot;

        if (!Interpret(zone_, NULL, &slot))

            assert(false);

    }

    if (Ke::IMessageReporter *reporter = zone_->errorReporter()) {

        for (size_t i = 0; i < units_.length(); i++) {

            TranslationUnit *unit = units_[i];

            // We don't explicitly report errors for dependency failures or OOM

            // (OOM is reported separately (:TODO:) and dep failures are redundant.

            if (!unit->errors()->length())

                continue;

            reporter->beginCompilationErrors(unit->module()->path()->chars());

            for (size_t j = 0; j < unit->errors()->length(); j++) {

                const CompileError &error = unit->errors()->at(j);

                reporter->reportCompilationError(error.message, error.line, error.col);

            }

            reporter->endCompilationErrors();

        }

    }

    return !units_[0]->failed();

}

void

CompileContext::enter(TranslationUnit *unit)

{

    assert(!active_);

    active_ = unit;

}

void

CompileContext::leave()

{

    assert(active_);

    active_ = NULL;

}

void

CompileContext::reportErrorVa(const SourcePosition &pos, Message msg, va_list ap)

{

    const char *report = BuildErrorMessage(Messages[msg].format, ap);

    if (!report) {

        active_->setOutOfMemory();

        return;

    }

    active_->appendError(report, pos.line, pos.col);

}

void

CompileContext::reportError(const SourcePosition &pos, Message msg, ...)

{

    va_list ap;

    va_start(ap, msg);

    reportErrorVa(pos, msg, ap);

    va_end(ap);

}

void

TranslationUnit::destroy()

{

    for (size_t i = 0; i < errors_.length(); i++)

        FreeErrorMessage(errors_[i].message);

}