--- parser3/src/main/Attic/core.C	2001/02/24 14:20:51	1.34
+++ parser3/src/main/Attic/core.C	2001/03/10 11:18:15	1.49
@@ -1,5 +1,5 @@
 /*
-$Id: core.C,v 1.34 2001/02/24 14:20:51 paf Exp $
+$Id: core.C,v 1.49 2001/03/10 11:18:15 paf Exp $
 */
 
 #include "pa_request.h"
@@ -8,17 +8,50 @@ $Id: core.C,v 1.34 2001/02/24 14:20:51 p
 #include "pa_vclass.h"
 
 #include <stdio.h>
+#include "classes/_root.h"
+#include "classes/_env.h"
+#include "classes/_string.h"
+#include "classes/_double.h"
+#include "classes/_int.h"
 
 void core() {
 	Pool pool;
+	initialize_string_class(pool, *(string_class=new(pool) VClass(pool)));
+	initialize_double_class(pool, *(double_class=new(pool) VClass(pool)));
+	initialize_int_class(pool, *(int_class=new(pool) VClass(pool)));
 	Request request(pool);
 	request.core();
 }
 
+Request::Request(Pool& apool) : Pooled(apool),
+	stack(apool),
+	root_class(apool),
+	env_class(apool),
+	fclasses(apool),
+	fclasses_array(apool),
+	lang(String::Untaint_lang::HTML_TYPO)
+{
+	// root class
+	initialize_root_class(pool(), root_class);
+	// adding root superclass, 
+	//   parent of all classes, 
+	//   operators holder
+	String ROOT(pool()); ROOT.APPEND_CONST(ROOT_NAME);
+	classes().put(ROOT, &root_class);
+
+	// env class
+	initialize_env_class(pool(), env_class);
+	String ENV(pool()); ENV.APPEND_CONST(ENV_NAME);
+	classes().put(ENV, &env_class);
+}
+
 void Request::core() {
 	TRY {
-		String name_RUN(pool()); name_RUN.APPEND_CONST("RUN");
-		char *result=execute_MAIN(construct_class(name_RUN, load_and_compile_RUN()));
+		char *file="Y:\\parser3\\src\\test.p";
+		String RUN(pool()); RUN.APPEND_CONST(RUN_NAME);
+		use(file, &RUN);
+
+		char *result=execute_MAIN();
 		printf("result-----------------\n%sEOF----------------\n", result);
 	} 
 	CATCH(e) {
@@ -45,56 +78,51 @@ void Request::core() {
 	END_CATCH
 }
 
-Array& Request::load_and_compile_RUN() {
-	char *file="Y:\\parser3\\src\\test.p";
+void Request::use(char *file, String *name) {
+	// TODO: обнаружить|решить cyclic dependences
 	char *source=file_read(pool(), file);
-	Array& compiled_methods=COMPILE(source, file);
-	return compiled_methods;
-}
+	if(!source)
+		THROW(0,0,
+			0,
+			"use: can not read '%s' file", file);
 
-VClass *Request::construct_class(String& name, Array& compiled_methods) {
-	// create new 'name' vclass, add it to request's classes
-	Array immediate_parents(pool());
-	// TODO: immediate_parents=@PARENTS
-
-	VClass *result=NEW VClass(pool(), immediate_parents);
-	result->set_name(name);
-	classes().put(name, result);
-		
-	for(int i=0; i<compiled_methods.size(); i++) {
-		// TODO: filter out @PARENTS & @CLASS & ?co?
-		Method &method=*static_cast<Method *>(compiled_methods.quick_get(i));
-		result->add_method(method.name, method);
-	}
+	COMPILE(source, name, file);
+	// TODO: запустить @STATIC[], если есть
 
-	return result;
+//	if(alias)
+		//classes().put(*alias, &vclass);
 }
 
-char *Request::execute_MAIN(VClass *class_RUN) {
-	// initialize contexts
-	self=root=rcontext=class_RUN;
-	wcontext=NEW WWrapper(pool(), class_RUN);
-
-	// locate @main code
+char *Request::execute_MAIN() {
+	// locate class with @main & it's code
 	String name_main(pool());
 	name_main.APPEND_CONST(MAIN_METHOD_NAME);
 
-	Value *value_main=class_RUN->get_element(name_main);
-	if(!value_main)
-		THROW(0,0,
-			class_RUN->name(), "class does not contain method '"MAIN_METHOD_NAME"'");
-
-	Junction *junction_main=value_main->get_junction();
-	const Method *method_main=junction_main->method;
-
-	if(!method_main)
-		THROW(0,0,
-			class_RUN->name(), 
-			"class does contain '"MAIN_METHOD_NAME"' but it is not a method");
-
-	// execute!	
-	execute(method_main->code);
-
-	// return chars
-	return wcontext->get_string()->cstr();
+	// looking for latest known @main
+	for(int i=classes_array().size(); --i>=0;) {
+		VClass *vclass=static_cast<VClass *>(classes_array().get(i));
+		Value *main=vclass->get_element(name_main);
+		if(main) { // found some 'main' element
+			Junction *junction=main->get_junction();
+			if(junction) {// it even has junction!
+				const Method *method=junction->method;
+				if(method) { // and junction is method-junction! call it
+					// initialize contexts
+					root=rcontext=self=vclass;
+					wcontext=NEW WWrapper(pool(), vclass, false /* not constructing */);
+					
+					// execute!	
+					execute(*method->parser_code);
+					
+					// return chars
+					return wcontext->get_string()->cstr();
+				}
+			}
+		}
+	}
+	
+	THROW(0,0,
+		0, 
+		"'"MAIN_METHOD_NAME"' method not found");
+	return 0;
 }