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

Diff for /parser3/src/main/execute.C between versions 1.3 and 1.22

version 1.3, 2001/02/21 06:21:20 version 1.22, 2001/02/22 16:21:49
Line 2 Line 2
   $Id$    $Id$
 */  */
   
 #include "pa_array.h"  #include "pa_array.h" 
 #include "code.h"  #include "code.h"
   #include "pa_request.h"
   #include "pa_vstring.h"
   #include "pa_vhash.h"
   
 #include <stdio.h>  #include <stdio.h>
   
   
 char *opcode_name[]={  char *opcode_name[]={
         "STRING",          "STRING",  "CODE_ARRAY",
         "CODE_ARRAY",  
         "WITH_ROOT",    "WITH_SELF",    "WITH_READ",    "WITH_WRITE",          "WITH_ROOT",    "WITH_SELF",    "WITH_READ",    "WITH_WRITE",
         "CONSTRUCT",          "CONSTRUCT",
         "EXPRESSION_EVAL",      "MODIFY_EVAL",          "EXPRESSION_EVAL",      "MODIFY_EVAL",
Line 23  char *opcode_name[]={ Line 26  char *opcode_name[]={
         "CALL"          "CALL"
 };  };
   
 void dump(int level, const Array *ops) {  void dump(int level, const Array& ops) {
         if(!ops)          int size=ops.size();
                 return;  
   
         int size=ops->size();  
         for(int i=0; i<size; i++) {          for(int i=0; i<size; i++) {
                 int code=reinterpret_cast<int>(ops->raw_get(i));                  int code=reinterpret_cast<int>(ops.quick_get(i));
                 printf("%*s%s", level*4, "", opcode_name[code]);                  printf("%*s%s", level*4, "", opcode_name[code]);
   
                 if(code==OP_STRING) {                  if(code==OP_STRING) {
                         printf(" \"%s\"", static_cast<const String *>(ops->raw_get(++i))->cstr());                          VString *vstring=static_cast<VString *>(ops.quick_get(++i));
                           printf(" \"%s\"", vstring->get_string()->cstr());
                 }                  }
                 printf("\n");                  printf("\n");
   
                 if(code==OP_CODE_ARRAY) {                  if(code==OP_CODE_ARRAY) {
                         const Array *local_ops=reinterpret_cast<const Array *>(ops->raw_get(++i));                          const Array *local_ops=reinterpret_cast<const Array *>(ops.quick_get(++i));
                         dump(level+1, local_ops);                          dump(level+1, *local_ops);
                 }                  }
         }          }
 }  }
   
 void execute(Pool *pool, const Array *ops) {  void Request::execute(Array& ops) {
         if(!ops)          if(0) {
                 return;                  puts("---------------------------");
                   dump(0, ops);
         puts("---------------------------");                  puts("---------------------------");
         dump(0, ops);          }
         puts("---------------------------");  
           int size=ops.size();
           for(int i=0; i<size; i++) {
                   int code=reinterpret_cast<int>(ops.quick_get(i));
                   printf("%d:%s", stack.top(), opcode_name[code]);
   
                   if(code==OP_CODE_ARRAY) {
                           const Array *local_ops=reinterpret_cast<const Array *>(ops.quick_get(++i));
                           //dump(level+1, *local_ops);
                   }
                   
                   switch(code) {
                   case OP_WITH_WRITE: 
                           {
                                   stack.push(wcontext);
                                   break;
                           }
                   case OP_WITH_READ: 
                           {
                                   stack.push(rcontext);
                                   break;
                           }
                   case OP_WITH_ROOT: 
                           {
                                   stack.push(root);
                                   break;
                           }
                   case OP_WITH_SELF: 
                           {
                                   stack.push(self);
                                   break;
                           }
                           
                   case OP_STRING:
                           {
                                   VString *vstring=static_cast<VString *>(ops.quick_get(++i));
                                   printf(" \"%s\"", vstring->get_string()->cstr());
                                   stack.push(vstring);
                                   break;
                           }
                           
                   case OP_CONSTRUCT:
                           {
                                   Value *value=static_cast<Value *>(stack.pop());
                                   VString *name=static_cast<VString *>(stack.pop());
                                   Value *ncontext=static_cast<Value *>(stack.pop());
                                   ncontext->put_element(*name, value);
                                   break;
                           }
                           
                   case OP_WRITE:
                           {
                                   Value *value=static_cast<Value *>(stack.pop());
                                   wcontext->write(value);
                                   break;
                           }
                           
                   case OP_GET_ELEMENT:
                           {
                                   Value *value=get_element();
                                   stack.push(value);
                                   break;
                           }
   
                   case OP_GET_ELEMENT__WRITE:
                           {
                                   Value *value=get_element();
                                   wcontext->write(value);
                                   break;
                           }
   
                   case OP_CREATE_EWPOOL:
                           {
                                   stack.push(wcontext);
                                   wcontext=NEW WContext(pool(), 0 /* empty */);
                                   break;
                           }
                   case OP_REDUCE_EWPOOL:
                           {
                                   Value *value=wcontext->value();
                                   wcontext=static_cast<WContext *>(stack.pop());
                                   stack.push(value);
                                   break;
                           }
                           
                   default:
                           printf("\tTODO");
                           break;
                   }
                   printf("\n");
           }
 }  }
   
   Value *Request::get_element() {
           VString *name=static_cast<VString *>(stack.pop());
           Value *ncontext=static_cast<Value *>(stack.pop());
           Value *value=ncontext->get_element(*name); // name áûâàåò method, òîãäà âûäà¸ò new junction(ÀÂÒÎÂÛ×ÈÑËßÒÜ=false, root,self,rcontext,wcontext,code)
           // name áûâàåò èìÿ junction, òîãäà èëè îñòàâëÿåò â ïîêîå, èëè âû÷èñëÿåò â çàâèñèìîñòè îò ôëàãà ÀÂÒÎÂÛ×ÈÑËßÒÜ
   
           if(!value) {
                   value=NEW VHash(pool());
                   ncontext->put_element(*name, value);
           }
           return value;
   }
   
Removed from v.1.3  
changed lines
  Added in v.1.22

E-mail: