//===----------- N3Initialise.cpp - Initialization of N3 ------------------===//
//
//                              N3
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//


#include <vector>

#include "llvm/LLVMContext.h"

#include "mvm/CompilationUnit.h"
#include "mvm/JIT.h"
#include "mvm/Threads/Locks.h"

#include "Assembly.h"
#include "CLIString.h"
#include "CLIJit.h"
#include "LockedMap.h"
#include "NativeUtil.h"
#include "MSCorlib.h"
#include "N3.h"
#include "N3ModuleProvider.h"
#include "Reader.h"
#include "VMArray.h"
#include "VMCache.h"
#include "VMClass.h"
#include "VMObject.h"
#include "VMThread.h"

using namespace n3;

N3* N3::bootstrapVM = 0;
mvm::Lock* VMObject::globalLock = 0;

VMCommonClass*         VMClassArray::SuperArray = 0;
std::vector<VMClass*>  VMClassArray::InterfacesArray;
std::vector<VMMethod*> VMClassArray::VirtualMethodsArray;
std::vector<VMMethod*> VMClassArray::StaticMethodsArray;
std::vector<VMField*>  VMClassArray::VirtualFieldsArray;
std::vector<VMField*>  VMClassArray::StaticFieldsArray;

#define DEF_TYPE(name, type)										\
	VMClass *MSCorlib::p##name = 0;

#define DEF_ARRAY_LLVM_TYPE(name, type)					\
	const llvm::Type* Array##name::llvmType = 0;

#define DEF_ARRAY_AND_TYPE(name, type)					\
	DEF_TYPE(name, type)													\
	VMClassArray *MSCorlib::array##name = 0;			\
	VMField* MSCorlib::ctor##name = 0;

ON_TYPES(DEF_ARRAY_AND_TYPE, _F_NT)
ON_TYPES(DEF_ARRAY_LLVM_TYPE, _F_NT)
ON_STRING(DEF_ARRAY_AND_TYPE, _F_NT)
ON_VOID(DEF_TYPE, _F_NT)

#undef DEF_ARRAY_LLVM_TYPE
#undef DEF_TYPE
#undef DEF_ARRAY_AND_TYPE

VMClass* MSCorlib::pValue = 0;
VMClass* MSCorlib::pEnum = 0;
VMClass* MSCorlib::pArray = 0;
VMClass* MSCorlib::pDelegate = 0;
VMClass* MSCorlib::pException = 0;


const llvm::Type* VMArray::llvmType;
const llvm::Type* VMObject::llvmType;
const llvm::Type* Enveloppe::llvmType;
const llvm::Type* CacheNode::llvmType;

VMMethod* MSCorlib::ctorPropertyType;
VMMethod* MSCorlib::ctorMethodType;
VMMethod* MSCorlib::ctorClrType;
VMClass*  MSCorlib::clrType;
VMField*  MSCorlib::typeClrType;
VMField*  MSCorlib::propertyPropertyType;
VMField*  MSCorlib::methodMethodType;
VMMethod* MSCorlib::ctorAssemblyReflection;
VMClass*  MSCorlib::assemblyReflection;
VMClass*  MSCorlib::typedReference;
VMField*  MSCorlib::assemblyAssemblyReflection;
VMClass*  MSCorlib::propertyType;
VMClass*  MSCorlib::methodType;
VMClass*  MSCorlib::resourceStreamType;
VMMethod* MSCorlib::ctorResourceStreamType;

const UTF8* N3::clinitName = 0;
const UTF8* N3::ctorName = 0;
const UTF8* N3::invokeName = 0;
const UTF8* N3::math = 0;
const UTF8* N3::system = 0;
const UTF8* N3::sqrt = 0;
const UTF8* N3::sin = 0;
const UTF8* N3::cos = 0;
const UTF8* N3::exp = 0;
const UTF8* N3::log = 0;
const UTF8* N3::floor = 0;
const UTF8* N3::log10 = 0;
const UTF8* N3::isNan = 0;
const UTF8* N3::pow = 0;
const UTF8* N3::floatName = 0;
const UTF8* N3::doubleName = 0;
const UTF8* N3::testInfinity = 0;

llvm::Function* CLIJit::printExecutionLLVM;
llvm::Function* CLIJit::indexOutOfBoundsExceptionLLVM;
llvm::Function* CLIJit::nullPointerExceptionLLVM;
llvm::Function* CLIJit::classCastExceptionLLVM;
llvm::Function* CLIJit::clearExceptionLLVM;
llvm::Function* CLIJit::compareExceptionLLVM;
llvm::Function* CLIJit::arrayLengthLLVM;

#ifdef WITH_TRACER
llvm::Function* CLIJit::markAndTraceLLVM;
const llvm::FunctionType* CLIJit::markAndTraceLLVMType;
#endif
llvm::Function* CLIJit::vmObjectTracerLLVM;
llvm::Function* CLIJit::initialiseClassLLVM;
llvm::Function* CLIJit::virtualLookupLLVM;
llvm::Function* CLIJit::arrayConsLLVM;
llvm::Function* CLIJit::arrayMultiConsLLVM;
llvm::Function* CLIJit::objConsLLVM;
llvm::Function* CLIJit::objInitLLVM;
llvm::Function* CLIJit::throwExceptionLLVM;
llvm::Function* CLIJit::instanceOfLLVM;
llvm::Function* CLIJit::getCLIExceptionLLVM;
llvm::Function* CLIJit::getCppExceptionLLVM;
llvm::Function* CLIJit::newStringLLVM;

static void initialiseVT() {
}

VMThread* VMThread::TheThread = 0;

static void initialiseStatics() {
  CLIJit::initialise();

  VMObject::globalLock = new mvm::LockNormal();

  N3* vm = N3::bootstrapVM = N3::allocateBootstrap();
  VMThread::TheThread = new VMThread(0, vm);
  
  vm->assemblyPath.push_back("");
  vm->assemblyPath.push_back(MSCorlib::libsPath);
  
  Assembly* ass = vm->constructAssembly(vm->asciizToUTF8("mscorlib"));

  if(!ass->resolve(1, "dll"))
    VMThread::get()->getVM()->error("can not load mscorlib.dll. Abort");

  vm->coreAssembly = ass;

#define INIT(var, nameSpace, name, type, prim) {\
  var = (VMClass*)vm->coreAssembly->loadTypeFromName( \
                                           vm->asciizToUTF8(name),     \
                                           vm->asciizToUTF8(nameSpace),\
                                           false, false, false, true); \
  var->isPrimitive = prim; \
  if (type) { \
    var->naturalType = type;  \
    var->virtualType = type;  \
  }}

	assert(VMObject::llvmType);
 
  INIT(MSCorlib::pObject,   "System", "Object",    VMObject::llvmType, false);
  INIT(MSCorlib::pValue,    "System", "ValueType", 0, false);
  INIT(MSCorlib::pVoid,     "System", "Void",      llvm::Type::getVoidTy(getGlobalContext()), true);
  INIT(MSCorlib::pBoolean,  "System", "Boolean",   llvm::Type::getInt1Ty(getGlobalContext()), true);
  INIT(MSCorlib::pUInt8,    "System", "Byte",      llvm::Type::getInt8Ty(getGlobalContext()), true);
  INIT(MSCorlib::pSInt8,    "System", "SByte",     llvm::Type::getInt8Ty(getGlobalContext()), true);
  INIT(MSCorlib::pChar,     "System", "Char",      llvm::Type::getInt16Ty(getGlobalContext()), true);
  INIT(MSCorlib::pSInt16,   "System", "Int16",     llvm::Type::getInt16Ty(getGlobalContext()), true);
  INIT(MSCorlib::pUInt16,   "System", "UInt16",    llvm::Type::getInt16Ty(getGlobalContext()), true);
  INIT(MSCorlib::pSInt32,   "System", "Int32",     llvm::Type::getInt32Ty(getGlobalContext()), true);
  INIT(MSCorlib::pUInt32,   "System", "UInt32",    llvm::Type::getInt32Ty(getGlobalContext()), true);
  INIT(MSCorlib::pSInt64,   "System", "Int64",     llvm::Type::getInt64Ty(getGlobalContext()), true);
  INIT(MSCorlib::pUInt64,   "System", "UInt64",    llvm::Type::getInt64Ty(getGlobalContext()), true);
  INIT(MSCorlib::pIntPtr,   "System", "IntPtr",    llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(getGlobalContext())), true);
  INIT(MSCorlib::pUIntPtr,  "System", "UIntPtr",   llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(getGlobalContext())), true);
  INIT(MSCorlib::pDouble,   "System", "Double",    llvm::Type::getDoubleTy(getGlobalContext()), true);
  INIT(MSCorlib::pFloat,    "System", "Single",    llvm::Type::getFloatTy(getGlobalContext()), true);
  INIT(MSCorlib::pEnum,     "System", "Enum",      llvm::Type::getInt32Ty(getGlobalContext()), true);
  INIT(MSCorlib::pArray,    "System", "Array",     0, true);
  INIT(MSCorlib::pException,"System", "Exception", 0, false);
  INIT(MSCorlib::pDelegate, "System", "Delegate",  0, false);

#undef INIT

  VMClassArray::SuperArray       = MSCorlib::pArray;

  MSCorlib::loadStringClass(vm);

#define BUILD_ARRAY(name, type)																				\
	MSCorlib::array##name = ass->constructArray(MSCorlib::p##name, 1);

	ON_TYPES(BUILD_ARRAY, _F_NT);
	ON_STRING(BUILD_ARRAY, _F_NT);

  N3::clinitName        = vm->asciizToUTF8(".cctor");
  N3::ctorName          = vm->asciizToUTF8(".ctor");
  N3::invokeName        = vm->asciizToUTF8("Invoke");
  N3::math              = vm->asciizToUTF8("Math");
  N3::system            = vm->asciizToUTF8("System");
  N3::sqrt              = vm->asciizToUTF8("Sqrt");
  N3::sin               = vm->asciizToUTF8("Sin");
  N3::cos               = vm->asciizToUTF8("Cos");
  N3::exp               = vm->asciizToUTF8("Exp");
  N3::log               = vm->asciizToUTF8("Log");
  N3::floor             = vm->asciizToUTF8("Floor");
  N3::log10             = vm->asciizToUTF8("Log10");
  N3::isNan             = vm->asciizToUTF8("IsNaN");
  N3::pow               = vm->asciizToUTF8("Pow");
  N3::floatName         = vm->asciizToUTF8("Float");
  N3::doubleName        = vm->asciizToUTF8("Double");
  N3::testInfinity      = vm->asciizToUTF8("TestInfinity");

	MSCorlib::pArray->resolveType(1, 0, 0);
	MSCorlib::pArray->resolveVT();

  MSCorlib::initialise(vm);
}


mvm::CompilationUnit* mvm::VirtualMachine::initialiseCLIVM() {
  if (!N3::bootstrapVM) {
    initialiseVT();
    initialiseStatics();
  }
  return 0;
}

void N3::runApplication(int argc, char** argv) {
  ((N3*)this)->runMain(argc, argv);
}

void N3::compile(const char* argv) {
  assert(0 && "This virtual machine does not perform static compilation yet!\n");
}

mvm::VirtualMachine* mvm::VirtualMachine::createCLIVM(mvm::CompilationUnit* C) {
  N3* vm = N3::allocate("", N3::bootstrapVM);
  return vm;
}