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

int g_xchg_dx_ax(void){  if (!lbl)  {    m--;    if (*m == 146) { DID(-1); }    m++;  }  GEN(146);  DID(1);}

bool lookahead(FastVolume * in, std::vector<int> &res, int start, int dir, int amount, int cur_gen){  int cur = start;  for(int i = 0; i <= amount; i++){    cur += dir;    if(in->mask[cur] & TRU)return false;    if(in->mask[cur] & (ZRO | MASK)){//we are out; mark everything in between      for(int j = i; j > 0; j--){	cur -= dir;		if(!(BDR & in->mask[cur])){	  if(GEN((in->mask[cur])) != 0) //check if the cell already had a generation	    in->record_operation(cur, BDR | (GEN(in->mask[cur])));	  else	    in->record_operation(cur, BDR | cur_gen);	  res.push_back(cur);	    };	      };      return true;  // was able to jump    };  };  return false; //no luck; just propagate one step.};

int g_pop_dx(void){  if (!lbl)  {    m--;    if (*m == 82) { DID(-1); }    if (*m == 80)    {      return g_mov_dx_ax() - 1;    }    if (*m == 83)    {      return g_mov_dx_bx() - 1;    }    if (*m == 81)    {      return g_mov_dx_cx() - 1;    }    m++;  }  GEN(90);  DID(1);}

//.........这里部分代码省略.........      }      v = atoi(token) / 39;      scan();      if (v > 255) v = 255;      g_pop_ax();      g_mov_ah_al();      g_mov_al(v & 0xff);      g_push_ax();    }    return;  }  if(token[0] == '"')  {    char * q = (token+1);    byte * b = stalloc(strlen(q)+1);    strcpy((char *)b, q);    g_mov_ax(caddr(b));    g_push_ax();    scan();    while(token[0] == '"')    {      char * q = (token+1);      byte * b;      stretract();      b = stalloc(strlen(q)+1);      strcpy((char *)b, q);      scan();    }    return;  }  if(tokeq("{"))  {    byte * l; byte * q; int c=0; int v=0; int lc;    scan();    l = m;    g_label();    g_nop();    assignments();    if (tokeq("}"))    {      scan();      g_ret();      q = stalloc(m - l);      memcpy(q, l, m - l);      m = l;      g_mov_ax(caddr(q));      g_push_ax();      return;    }    error("Missing }");    return;  }  if(tokeq("INLINE"))  {    byte * l; byte * q; int c=0; int v=0; int lc;    scan();    if(tokeq("{")) scan();    l = m;    g_label();    g_nop();    while(tokne("}"))    {      GEN(atoi(token));      scan();    }    scan();    g_ret();    q = stalloc(m - l);    memcpy(q, l, m - l);    m = l;    g_mov_ax(caddr(q));    g_push_ax();    return;  }  if(tokeq("("))  {    scan();    boolexpr();    if (tokeq(")"))    {      scan();      return;    }    error("Missing )");    return;  }  if(tokeq("*"))  {    scan();    boolexpr();    g_mov_bx(260);    g_mov_ax_BX();    g_pop_dx();    g_push_ax();    g_add_ax_dx();    g_mov_BX_ax();    return;  }  error("Unrecognized primitive");}

int g_mov_ah_al(void)   { GEN(0x88); GEN(0xC4); DID(2); }

int g_mov_al_ah(void)   { GEN(0x88); GEN(0xE0); DID(2); }

int g_add_al(sbyte s)   { GEN(4); GEN(s); DID(2); }

int g_jg(sbyte d)       { GEN(0x7F); GEN(d); DID(2); }

int g_shl_ax_1(void)    { GEN(209); GEN(224); DID(2); }

int g_sub_BX_al(void)   { GEN(0x28); GEN(7); DID(2); }

int g_add_BX_al(void)   { GEN(0); GEN(7); DID(2); }

int g_sub_BX_ax(void)   { GEN(0x29); GEN(7); DID(2); }

int g_add_BX_ax(void)   { GEN(1); GEN(7); DID(2); }

int g_cmp_al_dl(void)   { GEN(0x38); GEN(0xD0); DID(2); }

int g_cmp_dl(byte q)    { GEN(0x80); GEN(0xFA); GEN(q); DID(3); }

int g_jge(sbyte d)      { GEN(0x7D); GEN(d); DID(2); }

int g_jl(sbyte d)       { GEN(0x7C); GEN(d); DID(2); }

int g_shr_ax_1(void)    { GEN(209); GEN(232); DID(2); }

int g_add_bx_ax(void)   { GEN(1); GEN(0xC3); DID(2); }

int g_shl_ax_cl(void)   { GEN(211); GEN(224); DID(2); }

int g_jmp_bx(void)      { GEN(0xff); GEN(0xe3); DID(2); }

int g_shr_ax_cl(void)   { GEN(211); GEN(232); DID(2); }

int g_mov_ah_dl(void)   { GEN(0x88); GEN(0xD4); DID(2); }

int g_cmp_ax(word i)    { GEN(0x3D); GENW(i); g_label(); DID(3); }

int g_mov_dl_ah(void)   { GEN(0x88); GEN(0xE2); DID(2); }

int g_cmp_bx(word i)    { GEN(0x81); GEN(0xFB); GENW(i); g_label(); DID(4); }

/* * Process a single instruction. * * Returns "false" if something goes fatally wrong. */static bool processInstruction(VerifierData* vdata, u4 insnIdx,    BitVector* workBits){    const Method* meth = vdata->method;    const u2* insns = meth->insns + insnIdx;    DecodedInstruction decInsn;    dexDecodeInstruction(insns, &decInsn);    /*     * Add registers to the "GEN" or "KILL" sets.  We want to do KILL     * before GEN to handle cases where the source and destination     * register is the same.     */    switch (decInsn.opcode) {    case OP_NOP:    case OP_RETURN_VOID:    case OP_GOTO:    case OP_GOTO_16:    case OP_GOTO_32:        /* no registers are used */        break;    case OP_RETURN:    case OP_RETURN_OBJECT:    case OP_MONITOR_ENTER:    case OP_MONITOR_EXIT:    case OP_CHECK_CAST:    case OP_THROW:    case OP_PACKED_SWITCH:    case OP_SPARSE_SWITCH:    case OP_FILL_ARRAY_DATA:    case OP_IF_EQZ:    case OP_IF_NEZ:    case OP_IF_LTZ:    case OP_IF_GEZ:    case OP_IF_GTZ:    case OP_IF_LEZ:    case OP_SPUT:    case OP_SPUT_BOOLEAN:    case OP_SPUT_BYTE:    case OP_SPUT_CHAR:    case OP_SPUT_SHORT:    case OP_SPUT_OBJECT:        /* action <- vA */        GEN(workBits, decInsn.vA);        break;    case OP_RETURN_WIDE:    case OP_SPUT_WIDE:        /* action <- vA(wide) */        GENW(workBits, decInsn.vA);        break;    case OP_IF_EQ:    case OP_IF_NE:    case OP_IF_LT:    case OP_IF_GE:    case OP_IF_GT:    case OP_IF_LE:    case OP_IPUT:    case OP_IPUT_BOOLEAN:    case OP_IPUT_BYTE:    case OP_IPUT_CHAR:    case OP_IPUT_SHORT:    case OP_IPUT_OBJECT:        /* action <- vA, vB */        GEN(workBits, decInsn.vA);        GEN(workBits, decInsn.vB);        break;    case OP_IPUT_WIDE:        /* action <- vA(wide), vB */        GENW(workBits, decInsn.vA);        GEN(workBits, decInsn.vB);        break;    case OP_APUT:    case OP_APUT_BOOLEAN:    case OP_APUT_BYTE:    case OP_APUT_CHAR:    case OP_APUT_SHORT:    case OP_APUT_OBJECT:        /* action <- vA, vB, vC */        GEN(workBits, decInsn.vA);        GEN(workBits, decInsn.vB);        GEN(workBits, decInsn.vC);        break;    case OP_APUT_WIDE:        /* action <- vA(wide), vB, vC */        GENW(workBits, decInsn.vA);        GEN(workBits, decInsn.vB);        GEN(workBits, decInsn.vC);        break;//.........这里部分代码省略.........

int g_cmp_ax_dx(void)   { GEN(0x39); GEN(0xD0); DID(2); }

/* * Read power system data from a file and load it into a PS struct. */PS GetPS(const char* file_name){		//numbers of various items in the ps file.	int i, num_buses, num_branches, num_gens, num_shunts, *ids, pv=0, sh=0, src=0;	double base_mva;	PS ps;		//check input	if(file_name == NULL) return NULL;	FILE *ps_file = fopen(file_name, "r");	if(ps_file == NULL) return NULL;		//read off ps data sizes	if(fscanf(ps_file, "BASE_MVA %lg/n", &base_mva) != 1) return NULL;	if(fscanf(ps_file, "BUS %d/n", &num_buses) != 1) return NULL;	if(fscanf(ps_file, "BRANCH %d/n", &num_branches) != 1) return NULL;	if(fscanf(ps_file, "GEN %d/n", &num_gens) != 1) return NULL;	if(fscanf(ps_file, "SHUNT %d/n", &num_shunts) != 1) return NULL;		ps = malloc(sizeof(_PS));	if(!ps) return NULL;	ps->base_mva = base_mva;	ps->num_buses = num_buses;	ps->num_branches = num_branches;	ps->num_gens = num_gens;	ps->num_shunts = num_shunts;	ps->num_macs = num_gens;		//allocate memory for buses, branches, etc.	ps->buses = malloc(num_buses*sizeof(Bus));		ps->branches = malloc(num_branches*sizeof(Branch));	ps->gens = malloc(num_gens*sizeof(Gen));	ps->shunts = malloc(num_shunts*sizeof(Shunt));	ids = malloc(num_buses*sizeof(int));	ps->src_buses = malloc((num_shunts+num_gens)*sizeof(int));		//check out memory allocations	if(!ps->buses || !ps->branches || !ps->gens || !ps->shunts || !ids || !ps->src_buses){		FreePS(&ps);		if(ids) free(ids);		return NULL;	}		//read data from file and populate ps 	fscanf(ps_file, "/n");	for(i = 0; i < num_buses; i++){		fscanf(ps_file, "%d %d %lg %lg %lg %lg %d %lg %lg %lg %d %lg %lg/n", BUS(id), BUS(type), BUS(pd), BUS(qd), BUS(gs), BUS(bs), BUS(area), BUS(vmag), BUS(vang), BUS(base_kv), BUS(zone), BUS(vmax), BUS(vmin));		ids[i] = ps->buses[i].id;		}	 	//sort the bus array, get local indices, and locate the swing bus index	qsort(ps->buses, num_buses, sizeof(Bus), CompareBuses);	for(i = 0; i < num_buses; i++){ 		ps->buses[i].index = i;		ids[i] = ps->buses[i].id;		if(ps->buses[i].type == 3) ps->swing_bus = i;		}		//branches	int swap_temp;	fscanf(ps_file, "/n");	for(i = 0; i < num_branches; i++){		fscanf(ps_file, "%d %d %lg %lg %lg %lg %lg %lg/n", BR(from), BR(to), BR(r), BR(x), BR(b), BR(rate_a), BR(rate_b), BR(rate_c));				//check whether from is greater than to, and if so, swap. this		//helps identify parallel branches.		if(ps->branches[i].from > ps->branches[i].to){			swap_temp = ps->branches[i].from;			ps->branches[i].from = ps->branches[i].to;			ps->branches[i].to = swap_temp;		}		ps->branches[i].from_index = (int*)bsearch(&(ps->branches[i].from), ids, num_buses, sizeof(int), CompareBuses) - ids;		ps->branches[i].to_index = (int*)bsearch(&(ps->branches[i].to), ids, num_buses, sizeof(int), CompareBuses) - ids;	}		//generators	fscanf(ps_file, "/n");	for(i = 0; i < num_gens; i++){		fscanf(ps_file, "%d %lg %lg %lg %lg %lg %lg %d %lg %lg/n", GEN(bus), GEN(pg), GEN(qg), GEN(qmax), GEN(qmin), GEN(vsp), GEN(m_base), GEN(status), GEN(pmax), GEN(pmin));		ps->gens[i].index = (int*)bsearch(&(ps->gens[i].bus), ids, num_buses, sizeof(int), CompareBuses) - ids;		ps->gens[i].pg/=base_mva;		ps->gens[i].qg/=base_mva;	}	qsort(ps->gens, ps->num_gens, sizeof(Gen), CompareGen);		//shunts	fscanf(ps_file, "/n");	for(i = 0; i < num_shunts; i++){		fscanf(ps_file, "%d %lg %lg/n", SH(bus), SH(p), SH(q));		ps->shunts[i].index = (int*)bsearch(&(ps->shunts[i].bus), ids, num_buses, sizeof(int), CompareBuses) - ids;		ps->shunts[i].p/=base_mva;		ps->shunts[i].q/=base_mva;	}	qsort(ps->shunts, ps->num_shunts, sizeof(Shunt), CompareShunt);		//find the set union of load and generator buses	while(sh < num_shunts || pv < num_gens){//.........这里部分代码省略.........

int g_jle(sbyte d)      { GEN(0x7E); GEN(d); DID(2); }