[BACK]Return to core.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/Attic/core.C between versions 1.33 and 1.38

version 1.33, 2001/02/24 13:21:59 version 1.38, 2001/02/25 09:14:02
Line 17  void core() { Line 17  void core() {
   
 void Request::core() {  void Request::core() {
         TRY {          TRY {
                 String name_RUN(pool()); name_RUN.APPEND_CONST("RUN");                  char *file="Y:\\parser3\\src\\test.p";
                 char *result=execute_MAIN(construct_class(name_RUN, load_and_compile_RUN()));                  String RUN(pool()); RUN.APPEND_CONST(NAME_RUN);
                 printf("result-----------------\n%s\nEOF----------------\n", result);                  use(file, &RUN);
   
                   char *result=execute_MAIN();
                   printf("result-----------------\n%sEOF----------------\n", result);
         }           } 
         CATCH(e) {          CATCH(e) {
                 printf("\nERROR: ");                  printf("\nERROR: ");
Line 45  void Request::core() { Line 48  void Request::core() {
         END_CATCH          END_CATCH
 }  }
   
 Array& Request::load_and_compile_RUN() {  void Request::use(char *file, String *alias) {
         char *file="Y:\\parser3\\src\\test.p";  
         char *source=file_read(pool(), file);          char *source=file_read(pool(), file);
         Array& compiled_methods=COMPILE(source, file);          if(!source)
         return compiled_methods;                  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);  
         }  
   
         return result;          VClass& vclass=COMPILE(source, alias, file);
           String *vclass_name=vclass.name();
           if(!vclass_name)
                   return; //TODO: add operators 
           classes_array()+=&vclass;
           classes().put(*vclass_name, &vclass);
           if(alias)
                   classes().put(*alias, &vclass);
 }  }
   
 char *Request::execute_MAIN(VClass *class_RUN) {  char *Request::execute_MAIN() {
         // initialize contexts          // locate class with @main & it's code
         self=root=rcontext=class_RUN;  
         wcontext=NEW WWrapper(pool(), class_RUN);  
   
         // locate @main code  
         String name_main(pool());          String name_main(pool());
         name_main.APPEND_CONST(MAIN_METHOD_NAME);          name_main.APPEND_CONST(MAIN_METHOD_NAME);
   
         Value *value_main=class_RUN->get_element(name_main);          // looking for latest known @main
         if(!value_main)          for(int i=classes_array().size(); --i>=0;) {
                 THROW(0,0,                  VClass *vclass=static_cast<VClass *>(classes_array().get(i));
                         class_RUN->name(), "class does not contain method '"MAIN_METHOD_NAME"'");                  Value *main=vclass->get_element(name_main);
                   if(main) { // found some 'main' element
         Junction *junction_main=value_main->get_junction();                          Junction *junction=main->get_junction();
         const Method *method_main=junction_main->method;                          if(junction) {// it even has junction!
                                   const Method *method=junction->method;
         if(!method_main)                                  if(method) { // and junction is method-junction! call it
                 THROW(0,0,                                          // initialize contexts
                         class_RUN->name(),                                           self=root=rcontext=vclass;
                         "class does contain '"MAIN_METHOD_NAME"' but it is not a method");                                          wcontext=NEW WWrapper(pool(), vclass);
                                           
         // execute!                                               // execute!     
         execute(method_main->code);                                          execute(method->code);
                                           
         // return chars                                          // return chars
         return wcontext->get_string()->cstr();                                          return wcontext->get_string()->cstr();
                                   }
                           }
                   }
           }
           
           THROW(0,0,
                   0, 
                   "'"MAIN_METHOD_NAME"' method not found");
           return 0;
 }  }
Removed from v.1.33  
changed lines
  Added in v.1.38

E-mail: