[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.11 and 1.37

version 1.11, 2001/02/14 14:15:37 version 1.37, 2001/02/25 08:50:13
Line 1 Line 1
 enum Prefix {  /*
         NO_PREFIX,  $Id$
         ROOT_PREFIX,  */
         SELF_PREFIX  
 };  #include "pa_request.h"
   #include "pa_wwrapper.h"
 enum CHAR_TYPE {  #include "pa_common.h"
         NO_TYPE=0, // these got skipped by String::skip_to  #include "pa_vclass.h"
         VAR_START_TYPE,  
         METHOD_START_TYPE,  #include <stdio.h>
         STOP_TYPE,///=-1 // same as EOF type(-1), see String::skip_to  
         DOT_TYPE,  void core() {
         COLON_TYPE,          Pool pool;
         CONSTRUCTOR_BODY_START_TYPE,          Request request(pool);
         CONSTRUCTOR_BODY_FINISH_TYPE,          request.core();
         BLOCK_START_TYPE,  }
         BLOCK_FINISH_TYPE,  
           void Request::core() {
         Z_TYPE          TRY {
 };                  char *file="Y:\\parser3\\src\\test.p";
                   String RUN(pool()); RUN.APPEND_CONST(NAME_RUN);
 Char_types var_or_method_start;                  use(file, &RUN);
 Char_types var_or_method_start_or_constructor_stop;  
 Char_types var_or_method_start_or_block_stop;                  char *result=execute_MAIN();
 Char_types common_names_breaks, var_names_breaks, method_names_breaks;                  printf("result-----------------\n%sEOF----------------\n", result);
           } 
 void prepare() {          CATCH(e) {
         var_or_method_start.set('$', VAR_START_TYPE);                  printf("\nERROR: ");
         var_or_method_start.set('^', METHOD_START_TYPE);                  const String *problem_source=e.problem_source();
                   if(problem_source) {
         var_or_method_start_or_constructor_stop=var_or_method_start;                          const Origin& origin=problem_source->origin();
         var_or_method_start_or_constructor_stop.set(')', STOP_TYPE);                          if(origin.file)
                                   printf("%s(%d): ",
         var_or_method_start_or_block_stop=var_or_method_start;                                  origin.file, 1+origin.line);
         var_or_method_start_or_block_stop.set(']', STOP_TYPE);                          printf("'%s' ", 
                                   problem_source->cstr());
         common_names_breaks.set(0, ' ', STOP_TYPE);                  }
         common_names_breaks.set('.', DOT_TYPE);                  printf("%s", e.comment());
         common_names_breaks.set(':', COLON_TYPE);                  const String *type=e.type();
         common_names_breaks.set(')', STOP_TYPE); // var_or_method_start_or_constructor_stop                  if(type) {
         common_names_breaks.set(']', STOP_TYPE); // var_or_method_start_or_block_stop                          printf("  type: %s", type->cstr());
                           const String *code=e.code();
         var_names_breaks=common_names_breaks;                          if(code)
         var_names_breaks.set('(', CONSTRUCTOR_BODY_START_TYPE);                                  printf(", code: %s", code->cstr());
   
         method_names_breaks=common_names_breaks;  
         method_names_breaks.set('[', BLOCK_START_TYPE);  
 }  
   
 void process(method_self_n_params_n_locals& root, Value& self,  
                          arcontext& arcontext, WContext& awcontext,   
                          String_iterator& iter, Char_types& breaks) {  
         while(!iter.eof()) {  
                 String_iterator start(iter);  
                 CHAR_TYPE type=iter.skip_to(breaks);  
                 awcontext.write(start, iter);  
   
                 switch(type) {  
                 case VAR_START_TYPE:   
                         process_var(root, self, arcontext, awcontext, iter, breaks);  
                         break;  
                 case METHOD_START_TYPE:  
                         process_method(root, self, arcontext, awcontext, iter, breaks);  
                         break;  
                 case STOP_TYPE:  
                         return;  
                 }  
         }  
 }  
   
 void process_var(method_self_n_params_n_locals& root, Value& self,  
                                  arcontext& arcontext, WContext& awcontext,   
                                  String_iterator& iter, Char_types& breaks) {  
   
         // $name.field.subfield -- read  
         // $name.field.subfield(constructor code) -- construct  
         // $name.field.subfield[usage code & if none existed autoconstructed as VHash] -- use OR auto-VHash construct  
           
         Prefix prefix;  
         Array/*<String&>*/ names(pool);  // what.they.refer.to left-to-right list  
         CHAR_TYPE names_ended_before; // the char type after long name  
         get_names(  
                 iter, var_names_breaks,  
                 &prefix, &names, &names_ended_before); // can return count()=0 when $self alone  
   
         bool read_mode=name_ended_before==' ';  
         Value *context=  
                 prefix?  
                         prefix==ROOT_PREFIX?root:self:  
                 read_mode?arcontext:awcontext;  
           
         if(read_mode) {  
                 // 'context' dive into dotted path  
                 for(int i=0; i<names.count(); i++) {  
                         context=context->get_element(static_cast<Value *>(names.get[i]));  
                         if(!context) // no such object field, nothing bad, just ignore that  
                                 return;  
                 }  
                 awcontext.write(context);  
         } else { // write mode  
                 iter++; // skip '(' '['  
   
                 bool construct_mode=names_ended_before=='(';  
   
                 // 'context' dive into dotted path,   
                 int steps=names.count();  
                 // if constructing then "excluding last .name"  
                 if(construct_mode)  
                         if(!steps--) // bad: "$self("; now we can safely do ".get[steps]" below  
                                 pool.exception().raise("self re-construction prohibited");  
                 for(int i=0; i<steps; i++) {  
                         String& name=static_cast<String&>(names.get[i]);  
                         Value *next_current=context->get_element(name);  
                         if(next_current)  
                                 next_current=context->put_element(name, new(pool) VHash(pool));  
                         context=new_current;  
                 }  
   
                 if(construct_mode) {    
                         // .name(construct-code), processing on arcontext in empty temp awcontext  
                         // pure side effect, no awcontext.write here  
                         // last .name  
                         String& name=static_cast<String&>(names.get[steps]);  
                         WContext local_wcontext(pool /* empty */);  
                         process(root, self, arcontext, local_wcontext, iter, ')');  
                         context->put_element(name, local_wcontext.value());  
                 } else { // =='['  
                         // .name[with-code], processing on 'context'  
                         WContext local_context(pool, context);  
                         process(root, self, local_context, local_context, iter, ']');  
                         awcontext.write(local_context);  
                 }                  }
                                   printf("\n");
                 iter++; // skip ')' ']'  
         }          }
           END_CATCH
 }  }
   
 void process_method(method_self_n_params_n_locals& root, Value& self,  void Request::use(char *file, String *name) {
                                         arcontext& arcontext, WContext& awcontext,           char *source=file_read(pool(), file);
                                         String_iterator& iter, char char_to_stop_before) {          if(!source)
                           THROW(0,0,
         // ^name.field.subfield.method[..] -- plain call                          0,
         // ^name.field.subfield.method_ref[..] -- method ref call, when .get_method()!=0                          "use: can not read '%s' file", file);
         // ^class:method[..]  -- no dotted path allowed before/after  
         //  1: wcontext.object_class == 0?  -- constructor          VClass& vclass=COMPILE(source, file);
         //  2: wcontext.object_class.has_parent('class')? -- dynamic call          if(name) // they forced some name?
         //  3: not -------------------------------------? -- static call                  vclass.set_name(*name);
                   name=vclass.name();
         Prefix prefix;          if(!name)
         Array/*<String&>*/ names(pool);  // what.they.refer.to left-to-right list                  return; //TODO: add operators 
         CHAR_TYPE names_ended_before; // the char type after long name          classes_array()+=&vclass;
         get_names(          classes().put(*name, &vclass);
                 iter, method_names_breaks,  }
                 &prefix, &names, &names_ended_before); // can return count()=0 when ^self alone  
   char *Request::execute_MAIN() {
         Value *context=          // locate class with @main & it's code
                 prefix?          String name_main(pool());
                         prefix==ROOT_PREFIX?root:self:          name_main.APPEND_CONST(MAIN_METHOD_NAME);
                 arcontext;  
         iter++; // skip '['          // looking for latest known @main
           for(int i=classes_array().size(); --i>=0;) {
         // 'context' dive into dotted path, excluding last .name                  VClass *vclass=static_cast<VClass *>(classes_array().get(i));
         int steps=names.count()-1;                  Value *main=vclass->get_element(name_main);
         if(steps<0) // bad: "^self["; now we can safely do ".get[steps]" below                  if(main) { // found some 'main' element
                 pool.exception().raise("call: calling method named 'self'");                          Junction *junction=main->get_junction();
         for(int i=0; i<steps; i++) {                          if(junction) {// it even has junction!
                 String& name=static_cast<String&>(names.get[i]);                                  const Method *method=junction->method;
                 context=context->get_element(name);                                  if(method) { // and junction is method-junction! call it
                 if(!context) // no such object field, sad story: can't call method of void                                          // initialize contexts
                         pool.exception().raise(name, "call: to void.method");                                          self=root=rcontext=vclass;
         }                                          wcontext=NEW WWrapper(pool(), vclass);
                                                   
         // last .name                                          // execute!     
         String& name=static_cast<String&>(names.get[steps]);                                          execute(method->code);
         if(steps==0) { // the sole name on path, maybe ^class:method[ call                                          
                 String_iterator ni(name);                                          // return chars
                 if(ni.skip_to(':')) { // it is                                          return wcontext->get_string()->cstr();
                         ni++; // skip ':'                                  }
                         String method_name(pool); method_name.append(ni, 0);  
                         name=method_name; // trim "class:" prefix from the name  
   
                         String cn(pool);  cn.append(0, ni);  
                         Class *right_class=classes.get(cn);  
                         if(!right_class) // bad: no such class  
                                 pool.exception().raise(cn, "call: undefined class");  
                         Class *left_class=awcontext.get_class();  
                         if(left_class) {  
                                 if(left_class.has_parent(right_class)) // dynamic call  
                                         context=awcontext.value(); // it's 'self' instance  
                                 else // static call  
                                         context=right_class; // 'self' := class, not instance  
                         } else { // constructor: $some(^class:method[..]) call  
                                 context=new(pool) VClass(pool, right_class); // 'self' := new instance of 'class:'  
                                 awcontext.write(context);  
                         }                          }
                 }                  }
         }          }
         // first we're trying to locate method with that 'name'          
         Method *method=context.get_method(name);          THROW(0,0,
         if(!method) { // no such method: try to locate method ref field                  0, 
                 Value *value=context.get_element(name);                  "'"MAIN_METHOD_NAME"' method not found");
                 if(value) { // good: we have some element of that 'name'          return 0;
                         Method_ref *method_ref=value->get_method_ref();  
                         if(!method_ref) // bad: that field wasn't method_ref  
                                 pool.exception().raise(name, "call: this field is not a method reference");  
                         context=method_ref->self;  
                         method=method_ref->method;  
                 } else { // no element of that 'name', that must be operator then  
                         Operator *op=operators.get(name);  
                         if(!op) // bad: that 'name' is neither method nor field nor operator  
                                 pool.exception().raise(name, "call: neither method nor field nor operator");  
                         context=op->self;  
                         method=op;  
                 }  
         }  
   
   
         // evaluating param values  
         Array/*<Value&>*/ param_values(pool);  
         get_params(  
                 iter,  
                 arcontext,  
                 &param_values);  
         iter++; // skip ']'  
   
         // preparing contexts  
         method_self_n_params_n_locals local_rcontext(pool,   
                 context,  
                 method->param_names, param_values,  
                 method->local_names);  
         WContext local_wcontext(pool, context);  
         String_iterator local_iter(method->code);  
         // calling method/operator  
         process(  
                 local_rcontext/* $:vars */, context /* $self.vars */,  
                 local_rcontext, local_wcontext,   
                 local_iter, 0);  
         awcontext.write(local_wcontext);  
 }  
   
   
 enum Prefix {  
         NO_PREFIX,  
         ROOT_PREFIX,  
         SELF_PREFIX  
 };  
 void get_names(  
                 String_iterator& iter, Char_types& breaks,  
                 Prefix prefix, Array& names, CHAR_TYPE& names_ended_before) {  
   
         // can return count()=0 when $self alone  
 }  
   
 void get_params(  
                 String_iterator& iter,  
                 Value *arcontext,  
                 Array/*<Values&>*/& param_values) {  
 }  }
Removed from v.1.11  
changed lines
  Added in v.1.37

E-mail: