/*

 * 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/.

 */

#ifndef _include_jitcraft_compile_context_h_

#define _include_jitcraft_compile_context_h_

#include <stdarg.h>

#include <string>

#include "../Messages.h"

#include "../PoolAllocator.h"

#include "../Handles.h"

#include "../Modules.h"

#include "../Packages.h"

namespace ke {

class Zone;

class ParseTree;

class String;

class ImportScope;

class GlobalScope;

struct SourcePosition;

struct TranslationUnit;

class ImportStatement;

struct CompileError

{

    CompileError()

      : message(NULL)

    {

    }

    CompileError(unsigned line, unsigned col, const char *message)

      : line(line),

        col(col),

        message(message)

    {

    }

    unsigned line;

    unsigned col;

    const char *message;

};

struct TranslationUnit : public PoolObject

{

    TranslationUnit(Handle<Module> module)

      : tree_(NULL),

        importScope_(NULL),

        globalScope_(NULL),

        module_(module),

        enoughMemory_(true),

        dependencyFailed_(false)

    {

    }

    void destroy();

    ParseTree *tree_;

    PoolList<TranslationUnit *> dependents_;

    ImportScope *importScope_;

    GlobalScope *globalScope_;

    ScopedRoot<Module> module_;

    ParseTree *tree() const {

        return tree_;

    }

    PoolList<TranslationUnit *> &dependents() {

        return dependents_;

    }

    bool failed() const {

        return errors_.length() ||

               !enoughMemory_ ||

               dependencyFailed_;

    }

    void setImportScope(ImportScope *scope) {

        assert(!importScope_);

        importScope_ = scope;

    }

    void setGlobalScope(GlobalScope *scope) {

        assert(!globalScope_);

        globalScope_ = scope;

    }

    ImportScope *importScope() const {

        return importScope_;

    }

    GlobalScope *globalScope() const {

        return globalScope_;

    }

    Handle<Module> module() {

        return module_;

    }

    void setDependencyFailed() {

        dependencyFailed_ = true;

    }

    void setOutOfMemory() {

        enoughMemory_ = false;

    }

    void appendError(const char *report, unsigned line, unsigned col) {

        enoughMemory_ |= errors_.append(CompileError(line, col, report));

    }

    const Vector<CompileError> *errors() {

        return &errors_;

    }

  private:

    bool enoughMemory_;

    bool dependencyFailed_;

    Vector<CompileError> errors_;

};

class CompileContext

{

    Zone *zone_;

    Vector<TranslationUnit *> units_;

    Vector<TranslationUnit *> unparsed_;

    TranslationUnit *active_;

  private:

    char *loadSource(Handle<Module> module, size_t *length);

    bool parse(TranslationUnit *unit);

    bool evaluateImports(TranslationUnit *unit);

    bool propagateFailure();

    bool add(Handle<Module> module);

  public:

    CompileContext(Zone *zone);

    ~CompileContext();

    bool initialize(Handle<Package> package, const char *name);

    bool compile();

    void enter(TranslationUnit *unit);

    void leave();

    void reportErrorVa(const SourcePosition &pos, Message msg, va_list ap);

    void reportError(const SourcePosition &pos, Message msg, ...);

};

class AutoEnterCompileContext

{

    CompileContext &cc_;

  public:

    AutoEnterCompileContext(CompileContext &cc, TranslationUnit *unit)

      : cc_(cc)

    {

      cc_.enter(unit);

    }

    ~AutoEnterCompileContext() {

      cc_.leave();

    }

};

} // namespace ke

#endif // _include_jitcraft_compile_context_h_