/*

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