[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.1 and 1.60

version 1.1, 2001/02/11 19:35:39 version 1.60, 2001/03/12 12:00:05
Line 1 Line 1
 void process(Pool& pool,   /*
                          Value& self,          Parser
                          RContext& rcontext, WContext& wcontext,           Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
                          StringIterator& code, char char_to_stop_before) {          Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
           
         // $ on code?          $Id$
         process_dollar(pool, rcontext, wcontext, code, char_to_stop_before);  */
   
         // ^ on code?  #include "core.h"
         process_bird(pool, rcontext, wcontext, code, char_to_stop_before);  #include "_string.h"
 }  #include "_double.h"
   #include "_int.h"
 void process_dollar(Pool& pool,   #include "_table.h"
                                         Value& THIS,  #include "pa_request.h"
                                         RContext& rcontext, WContext& wcontext,   
                                         StringIterator& iter, char char_to_stop_before) {  #define GLOBAL_STRING(name, value)  name=new(pool) String(pool); name->APPEND_CONST(value)
   #define LOCAL_STRING(name, value)  String name(pool); name.APPEND_CONST(value)
         // $name.field.subfield -- read  
         // $name.field.subfield(constructor code) -- construct  String *unnamed_name;
         // $name.field.subfield[usage code & if none existed autoconstructed as VHash] -- use OR auto-VHash construct  String *empty_string;
           
         Array/*<String&>*/ names(pool);  // what.they.refer.to left-to-right list  String *auto_method_name;
         char names_ended_before; // the char after long name  String *main_method_name;
         get_names(  
                 iter, " ([",  String *main_class_name;
                 &names, &names_ended_before); // must return count()>0  String *root_class_name;
   String *env_class_name;
         bool read_mode=name_ended_before==' ';  String *table_class_name;
         Value *context=read_mode?rcontext:wcontext;  
           Hash *untaint_lang_name2enum;
         if(read_mode) {  
                 for(int i=0; i<names.count(); i++) {  
                         context=context->get_element(static_cast<Value *>(names.get[i]));  void core() {
                         if(!context) // no such object field, nothing bad, just ignore that          Pool pool;
                                 return;          
                 }          // names
                 wcontext.write(context);          GLOBAL_STRING(unnamed_name, "unnamed");
         } else { // write mode          empty_string=new(pool) String(pool); 
                 iter++; // skip '(' '['  
           GLOBAL_STRING(auto_method_name, AUTO_METHOD_NAME);
                 bool construct_mode=names_ended_before=='(';          GLOBAL_STRING(main_method_name, MAIN_METHOD_NAME);
           
                 int steps=names.count();          GLOBAL_STRING(main_class_name, MAIN_CLASS_NAME);
                 if(construct_mode)          GLOBAL_STRING(root_class_name, ROOT_CLASS_NAME);
                         steps--;          GLOBAL_STRING(env_class_name, ENV_CLASS_NAME);  
                 for(int i=0; i<steps; i++) {          GLOBAL_STRING(table_class_name, TABLE_CLASS_NAME);
                         String& name=static_cast<String&>(names.get[i]);  
                         Value *next_current=context->get_element(name);          // hashes
                         if(next_current)          untaint_lang_name2enum=new(pool) Hash(pool);
                                 next_current=context->put_element(name, new(pool) VHash(pool));          LOCAL_STRING(as_is, "as-is");  
                         context=new_current;          untaint_lang_name2enum->put(as_is, 
                 }                  static_cast<int>(String::Untaint_lang::AS_IS));
           LOCAL_STRING(sql, "sql");
                 if(construct_mode) {            untaint_lang_name2enum->put(sql, 
                         // pure side effect, no wcontext.write here                  static_cast<int>(String::Untaint_lang::SQL));
                         String& name=static_cast<String&>(names.get[steps]);          LOCAL_STRING(js, "js");
                         WContext local_wcontext(pool /* empty */);          untaint_lang_name2enum->put(js, 
                         process(pool, rcontext, local_wcontext, iter, ')');                  static_cast<int>(String::Untaint_lang::JS));
                         context->put_element(name, local_wcontext.value());          LOCAL_STRING(html, "html");
                 } else { // =='['          untaint_lang_name2enum->put(html, 
                         WContext local_context(pool, context);                  static_cast<int>(String::Untaint_lang::HTML));
                         process(pool, local_context, local_context, iter, ']');          LOCAL_STRING(html_typo, "html-typo");
                         wcontext.write(local_context);          untaint_lang_name2enum->put(html_typo, 
                 }                  static_cast<int>(String::Untaint_lang::HTML_TYPO));
                   
                 iter++; // skip ')' ']'          // read-only classes
         }          initialize_string_class(pool, *(string_class=new(pool) VClass(pool)));  string_class->freeze();
           initialize_double_class(pool, *(double_class=new(pool) VClass(pool)));  double_class->freeze();
           initialize_int_class(pool, *(int_class=new(pool) VClass(pool)));  int_class->freeze();
           initialize_table_class(pool, *(table_class=new(pool) VClass(pool)));  table_class->freeze();
   
           // request
           Request request(pool);
           request.core();
 }  }
   
 void process_bird(Pool& pool,   
                                   Value& self,  
                                   RContext& rcontext, WContext& wcontext,   
                                   StringIterator& iter, char char_to_stop_before) {  
           
         // ^name.field.subfield.method[..] -- plain call  
         // ^name.field.subfield.method_ref[..] -- method ref call, when .get_method()!=0  
           
         Array/*<String&>*/ names(pool);  // what.they.refer.to left-to-right list  
         char names_ended_before; // the char after long name  
         get_names(  
                 iter, "[",  
                 &names, &names_ended_before); // must return count()>0  
   
         Value *context=rcontext;  
         iter++; // skip '['  
   
         Value *local_self=context;  
         int steps=names.count()-1;  
         for(int i=0; i<steps; i++) {  
                 String& name=static_cast<String&>(names.get[i]);  
                 context=(local_self=context)->get_element(name);  
                 if(!context) // no such object field, sad story: can't call method of void  
                         pool.exception().raise(name, "call: to void.method");  
         }  
           
         String& name=static_cast<String&>(names.get[steps]);  
         // first we're trying to locate method with that 'name'  
         Method *method=context.get_method(name);  
         if(!method) { // no such method: try to locate method ref field  
                 Value *value=context.get_element(name);  
                 if(!value) // failed: no element of that 'name'  
                         pool.exception().raise(name, "call: no method field found");  
                 method=value->get_method();  
                 if(!method) // failed: that field wasn't method_ref  
                         pool.exception().raise(name, "call: this field is not a method reference");  
                 local_self=value->get_self();  
         }  
   
   
         Array/*<String&>*/ param_values(pool);  
         get_params(  
                 iter, "]",  
                 &param_values);  
         iter++; // skip ']'  
   
         Method_this_n_params local_rcontext(pool,   
                 local_self,  
                 method->param_names, param_values);  
         WContext local_wcontext(pool /* empty */);  
         process(pool, local_rcontext, local_wcontext, iter, ']');  
         wcontext.write(local_wcontext);  
 }  
   
Removed from v.1.1  
changed lines
  Added in v.1.60

E-mail: