/*

  * 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, const char *file)

   : zone_(zone),

     file_(file),

     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())

         return true;

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

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

         return false;

     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;

         // Mark the module as currently in translation.

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

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

     }

     // Intermediate phase. Decide which modules we should not perform

     // semantic analysis on.

     if (!propagateFailure())

         return false;

     // 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);

 }