How Bitcoin checks a spending script

751                break;
752
753                case OP_2ROT:
754                {
755                    // (x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2)
756                    if (stack.size() < 6)
757                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
758                    valtype vch1 = stacktop(-6);
759                    valtype vch2 = stacktop(-5);
760                    stack.erase(stack.end()-6, stack.end()-4);
761                    stack.push_back(vch1);
762                    stack.push_back(vch2);
763                }
764                break;
765
766                case OP_2SWAP:
767                {
768                    // (x1 x2 x3 x4 -- x3 x4 x1 x2)
769                    if (stack.size() < 4)
770                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
771                    swap(stacktop(-4), stacktop(-2));
772                    swap(stacktop(-3), stacktop(-1));
773                }
774                break;
775
776                case OP_IFDUP:
777                {
778                    // (x - 0 | x x)
779                    if (stack.size() < 1)
780                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
781                    valtype vch = stacktop(-1);
782                    if (CastToBool(vch))
783                        stack.push_back(vch);
784                }
785                break;
786
787                case OP_DEPTH:
788                {
789                    // -- stacksize
790                    CScriptNum bn(stack.size());
791                    stack.push_back(bn.getvch());
792                }
793                break;
794
795                case OP_DROP:
796                {
797                    // (x -- )
798                    if (stack.size() < 1)
799                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
800                    popstack(stack);
801                }
802                break;
803
804                case OP_DUP:
805                {
806                    // (x -- x x)
807                    if (stack.size() < 1)
808                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
809                    valtype vch = stacktop(-1);
810                    stack.push_back(vch);
811                }
812                break;
813
814                case OP_NIP:
815                {
816                    // (x1 x2 -- x2)
817                    if (stack.size() < 2)
818                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
819                    stack.erase(stack.end() - 2);
820                }
821                break;
822
823                case OP_OVER:
824                {
825                    // (x1 x2 -- x1 x2 x1)
826                    if (stack.size() < 2)
827                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
828                    valtype vch = stacktop(-2);
829                    stack.push_back(vch);
830                }
831                break;
832
833                case OP_PICK:
834                case OP_ROLL:
835                {
836                    // (xn ... x2 x1 x0 n - xn ... x2 x1 x0 xn)
837                    // (xn ... x2 x1 x0 n - ... x2 x1 x0 xn)
838                    if (stack.size() < 2)
839                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
840                    int n = CScriptNum(stacktop(-1), fRequireMinimal).getint();
841                    popstack(stack);
842                    if (n < 0 || n >= (int)stack.size())
843                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
844                    valtype vch = stacktop(-n-1);
845                    if (opcode == OP_ROLL)
846                        stack.erase(stack.end()-n-1);
847                    stack.push_back(vch);
848                }
849                break;
850
851                case OP_ROT:
852                {
853                    // (x1 x2 x3 -- x2 x3 x1)
854                    //  x2 x1 x3  after first swap
855                    //  x2 x3 x1  after second swap
856                    if (stack.size() < 3)
857                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
858                    swap(stacktop(-3), stacktop(-2));
859                    swap(stacktop(-2), stacktop(-1));
860                }
861                break;
862
863                case OP_SWAP:
864                {
865                    // (x1 x2 -- x2 x1)
866                    if (stack.size() < 2)
867                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
868                    swap(stacktop(-2), stacktop(-1));
869                }
870                break;
871
872                case OP_TUCK:
873                {
874                    // (x1 x2 -- x2 x1 x2)
875                    if (stack.size() < 2)
876                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
877                    valtype vch = stacktop(-1);
878                    stack.insert(stack.end()-2, vch);
879                }
880                break;
881
882
883                case OP_SIZE:
884                {
885                    // (in -- in size)
886                    if (stack.size() < 1)
887                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
888                    CScriptNum bn(stacktop(-1).size());
889                    stack.push_back(bn.getvch());
890                }
891                break;
892
893
894                //
895                // Bitwise logic
896                //
897                case OP_EQUAL:
898                case OP_EQUALVERIFY:
899                //case OP_NOTEQUAL: // use OP_NUMNOTEQUAL
900                {
901                    // (x1 x2 - bool)
902                    if (stack.size() < 2)
903                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
904                    valtype& vch1 = stacktop(-2);
905                    valtype& vch2 = stacktop(-1);
906                    bool fEqual = (vch1 == vch2);
907                    // OP_NOTEQUAL is disabled because it would be too easy to say
908                    // something like n != 1 and have some wiseguy pass in 1 with extra
909                    // zero bytes after it (numerically, 0x01 == 0x0001 == 0x000001)
910                    //if (opcode == OP_NOTEQUAL)
911                    //    fEqual = !fEqual;
912                    popstack(stack);
913                    popstack(stack);
914                    stack.push_back(fEqual ? vchTrue : vchFalse);
915                    if (opcode == OP_EQUALVERIFY)
916                    {
917                        if (fEqual)
918                            popstack(stack);
919                        else
920                            return set_error(serror, SCRIPT_ERR_EQUALVERIFY);
921                    }
922                }
923                break;
924
925
926                //
927                // Numeric
928                //
929                case OP_1ADD:
930                case OP_1SUB:
931                case OP_NEGATE:
932                case OP_ABS:
933                case OP_NOT:
934                case OP_0NOTEQUAL:
935                {
936                    // (in -- out)
937                    if (stack.size() < 1)
938                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
939                    CScriptNum bn(stacktop(-1), fRequireMinimal);
940                    switch (opcode)
941                    {
942                    case OP_1ADD:       bn += bnOne; break;
943                    case OP_1SUB:       bn -= bnOne; break;
944                    case OP_NEGATE:     bn = -bn; break;
945                    case OP_ABS:        if (bn < bnZero) bn = -bn; break;
946                    case OP_NOT:        bn = (bn == bnZero); break;
947                    case OP_0NOTEQUAL:  bn = (bn != bnZero); break;
948                    default:            assert(!"invalid opcode"); break;
949                    }
950                    popstack(stack);
951                    stack.push_back(bn.getvch());
952                }
953                break;
954
955                case OP_ADD:
956                case OP_SUB:
957                case OP_BOOLAND:
958                case OP_BOOLOR:
959                case OP_NUMEQUAL:
960                case OP_NUMEQUALVERIFY:
961                case OP_NUMNOTEQUAL:
962                case OP_LESSTHAN:
963                case OP_GREATERTHAN:
964                case OP_LESSTHANOREQUAL:
965                case OP_GREATERTHANOREQUAL:
966                case OP_MIN:
967                case OP_MAX:
968                {
969                    // (x1 x2 -- out)
970                    if (stack.size() < 2)
971                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
972                    CScriptNum bn1(stacktop(-2), fRequireMinimal);
973                    CScriptNum bn2(stacktop(-1), fRequireMinimal);
974                    CScriptNum bn(0);
975                    switch (opcode)
976                    {
977                    case OP_ADD:
978                        bn = bn1 + bn2;
979                        break;
980
981                    case OP_SUB:
982                        bn = bn1 - bn2;
983                        break;
984
985                    case OP_BOOLAND:             bn = (bn1 != bnZero && bn2 != bnZero); break;
986                    case OP_BOOLOR:              bn = (bn1 != bnZero || bn2 != bnZero); break;
987                    case OP_NUMEQUAL:            bn = (bn1 == bn2); break;
988                    case OP_NUMEQUALVERIFY:      bn = (bn1 == bn2); break;
989                    case OP_NUMNOTEQUAL:         bn = (bn1 != bn2); break;
990                    case OP_LESSTHAN:            bn = (bn1 < bn2); break;
991                    case OP_GREATERTHAN:         bn = (bn1 > bn2); break;
992                    case OP_LESSTHANOREQUAL:     bn = (bn1 <= bn2); break;
993                    case OP_GREATERTHANOREQUAL:  bn = (bn1 >= bn2); break;
994                    case OP_MIN:                 bn = (bn1 < bn2 ? bn1 : bn2); break;
995                    case OP_MAX:                 bn = (bn1 > bn2 ? bn1 : bn2); break;
996                    default:                     assert(!"invalid opcode"); break;
997                    }
998                    popstack(stack);
999                    popstack(stack);
1000                    stack.push_back(bn.getvch());