Java Lua.GET_OPCODE属性代码示例

private void findUpvalues() {
	int[] code = prototype.code;
	int n = code.length;
	
	// propogate to inner prototypes
	String[] names = findInnerprotoNames();
	for ( int pc=0; pc<n; pc++ ) {
		if ( Lua.GET_OPCODE(code[pc]) == Lua.OP_CLOSURE ) {
			int bx = Lua.GETARG_Bx(code[pc]);
			Prototype newp = prototype.p[bx];
			UpvalInfo[] newu = new UpvalInfo[newp.upvalues.length];
			String newname = name + "$" + names[bx];
			for ( int j=0; j<newp.upvalues.length; ++j ) {
				Upvaldesc u = newp.upvalues[j];
				newu[j] = u.instack? findOpenUp(pc,u.idx) : upvals[u.idx];
			}
			subprotos[bx] = new ProtoInfo(newp, newname, newu);
		}
	}
	
	// mark all upvalues that are written locally as read/write
	for ( int pc=0; pc<n; pc++ ) {
		if ( Lua.GET_OPCODE(code[pc]) == Lua.OP_SETUPVAL )
			upvals[Lua.GETARG_B(code[pc])].rw = true;
	}
}
 

static boolean checkopenop(Prototype pt, int pc)
{
	int i = pt.code[(pc) + 1];
	switch(Lua.GET_OPCODE(i))
	{
		case Lua.OP_CALL:
		case Lua.OP_TAILCALL:
		case Lua.OP_RETURN:
		case Lua.OP_SETLIST:
		{
			if(!(Lua.GETARG_B(i) == 0)) return false;
			return true;
		}
		default:
			return false; /* invalid instruction after an open call */
	}
}
 

private boolean isLoopVariable(VarInfo var) {
	if ( var.pc >= 0 ) {
		switch ( Lua.GET_OPCODE(pi.prototype.code[var.pc]) ) {
		case Lua.OP_TFORLOOP:
		case Lua.OP_FORLOOP:
			return true;
		}
	}
	return false;
}
 

static NameWhat getfuncname(DebugLib.CallFrame frame) {
	if (!frame.f.isclosure())
		return new NameWhat(frame.f.classnamestub(), "Java");
	Prototype p = frame.f.checkclosure().p;
	int pc = frame.pc;
	int i = p.code[pc]; /* calling instruction */
	LuaString tm;
	switch (Lua.GET_OPCODE(i)) {
		case Lua.OP_CALL:
		case Lua.OP_TAILCALL: /* get function name */
			return getobjname(p, pc, Lua.GETARG_A(i));
		case Lua.OP_TFORCALL: /* for iterator */
	    	return new NameWhat("(for iterator)", "(for iterator");
	    /* all other instructions can call only through metamethods */
	    case Lua.OP_SELF:
	    case Lua.OP_GETTABUP:
	    case Lua.OP_GETTABLE: tm = LuaValue.INDEX; break;
	    case Lua.OP_SETTABUP:
	    case Lua.OP_SETTABLE: tm = LuaValue.NEWINDEX; break;
	    case Lua.OP_EQ: tm = LuaValue.EQ; break;
	    case Lua.OP_ADD: tm = LuaValue.ADD; break;
	    case Lua.OP_SUB: tm = LuaValue.SUB; break;
	    case Lua.OP_MUL: tm = LuaValue.MUL; break;
	    case Lua.OP_DIV: tm = LuaValue.DIV; break;
	    case Lua.OP_MOD: tm = LuaValue.MOD; break;
	    case Lua.OP_POW: tm = LuaValue.POW; break;
	    case Lua.OP_UNM: tm = LuaValue.UNM; break;
	    case Lua.OP_LEN: tm = LuaValue.LEN; break;
	    case Lua.OP_LT: tm = LuaValue.LT; break;
	    case Lua.OP_LE: tm = LuaValue.LE; break;
	    case Lua.OP_CONCAT: tm = LuaValue.CONCAT; break;
	    default:
	      return null;  /* else no useful name can be found */
	}
	return new NameWhat( tm.tojstring(), "metamethod" );
}
 

/**
 * Checks if this {@link VarInfo} is a loop variable
 *
 * @param var The variable to check
 * @return If this variable is one used in a loop
 */
private boolean isLoopVariable(VarInfo var) {
	if (var.pc >= 0) {
		switch (Lua.GET_OPCODE(pi.prototype.code[var.pc])) {
			case Lua.OP_TFORLOOP:
			case Lua.OP_FORLOOP:
				return true;
		}
	}
	return false;
}
 

/**
 * Find upvalues and create child prototypes
 */
public void findUpvalues() {
	int[] code = info.prototype.code;
	int n = code.length;

	// Propagate to inner prototypes
	for (int pc = 0; pc < n; pc++) {
		if (Lua.GET_OPCODE(code[pc]) == Lua.OP_CLOSURE) {
			int bx = Lua.GETARG_Bx(code[pc]);
			Prototype childPrototype = info.prototype.p[bx];
			String childName = info.name + "$" + bx;

			UpvalueInfo[] childUpvalues = null;

			if (childPrototype.nups > 0) {
				childUpvalues = new UpvalueInfo[childPrototype.nups];
				for (int j = 0; j < childPrototype.nups; ++j) {
					int i = code[++pc];
					int b = Lua.GETARG_B(i);
					childUpvalues[j] = (i & 4) != 0 ? info.upvalues[b] : findOpenUp(pc, b);
				}
			}

			info.subprotos[bx] = new ProtoInfo(childPrototype, info.loader, childName, childUpvalues);
		}
	}

	// Mark all upvalues that are written locally as read/write
	for (int instruction : code) {
		if (Lua.GET_OPCODE(instruction) == Lua.OP_SETUPVAL) {
			info.upvalues[Lua.GETARG_B(instruction)].readWrite = true;
		}
	}
}
 

static boolean precheck(Prototype pt)
{
	if(!(pt.maxstacksize <= MAXSTACK)) return false;
	lua_assert(pt.numparams + (pt.is_vararg & Lua.VARARG_HASARG) <= pt.maxstacksize);
	lua_assert((pt.is_vararg & Lua.VARARG_NEEDSARG) == 0
	        || (pt.is_vararg & Lua.VARARG_HASARG) != 0);
	if(!(pt.upvalues.length <= pt.nups)) return false;
	if(!(pt.lineinfo.length == pt.code.length || pt.lineinfo.length == 0)) return false;
	if(!(Lua.GET_OPCODE(pt.code[pt.code.length - 1]) == Lua.OP_RETURN)) return false;
	return true;
}
 

private void resolveBranches() {
	int nc = p.code.length; 
	for (int pc = 0; pc < nc; pc++) {
		if (branches[pc] != null) {
			int t=targets[pc];
			while ( t<branchDestHandles.length && branchDestHandles[t] == null )
				t++;
			if ( t>= branchDestHandles.length )
				 throw new IllegalArgumentException("no target at or after "+targets[pc]+" op="+Lua.GET_OPCODE(p.code[targets[pc]]));
			branches[pc].setTarget(branchDestHandles[t]);
		}
	}
}
 

static NameWhat getfuncname(DebugLib.CallFrame frame) {
    if (!frame.f.isclosure())
        return new NameWhat(frame.f.classnamestub(), "Java");
    Prototype p = frame.f.checkclosure().p;
    int pc = frame.pc;
    int i = p.code[pc]; /* calling instruction */
    LuaString tm;
    switch (Lua.GET_OPCODE(i)) {
        case Lua.OP_CALL:
        case Lua.OP_TAILCALL: /* get function name */
            return getobjname(p, pc, Lua.GETARG_A(i));
        case Lua.OP_TFORCALL: /* for iterator */
            return new NameWhat("(for iterator)", "(for iterator");
        /* all other instructions can call only through metamethods */
        case Lua.OP_SELF:
        case Lua.OP_GETTABUP:
        case Lua.OP_GETTABLE:
            tm = LuaValue.INDEX;
            break;
        case Lua.OP_SETTABUP:
        case Lua.OP_SETTABLE:
            tm = LuaValue.NEWINDEX;
            break;
        case Lua.OP_EQ:
            tm = LuaValue.EQ;
            break;
        case Lua.OP_ADD:
            tm = LuaValue.ADD;
            break;
        case Lua.OP_SUB:
            tm = LuaValue.SUB;
            break;
        case Lua.OP_MUL:
            tm = LuaValue.MUL;
            break;
        case Lua.OP_DIV:
            tm = LuaValue.DIV;
            break;
        case Lua.OP_MOD:
            tm = LuaValue.MOD;
            break;
        case Lua.OP_POW:
            tm = LuaValue.POW;
            break;
        case Lua.OP_UNM:
            tm = LuaValue.UNM;
            break;
        case Lua.OP_LEN:
            tm = LuaValue.LEN;
            break;
        case Lua.OP_LT:
            tm = LuaValue.LT;
            break;
        case Lua.OP_LE:
            tm = LuaValue.LE;
            break;
        case Lua.OP_CONCAT:
            tm = LuaValue.CONCAT;
            break;
        default:
            return null;  /* else no useful name can be found */
    }
    return new NameWhat(tm.tojstring(), "metamethod");
}
 

public static void visitBranches( Prototype p, BranchVisitor visitor ) {
	int sbx,j,c;
	int[] code = p.code;
	int n = code.length;
	for ( int i=0; i<n; i++ ) {
		int ins = code[i];
		switch ( Lua.GET_OPCODE( ins ) ) {
		case Lua.OP_LOADBOOL:
			if ( 0 == Lua.GETARG_C(ins) )
				break;
			if ( Lua.GET_OPCODE(code[i+1]) == Lua.OP_JMP  )
				throw new IllegalArgumentException("OP_LOADBOOL followed by jump at "+i);
			visitor.visitBranch( i, i+2 );
			continue;
		case Lua.OP_EQ:
		case Lua.OP_LT:
		case Lua.OP_LE:
		case Lua.OP_TEST: 
		case Lua.OP_TESTSET:
			if ( Lua.GET_OPCODE(code[i+1]) != Lua.OP_JMP  )
				throw new IllegalArgumentException("test not followed by jump at "+i); 
			sbx = Lua.GETARG_sBx(code[i+1]);
			++i;
			j = i + sbx + 1;
			visitor.visitBranch( i, j );
			visitor.visitBranch( i, i+1 ); 				
			continue;
		case Lua.OP_TFORLOOP:
		case Lua.OP_FORLOOP:
			sbx = Lua.GETARG_sBx(ins);
			j = i + sbx + 1;
			visitor.visitBranch( i, j );
			visitor.visitBranch( i, i+1 ); 				
			continue;
		case Lua.OP_JMP:
		case Lua.OP_FORPREP:
			sbx = Lua.GETARG_sBx(ins);
			j = i + sbx + 1;
			visitor.visitBranch( i, j );
			continue;
		case Lua.OP_TAILCALL:
		case Lua.OP_RETURN:
			visitor.visitReturn( i );
			continue;
		}
		if ( i+1<n && visitor.isbeg[i+1] )
			visitor.visitBranch( i, i+1 );
	}
}
 

public final void visitBranches(Prototype p) {
	int branchOffset, branchTo;
	int[] code = p.code;
	int n = code.length;
	for (int i = 0; i < n; i++) {
		int ins = code[i];
		switch (Lua.GET_OPCODE(ins)) {
			case Lua.OP_LOADBOOL:
				if (0 == Lua.GETARG_C(ins)) {
					break;
				}
				if (Lua.GET_OPCODE(code[i + 1]) == Lua.OP_JMP) {
					throw new IllegalArgumentException("OP_LOADBOOL followed by jump at " + i);
				}
				visitBranch(i, i + 2);
				continue;
			case Lua.OP_EQ:
			case Lua.OP_LT:
			case Lua.OP_LE:
			case Lua.OP_TEST:
			case Lua.OP_TESTSET:
			case Lua.OP_TFORLOOP:
				if (Lua.GET_OPCODE(code[i + 1]) != Lua.OP_JMP) {
					throw new IllegalArgumentException("test not followed by jump at " + i);
				}
				branchOffset = Lua.GETARG_sBx(code[i + 1]);
				++i;
				branchTo = i + branchOffset + 1;
				visitBranch(i, branchTo);
				visitBranch(i, i + 1);
				continue;
			case Lua.OP_FORLOOP:
				branchOffset = Lua.GETARG_sBx(ins);
				branchTo = i + branchOffset + 1;
				visitBranch(i, branchTo);
				visitBranch(i, i + 1);
				continue;
			case Lua.OP_JMP:
			case Lua.OP_FORPREP:
				branchOffset = Lua.GETARG_sBx(ins);
				branchTo = i + branchOffset + 1;
				visitBranch(i, branchTo);
				continue;
			case Lua.OP_TAILCALL:
			case Lua.OP_RETURN:
				visitReturn(i);
				continue;
		}
		if (i + 1 < n && isBeginning[i + 1]) {
			visitBranch(i, i + 1);
		}
	}
}
 

public JavaBuilder(ProtoInfo pi, String classname, String filename) {
	this.pi = pi;
	this.p = pi.prototype;
	this.classname = classname;
	
	// what class to inherit from
	superclassType = p.numparams;
	if ( p.is_vararg != 0 || superclassType >= SUPERTYPE_VARARGS )
		superclassType = SUPERTYPE_VARARGS;
	for ( int i=0, n=p.code.length; i<n; i++ ) {
		int inst = p.code[i];
		int o = Lua.GET_OPCODE(inst);
		if ( (o == Lua.OP_TAILCALL) ||
		     ((o == Lua.OP_RETURN) && (Lua.GETARG_B(inst) < 1 || Lua.GETARG_B(inst) > 2)) ) {
			superclassType = SUPERTYPE_VARARGS;
			break;
		}
	}
	
	// create class generator
	cg = new ClassGen(classname, SUPER_NAME_N[superclassType], filename,
			Constants.ACC_PUBLIC | Constants.ACC_SUPER, null);
	cp = cg.getConstantPool(); // cg creates constant pool

	// main instruction lists
	factory = new InstructionFactory(cg);
	init = new InstructionList();
	main = new InstructionList();

	// create the fields
	for ( int i=0; i<p.upvalues.length; i++ ) {
		boolean isrw = pi.isReadWriteUpvalue( pi.upvals[i] ); 
		Type uptype = isrw? (Type) TYPE_LOCALUPVALUE: (Type) TYPE_LUAVALUE;
		FieldGen fg = new FieldGen(0, uptype, upvalueName(i), cp);
		cg.addField(fg.getField());
	}
	
	// create the method
	mg = new MethodGen( Constants.ACC_PUBLIC | Constants.ACC_FINAL, // access flags
			RETURN_TYPE_N[superclassType], // return type
			ARG_TYPES_N[superclassType], // argument types
			ARG_NAMES_N[superclassType], // arg names
			METH_NAME_N[superclassType], 
			STR_LUAVALUE, // method, defining class
			main, cp);
	
	// initialize the values in the slots
	initializeSlots();	

	// initialize branching
	int nc = p.code.length;
	targets = new int[nc];
	branches = new BranchInstruction[nc];
	branchDestHandles = new InstructionHandle[nc];
	lastInstrHandles = new InstructionHandle[nc];
}