C:\JS_KRESREAL\HBP_konverzia\lua\lopcodes.h		C:\JS_LUA\lua-5.2.0\src\lopcodes.h
	/*		/*
	** $Id: lopcodes.h,v 1.142 2011/07/15 12:50:29 roberto Exp $		** $Id: lopcodes.h,v 1.142 2011/07/15 12:50:29 roberto Exp $
	** Opcodes for Lua virtual machine		** Opcodes for Lua virtual machine
	** See Copyright Notice in lua.h		** See Copyright Notice in lua.h
	*/		*/
	#ifndef lopcodes_h		#ifndef lopcodes_h
	#define lopcodes_h		#define lopcodes_h
	#include "llimits.h"		#include "llimits.h"
	/*===========================================================================		/*===========================================================================
	We assume that instructions are unsigned numbers.		We assume that instructions are unsigned numbers.
	All instructions have an opcode in the first 6 bits.		All instructions have an opcode in the first 6 bits.
	Instructions can have the following fields:		Instructions can have the following fields:
	`A' : 8 bits		`A' : 8 bits
	`B' : 9 bits		`B' : 9 bits
	`C' : 9 bits		`C' : 9 bits
	'Ax' : 26 bits ('A', 'B', and 'C' together)		'Ax' : 26 bits ('A', 'B', and 'C' together)
	`Bx' : 18 bits (`B' and `C' together)		`Bx' : 18 bits (`B' and `C' together)
	`sBx' : signed Bx		`sBx' : signed Bx
	A signed argument is represented in excess K; that is, the number		A signed argument is represented in excess K; that is, the number
	value is the unsigned value minus K. K is exactly the maximum value		value is the unsigned value minus K. K is exactly the maximum value
	for that argument (so that -max is represented by 0, and +max is		for that argument (so that -max is represented by 0, and +max is
	represented by 2*max), which is half the maximum for the corresponding		represented by 2*max), which is half the maximum for the corresponding
	unsigned argument.		unsigned argument.
	===========================================================================*/		===========================================================================*/
	enum OpMode {iABC, iABx, iAsBx, iAx};  /* basic instruction format */		enum OpMode {iABC, iABx, iAsBx, iAx};  /* basic instruction format */
	/*		/*
	** size and position of opcode arguments.		** size and position of opcode arguments.
	*/		*/
	#define SIZE_C      9		#define SIZE_C      9
	#define SIZE_B      9		#define SIZE_B      9
	#define SIZE_Bx     (SIZE_C + SIZE_B)		#define SIZE_Bx     (SIZE_C + SIZE_B)
	#define SIZE_A      8		#define SIZE_A      8
	#define SIZE_Ax     (SIZE_C + SIZE_B + SIZE_A)		#define SIZE_Ax     (SIZE_C + SIZE_B + SIZE_A)
	#define SIZE_OP     6		#define SIZE_OP     6
	#define POS_OP      0		#define POS_OP      0
	#define POS_A       (POS_OP + SIZE_OP)		#define POS_A       (POS_OP + SIZE_OP)
	#define POS_C       (POS_A + SIZE_A)		#define POS_C       (POS_A + SIZE_A)
	#define POS_B       (POS_C + SIZE_C)		#define POS_B       (POS_C + SIZE_C)
	#define POS_Bx      POS_C		#define POS_Bx      POS_C
	#define POS_Ax      POS_A		#define POS_Ax      POS_A
	/*		/*
	** limits for opcode arguments.		** limits for opcode arguments.
	** we use (signed) int to manipulate most arguments,		** we use (signed) int to manipulate most arguments,
	** so they must fit in LUAI_BITSINT-1 bits (-1 for sign)		** so they must fit in LUAI_BITSINT-1 bits (-1 for sign)
	*/		*/
	#if SIZE_Bx < LUAI_BITSINT-1		#if SIZE_Bx < LUAI_BITSINT-1
	#define MAXARG_Bx        ((1<<SIZE_Bx)-1)		#define MAXARG_Bx        ((1<<SIZE_Bx)-1)
	#define MAXARG_sBx        (MAXARG_Bx>>1)         /* `sBx' is signed */		#define MAXARG_sBx        (MAXARG_Bx>>1)         /* `sBx' is signed */
	#else		#else
	#define MAXARG_Bx        MAX_INT		#define MAXARG_Bx        MAX_INT
	#define MAXARG_sBx        MAX_INT		#define MAXARG_sBx        MAX_INT
	#endif		#endif
	#if SIZE_Ax < LUAI_BITSINT-1		#if SIZE_Ax < LUAI_BITSINT-1
	#define MAXARG_Ax   ((1<<SIZE_Ax)-1)		#define MAXARG_Ax   ((1<<SIZE_Ax)-1)
	#else		#else
	#define MAXARG_Ax   MAX_INT		#define MAXARG_Ax   MAX_INT
	#endif		#endif
	#define MAXARG_A        ((1<<SIZE_A)-1)		#define MAXARG_A        ((1<<SIZE_A)-1)
	#define MAXARG_B        ((1<<SIZE_B)-1)		#define MAXARG_B        ((1<<SIZE_B)-1)
	#define MAXARG_C        ((1<<SIZE_C)-1)		#define MAXARG_C        ((1<<SIZE_C)-1)
	/* creates a mask with `n' 1 bits at position `p' */		/* creates a mask with `n' 1 bits at position `p' */
	#define MASK1(n,p)  ((~((~(Instruction)0)<<(n)))<<(p))		#define MASK1(n,p)  ((~((~(Instruction)0)<<(n)))<<(p))
	/* creates a mask with `n' 0 bits at position `p' */		/* creates a mask with `n' 0 bits at position `p' */
	#define MASK0(n,p)  (~MASK1(n,p))		#define MASK0(n,p)  (~MASK1(n,p))
	/*		/*
	** the following macros help to manipulate instructions		** the following macros help to manipulate instructions
	*/		*/
	#define GET_OPCODE(i)   (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0)))		#define GET_OPCODE(i)   (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0)))
	#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \		#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \
	((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP))))		((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP))))
	#define getarg(i,pos,size)  (cast(int, ((i)>>pos) & MASK1(size,0)))		#define getarg(i,pos,size)  (cast(int, ((i)>>pos) & MASK1(size,0)))
	#define setarg(i,v,pos,size)    ((i) = (((i)&MASK0(size,pos)) | \		#define setarg(i,v,pos,size)    ((i) = (((i)&MASK0(size,pos)) | \
	((cast(Instruction, v)<<pos)&MASK1(size,pos))))		((cast(Instruction, v)<<pos)&MASK1(size,pos))))
	#define GETARG_A(i) getarg(i, POS_A, SIZE_A)		#define GETARG_A(i) getarg(i, POS_A, SIZE_A)
	#define SETARG_A(i,v)   setarg(i, v, POS_A, SIZE_A)		#define SETARG_A(i,v)   setarg(i, v, POS_A, SIZE_A)
	#define GETARG_B(i) getarg(i, POS_B, SIZE_B)		#define GETARG_B(i) getarg(i, POS_B, SIZE_B)
	#define SETARG_B(i,v)   setarg(i, v, POS_B, SIZE_B)		#define SETARG_B(i,v)   setarg(i, v, POS_B, SIZE_B)
	#define GETARG_C(i) getarg(i, POS_C, SIZE_C)		#define GETARG_C(i) getarg(i, POS_C, SIZE_C)
	#define SETARG_C(i,v)   setarg(i, v, POS_C, SIZE_C)		#define SETARG_C(i,v)   setarg(i, v, POS_C, SIZE_C)
	#define GETARG_Bx(i)    getarg(i, POS_Bx, SIZE_Bx)		#define GETARG_Bx(i)    getarg(i, POS_Bx, SIZE_Bx)
	#define SETARG_Bx(i,v)  setarg(i, v, POS_Bx, SIZE_Bx)		#define SETARG_Bx(i,v)  setarg(i, v, POS_Bx, SIZE_Bx)
	#define GETARG_Ax(i)    getarg(i, POS_Ax, SIZE_Ax)		#define GETARG_Ax(i)    getarg(i, POS_Ax, SIZE_Ax)
	#define SETARG_Ax(i,v)  setarg(i, v, POS_Ax, SIZE_Ax)		#define SETARG_Ax(i,v)  setarg(i, v, POS_Ax, SIZE_Ax)
	#define GETARG_sBx(i)   (GETARG_Bx(i)-MAXARG_sBx)		#define GETARG_sBx(i)   (GETARG_Bx(i)-MAXARG_sBx)
	#define SETARG_sBx(i,b) SETARG_Bx((i),cast(unsigned int, (b)+MAXARG_sBx))		#define SETARG_sBx(i,b) SETARG_Bx((i),cast(unsigned int, (b)+MAXARG_sBx))
	#define CREATE_ABC(o,a,b,c) ((cast(Instruction, o)<<POS_OP) \		#define CREATE_ABC(o,a,b,c) ((cast(Instruction, o)<<POS_OP) \
	| (cast(Instruction, a)<<POS_A) \		| (cast(Instruction, a)<<POS_A) \
	| (cast(Instruction, b)<<POS_B) \		| (cast(Instruction, b)<<POS_B) \
	| (cast(Instruction, c)<<POS_C))		| (cast(Instruction, c)<<POS_C))
	#define CREATE_ABx(o,a,bc)  ((cast(Instruction, o)<<POS_OP) \		#define CREATE_ABx(o,a,bc)  ((cast(Instruction, o)<<POS_OP) \
	| (cast(Instruction, a)<<POS_A) \		| (cast(Instruction, a)<<POS_A) \
	| (cast(Instruction, bc)<<POS_Bx))		| (cast(Instruction, bc)<<POS_Bx))
	#define CREATE_Ax(o,a)      ((cast(Instruction, o)<<POS_OP) \		#define CREATE_Ax(o,a)      ((cast(Instruction, o)<<POS_OP) \
	| (cast(Instruction, a)<<POS_Ax))		| (cast(Instruction, a)<<POS_Ax))
	/*		/*
	** Macros to operate RK indices		** Macros to operate RK indices
	*/		*/
	/* this bit 1 means constant (0 means register) */		/* this bit 1 means constant (0 means register) */
	#define BITRK       (1 << (SIZE_B - 1))		#define BITRK       (1 << (SIZE_B - 1))
	/* test whether value is a constant */		/* test whether value is a constant */
	#define ISK(x)      ((x) & BITRK)		#define ISK(x)      ((x) & BITRK)
	/* gets the index of the constant */		/* gets the index of the constant */
	#define INDEXK(r)   ((int)(r) & ~BITRK)		#define INDEXK(r)   ((int)(r) & ~BITRK)
	#define MAXINDEXRK  (BITRK - 1)		#define MAXINDEXRK  (BITRK - 1)
	/* code a constant index as a RK value */		/* code a constant index as a RK value */
	#define RKASK(x)    ((x) | BITRK)		#define RKASK(x)    ((x) | BITRK)
	/*		/*
	** invalid register that fits in 8 bits		** invalid register that fits in 8 bits
	*/		*/
	#define NO_REG      MAXARG_A		#define NO_REG      MAXARG_A
	/*		/*
	** R(x) - register		** R(x) - register
	** Kst(x) - constant (in constant table)		** Kst(x) - constant (in constant table)
	** RK(x) == if ISK(x) then Kst(INDEXK(x)) else R(x)		** RK(x) == if ISK(x) then Kst(INDEXK(x)) else R(x)
	*/		*/
	/*		/*
	** grep "ORDER OP" if you change these enums		** grep "ORDER OP" if you change these enums
	*/		*/
	typedef enum {		typedef enum {
	/*----------------------------------------------------------------------		/*----------------------------------------------------------------------
	name        args    description		name        args    description
	------------------------------------------------------------------------*/		------------------------------------------------------------------------*/
	OP_MOVE,/*   A B R(A) := R(B)                    */		OP_MOVE,/*   A B R(A) := R(B)                    */
	OP_LOADK,/*   A Bx    R(A) := Kst(Bx)                 */		OP_LOADK,/*   A Bx    R(A) := Kst(Bx)                 */
	OP_LOADKX,/*   A   R(A) := Kst(extra arg)              */		OP_LOADKX,/*   A   R(A) := Kst(extra arg)              */
	OP_LOADBOOL,/*   A B C   R(A) := (Bool)B; if (C) pc++            */		OP_LOADBOOL,/*   A B C   R(A) := (Bool)B; if (C) pc++            */
	OP_LOADNIL,/*   A B R(A), R(A+1), ..., R(A+B) := nil        */		OP_LOADNIL,/*   A B R(A), R(A+1), ..., R(A+B) := nil        */
	OP_GETUPVAL,/*   A B R(A) := UpValue[B]              */		OP_GETUPVAL,/*   A B R(A) := UpValue[B]              */
	OP_GETTABUP,/*   A B C   R(A) := UpValue[B][RK(C)]           */		OP_GETTABUP,/*   A B C   R(A) := UpValue[B][RK(C)]           */
	OP_GETTABLE,/*   A B C   R(A) := R(B)[RK(C)]             */		OP_GETTABLE,/*   A B C   R(A) := R(B)[RK(C)]             */
	OP_SETTABUP,/*   A B C   UpValue[A][RK(B)] := RK(C)          */		OP_SETTABUP,/*   A B C   UpValue[A][RK(B)] := RK(C)          */
	OP_SETUPVAL,/*   A B UpValue[B] := R(A)              */		OP_SETUPVAL,/*   A B UpValue[B] := R(A)              */
	OP_SETTABLE,/*   A B C   R(A)[RK(B)] := RK(C)                */		OP_SETTABLE,/*   A B C   R(A)[RK(B)] := RK(C)                */
	OP_NEWTABLE,/*   A B C   R(A) := {} (size = B,C)             */		OP_NEWTABLE,/*   A B C   R(A) := {} (size = B,C)             */
	OP_SELF,/*   A B C   R(A+1) := R(B); R(A) := R(B)[RK(C)]     */		OP_SELF,/*   A B C   R(A+1) := R(B); R(A) := R(B)[RK(C)]     */
	OP_ADD,/*   A B C   R(A) := RK(B) + RK(C)               */		OP_ADD,/*   A B C   R(A) := RK(B) + RK(C)               */
	OP_SUB,/*   A B C   R(A) := RK(B) - RK(C)               */		OP_SUB,/*   A B C   R(A) := RK(B) - RK(C)               */
	OP_MUL,/*   A B C   R(A) := RK(B) * RK(C)               */		OP_MUL,/*   A B C   R(A) := RK(B) * RK(C)               */
	OP_DIV,/*   A B C   R(A) := RK(B) / RK(C)               */		OP_DIV,/*   A B C   R(A) := RK(B) / RK(C)               */
	OP_MOD,/*   A B C   R(A) := RK(B) % RK(C)               */		OP_MOD,/*   A B C   R(A) := RK(B) % RK(C)               */
	OP_POW,/*   A B C   R(A) := RK(B) ^ RK(C)               */		OP_POW,/*   A B C   R(A) := RK(B) ^ RK(C)               */
	#ifdef GCW_BIT
	OP_BAND,/*       A B C   R(A) := RK(B) & RK(C)                           */
	OP_BOR,/*        A B C   R(A) := RK(B) | RK(C)                           */
	OP_BXOR,/*       A B C   R(A) := RK(B) ^^ RK(C)                           */
	OP_BLSH,/*       A B C   R(A) := RK(B) << RK(C)                           */
	OP_BRSH,/*       A B C   R(A) := RK(B) >> RK(C)                           */
	OP_LAND,/*       A B C   R(A) := RK(B) && RK(C)                           */
	OP_LOR,/*        A B C   R(A) := RK(B) || RK(C)                           */
	OP_BNOT,/*        A B C   R(A) := ~RK(B)                                   */
	OP_LNOT,/*        A B C   R(A) := !RK(B)                                   */
	#endif
	OP_UNM,/*   A B R(A) := -R(B)                   */		OP_UNM,/*   A B R(A) := -R(B)                   */
	OP_NOT,/*   A B R(A) := not R(B)                */		OP_NOT,/*   A B R(A) := not R(B)                */
	OP_LEN,/*   A B R(A) := length of R(B)              */		OP_LEN,/*   A B R(A) := length of R(B)              */
	OP_CONCAT,/*   A B C   R(A) := R(B).. ... ..R(C)           */		OP_CONCAT,/*   A B C   R(A) := R(B).. ... ..R(C)           */
	OP_JMP,/*   A sBx   pc+=sBx; if (A) close all upvalues >= R(A) + 1  */		OP_JMP,/*   A sBx   pc+=sBx; if (A) close all upvalues >= R(A) + 1  */
	OP_EQ,/*   A B C   if ((RK(B) == RK(C)) ~= A) then pc++        */		OP_EQ,/*   A B C   if ((RK(B) == RK(C)) ~= A) then pc++        */
	OP_LT,/*   A B C   if ((RK(B) <  RK(C)) ~= A) then pc++        */		OP_LT,/*   A B C   if ((RK(B) <  RK(C)) ~= A) then pc++        */
	OP_LE,/*   A B C   if ((RK(B) <= RK(C)) ~= A) then pc++        */		OP_LE,/*   A B C   if ((RK(B) <= RK(C)) ~= A) then pc++        */
	OP_TEST,/*   A C if not (R(A) <=> C) then pc++           */		OP_TEST,/*   A C if not (R(A) <=> C) then pc++           */
	OP_TESTSET,/*   A B C   if (R(B) <=> C) then R(A) := R(B) else pc++ */		OP_TESTSET,/*   A B C   if (R(B) <=> C) then R(A) := R(B) else pc++ */
	OP_CALL,/*   A B C   R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */		OP_CALL,/*   A B C   R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
	OP_TAILCALL,/*   A B C   return R(A)(R(A+1), ... ,R(A+B-1))      */		OP_TAILCALL,/*   A B C   return R(A)(R(A+1), ... ,R(A+B-1))      */
	OP_RETURN,/*   A B return R(A), ... ,R(A+B-2)  (see note)  */		OP_RETURN,/*   A B return R(A), ... ,R(A+B-2)  (see note)  */
	OP_FORLOOP,/*   A sBx   R(A)+=R(A+2);		OP_FORLOOP,/*   A sBx   R(A)+=R(A+2);
	if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/		if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
	OP_FORPREP,/*   A sBx   R(A)-=R(A+2); pc+=sBx               */		OP_FORPREP,/*   A sBx   R(A)-=R(A+2); pc+=sBx               */
	OP_TFORCALL,/*   A C R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2));  */		OP_TFORCALL,/*   A C R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2));  */
	OP_TFORLOOP,/*   A sBx   if R(A+1) ~= nil then { R(A)=R(A+1); pc += sBx }*/		OP_TFORLOOP,/*   A sBx   if R(A+1) ~= nil then { R(A)=R(A+1); pc += sBx }*/
	OP_SETLIST,/*   A B C   R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B    */		OP_SETLIST,/*   A B C   R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B    */
	OP_CLOSURE,/*   A Bx    R(A) := closure(KPROTO[Bx])         */		OP_CLOSURE,/*   A Bx    R(A) := closure(KPROTO[Bx])         */
	OP_VARARG,/*   A B R(A), R(A+1), ..., R(A+B-2) = vararg        */		OP_VARARG,/*   A B R(A), R(A+1), ..., R(A+B-2) = vararg        */
	OP_EXTRAARG/*   Ax  extra (larger) argument for previous opcode */		OP_EXTRAARG/*   Ax  extra (larger) argument for previous opcode */
	} OpCode;		} OpCode;
	#define NUM_OPCODES (cast(int, OP_EXTRAARG) + 1)		#define NUM_OPCODES (cast(int, OP_EXTRAARG) + 1)
	/*===========================================================================		/*===========================================================================
	Notes:		Notes:
	(*) In OP_CALL, if (B == 0) then B = top. If (C == 0), then `top' is		(*) In OP_CALL, if (B == 0) then B = top. If (C == 0), then `top' is
	set to last_result+1, so next open instruction (OP_CALL, OP_RETURN,		set to last_result+1, so next open instruction (OP_CALL, OP_RETURN,
	OP_SETLIST) may use `top'.		OP_SETLIST) may use `top'.
	(*) In OP_VARARG, if (B == 0) then use actual number of varargs and		(*) In OP_VARARG, if (B == 0) then use actual number of varargs and
	set top (like in OP_CALL with C == 0).		set top (like in OP_CALL with C == 0).
	(*) In OP_RETURN, if (B == 0) then return up to `top'.		(*) In OP_RETURN, if (B == 0) then return up to `top'.
	(*) In OP_SETLIST, if (B == 0) then B = `top'; if (C == 0) then next		(*) In OP_SETLIST, if (B == 0) then B = `top'; if (C == 0) then next
	'instruction' is EXTRAARG(real C).		'instruction' is EXTRAARG(real C).
	(*) In OP_LOADKX, the next 'instruction' is always EXTRAARG.		(*) In OP_LOADKX, the next 'instruction' is always EXTRAARG.
	(*) For comparisons, A specifies what condition the test should accept		(*) For comparisons, A specifies what condition the test should accept
	(true or false).		(true or false).
	(*) All `skips' (pc++) assume that next instruction is a jump.		(*) All `skips' (pc++) assume that next instruction is a jump.
	===========================================================================*/		===========================================================================*/
	/*		/*
	** masks for instruction properties. The format is:		** masks for instruction properties. The format is:
	** bits 0-1: op mode		** bits 0-1: op mode
	** bits 2-3: C arg mode		** bits 2-3: C arg mode
	** bits 4-5: B arg mode		** bits 4-5: B arg mode
	** bit 6: instruction set register A		** bit 6: instruction set register A
	** bit 7: operator is a test (next instruction must be a jump)		** bit 7: operator is a test (next instruction must be a jump)
	*/		*/
	enum OpArgMask {		enum OpArgMask {
	OpArgN,  /* argument is not used */		OpArgN,  /* argument is not used */
	OpArgU,  /* argument is used */		OpArgU,  /* argument is used */
	OpArgR,  /* argument is a register or a jump offset */		OpArgR,  /* argument is a register or a jump offset */
	OpArgK   /* argument is a constant or register/constant */		OpArgK   /* argument is a constant or register/constant */
	};		};
	LUAI_DDEC const lu_byte luaP_opmodes[NUM_OPCODES];		LUAI_DDEC const lu_byte luaP_opmodes[NUM_OPCODES];
	#define getOpMode(m)    (cast(enum OpMode, luaP_opmodes[m] & 3))		#define getOpMode(m)    (cast(enum OpMode, luaP_opmodes[m] & 3))
	#define getBMode(m) (cast(enum OpArgMask, (luaP_opmodes[m] >> 4) & 3))		#define getBMode(m) (cast(enum OpArgMask, (luaP_opmodes[m] >> 4) & 3))
	#define getCMode(m) (cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3))		#define getCMode(m) (cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3))
	#define testAMode(m)    (luaP_opmodes[m] & (1 << 6))		#define testAMode(m)    (luaP_opmodes[m] & (1 << 6))
	#define testTMode(m)    (luaP_opmodes[m] & (1 << 7))		#define testTMode(m)    (luaP_opmodes[m] & (1 << 7))
	LUAI_DDEC const char *const luaP_opnames[NUM_OPCODES+1];  /* opcode names */		LUAI_DDEC const char *const luaP_opnames[NUM_OPCODES+1];  /* opcode names */
	/* number of list items to accumulate before a SETLIST instruction */		/* number of list items to accumulate before a SETLIST instruction */
	#define LFIELDS_PER_FLUSH   50		#define LFIELDS_PER_FLUSH   50
	#endif		#endif