自学教程：C++ CHECK_TYPES函数代码示例

void c_mod() {    CHECK_TYPES(sp - 1, T_NUMBER, 1, F_MOD);    CHECK_TYPES(sp, T_NUMBER, 2, F_MOD);    if ((sp--)->u.number == 0)	error("Modulus by zero./n");    sp->u.number %= (sp+1)->u.number;}

void zu::postfix_writer::do_zuidentifier_node(zu::zuidentifier_node * const node, int lvl) {	  CHECK_TYPES(_compiler, _symtab, node);          node->accept(this,lvl);          CHECK_TYPES(_compiler, _symtab, node);  // simplified generation: all variables are global          _pf.ADDR(node->id());}

void c_foreach P3(int, flags, int, idx1, int, idx2) {    IF_DEBUG(stack_in_use_as_temporary++);        if (flags & 4) {	CHECK_TYPES(sp, T_MAPPING, 2, F_FOREACH);		push_refed_array(mapping_indices(sp->u.map));	(++sp)->type = T_NUMBER;	sp->u.lvalue = (sp-1)->u.arr->item;	sp->subtype = (sp-1)->u.arr->size;		    	(++sp)->type = T_LVALUE;	if (flags & 2)	    sp->u.lvalue = &current_object->variables[idx1 + variable_index_offset];	else	    sp->u.lvalue = fp + idx1;    } else     if (sp->type == T_STRING) {	(++sp)->type = T_NUMBER;	sp->u.lvalue_byte = (unsigned char *)((sp-1)->u.string);	sp->subtype = SVALUE_STRLEN(sp - 1);    } else {	CHECK_TYPES(sp, T_ARRAY, 2, F_FOREACH);	(++sp)->type = T_NUMBER;	sp->u.lvalue = (sp-1)->u.arr->item;	sp->subtype = (sp-1)->u.arr->size;    }    (++sp)->type = T_LVALUE;    if (flags & 1)	sp->u.lvalue = &current_object->variables[idx2 + variable_index_offset];    else	sp->u.lvalue = fp + idx2;}

void c_foreach(int  flags, int  idx1, int  idx2) {    IF_DEBUG(stack_in_use_as_temporary++);        if (flags & FOREACH_MAPPING) {	CHECK_TYPES(sp, T_MAPPING, 2, F_FOREACH);		push_refed_array(mapping_indices(sp->u.map));	STACK_INC;	sp->type = T_NUMBER;	sp->u.lvalue = (sp-1)->u.arr->item;	sp->subtype = (sp-1)->u.arr->size;		    	STACK_INC;	sp->type = T_LVALUE;	if (flags & FOREACH_LEFT_GLOBAL) {	    sp->u.lvalue = &current_object->variables[idx1 + variable_index_offset];	} else {	    sp->u.lvalue = fp + idx1;	}    } else     if (sp->type == T_STRING) {	STACK_INC;	sp->type = T_NUMBER;	sp->u.lvalue_byte = (unsigned char *)((sp-1)->u.string);	sp->subtype = SVALUE_STRLEN(sp - 1);    } else {	CHECK_TYPES(sp, T_ARRAY, 2, F_FOREACH);	STACK_INC;	sp->type = T_NUMBER;	sp->u.lvalue = (sp-1)->u.arr->item;	sp->subtype = (sp-1)->u.arr->size;    }    if (flags & FOREACH_RIGHT_GLOBAL) {	STACK_INC;	sp->type = T_LVALUE;	sp->u.lvalue = &current_object->variables[idx2 + variable_index_offset];    } else if (flags & FOREACH_REF) {	ref_t *ref = make_ref();	svalue_t *loc = fp + idx2;	/* foreach guarantees our target remains valid */	ref->lvalue = 0;	ref->sv.type = T_NUMBER;	STACK_INC;	sp->type = T_REF;	sp->u.ref = ref;	DEBUG_CHECK(loc->type != T_NUMBER && loc->type != T_REF, "Somehow a reference in foreach acquired a value before coming into scope");	loc->type = T_REF;	loc->u.ref = ref;	ref->ref++;    } else {	STACK_INC;	sp->type = T_LVALUE;	sp->u.lvalue = fp + idx2;    }}

void c_parse_command(int  num_arg) {    svalue_t *arg;    svalue_t *fp;    int i;    /*     * type checking on first three required parameters to parse_command()     */    arg = sp - 2;    CHECK_TYPES(&arg[0], T_STRING, 1, F_PARSE_COMMAND);    CHECK_TYPES(&arg[1], T_OBJECT | T_ARRAY, 2, F_PARSE_COMMAND);    CHECK_TYPES(&arg[2], T_STRING, 3, F_PARSE_COMMAND);    /*     * allocate stack frame for rvalues and return value (number of matches);     * perform some stack manipulation;     */    fp = sp;    CHECK_STACK_OVERFLOW(num_arg + 1);    sp += num_arg + 1;    arg = sp;    *(arg--) = *(fp--);		/* move pattern to top of stack */    *(arg--) = *(fp--);		/* move source object or array to just below 				   the pattern */    *(arg) = *(fp);		/* move source string just below the object */    fp->type = T_NUMBER;    /*     * prep area for rvalues     */    for (i = 1; i <= num_arg; i++)	fp[i].type = T_INVALID;    /*     * do it...     */    i = parse(arg[0].u.string, &arg[1], arg[2].u.string, &fp[1], num_arg);    /*     * remove mandatory parameters     */    pop_3_elems();    /*     * save return value on stack     */    fp->u.number = i;}

void pwn::postfix_writer::do_simple_lvalue_node(pwn::simple_lvalue_node * const node, int lvl) {  CHECK_TYPES(_compiler, _symtab, node);  std::string id = fix_id(node->value());  std::shared_ptr<pwn::symbol> symbol = _symtab.find(id);     if ( ! _current_function) {    // global context    if ( ! symbol->is_var()) {      throw "Error: assigning a value to a function";    }        _pf.ADDR(id);  } else {    // local context    bool is_return_symbol = ( ! symbol->is_var()) // the symbol is a function                         && (_current_function->name() == symbol->name()) // the symbol has the same name as the current function                         && ( ! is_void(_current_function->type())); // the function doesnt "return" void                             if (is_return_symbol) {      if (is_double(_current_function->type())) {        _pf.LOCAL(-8); // double @ -8      } else {        _pf.LOCAL(-4); // int, string, pointer @ -4      }    } else if (symbol->is_var() && symbol->name() != _current_function->name()) {      _pf.LOCAL(symbol->offset());    } else {      throw "Error: invalid left value";    }  }}

void zu::postfix_writer::do_var_declaration_node(zu::var_declaration_node * const node, int lvl){    CHECK_TYPES(_compiler, _symtab, node);    std::string identifier = *(node->identifier()->identifier());    std::shared_ptr<zu::symbol> symbol = _symtab.find(identifier);        if(node->ext()){        _pf.EXTERN(identifier);    }else if(!_am_I_in_function){        if(node->visibility()){            _pf.GLOBAL(identifier, _pf.OBJ());            symbol->is_global(true);        }        _pf.BSS();        _pf.ALIGN();        _pf.LABEL(identifier);        _pf.BYTE(node->type()->size());        _pf.TEXT();        _pf.ALIGN();            }else{        if(_is_arg){            symbol->offset(_arg_offset);            _arg_offset += symbol->type()->size();            symbol->is_global(false);        }else {            symbol->offset(-_max_offset);            _max_offset -= symbol->type()->size();            symbol->is_global(false);        }    }           }

void zu::postfix_writer::do_div_node(cdk::div_node * const node, int lvl) {    //debug(node, lvl);  CHECK_TYPES(_compiler, _symtab, node);  node->left()->accept(this, lvl+2);  node->right()->accept(this, lvl+2);  _pf.DIV();}

void zu::xml_writer::do_println_node(zu::println_node * const node, int lvl) {  // FIXME  CHECK_TYPES(_compiler, _symtab, node);  openTag(node, lvl);  node->argument()->accept(this, lvl + 2);  closeTag(node, lvl);}

void pwn::postfix_writer::do_neg_node(cdk::neg_node * const node, int lvl) {  CHECK_TYPES(_compiler, _symtab, node);  node->argument()->accept(this, lvl); // determine the value  if (node->type()->name() == basic_type::TYPE_DOUBLE)    _pf.DNEG();  if (node->type()->name() == basic_type::TYPE_INT)    _pf.NEG(); // 2-complement}