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

void CItem::Spawn_KillChildren(){	// kill all creatures spawned from this !	DEBUG_CHECK( IsType(IT_SPAWN_CHAR));	int iCurrent = m_itSpawnChar.m_current;	for ( int j = 0; j < 256; j++ )	// loop through all maps	{		if ( !g_MapList.m_maps[j] ) continue;		// skip unsupported maps		for ( int i = 0; i < g_MapList.GetSectorQty(j); i++ )		{			CSector * pSector = g_World.GetSector(j, i);			ASSERT(pSector);			CChar * pCharNext;			CChar * pChar = STATIC_CAST <CChar*>( pSector->m_Chars_Active.GetHead());			for ( ; pChar!=NULL; pChar = pCharNext )			{				pCharNext = pChar->GetNext();				if ( pChar->NPC_IsSpawnedBy( this ))				{					pChar->Delete();					iCurrent --;				}			}		}	}	if (iCurrent && ! g_Serv.IsLoading())	{		DEBUG_CHECK(iCurrent==0);	}	m_itSpawnChar.m_current = 0;	// Should not be necessary	Spawn_OnTick( false );}

int secp256k1_ecdsa_verify(const secp256k1_context_t* ctx, const unsigned char *msg32, const unsigned char *sig, int siglen, const unsigned char *pubkey, int pubkeylen) {    secp256k1_ge_t q;    secp256k1_ecdsa_sig_t s;    secp256k1_scalar_t m;    int ret = -3;    DEBUG_CHECK(ctx != NULL);    DEBUG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));    DEBUG_CHECK(msg32 != NULL);    DEBUG_CHECK(sig != NULL);    DEBUG_CHECK(pubkey != NULL);    secp256k1_scalar_set_b32(&m, msg32, NULL);    if (secp256k1_eckey_pubkey_parse(&q, pubkey, pubkeylen)) {        if (secp256k1_ecdsa_sig_parse(&s, sig, siglen)) {            if (secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &s, &q, &m)) {                /* success is 1, all other values are fail */                ret = 1;            } else {                ret = 0;            }        } else {            ret = -2;        }    } else {        ret = -1;    }    return ret;}

int secp256k1_ec_pubkey_tweak_mul(const secp256k1_context_t* ctx, unsigned char *pubkey, int pubkeylen, const unsigned char *tweak) {    secp256k1_ge_t p;    secp256k1_scalar_t factor;    int ret = 0;    int overflow = 0;    DEBUG_CHECK(ctx != NULL);    DEBUG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));    DEBUG_CHECK(pubkey != NULL);    DEBUG_CHECK(tweak != NULL);    secp256k1_scalar_set_b32(&factor, tweak, &overflow);    if (!overflow) {        ret = secp256k1_eckey_pubkey_parse(&p, pubkey, pubkeylen);        if (ret) {            ret = secp256k1_eckey_pubkey_tweak_mul(&ctx->ecmult_ctx, &p, &factor);        }        if (ret) {            int oldlen = pubkeylen;            ret = secp256k1_eckey_pubkey_serialize(&p, pubkey, &pubkeylen, oldlen <= 33);            VERIFY_CHECK(pubkeylen == oldlen);        }    }    return ret;}

int secp256k1_ecdsa_pubkey_tweak_mul(unsigned char *pubkey, int pubkeylen, const unsigned char *tweak) {    DEBUG_CHECK(secp256k1_ecmult_consts != NULL);    DEBUG_CHECK(pubkey != NULL);    DEBUG_CHECK(tweak != NULL);    int ret = 1;    secp256k1_num_t factor;    secp256k1_num_init(&factor);    secp256k1_num_set_bin(&factor, tweak, 32);    if (secp256k1_num_is_zero(&factor))        ret = 0;    if (secp256k1_num_cmp(&factor, &secp256k1_ge_consts->order) >= 0)        ret = 0;    secp256k1_ge_t p;    if (ret) {        if (!secp256k1_ecdsa_pubkey_parse(&p, pubkey, pubkeylen))            ret = 0;    }    if (ret) {        secp256k1_num_t zero;        secp256k1_num_init(&zero);        secp256k1_num_set_int(&zero, 0);        secp256k1_gej_t pt;        secp256k1_gej_set_ge(&pt, &p);        secp256k1_ecmult(&pt, &pt, &factor, &zero);        secp256k1_num_free(&zero);        secp256k1_ge_set_gej(&p, &pt);        int oldlen = pubkeylen;        secp256k1_ecdsa_pubkey_serialize(&p, pubkey, &pubkeylen, oldlen <= 33);        VERIFY_CHECK(pubkeylen == oldlen);    }    secp256k1_num_free(&factor);    return ret;}

int secp256k1_ecdsa_verify(const unsigned char *msg, int msglen, const unsigned char *sig, int siglen, const unsigned char *pubkey, int pubkeylen) {    DEBUG_CHECK(secp256k1_ecmult_consts != NULL);    DEBUG_CHECK(msg != NULL);    DEBUG_CHECK(msglen <= 32);    DEBUG_CHECK(sig != NULL);    DEBUG_CHECK(pubkey != NULL);    int ret = -3;    secp256k1_num_t m;     secp256k1_num_init(&m);    secp256k1_ecdsa_sig_t s;    secp256k1_ecdsa_sig_init(&s);    secp256k1_ge_t q;    secp256k1_num_set_bin(&m, msg, msglen);    if (!secp256k1_ecdsa_pubkey_parse(&q, pubkey, pubkeylen)) {        ret = -1;        goto end;    }    if (!secp256k1_ecdsa_sig_parse(&s, sig, siglen)) {        ret = -2;        goto end;    }    if (!secp256k1_ecdsa_sig_verify(&s, &q, &m)) {        ret = 0;        goto end;    }    ret = 1;end:    secp256k1_ecdsa_sig_free(&s);    secp256k1_num_free(&m);    return ret;}

int secp256k1_ecdsa_privkey_tweak_add(unsigned char *seckey, const unsigned char *tweak) {    DEBUG_CHECK(seckey != NULL);    DEBUG_CHECK(tweak != NULL);    int ret = 1;    secp256k1_num_t term;    secp256k1_num_init(&term);    secp256k1_num_set_bin(&term, tweak, 32);    if (secp256k1_num_cmp(&term, &secp256k1_ge_consts->order) >= 0)        ret = 0;    secp256k1_num_t sec;    secp256k1_num_init(&sec);    if (ret) {        secp256k1_num_set_bin(&sec, seckey, 32);        secp256k1_num_add(&sec, &sec, &term);        secp256k1_num_mod(&sec, &secp256k1_ge_consts->order);        if (secp256k1_num_is_zero(&sec))            ret = 0;    }    if (ret)        secp256k1_num_get_bin(seckey, 32, &sec);    secp256k1_num_clear(&sec);    secp256k1_num_clear(&term);    secp256k1_num_free(&sec);    secp256k1_num_free(&term);    return ret;}

int secp256k1_ecdsa_pubkey_tweak_add(unsigned char *pubkey, int pubkeylen, const unsigned char *tweak) {    DEBUG_CHECK(secp256k1_ecmult_consts != NULL);    DEBUG_CHECK(pubkey != NULL);    DEBUG_CHECK(tweak != NULL);    int ret = 1;    secp256k1_num_t term;    secp256k1_num_init(&term);    secp256k1_num_set_bin(&term, tweak, 32);    if (secp256k1_num_cmp(&term, &secp256k1_ge_consts->order) >= 0)        ret = 0;    secp256k1_ge_t p;    if (ret) {        if (!secp256k1_ecdsa_pubkey_parse(&p, pubkey, pubkeylen))            ret = 0;    }    if (ret) {        secp256k1_gej_t pt;        secp256k1_gej_set_ge(&pt, &p);        secp256k1_num_t one;        secp256k1_num_init(&one);        secp256k1_num_set_int(&one, 1);        secp256k1_ecmult(&pt, &pt, &one, &term);        secp256k1_num_free(&one);        if (secp256k1_gej_is_infinity(&pt))            ret = 0;        secp256k1_ge_set_gej(&p, &pt);        int oldlen = pubkeylen;        secp256k1_ecdsa_pubkey_serialize(&p, pubkey, &pubkeylen, oldlen <= 33);        VERIFY_CHECK(pubkeylen == oldlen);    }    secp256k1_num_free(&term);    return ret;}

void free_db_conn (db_t * db){	DEBUG_CHECK(db->flags & DB_FLAG_EMPTY, "Freeing DB connection that is already freed/n");	DEBUG_CHECK(!dbConnUsed, "Freeing DB connection when dbConnUsed == 0/n");	dbConnUsed--;	db->flags |= DB_FLAG_EMPTY;}

/* * Read something back in from swap.  Return the size. *   blockp    - a pointer to what will hold the block read in *   loc       - position in the swap file to read from */static intswap_in(char **  blockp, int  loc){    int size;    DEBUG_CHECK(!blockp, "blockp null in swap_in()/n");        if (loc == -1)	return 0;    swap_seek(loc, 0);#ifdef SWAP_USE_FD    /* find out size */    if (read(swap_file, &size, sizeof size) == -1)        fatal("Couldn't read the swap file./n");    DEBUG_CHECK(size <= 0, "Illegal size read from swap file./n");    *blockp = DXALLOC(size, TAG_SWAP, "swap_in");    if (read(swap_file, *blockp, size) == -1)        fatal("Couldn't read the swap file./n");#else    /* find out size */    if (fread((char *) &size, sizeof size, 1, swap_file) == -1)	fatal("Couldn't read the swap file./n");    DEBUG_CHECK(size <= 0, "Illegal size read from swap file./n");    *blockp = DXALLOC(size, TAG_SWAP, "swap_in");    if (fread(*blockp, size, 1, swap_file) == -1)	fatal("Couldn't read the swap file./n");#endif    total_bytes_swapped -= size;    return size;}

int secp256k1_ec_pubkey_verify(const secp256k1_context_t* ctx, const unsigned char *pubkey, int pubkeylen) {    secp256k1_ge_t q;    DEBUG_CHECK(ctx != NULL);    DEBUG_CHECK(pubkey != NULL);    (void)ctx;    return secp256k1_eckey_pubkey_parse(&q, pubkey, pubkeylen);}

int secp256k1_ecdsa_pubkey_compress(unsigned char *pubkey, int *pubkeylen) {    DEBUG_CHECK(pubkey != NULL);    DEBUG_CHECK(pubkeylen != NULL);    secp256k1_ge_t p;    if (!secp256k1_ecdsa_pubkey_parse(&p, pubkey, *pubkeylen))        return 0;    secp256k1_ecdsa_pubkey_serialize(&p, pubkey, pubkeylen, 1);    return 1;}

int secp256k1_ecdsa_privkey_import(unsigned char *seckey, const unsigned char *privkey, int privkeylen) {    DEBUG_CHECK(seckey != NULL);    DEBUG_CHECK(privkey != NULL);    secp256k1_num_t key;    secp256k1_num_init(&key);    int ret = secp256k1_ecdsa_privkey_parse(&key, privkey, privkeylen);    if (ret)        secp256k1_num_get_bin(seckey, 32, &key);    secp256k1_num_free(&key);    return ret;}

int secp256k1_ecdsa_privkey_export(const unsigned char *seckey, unsigned char *privkey, int *privkeylen, int compressed) {    DEBUG_CHECK(seckey != NULL);    DEBUG_CHECK(privkey != NULL);    DEBUG_CHECK(privkeylen != NULL);    secp256k1_num_t key;    secp256k1_num_init(&key);    secp256k1_num_set_bin(&key, seckey, 32);    int ret = secp256k1_ecdsa_privkey_serialize(privkey, privkeylen, &key, compressed);    secp256k1_num_free(&key);    return ret;}

/*This function reads images in to a vector.  That vector is then mean subtractedand then projected onto an optimal basis (PCA, LDA or LPP). Returned is a matrixthat contains the images after they have been projected onto the subspace.*/MatrixreadAndProjectImages (Subspace *s, char *imageNamesFile, char *imageDirectory, int *numImages, ImageList **srt){    int i, j;    Matrix images, vector, smallVector;    char name[FILE_LINE_LENGTH];    ImageList *subject, *replicate;    DEBUG(1, "Reading training file names from file");    *srt = getImageNames(imageNamesFile, numImages);    DEBUG_CHECK(*srt, "Error: header no imagenames found in file image list file");    /* Automatically determine number of pixels in images    */    sprintf(name, "%s/%s", imageDirectory, (*srt)->filename);    DEBUG(1, "Autodetecting number of pixels, i.e. vector length based on the size of image 0.");    DEBUG_CHECK (autoFileLength(name) == s->numPixels, "Images sizes do not match subspace basis vector size");    DEBUG_INT(1, "Vector length", s->numPixels);    DEBUG_CHECK(s->numPixels > 0, "Error positive value required for a Vector Length");    /*Images stored in the columns of a matrix */    DEBUG(1, "Allocating image matrix");    images = makeMatrix(s->basis->col_dim, *numImages);    vector = makeMatrix(s->numPixels, 1);    i = 0;    for (subject = *srt; subject; subject = subject->next_subject) {        for (replicate = subject; replicate; replicate = replicate->next_replicate) {            if (debuglevel > 0)                printf("%s ", replicate->filename);            sprintf(name, "%s/%s", imageDirectory, replicate->filename);            replicate->imageIndex = i;            readFile(name, 0, vector);            writeProgress("Reading images", i,*numImages);            smallVector = centerThenProjectImages(s, vector);            /* Copy the smaller vector into the image matrix*/            for (j = 0; j < smallVector->row_dim; j++) {                ME(images, j, i) = ME(smallVector, j, 0);            }            freeMatrix(smallVector);            i++;  /* increament the image index */        }        if (debuglevel > 0)            printf("/n");    }    return images;}

int secp256k1_ec_pubkey_decompress(const secp256k1_context_t* ctx, unsigned char *pubkey, int *pubkeylen) {    secp256k1_ge_t p;    int ret = 0;    DEBUG_CHECK(pubkey != NULL);    DEBUG_CHECK(pubkeylen != NULL);    (void)ctx;    if (secp256k1_eckey_pubkey_parse(&p, pubkey, *pubkeylen)) {        ret = secp256k1_eckey_pubkey_serialize(&p, pubkey, pubkeylen, 0);    }    return ret;}

int secp256k1_ec_seckey_verify(const secp256k1_context_t* ctx, const unsigned char *seckey) {    secp256k1_scalar_t sec;    int ret;    int overflow;    DEBUG_CHECK(ctx != NULL);    DEBUG_CHECK(seckey != NULL);    (void)ctx;    secp256k1_scalar_set_b32(&sec, seckey, &overflow);    ret = !secp256k1_scalar_is_zero(&sec) && !overflow;    secp256k1_scalar_clear(&sec);    return ret;}

int secp256k1_ec_privkey_import(const secp256k1_context_t* ctx, unsigned char *seckey, const unsigned char *privkey, int privkeylen) {    secp256k1_scalar_t key;    int ret = 0;    DEBUG_CHECK(seckey != NULL);    DEBUG_CHECK(privkey != NULL);    (void)ctx;    ret = secp256k1_eckey_privkey_parse(&key, privkey, privkeylen);    if (ret) {        secp256k1_scalar_get_b32(seckey, &key);    }    secp256k1_scalar_clear(&key);    return ret;}

int secp256k1_ec_privkey_export(const secp256k1_context_t* ctx, const unsigned char *seckey, unsigned char *privkey, int *privkeylen, int compressed) {    secp256k1_scalar_t key;    int ret = 0;    DEBUG_CHECK(seckey != NULL);    DEBUG_CHECK(privkey != NULL);    DEBUG_CHECK(privkeylen != NULL);    DEBUG_CHECK(ctx != NULL);    DEBUG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));    secp256k1_scalar_set_b32(&key, seckey, NULL);    ret = secp256k1_eckey_privkey_serialize(&ctx->ecmult_gen_ctx, privkey, privkeylen, &key, compressed);    secp256k1_scalar_clear(&key);    return ret;}

bool CItem::Ship_Plank( bool fOpen ){	// IT_SHIP_PLANK to IT_SHIP_SIDE and IT_SHIP_SIDE_LOCKED	// This item is the ships plank.	CItemBase * pItemDef = Item_GetDef();	ITEMID_TYPE idState = (ITEMID_TYPE) RES_GET_INDEX( pItemDef->m_ttShipPlank.m_idState );	if ( ! idState )	{		// Broken ?		return( false );	}	if ( IsType(IT_SHIP_PLANK))	{		if ( fOpen )			return( true );	}	else	{		DEBUG_CHECK( IsType(IT_SHIP_SIDE) || IsType(IT_SHIP_SIDE_LOCKED));		if ( ! fOpen )			return( true );	}	SetID( idState );	Update();	return( true );}

bool ResourcePack::IsCorrectState(){	DEBUG_CHECK(minerals >= 0 && gas >= 0 && supply >= 0);	if (minerals >= 0 && gas >= 0 && supply >= 0)		return true;	return false;}

void c_return_zero() {    pop_n_elems(csp->num_local_variables);    sp++;    DEBUG_CHECK(sp != fp, "Bad stack at c_return/n");    *sp = const0;    pop_control_stack();}

void c_call(int  func, int  num_arg) {    function_t *funp;        func += function_index_offset;    /*     * Find the function in the function table. As the     * function may have been redefined by inheritance, we     * must look in the last table, which is pointed to by     * current_object.     */    DEBUG_CHECK(func >= current_object->prog->last_inherited +		current_object->prog->num_functions_defined,		"Illegal function index/n");        if (current_object->prog->function_flags[func] & FUNC_UNDEFINED)	error("Undefined function: %s/n", function_name(current_object->prog, func));    /* Save all important global stack machine registers */    push_control_stack(FRAME_FUNCTION);        caller_type = ORIGIN_LOCAL;    /* This assigment must be done after push_control_stack() */    current_prog = current_object->prog;    /*     * If it is an inherited function, search for the real     * definition.     */    csp->num_local_variables = num_arg + num_varargs;    num_varargs = 0;    funp = setup_new_frame(func);    csp->pc = pc;	/* The corrected return address */    call_program(current_prog, funp->address);}

/* Note that now, once the master object loads once, there is ALWAYS a * master object, so the only way this can fail is if the master object * hasn't loaded yet.  In that case, we return (svalue_t *)-1, and the * calling routine should let the check succeed. 失败只可能是还没有load进master  这像是在让master调用函数？   */svalue_t *apply_master_ob(int  fun, int  num_arg)	/* 将master应用起来？ */{    if (!master_ob) {        pop_n_elems(num_arg);	/* 只要master还没有load进来，就将栈清空？ */        return (svalue_t *)-1;    }    if (master_applies[fun].func) {		/* 这里会调用不同的函数，函数都在里边？ */#ifdef TRACE        if (TRACEP(TRACE_APPLY)) {            do_trace("master apply", master_applies[fun].func->name, "/n");        }#endif        DEBUG_CHECK(master_ob->flags & O_SWAPPED, "Master object swapped!/n");        call_direct(master_ob, master_applies[fun].index, ORIGIN_DRIVER, num_arg);	/* 像是在调用函数？ */        free_svalue(&apply_ret_value, "apply_master_ob");        apply_ret_value = *sp--;		/* 从栈中取出返回值 */        return &apply_ret_value;    } else {        pop_n_elems(num_arg);        return 0;    }}

bool isBasicLatinLetter(uint32_t cp) {  // 0-31: misc whitespace chars, hex tablet things  // 33-64: misc punc, digits, more misc punc  // 33 = '!''  // 54 = '6'  // 64 = '@'  if (cp <= 64) {    return false;  }  if (cp <= 96 && cp > 90) {    // lbracket, backslash, etc    return false;  }  // 122 = 'z'  if (cp > 122) {    DEBUG_CHECK(cp <= 127);    return false;  }  // remaining characters are letters  return true;}

/*** Reads a FERET nrm file** @param fn Filename* @param numpix Number of pixels to read* @returns An malloc'd array of floats*/float *readFeretRaster(const char *fn,  int numpix){    FILE *fp;    float* data;    fp = fopen(fn, "rb");    if (fp == NULL)    {        fprintf (stderr, "failed to open %s", fn);        exit(0);    }    data = (float*)malloc(sizeof(float)*numpix);    DEBUG_CHECK (data, "malloc failed");    if (!fread(data, sizeof(float), numpix, fp))    {        fprintf (stderr, "fread in readFeretRaster failed");        exit(0);    }    if (isMachineLittleEndian()) byteswap_4(data, numpix);    fclose(fp);    return data;}

/*** Reads all of the names in a file into an array of* strings. Each element of the array is a char pointer.** If nStrings is non-NULL, the number of strings is* returned in nStrings.** The array is always one larger than nStrings elements* long and the last element is a NULL.** @param fileName Name of file to read* @param nStrings Optional pointer to integer that will on return contain*                 the count of strings read from the file* @returns A NULL-terminated list of NULL-terminated strings*/ListOfStringsreadListOfStrings (const char *fileName, int *nStrings){    Tokenizer tok;    void *stringList = NULL;    FILE *f;    char *string;    ListOfStrings array;    size_t numStrings;    f = fopen (fileName, "r");    DEBUG_CHECK (f, "Unable to read file");    tokenizerInit (&tok, tokenizerStreamReader, f);    while (!tokenizerEndOfFile (&tok))    {        string = strdup (tokenizerGetWord (&tok));        listAccumulate (&stringList, &string, sizeof (unsigned char *));    }    fclose (f);    /* Add a terminating NULL */    string = NULL;    listAccumulate (&stringList, &string, sizeof (unsigned char *));    array = (ListOfStrings)listToArray (&stringList, sizeof (unsigned char *), &numStrings);    if (nStrings) *nStrings = numStrings - 1; /* Don't count the NULL */    return array;}

/* nonstatic, is used in mappings too */int sameval P2(svalue_t *, arg1, svalue_t *, arg2){    DEBUG_CHECK(!arg1 || !arg2, "Null pointer passed to sameval./n");    switch (arg1->type | arg2->type) {    case T_NUMBER:	return arg1->u.number == arg2->u.number;    case T_ARRAY:    case T_CLASS:	return arg1->u.arr == arg2->u.arr;    case T_STRING:	if (SVALUE_STRLEN_DIFFERS(arg1, arg2)) return 0;	return !strcmp(arg1->u.string, arg2->u.string);    case T_OBJECT:	return arg1->u.ob == arg2->u.ob;    case T_MAPPING:	return arg1->u.map == arg2->u.map;    case T_FUNCTION:	return arg1->u.fp == arg2->u.fp;    case T_REAL:	return arg1->u.real == arg2->u.real;    case T_BUFFER:	return arg1->u.buf == arg2->u.buf;    }    return 0;}

/* invert a matrix using Gaussian Elimination */Matrix invertRREF(Matrix m) {    int prealloc = alloc_matrix;    int i,j;    Matrix tmp = makeZeroMatrix(m->row_dim, m->col_dim*2);    Matrix inverse = makeMatrix(m->row_dim, m->col_dim);    DEBUG_CHECK(m->row_dim == m->col_dim,"Matrix can only be inverted if it is square");    /* build the tmp Matrix which will be passed to RREF */    for( i = 0; i < m->row_dim; i++) {        for( j = 0; j < m->col_dim; j++) {            ME(tmp,i,j) = ME(m,i,j);            if(i == j) {                ME(tmp,i,j+m->col_dim) = 1;            }        }    }    matrixRREF(tmp);    for( i = 0; i < m->row_dim; i++) {        for( j = 0; j < m->col_dim; j++) {            ME(inverse,i,j) = ME(tmp,i,j+m->col_dim);        }    }    freeMatrix(tmp);    if(prealloc != alloc_matrix - 1) {        printf("Error deallocating matricies <%s>: pre=%d post=%d",__FUNCTION__, prealloc, alloc_matrix);        exit(1);    }    return inverse;}

int secp256k1_ecdsa_sign_compact(const secp256k1_context_t* ctx, const unsigned char *msg32, unsigned char *sig64, const unsigned char *seckey, secp256k1_nonce_function_t noncefp, const void* noncedata, int *recid) {    secp256k1_ecdsa_sig_t sig;    secp256k1_scalar_t sec, non, msg;    int ret = 0;    int overflow = 0;    unsigned int count = 0;    DEBUG_CHECK(ctx != NULL);    DEBUG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));    DEBUG_CHECK(msg32 != NULL);    DEBUG_CHECK(sig64 != NULL);    DEBUG_CHECK(seckey != NULL);    if (noncefp == NULL) {        noncefp = secp256k1_nonce_function_default;    }    secp256k1_scalar_set_b32(&sec, seckey, &overflow);    /* Fail if the secret key is invalid. */    if (!overflow && !secp256k1_scalar_is_zero(&sec)) {        secp256k1_scalar_set_b32(&msg, msg32, NULL);        while (1) {            unsigned char nonce32[32];            ret = noncefp(nonce32, msg32, seckey, count, noncedata);            if (!ret) {                break;            }            secp256k1_scalar_set_b32(&non, nonce32, &overflow);            memset(nonce32, 0, 32);            if (!secp256k1_scalar_is_zero(&non) && !overflow) {                if (secp256k1_ecdsa_sig_sign(&ctx->ecmult_gen_ctx, &sig, &sec, &msg, &non, recid)) {                    break;                }            }            count++;        }        if (ret) {            secp256k1_scalar_get_b32(sig64, &sig.r);            secp256k1_scalar_get_b32(sig64 + 32, &sig.s);        }        secp256k1_scalar_clear(&msg);        secp256k1_scalar_clear(&non);        secp256k1_scalar_clear(&sec);    }    if (!ret) {        memset(sig64, 0, 64);    }    return ret;}

void c_foreach(int  flags, int  idx1, int  idx2) {    IF_DEBUG(stack_in_use_as_temporary++);        if (flags & FOREACH_MAPPING) {	CHECK_TYPES(sp, T_MAPPING, 2, F_FOREACH);		push_refed_array(mapping_indices(sp->u.map));	STACK_INC;	sp->type = T_NUMBER;	sp->u.lvalue = (sp-1)->u.arr->item;	sp->subtype = (sp-1)->u.arr->size;		    	STACK_INC;	sp->type = T_LVALUE;	if (flags & FOREACH_LEFT_GLOBAL) {	    sp->u.lvalue = &current_object->variables[idx1 + variable_index_offset];	} else {	    sp->u.lvalue = fp + idx1;	}    } else     if (sp->type == T_STRING) {	STACK_INC;	sp->type = T_NUMBER;	sp->u.lvalue_byte = (unsigned char *)((sp-1)->u.string);	sp->subtype = SVALUE_STRLEN(sp - 1);    } else {	CHECK_TYPES(sp, T_ARRAY, 2, F_FOREACH);	STACK_INC;	sp->type = T_NUMBER;	sp->u.lvalue = (sp-1)->u.arr->item;	sp->subtype = (sp-1)->u.arr->size;    }    if (flags & FOREACH_RIGHT_GLOBAL) {	STACK_INC;	sp->type = T_LVALUE;	sp->u.lvalue = &current_object->variables[idx2 + variable_index_offset];    } else if (flags & FOREACH_REF) {	ref_t *ref = make_ref();	svalue_t *loc = fp + idx2;	/* foreach guarantees our target remains valid */	ref->lvalue = 0;	ref->sv.type = T_NUMBER;	STACK_INC;	sp->type = T_REF;	sp->u.ref = ref;	DEBUG_CHECK(loc->type != T_NUMBER && loc->type != T_REF, "Somehow a reference in foreach acquired a value before coming into scope");	loc->type = T_REF;	loc->u.ref = ref;	ref->ref++;    } else {	STACK_INC;	sp->type = T_LVALUE;	sp->u.lvalue = fp + idx2;    }}