[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.21 and 1.49

version 1.21, 2001/02/20 18:45:52 version 1.49, 2001/03/10 11:18:15
Line 1 Line 1
 /*  /*
   $Id$  $Id$
 */  */
   
   #include "pa_request.h"
   #include "pa_wwrapper.h"
   #include "pa_common.h"
   #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 {
                   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) {
                   printf("\nERROR: ");
                   const String *problem_source=e.problem_source();
                   if(problem_source) {
                           const Origin& origin=problem_source->origin();
                           if(origin.file)
                                   printf("%s(%d): ",
                                   origin.file, 1+origin.line);
                           printf("'%s' ", 
                                   problem_source->cstr());
                   }
                   printf("%s", e.comment());
                   const String *type=e.type();
                   if(type) {
                           printf("  type: %s", type->cstr());
                           const String *code=e.code();
                           if(code)
                                   printf(", code: %s", code->cstr());
                   }
                   printf("\n");
           }
           END_CATCH
   }
   
   void Request::use(char *file, String *name) {
           // TODO: обнаружить|решить cyclic dependences
           char *source=file_read(pool(), file);
           if(!source)
                   THROW(0,0,
                           0,
                           "use: can not read '%s' file", file);
   
           COMPILE(source, name, file);
           // TODO: запустить @STATIC[], если есть
   
   //      if(alias)
                   //classes().put(*alias, &vclass);
   }
   
   char *Request::execute_MAIN() {
           // locate class with @main & it's code
           String name_main(pool());
           name_main.APPEND_CONST(MAIN_METHOD_NAME);
   
           // 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;
   }
Removed from v.1.21  
changed lines
  Added in v.1.49

E-mail: