Method Compile

NULLC/Compiler.cpp:1109–1359

#endif

bool Compiler::Compile(const char* str, bool noClear)
{
	CodeInfo::nodeList.clear();
	NodeZeroOP::DeleteNodes();

	if(!noClear)
	{
		lexer.Clear(baseModuleSize);
		moduleSource.clear();
		dupStringsModule.Clear();
		funcMap.clear();
		importStack.clear();
		moduleStack.clear();
		codeSourceRange.clear();
	}
	unsigned int lexStreamStart = lexer.GetStreamSize();
	lexer.Lexify(str);
	unsigned int lexStreamEnd = lexer.GetStreamSize();

	unsigned moduleBase = moduleStack.size();

	if(BinaryCache::GetBytecode("$base$.nc"))
		moduleStack.push_back(ModuleInfo("$base$.nc", BinaryCache::GetBytecode("$base$.nc"), 0, CodeRange(lexer.GetStreamStart()[0].pos, lexer.GetStreamStart()[baseModuleSize - 1].pos)));

	const char *importPath = BinaryCache::GetImportPath();

	Lexeme *start = &lexer.GetStreamStart()[lexStreamStart];
	while(start->type == lex_import)
	{
		start++;
		char path[256], *cPath = path, *pathNoImport = path;
		Lexeme *name = start;
		if(start->type != lex_string)
		{
			CodeInfo::lastError.Init("ERROR: string expected after import", start->pos);
			return false;
		}
		cPath += SafeSprintf(cPath, 256, "%s%.*s", importPath ? importPath : "", start->length, start->pos);
		if(importPath)
			pathNoImport = path + strlen(importPath);

		start++;
		while(start->type == lex_point)
		{
			start++;
			if(start->type != lex_string)
			{
				CodeInfo::lastError.Init("ERROR: string expected after '.'", start->pos);
				return false;
			}
			cPath += SafeSprintf(cPath, 256 - int(cPath - path), "/%.*s", start->length, start->pos);
			start++;
		}
		if(start->type != lex_semicolon)
		{
			CodeInfo::lastError.Init("ERROR: ';' not found after import expression", name->pos);
			return false;
		}