/*

 * Copyright (C) 2012 David Anderson

 *

 * This file is part of JITCraft.

 *

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

 * 

 * Foobar 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

 * JITCraft. 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"

namespace ke {

class Zone;

class ParseTree;

class String;

class ImportScope;

class GlobalScope;

struct SourcePosition;

struct TranslationUnit;

class ImportStatement;

struct TranslationUnit : public PoolObject

{

    TranslationUnit()

      : tree_(NULL),

        failed_(false),

        importScope_(NULL),

        globalScope_(NULL)

    {

    }

    ParseTree *tree_;

    const char *path_;

    bool failed_;

    PoolList<TranslationUnit *> dependents_;

    ImportScope *importScope_;

    GlobalScope *globalScope_;

    ScopedRoot<Module> module_;

    ParseTree *tree() const {

        return tree_;

    }

    PoolList<TranslationUnit *> &dependents() {

        return dependents_;

    }

    bool failed() const {

        return failed_;

    }

    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_;

    }

};

class CompileContext

{

    Zone *zone_;

    unsigned failures_;

    const char *file_;

    Vector<TranslationUnit *> units_;

    Vector<TranslationUnit *> unparsed_;

  private:

    char *loadSource(const char *file, size_t *length);

    bool parse(TranslationUnit *unit);

    bool evaluateImports(TranslationUnit *unit);

    bool propagateFailure();

  public:

    CompileContext(Zone *zone, const char *file);

    ~CompileContext();

    bool addTranslationUnit(TranslationUnit *unit);

    bool compile();

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

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

    unsigned failures() const {

        return failures_;

    }

};

}

#endif // _include_jitcraft_compile_context_h_