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

Diff for /parser3/src/main/compile_tools.C between versions 1.2 and 1.11

version 1.2, 2001/02/20 19:21:13 version 1.11, 2001/02/22 15:17:40
Line 6 Line 6
 #include "pa_string.h"  #include "pa_string.h"
 #include "pa_array.h"  #include "pa_array.h"
 #include "pa_exception.h"  #include "pa_exception.h"
   #include "pa_vstring.h"
   
 void *N(void *apool) {  Array *L(VString *vstring) {
         Pool& pool=*static_cast<Pool *>(apool);  
         return new(pool) Array(pool);  
 }  
   
 void A(void **result, enum OPCODE acode) {  
         int code=acode;  
         (*static_cast<Array *>(*result))+=reinterpret_cast<Array::Item *>(code);  
 }  
   
 void G(void **result, void *param) {  
         (*static_cast<Array *>(*result))+=param;  
 }  
   
 void *L(void *astring) {  
         String *string=static_cast<String *>(astring);  
   
         // empty ops array          // empty ops array
         void *result=N(&string->pool());          Array *result=N(vstring->pool());
   
         // append OP_STRING          // append OP_STRING
         int code=OP_STRING;          Operation op; op.code=OP_STRING;
         *(static_cast<Array *>(result))+=reinterpret_cast<Array::Item *>(code);          *result+=op.cast;
   
         // append 'string'          // append 'vstring'
         *(static_cast<Array *>(result))+=string;          *result+=vstring;
   
         return result;          return result;
 }  }
   
 void *LS(void *literal) {  String *LA2S(Array *literal_string_array, int offset) {
         return const_cast<void *>(static_cast<Array *>(literal)->get(1));          Operation op;
 }          op.cast=literal_string_array->get(offset+0);
           if(op.code!=OP_STRING)
                   return 0;
   
 void P(void **result, void *code_array) {          return static_cast<VString *>(literal_string_array->get(offset+1))->get_string();
         (*(static_cast<Array *>(*result))).append_array(*static_cast<Array *>(code_array));  
 }  }
   
   
   void push_LS(struct parse_control *pc, lexical_state new_state) {
 void push_LS(struct parse_control *pc) {  
         if(pc->sp<MAX_LEXICAL_STATES) {          if(pc->sp<MAX_LEXICAL_STATES) {
                 pc->stack[pc->sp++]=pc->ls;  pc->ls=LS_VAR_NAME_SIMPLE;                  pc->stack[pc->sp++]=pc->ls;  pc->ls=new_state;
         } else          } else
                 (static_cast<Pool *>(pc->pool))->exception().raise(0, 0, 0,                   pc->pool->THROW(0, 0, 0, "push_LS: stack overflow");
                         "push_LS: stack overflow");  
 }  }
 void pop_LS(struct parse_control *pc) {  void pop_LS(struct parse_control *pc) {
         if(--pc->sp>=0)          if(--pc->sp>=0)
                 pc->ls=pc->stack[pc->sp];                  pc->ls=pc->stack[pc->sp];
         else          else
                 (static_cast<Pool *>(pc->pool))->exception().raise(0, 0, 0,                   pc->pool->THROW(0, 0, 0, "push_LS: stack underflow");
                         "push_LS: stack underflow");  
 }  
   
 void *string_create(void *apool) {  
         Pool& pool=*static_cast<Pool *>(apool);  
         return new(pool) String(pool);  
 }  
   
 void real_cstring_append(CSTRING_APPEND_PARAMS) {  
         static_cast<String *>(astring)->APPEND(piece, size, file, line);  
 }  
   
 char *string_cstr(void *astring) {  
         return static_cast<String *>(astring)->cstr();  
 }  
   
 /* exception */  
   
 void exception(void *pool,   
                 void *atype, void *acode,  
                 void *aproblem_source,   
                 char *acomment) {  
         static_cast<Pool *>(pool)->exception().raise(  
                 static_cast<class String *>(atype),   
                 static_cast<class String *>(acode),   
                 static_cast<class String *>(aproblem_source),   
                 acomment);  
 }  }
Removed from v.1.2  
changed lines
  Added in v.1.11

E-mail: