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

int secp256k1_ec_privkey_negate(const secp256k1_context* ctx, unsigned char *seckey) {    secp256k1_scalar sec;    VERIFY_CHECK(ctx != NULL);    ARG_CHECK(seckey != NULL);    secp256k1_scalar_set_b32(&sec, seckey, NULL);    secp256k1_scalar_negate(&sec, &sec);    secp256k1_scalar_get_b32(seckey, &sec);    return 1;}

int secp256k1_ecdsa_signature_parse_compact(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input64) {    secp256k1_scalar r, s;    int ret = 1;    int overflow = 0;    (void)ctx;    ARG_CHECK(sig != NULL);    ARG_CHECK(input64 != NULL);    secp256k1_scalar_set_b32(&r, &input64[0], &overflow);    ret &= !overflow;    secp256k1_scalar_set_b32(&s, &input64[32], &overflow);    ret &= !overflow;    if (ret) {        secp256k1_ecdsa_signature_save(sig, &r, &s);    } else {        memset(sig, 0, sizeof(*sig));    }    return ret;}

int secp256k1_ec_privkey_tweak_mul(const secp256k1_context* ctx, unsigned char *seckey, const unsigned char *tweak) {    secp256k1_scalar factor;    secp256k1_scalar sec;    int ret = 0;    int overflow = 0;    VERIFY_CHECK(ctx != NULL);    ARG_CHECK(seckey != NULL);    ARG_CHECK(tweak != NULL);    secp256k1_scalar_set_b32(&factor, tweak, &overflow);    secp256k1_scalar_set_b32(&sec, seckey, NULL);    ret = !overflow && secp256k1_eckey_privkey_tweak_mul(&sec, &factor);    memset(seckey, 0, 32);    if (ret) {        secp256k1_scalar_get_b32(seckey, &sec);    }    secp256k1_scalar_clear(&sec);    secp256k1_scalar_clear(&factor);    return ret;}

int ffiPushStringOfLength(int srcIndex, int length){	char *ptr;	ARG_CHECK(); /* fail before allocating */	ptr = (char*) malloc(length+1);	if(!ptr) return primitiveFail();	memcpy(ptr, (void*)srcIndex, length);	ptr[length] = 0;	ffiTempStrings[ffiTempStringCount++] = ptr;	ARG_PUSH((int)ptr);	return 1;}

int secp256k1_ec_seckey_verify(const secp256k1_context* ctx, const unsigned char *seckey) {    secp256k1_scalar sec;    int ret;    int overflow;    VERIFY_CHECK(ctx != NULL);    ARG_CHECK(seckey != NULL);    secp256k1_scalar_set_b32(&sec, seckey, &overflow);    ret = !overflow && !secp256k1_scalar_is_zero(&sec);    secp256k1_scalar_clear(&sec);    return ret;}

int secp256k1_ec_pubkey_serialize(const secp256k1_context* ctx, unsigned char *output, size_t *outputlen, const secp256k1_pubkey* pubkey, unsigned int flags) {    secp256k1_ge Q;    size_t len;    int ret = 0;    VERIFY_CHECK(ctx != NULL);    ARG_CHECK(outputlen != NULL);    ARG_CHECK(*outputlen >= ((flags & SECP256K1_FLAGS_BIT_COMPRESSION) ? 33 : 65));    len = *outputlen;    *outputlen = 0;    ARG_CHECK(output != NULL);    memset(output, 0, len);    ARG_CHECK(pubkey != NULL);    ARG_CHECK((flags & SECP256K1_FLAGS_TYPE_MASK) == SECP256K1_FLAGS_TYPE_COMPRESSION);    if (secp256k1_pubkey_load(ctx, &Q, pubkey)) {        ret = secp256k1_eckey_pubkey_serialize(&Q, output, &len, flags & SECP256K1_FLAGS_BIT_COMPRESSION);        if (ret) {            *outputlen = len;        }    }    return ret;}

int secp256k1_ec_pubkey_create(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *seckey) {    secp256k1_gej pj;    secp256k1_ge p;    secp256k1_scalar sec;    int overflow;    int ret = 0;    VERIFY_CHECK(ctx != NULL);    ARG_CHECK(pubkey != NULL);    memset(pubkey, 0, sizeof(*pubkey));    ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));    ARG_CHECK(seckey != NULL);    secp256k1_scalar_set_b32(&sec, seckey, &overflow);    ret = (!overflow) & (!secp256k1_scalar_is_zero(&sec));    if (ret) {        secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &pj, &sec);        secp256k1_ge_set_gej(&p, &pj);        secp256k1_pubkey_save(pubkey, &p);    }    secp256k1_scalar_clear(&sec);    return ret;}

int secp256k1_ec_pubkey_tweak_mul(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *tweak) {    secp256k1_ge p;    secp256k1_scalar factor;    int ret = 0;    int overflow = 0;    VERIFY_CHECK(ctx != NULL);    ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));    ARG_CHECK(pubkey != NULL);    ARG_CHECK(tweak != NULL);    secp256k1_scalar_set_b32(&factor, tweak, &overflow);    if (!overflow && secp256k1_pubkey_load(ctx, &p, pubkey)) {        ret = secp256k1_eckey_pubkey_tweak_mul(&ctx->ecmult_ctx, &p, &factor);        if (ret) {            secp256k1_pubkey_save(pubkey, &p);        } else {            memset(pubkey, 0, sizeof(*pubkey));        }    }    return ret;}

int secp256k1_ec_privkey_tweak_add(const secp256k1_context* ctx, unsigned char *seckey, const unsigned char *tweak) {    secp256k1_scalar term;    secp256k1_scalar sec;    int ret = 0;    int overflow = 0;    VERIFY_CHECK(ctx != NULL);    ARG_CHECK(seckey != NULL);    ARG_CHECK(tweak != NULL);    (void)ctx;    secp256k1_scalar_set_b32(&term, tweak, &overflow);    secp256k1_scalar_set_b32(&sec, seckey, NULL);    ret = !overflow && secp256k1_eckey_privkey_tweak_add(&sec, &term);    if (ret) {        secp256k1_scalar_get_b32(seckey, &sec);    }    secp256k1_scalar_clear(&sec);    secp256k1_scalar_clear(&term);    return ret;}

/********************************************************************/ /** * Opens pictDB file and calls do_list command. ********************************************************************** */int do_list_cmd(int args, char* argv[]){    ARG_CHECK(args, 2);    struct pictdb_file db_file;    int ret = do_open(argv[1], "rb", &db_file);    if (ret == 0) {        do_list(&db_file);    }    do_close(&db_file);    return ret;}

int secp256k1_ec_pubkey_combine(const secp256k1_context* ctx, secp256k1_pubkey *pubnonce, const secp256k1_pubkey * const *pubnonces, size_t n) {    size_t i;    secp256k1_gej Qj;    secp256k1_ge Q;    ARG_CHECK(pubnonce != NULL);    memset(pubnonce, 0, sizeof(*pubnonce));    ARG_CHECK(n >= 1);    ARG_CHECK(pubnonces != NULL);    secp256k1_gej_set_infinity(&Qj);    for (i = 0; i < n; i++) {        secp256k1_pubkey_load(ctx, &Q, pubnonces[i]);        secp256k1_gej_add_ge(&Qj, &Qj, &Q);    }    if (secp256k1_gej_is_infinity(&Qj)) {        return 0;    }    secp256k1_ge_set_gej(&Q, &Qj);    secp256k1_pubkey_save(pubnonce, &Q);    return 1;}

int secp256k1_ec_pubkey_negate(const secp256k1_context* ctx, secp256k1_pubkey *pubkey) {    int ret = 0;    secp256k1_ge p;    VERIFY_CHECK(ctx != NULL);    ARG_CHECK(pubkey != NULL);    ret = secp256k1_pubkey_load(ctx, &p, pubkey);    memset(pubkey, 0, sizeof(*pubkey));    if (ret) {        secp256k1_ge_neg(&p, &p);        secp256k1_pubkey_save(pubkey, &p);    }    return ret;}

/********************************************************************/ /** * Deletes a picture from the database. */int do_delete_cmd(int args, char* argv[]){    ARG_CHECK(args, 3);    struct pictdb_file db_file;    int ret = do_open(argv[1], "rb+", &db_file);    if (ret == 0) {        puts("Delete");        ret = do_delete(&db_file, argv[2]);    }    do_close(&db_file);    return ret;}

static int secp256k1_pubkey_load(const secp256k1_context* ctx, secp256k1_ge* ge, const secp256k1_pubkey* pubkey) {    if (sizeof(secp256k1_ge_storage) == 64) {        /* When the secp256k1_ge_storage type is exactly 64 byte, use its         * representation inside secp256k1_pubkey, as conversion is very fast.         * Note that secp256k1_pubkey_save must use the same representation. */        secp256k1_ge_storage s;        memcpy(&s, &pubkey->data[0], sizeof(s));        secp256k1_ge_from_storage(ge, &s);    } else {        /* Otherwise, fall back to 32-byte big endian for X and Y. */        secp256k1_fe x, y;        secp256k1_fe_set_b32(&x, pubkey->data);        secp256k1_fe_set_b32(&y, pubkey->data + 32);        secp256k1_ge_set_xy(ge, &x, &y);    }    ARG_CHECK(!secp256k1_fe_is_zero(&ge->x));    return 1;}

int secp256k1_ecdsa_signature_normalize(const secp256k1_context* ctx, secp256k1_ecdsa_signature *sigout, const secp256k1_ecdsa_signature *sigin) {    secp256k1_scalar r, s;    int ret = 0;    VERIFY_CHECK(ctx != NULL);    ARG_CHECK(sigin != NULL);    secp256k1_ecdsa_signature_load(ctx, &r, &s, sigin);    ret = secp256k1_scalar_is_high(&s);    if (sigout != NULL) {        if (ret) {            secp256k1_scalar_negate(&s, &s);        }        secp256k1_ecdsa_signature_save(sigout, &r, &s);    }    return ret;}

int secp256k1_context_randomize(secp256k1_context* ctx, const unsigned char *seed32) {    VERIFY_CHECK(ctx != NULL);    ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));    secp256k1_ecmult_gen_blind(&ctx->ecmult_gen_ctx, seed32);    return 1;}

/********************************************************************/ /** * Prepares and calls do_create command.********************************************************************** */int do_create_cmd(int args, char* argv[]){    ARG_CHECK(args, 2);    char* filename = argv[1];    args -= 2;    argv += 2;    uint32_t max_files = FILE_DEFAULT;    uint16_t x_thumb_res = THUMB_DEFAULT;    uint16_t y_thumb_res = THUMB_DEFAULT;    uint16_t x_small_res = SMALL_DEFAULT;    uint16_t y_small_res = SMALL_DEFAULT;    // Use of int instead of size_t for the comparison with args    // For each command line argument, checks if there are enough arguments    // remaining, converts the arguments to integers and assigns them to the    // variable, and then checks if the variable is valid.    for (int i = 0; i < args; ++i) {        switch (parse_create_options(argv[i])) {        case MAX_FILES:            OPTION_ARG_CHECK(args, i, 1);            max_files = atouint32(argv[i + 1]);            if (max_files == 0 || max_files > MAX_MAX_FILES) {                return ERR_MAX_FILES;            }            i += 1;            break;        case THUMB_RES:            OPTION_ARG_CHECK(args, i, 2);            x_thumb_res = atouint16(argv[i + 1]);            y_thumb_res = atouint16(argv[i + 2]);            RES_CHECK(x_thumb_res, y_thumb_res, THUMB_MAX);            i += 2;            break;        case SMALL_RES:            OPTION_ARG_CHECK(args, i, 2);            x_small_res = atouint16(argv[i + 1]);            y_small_res = atouint16(argv[i + 2]);            RES_CHECK(x_small_res, y_small_res, SMALL_MAX);            i += 2;            break;        case INVALID_OPTION:            return ERR_INVALID_ARGUMENT;        }    }    puts("Create");    struct pictdb_header db_header = {        .max_files = max_files,        .res_resized = { x_thumb_res, y_thumb_res, x_small_res, y_small_res }    };    struct pictdb_file db_file = {.header = db_header };    int ret = do_create(filename, &db_file);    if (ret == 0) {        print_header(&db_file.header);    }    do_close(&db_file);    return ret;}