Return to compile_tools.C CVS log

Up to [parser3project] / parser3 / src / main

Annotation of parser3/src/main/compile_tools.C, revision 1.14

1.1       paf         1: /*
1.14    ! paf         2:   $Id: compile_tools.C,v 1.13 2001/02/24 08:28:37 paf Exp $
1.1       paf         3: */
                      4: 
                      5: #include "compile_tools.h"
                      6: #include "pa_string.h"
                      7: #include "pa_array.h"
                      8: #include "pa_exception.h"
1.9       paf         9: #include "pa_vstring.h"
1.1       paf        10: 
1.12      paf        11: void PVS(Array/*<op>*/ *result, VString *vstring) {
1.1       paf        12:        // append OP_STRING
1.9       paf        13:        Operation op; op.code=OP_STRING;
1.6       paf        14:        *result+=op.cast;
1.1       paf        15: 
1.9       paf        16:        // append 'vstring'
                     17:        *result+=vstring;
1.12      paf        18: }
1.13      paf        19: 
                     20: void PCA(Array/*<op>*/ *result, Array/*<op>*/ *code_array) {
                     21:        // append OP_CODE
                     22:        Operation op; op.code=OP_CODE;
                     23:        *result+=op.cast;
                     24: 
                     25:        // append 'vstring'
                     26:        *result+=code_array;
                     27: }
                     28: 
1.12      paf        29: 
1.14    ! paf        30: Array *SL(VString *vstring) {
1.12      paf        31:        // empty ops array
                     32:        Array *result=N(vstring->pool());
                     33: 
                     34:        // append 'vstring' to 'result'
                     35:        PVS(result, vstring);
1.1       paf        36: 
                     37:        return result;
                     38: }
1.14    ! paf        39: Array *CL(VClass *vclass) {
        !            40:        // empty ops array
        !            41:        Array *result=N(vclass->pool());
        !            42: 
        !            43:        // append OP_CLASS
        !            44:        Operation op; op.code=OP_CLASS;
        !            45:        *result+=op.cast;
        !            46: 
        !            47:        // append 'vclass'
        !            48:        *result+=vclass;
        !            49: 
        !            50:        return result;
        !            51: }
1.1       paf        52: 
1.14    ! paf        53: String *SLA2S(Array *literal_string_array, int offset) {
1.11      paf        54:        Operation op;
                     55:        op.cast=literal_string_array->get(offset+0);
                     56:        if(op.code!=OP_STRING)
                     57:                return 0;
                     58: 
1.10      paf        59:        return static_cast<VString *>(literal_string_array->get(offset+1))->get_string();
1.1       paf        60: }
                     61: 
                     62: 
1.5       paf        63: void push_LS(struct parse_control *pc, lexical_state new_state) {
1.1       paf        64:        if(pc->sp<MAX_LEXICAL_STATES) {
1.5       paf        65:                pc->stack[pc->sp++]=pc->ls;  pc->ls=new_state;
1.1       paf        66:        } else
1.7       paf        67:                pc->pool->THROW(0, 0, 0, "push_LS: stack overflow");
1.1       paf        68: }
                     69: void pop_LS(struct parse_control *pc) {
                     70:        if(--pc->sp>=0)
                     71:                pc->ls=pc->stack[pc->sp];
                     72:        else
1.7       paf        73:                pc->pool->THROW(0, 0, 0, "push_LS: stack underflow");
1.1       paf        74: }