diff --git a/compiler/codegen.c b/compiler/codegen.c index 035b1e2..9a0ba39 100644 --- a/compiler/codegen.c +++ b/compiler/codegen.c @@ -67,8 +67,8 @@ fix_labels(OpcodeBuf *ob) int address; for (i = 0; i < ob->size; i++) { - if (ob->code[i] == JUMP - || ob->code[i] == JUMPIF) { + if (ob->code[i] == OP_JUMP + || ob->code[i] == OP_JUMPIF) { label = (ob->code[i+1] << 8) + (ob->code[i+2]); address = ob->label_table[label].label_address; ob->code[i+1] = (SVM_Byte)(address >> 8); @@ -270,9 +270,9 @@ generate_boolean_expression(SVM_Executable *cf, Expression *expr, OpcodeBuf *ob) { if (expr->u.boolean_value) { - generate_code(ob, TRUE, 1); + generate_code(ob, OP_TRUE, 1); } else { - generate_code(ob, FALSE, 0); + generate_code(ob, OP_FALSE, 0); } } @@ -281,9 +281,9 @@ generate_int_expression(SVM_Executable *cf, int value, OpcodeBuf *ob) { if (value >= 0 && value < 256) { - generate_code(ob, PUSHDATA1, value); + generate_code(ob, OP_PUSHDATA1, value); } else if (value >= 0 && value < 65536) { - generate_code(ob, PUSHDATA2, value); + generate_code(ob, OP_PUSHDATA2, value); } else { // TODO: add constpool } @@ -310,7 +310,7 @@ generate_identifier_expression(SVM_Executable *exe, Block *block, generate_identifier(expr->u.identifier, ob); break; case FUNC_DEFINITION: - generate_code(ob, INVOKE); + generate_code(ob, OP_INVOKE); break; case CONST_DEFINITION: generate_identifier(expr->u.identifier, ob); @@ -395,8 +395,8 @@ generate_logical_expression(SVM_Executable *exe, Block *block, true_label = get_label(ob); generate_expression(exe, block, expr->u.binary_expression->left, ob); - generate_code(ob, DUP); - generate_code(ob, JUMPIF, true_label); + generate_code(ob, OP_DUP); + generate_code(ob, OP_JUMPIF, true_label); generate_expression(exe, block, expr->u.binary_expression->right, ob); generate_code(ob, code); set_label(ob, true_label); @@ -428,60 +428,60 @@ generate_expression(SVM_Executable *exe, Block *current_block, break; case ADD_EXPRESSION: generate_binary_expression(exe, current_block, expr, - ADD, ob); + OP_ADD, ob); break; case SUB_EXPRESSION: generate_binary_expression(exe, current_block, expr, - SUB, ob); + OP_SUB, ob); break; case MUL_EXPRESSION: generate_binary_expression(exe, current_block, expr, - MUL, ob); + OP_MUL, ob); break; case DIV_EXPRESSION: generate_binary_expression(exe, current_block, expr, - DIV, ob); + OP_DIV, ob); break; case MOD_EXPRESSION: generate_binary_expression(exe, current_block, expr, - MOD, ob); + OP_MOD, ob); break; case EQ_EXPRESSION: generate_binary_expression(exe, current_block, expr, - EQUAL, ob); + OP_EQUAL, ob); break; case NE_EXPRESSION: generate_binary_expression(exe, current_block, expr, - NOTEQUAL0, ob); + OP_0NOTEQUAL, ob); break; case GT_EXPRESSION: generate_binary_expression(exe, current_block, expr, - GREATERTHAN, ob); + OP_GREATERTHAN, ob); break; case GE_EXPRESSION: generate_binary_expression(exe, current_block, expr, - GREATERTHANOREQUAL, ob); + OP_GREATERTHANOREQUAL, ob); break; case LT_EXPRESSION: generate_binary_expression(exe, current_block, expr, - LESSTHAN, ob); + OP_LESSTHAN, ob); break; case LE_EXPRESSION: generate_binary_expression(exe, current_block, expr, - LESSTHANOREQUAL, ob); + OP_LESSTHANOREQUAL, ob); case MINUS_EXPRESSION: generate_expression(exe, current_block, expr->u.unary_expression, ob); - generate_code(ob, NEGATE); + generate_code(ob, OP_NEGATE); break; case AND_EXPRESSION: - generate_logical_expression(exe, current_block, expr, ob, AND); + generate_logical_expression(exe, current_block, expr, ob, OP_AND); break; case OR_EXPRESSION: - generate_logical_expression(exe, current_block, expr, ob, OR); + generate_logical_expression(exe, current_block, expr, ob, OP_OR); break; case NOT_EXPRESSION: generate_expression(exe, current_block, expr->u.unary_expression, ob); - generate_code(ob, NOT); + generate_code(ob, OP_NOT); break; default: printf("expr->kind..%d\n", expr->kind); @@ -495,7 +495,7 @@ generate_expression_statement(SVM_Executable *exe, Block *block, OpcodeBuf *ob) { generate_expression(exe, block, expr, ob); - generate_code(ob, DROP); + generate_code(ob, OP_DROP); } // TODO: huge swith-case diff --git a/compiler/opcode.c b/compiler/opcode.c index 6e01a06..b485f22 100644 --- a/compiler/opcode.c +++ b/compiler/opcode.c @@ -1,88 +1,189 @@ #include "../include/SVM_code.h" OpcodeInfo svm_opcode_info[] = { - {"FALSE", "", -1}, - {"PUSHDATA1", "b", 1}, - {"PUSHDATA2", "s", 1}, - {"PUSHDATA4", "l", 1}, - {"NEGATE", "", 0}, - {"NOP", "", 1}, - {"JUMP", "", -1}, - {"JUMPIF", "", -1}, - {"VERIFY", "", -1}, - {"FAIL", "", -1}, - {"TOALTSTACK", "", 1}, - {"FROMALTSTACK", "", 1}, - {"DROP2", "", -1}, - {"DUP2", "", 1}, - {"DUP3", "", 1}, - {"OVER2", "", 1}, - {"ROT2", "", 1}, - {"SWAP2", "", 1}, - {"IFDUP", "", 1}, - {"DEPTH", "", 1}, - {"DROP", "", -1}, - {"DUP", "", 1}, - {"NIP", "", 1}, - {"OVER", "", 1}, - {"PICK", "", 1}, - {"ROLL", "", 1}, - {"ROT", "", 1}, - {"SWAP", "", 1}, - {"TUCK", "", 1}, - {"CAT", "", 1}, - {"SUBSTR", "", 1}, - {"LEFT", "", 1}, - {"RIGHT", "", 1}, - {"SIZE", "", 1}, - {"CATPUSHDATA", "", 1}, - {"INVERT", "", 1}, - {"AND", "", -1}, - {"OR", "", -1}, - {"XOR", "", -1}, - {"EQUAL", "", -1}, - {"EQUALVERIFY", "", -1}, - {"ADD1", "", -1}, - {"SUB1", "", -1}, - {"MUL2", "", -1}, - {"DIV2", "", -1}, - {"NEGATE", "", -1}, - {"ABS", "", 0}, - {"NOT", "", 0}, - {"NOTEQUAL0", "", 0}, - {"ADD", "", -1}, - {"SUB", "", -1}, - {"MUL", "", -1}, - {"DIV", "", -1}, - {"MOD", "", -1}, - {"LSHIFT", "", -1}, - {"RSHIFT", "", -1}, - {"BOOLAND", "", -1}, - {"BOOLOR", "", -1}, - {"NUMEQUAL", "", -1}, - {"NUMEQUALVERIFY", "", -1}, - {"NUMNOTEQUAL", "", -1}, - {"LESSTHAN", "", -1}, - {"GREATERTHAN", "", -1}, - {"LESSTHANOREQUAL", "", -1}, - {"GREATERTHANOREQUAL", "", -1}, - {"MIN", "", -1}, - {"MAX", "", -1}, - {"WITHIN", "", -1}, - /**********/ - {"SHA256", "", 0}, - {"SHA3", "", 0}, - {"HASH160", "", 0}, - {"CHECKSIG", "", -1}, - {"CHECKMULTISIG", "", -1}, - {"TXSIGHASH", "", 0}, - /**********/ - {"CHECKOUTPUT", "", -1}, - {"ASSET", "", -1}, - {"AMOUNT", "", -1}, - {"PROGRAM", "", -1}, - {"INDEX", "", -1}, - {"ENTRYID", "", -1}, - {"OUTPUTID", "", -1}, - {"BLOCKHEIGHT", "", -1}, + [OP_FALSE] = {"FALSE", "b", 1}, + + [OP_DATA_1] = {"DATA_1", "a", 2}, + [OP_DATA_2] = {"DATA_2", "a", 2}, + [OP_DATA_3] = {"DATA_3", "a", 2}, + [OP_DATA_4] = {"DATA_4", "a", 2}, + [OP_DATA_5] = {"DATA_5", "a", 2}, + [OP_DATA_6] = {"DATA_6", "a", 2}, + [OP_DATA_7] = {"DATA_7", "a", 2}, + [OP_DATA_8] = {"DATA_8", "a", 2}, + [OP_DATA_9] = {"DATA_9", "a", 2}, + [OP_DATA_10] = {"DATA_10", "a", 2}, + [OP_DATA_11] = {"DATA_11", "a", 2}, + [OP_DATA_12] = {"DATA_12", "a", 2}, + [OP_DATA_13] = {"DATA_13", "a", 2}, + [OP_DATA_14] = {"DATA_14", "a", 2}, + [OP_DATA_15] = {"DATA_15", "a", 2}, + [OP_DATA_16] = {"DATA_16", "a", 2}, + [OP_DATA_17] = {"DATA_17", "a", 2}, + [OP_DATA_18] = {"DATA_18", "a", 2}, + [OP_DATA_19] = {"DATA_19", "a", 2}, + [OP_DATA_20] = {"DATA_20", "a", 2}, + [OP_DATA_21] = {"DATA_21", "a", 2}, + [OP_DATA_22] = {"DATA_22", "a", 2}, + [OP_DATA_23] = {"DATA_23", "a", 2}, + [OP_DATA_24] = {"DATA_24", "a", 2}, + [OP_DATA_25] = {"DATA_25", "a", 2}, + [OP_DATA_26] = {"DATA_26", "a", 2}, + [OP_DATA_27] = {"DATA_27", "a", 2}, + [OP_DATA_28] = {"DATA_28", "a", 2}, + [OP_DATA_29] = {"DATA_29", "a", 2}, + [OP_DATA_30] = {"DATA_30", "a", 2}, + [OP_DATA_31] = {"DATA_31", "a", 2}, + [OP_DATA_32] = {"DATA_32", "a", 2}, + [OP_DATA_33] = {"DATA_33", "a", 2}, + [OP_DATA_34] = {"DATA_34", "a", 2}, + [OP_DATA_35] = {"DATA_35", "a", 2}, + [OP_DATA_36] = {"DATA_36", "a", 2}, + [OP_DATA_37] = {"DATA_37", "a", 2}, + [OP_DATA_38] = {"DATA_38", "a", 2}, + [OP_DATA_39] = {"DATA_39", "a", 2}, + [OP_DATA_40] = {"DATA_40", "a", 2}, + [OP_DATA_41] = {"DATA_41", "a", 2}, + [OP_DATA_42] = {"DATA_42", "a", 2}, + [OP_DATA_43] = {"DATA_43", "a", 2}, + [OP_DATA_44] = {"DATA_44", "a", 2}, + [OP_DATA_45] = {"DATA_45", "a", 2}, + [OP_DATA_46] = {"DATA_46", "a", 2}, + [OP_DATA_47] = {"DATA_47", "a", 2}, + [OP_DATA_48] = {"DATA_48", "a", 2}, + [OP_DATA_49] = {"DATA_49", "a", 2}, + [OP_DATA_50] = {"DATA_50", "a", 2}, + [OP_DATA_51] = {"DATA_51", "a", 2}, + [OP_DATA_52] = {"DATA_52", "a", 2}, + [OP_DATA_53] = {"DATA_53", "a", 2}, + [OP_DATA_54] = {"DATA_54", "a", 2}, + [OP_DATA_55] = {"DATA_55", "a", 2}, + [OP_DATA_56] = {"DATA_56", "a", 2}, + [OP_DATA_57] = {"DATA_57", "a", 2}, + [OP_DATA_58] = {"DATA_58", "a", 2}, + [OP_DATA_59] = {"DATA_59", "a", 2}, + [OP_DATA_60] = {"DATA_60", "a", 2}, + [OP_DATA_61] = {"DATA_61", "a", 2}, + [OP_DATA_62] = {"DATA_62", "a", 2}, + [OP_DATA_63] = {"DATA_63", "a", 2}, + [OP_DATA_64] = {"DATA_64", "a", 2}, + [OP_DATA_65] = {"DATA_65", "a", 2}, + [OP_DATA_66] = {"DATA_66", "a", 2}, + [OP_DATA_67] = {"DATA_67", "a", 2}, + [OP_DATA_68] = {"DATA_68", "a", 2}, + [OP_DATA_69] = {"DATA_69", "a", 2}, + [OP_DATA_70] = {"DATA_70", "a", 2}, + [OP_DATA_71] = {"DATA_71", "a", 2}, + [OP_DATA_72] = {"DATA_72", "a", 2}, + [OP_DATA_73] = {"DATA_73", "a", 2}, + [OP_DATA_74] = {"DATA_74", "a", 2}, + [OP_DATA_75] = {"DATA_75", "a", 2}, + + + [OP_PUSHDATA1] = {"PUSHDATA1", "a", 2}, + [OP_PUSHDATA2] = {"PUSHDATA2", "a", 2}, + [OP_PUSHDATA4] = {"PUSHDATA4", "a", 2}, + [OP_1NEGATE] = {"NEGATE", "l", 0}, + + [OP_1] = {"1", "b", 1}, + [OP_2] = {"2", "b", 1}, + [OP_3] = {"3", "b", 1}, + [OP_4] = {"4", "b", 1}, + [OP_5] = {"5", "b", 1}, + [OP_6] = {"6", "b", 1}, + [OP_7] = {"7", "b", 1}, + [OP_8] = {"8", "b", 1}, + [OP_9] = {"9", "b", 1}, + [OP_10] = {"10", "b", 1}, + [OP_11] = {"11", "b", 1}, + [OP_12] = {"12", "b", 1}, + [OP_13] = {"13", "b", 1}, + [OP_14] = {"14", "b", 1}, + [OP_15] = {"15", "b", 1}, + [OP_16] = {"16", "b", 1}, + + [OP_NOP] = {"NOP", "b", 1}, + + [OP_JUMP] = {"JUMP", "l", 1}, + [OP_JUMPIF] = {"JUMPIF", "l", 1}, + [OP_VERIFY] = {"VERIFY", "b", 0}, + [OP_FAIL] = {"FAIL", "b", 0}, + + [OP_TOALTSTACK] = {"TOALTSTACK", "b", -1}, + [OP_FROMALTSTACK] = {"FROMALTSTACK", "b", 1}, + [OP_2DROP] = {"DROP2", "s", -2}, + [OP_2DUP] = {"DUP2", "s", 2}, + [OP_3DUP] = {"DUP3", "l", 3}, + [OP_2OVER] = {"OVER2", "l", 2}, + [OP_2ROT] = {"ROT2", "s", 0}, + [OP_2SWAP] = {"SWAP2", "s", 0}, + [OP_IFDUP] = {"IFDUP", "b", 1}, + [OP_DEPTH] = {"DEPTH", "b", 1}, + [OP_DROP] = {"DROP", "b", -1}, + [OP_DUP] = {"DUP", "b", 1}, + [OP_NIP] = {"NIP", "b", -1}, + [OP_OVER] = {"OVER", "b", 1}, + [OP_PICK] = {"PICK", "b", 1}, + [OP_ROLL] = {"ROLL", "b", 0}, + [OP_ROT] = {"ROT", "b", 0}, + [OP_SWAP] = {"SWAP", "b", 0}, + [OP_TUCK] = {"TUCK", "b", 1}, + + [OP_CAT] = {"CAT", "s", -1}, + [OP_SUBSTR] = {"SUBSTR", "l", -2}, + [OP_LEFT] = {"LEFT", "s", -1}, + [OP_RIGHT] = {"RIGHT", "s", -1}, + [OP_SIZE] = {"SIZE", "b", 1}, + [OP_CATPUSHDATA] = {"CATPUSHDATA", "s", -1}, + + [OP_INVERT] = {"INVERT", "b", 0}, + [OP_AND] = {"AND", "b", 0}, + [OP_OR] = {"OR", "b", 0}, + [OP_XOR] = {"XOR", "b", 0}, + [OP_EQUAL] = {"EQUAL", "b", 1}, + [OP_EQUALVERIFY] = {"EQUALVERIFY", "", 1}, + + [OP_1ADD] = {"ADD1", "b", 0}, + [OP_1SUB] = {"SUB1", "b", 0}, + [OP_2MUL] = {"MUL2", "b", 0}, + [OP_2DIV] = {"DIV2", "b", 0}, + [OP_NEGATE] = {"NEGATE", "b", 0}, + [OP_ABS] = {"ABS", "b", 0}, + [OP_NOT] = {"NOT", "b", 0}, + [OP_0NOTEQUAL] = {"NOTEQUAL0", "b", 0}, + [OP_ADD] = {"ADD", "b", 1}, + [OP_SUB] = {"SUB", "b", 11}, + [OP_MUL] = {"MUL", "b", 1}, + [OP_DIV] = {"DIV", "b", 1}, + [OP_MOD] = {"MOD", "b", 1}, + [OP_LSHIFT] = {"LSHIFT", "b", 1}, + [OP_RSHIFT] = {"RSHIFT", "b", 1}, + [OP_BOOLAND] = {"BOOLAND", "b", 1}, + [OP_BOOLOR] = {"BOOLOR", "b", 1}, + [OP_NUMEQUAL] = {"NUMEQUAL", "b", 1}, + [OP_NUMEQUALVERIFY] = {"NUMEQUALVERIFY", "b", 1}, + [OP_NUMNOTEQUAL] = {"NUMNOTEQUAL", "b", 1}, + [OP_LESSTHAN] = {"LESSTHAN", "b", 1}, + [OP_GREATERTHAN] = {"GREATERTHAN", "b", 1}, + [OP_LESSTHANOREQUAL] = {"LESSTHANOREQUAL", "b", 1}, + [OP_GREATERTHANOREQUAL] = {"GREATERTHANOREQUAL", "b", 1}, + [OP_MIN] = {"MIN", "b", 1}, + [OP_MAX] = {"MAX", "b", 1}, + [OP_WITHIN] = {"WITHIN", "b", 1}, + + [OP_SHA256] = {"SHA256", "b", 1}, + [OP_SHA3] = {"SHA3", "b", 1}, + [OP_HASH160] = {"HASH160", "b", 1}, + [OP_CHECKSIG] = {"CHECKSIG", "b", 1}, + [OP_CHECKMULTISIG] = {"CHECKMULTISIG", "b", 1}, + [OP_TXSIGHASH] = {"TXSIGHASH", "b", 1}, + + [OP_CHECKOUTPUT] = {"CHECKOUTPUT", "b", 1}, + [OP_ASSET] = {"ASSET", "b", 1}, + [OP_AMOUNT] = {"AMOUNT", "b", 1}, + [OP_PROGRAM] = {"PROGRAM", "b", 1}, + [OP_INDEX] = {"INDEX", "b", 1}, + [OP_ENTRYID] = {"ENTRYID", "b", 1}, + [OP_OUTPUTID] = {"OUTPUTID", "b", 1}, + [OP_BLOCKHEIGHT] = {"BLOCKHEIGHT", "b", 1} }; \ No newline at end of file diff --git a/include/SVM_code.h b/include/SVM_code.h index c490872..70aed41 100644 --- a/include/SVM_code.h +++ b/include/SVM_code.h @@ -2,96 +2,206 @@ #define _SVMCODE_H_ typedef enum { - FALSE = 0x00, - ZERO = 0x00, + OP_FALSE = 0x00, + OP_0 = 0x00, // synonym + + // n size data + OP_DATA_1 = 0x01, + OP_DATA_2 = 0x02, + OP_DATA_3 = 0x03, + OP_DATA_4 = 0x04, + OP_DATA_5 = 0x05, + OP_DATA_6 = 0x06, + OP_DATA_7 = 0x07, + OP_DATA_8 = 0x08, + OP_DATA_9 = 0x09, + OP_DATA_10 = 0x0a, + OP_DATA_11 = 0x0b, + OP_DATA_12 = 0x0c, + OP_DATA_13 = 0x0d, + OP_DATA_14 = 0x0e, + OP_DATA_15 = 0x0f, + OP_DATA_16 = 0x10, + OP_DATA_17 = 0x11, + OP_DATA_18 = 0x12, + OP_DATA_19 = 0x13, + OP_DATA_20 = 0x14, + OP_DATA_21 = 0x15, + OP_DATA_22 = 0x16, + OP_DATA_23 = 0x17, + OP_DATA_24 = 0x18, + OP_DATA_25 = 0x19, + OP_DATA_26 = 0x1a, + OP_DATA_27 = 0x1b, + OP_DATA_28 = 0x1c, + OP_DATA_29 = 0x1d, + OP_DATA_30 = 0x1e, + OP_DATA_31 = 0x1f, + OP_DATA_32 = 0x20, + OP_DATA_33 = 0x21, + OP_DATA_34 = 0x22, + OP_DATA_35 = 0x23, + OP_DATA_36 = 0x24, + OP_DATA_37 = 0x25, + OP_DATA_38 = 0x26, + OP_DATA_39 = 0x27, + OP_DATA_40 = 0x28, + OP_DATA_41 = 0x29, + OP_DATA_42 = 0x2a, + OP_DATA_43 = 0x2b, + OP_DATA_44 = 0x2c, + OP_DATA_45 = 0x2d, + OP_DATA_46 = 0x2e, + OP_DATA_47 = 0x2f, + OP_DATA_48 = 0x30, + OP_DATA_49 = 0x31, + OP_DATA_50 = 0x32, + OP_DATA_51 = 0x33, + OP_DATA_52 = 0x34, + OP_DATA_53 = 0x35, + OP_DATA_54 = 0x36, + OP_DATA_55 = 0x37, + OP_DATA_56 = 0x38, + OP_DATA_57 = 0x39, + OP_DATA_58 = 0x3a, + OP_DATA_59 = 0x3b, + OP_DATA_60 = 0x3c, + OP_DATA_61 = 0x3d, + OP_DATA_62 = 0x3e, + OP_DATA_63 = 0x3f, + OP_DATA_64 = 0x40, + OP_DATA_65 = 0x41, + OP_DATA_66 = 0x42, + OP_DATA_67 = 0x43, + OP_DATA_68 = 0x44, + OP_DATA_69 = 0x45, + OP_DATA_70 = 0x46, + OP_DATA_71 = 0x47, + OP_DATA_72 = 0x48, + OP_DATA_73 = 0x49, + OP_DATA_74 = 0x4a, + OP_DATA_75 = 0x4b, - ONE = 0x51, - TRUE = 0x51, + // prefix_len + data + OP_PUSHDATA1 = 0x4c, + OP_PUSHDATA2 = 0x4d, + OP_PUSHDATA4 = 0x4e, + OP_1NEGATE = 0x4f, - PUSHDATA1 = 0x4c, - PUSHDATA2, - PUSHDATA4, - NEGATE1, - NOP, - JUMP, - JUMPIF, - VERIFY, - FAIL, - TOALTSTACK, - FROMALTSTACK, - DROP2, - DUP2, - DUP3, - OVER2, - ROT2, - SWAP2, - IFDUP, - DEPTH, - DROP, - DUP, - NIP, - OVER, - PICK, - ROLL, - ROT, - SWAP, - TUCK, - CAT, - SUBSTR, - LEFT, - RIGHT, - SIZE, - CATPUSHDATA, - INVERT, - AND, - OR, - XOR, - EQUAL, - EQUALVERIFY, - ADD1, - SUB1, - MUL2, - DIV2, - NEGATE, - ABS, - NOT, - NOTEQUAL0, - ADD, - SUB, - MUL, - DIV, - MOD, - LSHIFT, - RSHIFT, - BOOLAND, - BOOLOR, - NUMEQUAL, - NUMEQUALVERIFY, - NUMNOTEQUAL, - LESSTHAN, - GREATERTHAN, - LESSTHANOREQUAL, - GREATERTHANOREQUAL, - MIN, - MAX, - WITHIN, - /**********/ - SHA256, - SHA3, - HASH160, - CHECKSIG, - CHECKMULTISIG, - TXSIGHASH, - /**********/ - CHECKOUTPUT, - ASSET, - AMOUNT, - PROGRAM, - INDEX, - ENTRYID, - OUTPUTID, - BLOCKHEIGHT, - INVOKE + // number 1-16 + OP_1 = 0x51, + OP_TRUE = 0x51, // synonym + OP_2 = 0x52, + OP_3 = 0x53, + OP_4 = 0x54, + OP_5 = 0x55, + OP_6 = 0x56, + OP_7 = 0x57, + OP_8 = 0x58, + OP_9 = 0x59, + OP_10 = 0x5a, + OP_11 = 0x5b, + OP_12 = 0x5c, + OP_13 = 0x5d, + OP_14 = 0x5e, + OP_15 = 0x5f, + OP_16 = 0x60, + + OP_NOP = 0x61, + + // jump control flow + OP_JUMP = 0x63, + OP_JUMPIF = 0x64, + OP_VERIFY = 0x69, + OP_FAIL = 0x6a, + OP_CHECKPREDICATE = 0xc0, + + // stack control + OP_TOALTSTACK = 0x6b, + OP_FROMALTSTACK = 0x6c, + OP_2DROP = 0x6d, + OP_2DUP = 0x6e, + OP_3DUP = 0x6f, + OP_2OVER = 0x70, + OP_2ROT = 0x71, + OP_2SWAP = 0x72, + OP_IFDUP = 0x73, + OP_DEPTH = 0x74, + OP_DROP = 0x75, + OP_DUP = 0x76, + OP_NIP = 0x77, + OP_OVER = 0x78, + OP_PICK = 0x79, + OP_ROLL = 0x7a, + OP_ROT = 0x7b, + OP_SWAP = 0x7c, + OP_TUCK = 0x7d, + + //string control + OP_CAT = 0x7e, + OP_SUBSTR = 0x7f, + OP_LEFT = 0x80, + OP_RIGHT = 0x81, + OP_SIZE = 0x82, + OP_CATPUSHDATA = 0x89, + + // bit + OP_INVERT = 0x83, + OP_AND = 0x84, + OP_OR = 0x85, + OP_XOR = 0x86, + OP_EQUAL = 0x87, + OP_EQUALVERIFY = 0x88, + + // number + OP_1ADD = 0x8b, + OP_1SUB = 0x8c, + OP_2MUL = 0x8d, + OP_2DIV = 0x8e, + OP_NEGATE = 0x8f, + OP_ABS = 0x90, + OP_NOT = 0x91, + OP_0NOTEQUAL = 0x92, + OP_ADD = 0x93, + OP_SUB = 0x94, + OP_MUL = 0x95, + OP_DIV = 0x96, + OP_MOD = 0x97, + OP_LSHIFT = 0x98, + OP_RSHIFT = 0x99, + OP_BOOLAND = 0x9a, + OP_BOOLOR = 0x9b, + OP_NUMEQUAL = 0x9c, + OP_NUMEQUALVERIFY = 0x9d, + OP_NUMNOTEQUAL = 0x9e, + OP_LESSTHAN = 0x9f, + OP_GREATERTHAN = 0xa0, + OP_LESSTHANOREQUAL = 0xa1, + OP_GREATERTHANOREQUAL = 0xa2, + OP_MIN = 0xa3, + OP_MAX = 0xa4, + OP_WITHIN = 0xa5, + + // crypt + OP_SHA256 = 0xa8, + OP_SHA3 = 0xaa, + OP_HASH160 = 0xab, + OP_CHECKSIG = 0xac, + OP_CHECKMULTISIG = 0xad, + OP_TXSIGHASH = 0xae, + + // utxo + OP_CHECKOUTPUT = 0xc1, + OP_ASSET = 0xc2, + OP_AMOUNT = 0xc3, + OP_PROGRAM = 0xc4, + OP_INDEX = 0xc9, + OP_ENTRYID = 0xca, + OP_OUTPUTID = 0xcb, + OP_BLOCKHEIGHT = 0xcd, + + // pseudo + OP_INVOKE = 0xd0 }SVM_Opcode; typedef struct {