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

bool videoInputCamera::setSizeAndSubtype() {	//store current mediatype	AM_MEDIA_TYPE * tmpType = NULL;	HRESULT	hr = pStreamConfig->GetFormat(&tmpType);	if(hr != S_OK)return false;	VIDEOINFOHEADER *lpVih =  reinterpret_cast<VIDEOINFOHEADER*>(pAmMediaType->pbFormat);	HEADER(lpVih)->biWidth  = cfg->cam_width;	HEADER(lpVih)->biHeight = cfg->cam_height;	pAmMediaType->formattype = FORMAT_VideoInfo;	pAmMediaType->majortype  = MEDIATYPE_Video;	pAmMediaType->subtype	 = getMediaSubtype(cfg->cam_format);	//buffer size	pAmMediaType->lSampleSize = cfg->cam_width* cfg->cam_height*3;	//set fps if requested	lpVih->AvgTimePerFrame = (unsigned long)(10000000 /  cfg->cam_fps);	//okay lets try new size	hr = pStreamConfig->SetFormat(pAmMediaType);	if(hr == S_OK){		if( tmpType != NULL )deleteMediaType(tmpType);		return true;	}else{		pStreamConfig->SetFormat(tmpType);		if( tmpType != NULL )deleteMediaType(tmpType);	}	return false;}

/* sort the IDE block as per the typelib spec: IID order, unresolved first */static voidsort_ide_block(TreeState *state){    XPTInterfaceDirectoryEntry *ide;    int i;    /* boy, I sure hope qsort works correctly everywhere */#ifdef DEBUG_shaver_sort    fputs("before sort:/n", stderr);    for (i = 0; i < IFACES(state); i++) {        fputs("  ", stderr);        print_IID(&HEADER(state)->interface_directory[i].iid, stderr);        fputc('/n', stderr);    }#endif    qsort(HEADER(state)->interface_directory, IFACES(state),          sizeof(*ide), compare_IDEs);#ifdef DEBUG_shaver_sort    fputs("after sort:/n", stderr);    for (i = 0; i < IFACES(state); i++) {        fputs("  ", stderr);        print_IID(&HEADER(state)->interface_directory[i].iid, stderr);        fputc('/n', stderr);    }#endif    for (i = 0; i < IFACES(state); i++) {        ide = HEADER(state)->interface_directory + i;        g_hash_table_insert(IFACE_MAP(state), ide->name, (void *)(i + 1));    }    return;}

rt_public EIF_BOOLEAN eequal(register EIF_REFERENCE target, register EIF_REFERENCE source){	/* Eiffel standard equality: it assumes that dynamic type of Eiffel	 * object refered by `source' conforms to dynamic type of Eiffel	 * object refered by `target'. `source' and `target' cannot be NULL	 * or special objects here.	 * If both `source' and `target' have the same dynamic type and this	 * type is not composite, then perform a block comparison; otherwise	 * perform a field by field comparison.	 * It is the feature `standard_is_equal' of class ANY.	 * Return a boolean.	 */	REQUIRE ("source_not_null", source);	REQUIRE ("target_not_null", target);	if (source == target) {			/* Minor optimization, if references are equal then it is the same object. */		return EIF_TRUE;	}	if (Dftype(source) == Dftype(target)) {		/* Dynamic type are the same: because of the intra-expanded		 * references, we can perform only a block comparison if		 * the target (or the source) is a composite object (i.e: it has		 * expanded attributes): since an attribute keeps expanded or		 * not expanded all the time, we can test either the source or		 * the target.		 */		if (HEADER(source)->ov_flags & EO_SPEC) {				/* Works for both SPECIAL and TUPLE object */				/* Eiffel standard equality on special objects: type check assumes				* the comparison is on areas of the same type (containing the same				* thing). Called by the redefinition of feature `equal' of special				* class. `source' and/or `target' cannot be NULL.				* Return a boolean.				*/				/* First condition: same count */			if				((RT_SPECIAL_COUNT(source) != RT_SPECIAL_COUNT(target)) ||				(RT_SPECIAL_ELEM_SIZE(source) != RT_SPECIAL_ELEM_SIZE(target)))			{				return EIF_FALSE;			} else {					/* Second condition: block equality */				return EIF_TEST(!memcmp (source, target, RT_SPECIAL_VISIBLE_SIZE(source)));			}		} else {			if (!(HEADER(source)->ov_flags & EO_COMP))	/* Perform a block comparison */				return EIF_TEST(!memcmp (source, target, EIF_Size(Dtype(source))));			else				return e_field_equal(target, source);		}	}	/* Field by field comparison */	return EIF_FALSE;}

gboolean http_request_ok (http_request *h) {    guint hdr_len = http_get_hdr_len( h->buffer->str );    guint c_len;    if (hdr_len != 0) {	if(CONFd("Verbosity") >= 8) g_warning( "http_request_ok: hdr_len %d", hdr_len );	if ( HEADER("Content-length") && (c_len=atoi(HEADER("Content-length")) <= (h->buffer->len - hdr_len)) ) {	    if(CONFd("Verbosity") >= 8) g_warning( "http_request_ok: Parsing query from HTTP-Content." );	    http_parse_query( h, &(h->buffer->str[hdr_len]) );	    h->complete++;	    if(CONFd("Verbosity") >= 8) g_warning( "http_request_ok: Query parsing finished, exiting." );	    return TRUE;	}	else if (HEADER("Content-length") && (CONFd("Verbosity") >= 8))             g_warning( "http_request_ok: HEADER was OK, but CONTENT reading failed." );	else if(CONFd("Verbosity") >= 8)             g_warning( "http_request_ok: No Content-length header, parsing query from URI." );	http_parse_query( h, NULL );	if (!h->query) {          if (CONFd("Verbosity") >= 8) g_message("http_request_ok: No QUERY found.");        }	else if (CONFd("Verbosity") >= 8) {	    GString *z;            z = g_hash_as_string( h->query );            g_debug( "http_request_ok: Query: %s", z->str );            g_string_free(z, 1);        }	h->complete++;	if(CONFd("Verbosity") >= 8) g_warning( "http_request_ok: Query parsing finished, exiting." );	return TRUE;    }    if(CONFd("Verbosity") >= 6) g_warning( "http_request_ok: Request not HTTP: <CR><LF><CR><LF> (header_end) NOT found" );    return FALSE;}

rt_public void eif_std_ref_copy(register EIF_REFERENCE source, register EIF_REFERENCE target){    /* Copy Eiffel object `source' into Eiffel object `target'.     * Dynamic type of `source' is supposed to be the same as dynamic type     * of `target'. It assumes also that `source' and `target' are not     * references on special objects.     * Problem: updating intra-references on expanded object     * because the garbage collector needs to explore those references.     */    uint16 flags;			/* Source object flags */    union overhead *s_zone;	/* Source object header */    union overhead *t_zone;	/* Target object header */#ifdef ISE_GC    EIF_REFERENCE enclosing;					/* Enclosing target object */#endif    rt_uint_ptr size;    s_zone = HEADER(source);    flags = s_zone->ov_flags;    t_zone = HEADER(target);    if (s_zone->ov_dftype == t_zone->ov_dftype) {        if (flags & EO_COMP) {            /* Case of composite object: updating of references on expanded objects. */            eif_std_field_copy (source, target);        } else {            /* Copy of source object into target object with same dynamic type. Block copy here. */            if (flags & EO_SPEC) {                size = RT_SPECIAL_VISIBLE_SIZE(source);            } else {                size = EIF_Size(s_zone->ov_dtype);            }            memmove(target, source, size);        }#ifdef ISE_GC        /* Precompute the enclosing target object */        enclosing = target;					/* By default */        if (eif_is_nested_expanded(t_zone->ov_flags)) {            enclosing -= t_zone->ov_size & B_SIZE;        }        /* Perform aging tests. We need the address of the enclosing object to         * update the flags there, in case the target is to be memorized.         */        flags = HEADER(enclosing)->ov_flags;        CHECK ("Not forwarded", !(HEADER (enclosing)->ov_size & B_FWD));        if (            flags & EO_OLD &&			/* Object is old */            !(flags & EO_REM)	&&		/* Not remembered */            refers_new_object(target)	/* And copied refers to new objects */        )            erembq(enclosing);			/* Then remember the enclosing object */#endif /* ISE_GC */    }}

void cm_TRC_traceLoadMap(        t_nmfTraceComponentCommandDescription command,        const t_component_instance* component){    if(cm_trace_enabled)    {        struct t_nmfTraceComponent   trace;        /*         * Generate instantiate trace         */        trace.header.v = HEADER(TRACE_TYPE_COMPONENT, sizeof(trace));        trace.command = (t_uint16)command;        trace.domainId = (t_uint16)component->Template->dspId + 1;        trace.componentContext = (t_uint32)component->thisAddress;        trace.componentUserContext = (t_uint32)component;        cm_StringCopy((char*)trace.componentLocalName, component->pathname, MAX_COMPONENT_NAME_LENGTH);        cm_StringCopy((char*)trace.componentTemplateName, component->Template->name, MAX_TEMPLATE_NAME_LENGTH);        writeN((struct t_nmfTraceChannelHeader*)&trace);        if(command == TRACE_COMPONENT_COMMAND_ADD)        {            struct t_nmfTraceMethod tracemethod;            int i, j, k;            /*             * Generate method trace             */            tracemethod.header.v = HEADER(TRACE_TYPE_METHOD, sizeof(tracemethod));            tracemethod.domainId = (t_uint16)component->Template->dspId + 1;            tracemethod.componentContext = (t_uint32)component->thisAddress;            for(i = 0; i < component->Template->provideNumber; i++)            {                t_interface_provide* provide = &component->Template->provides[i];                t_interface_provide_loaded* provideLoaded = &component->Template->providesLoaded[i];                for(j = 0; j < provide->collectionSize; j++)                {                    for(k = 0; k < provide->interface->methodNumber; k++)                    {                        tracemethod.methodId = provideLoaded->indexesLoaded[j][k].methodAddresses;                        cm_StringCopy((char*)tracemethod.methodName, provide->interface->methodNames[k], MAX_INTERFACE_METHOD_NAME_LENGTH);                        writeN((struct t_nmfTraceChannelHeader*)&tracemethod);                    }                }            }        }    }}

rt_private void spcopy(register EIF_REFERENCE source, register EIF_REFERENCE target){    /* Copy a special Eiffel object into another one. It assumes that     * `source' and `target' are not NULL and that count of `target' is greater     * than count of `source'.     */    rt_uint_ptr field_size;    rt_uint_ptr t_count, s_count;#ifdef ISE_GC    uint16 flags;#endif    REQUIRE ("source not null", source);    REQUIRE ("target not null", target);    REQUIRE ("source is special", HEADER(source)->ov_flags & EO_SPEC);    REQUIRE ("target is special", HEADER(target)->ov_flags & EO_SPEC);    REQUIRE ("target_elem_size_identical", RT_SPECIAL_ELEM_SIZE(target) == RT_SPECIAL_ELEM_SIZE(source));    /* Because we can call copy with special/tuples of different size, we have to take the min size     * of the two objects to know exactly how much we are allowed to copy without causing a     * memory corruption. In case users actually call `copy' directly, not indirectly via `twin',     * the postcondition of `copy' will be violated, although it would have been better to have     * a precondition it is much better than memory corruption.*/    /* FIXME: Once `copy' is not exported anymore to ANY, but just TUPLE/SPECIAL then we will be able     * to add RT_SPECIAL_COUNT(target) == RT_SPECIAL_COUNT(source) as precondition of `spcopy'.*/    t_count = RT_SPECIAL_COUNT(target);    s_count = RT_SPECIAL_COUNT(source);    field_size = (t_count > s_count ? s_count : t_count) * (rt_uint_ptr) RT_SPECIAL_ELEM_SIZE (source);    memmove(target, source, field_size);			/* Block copy */#ifdef ISE_GC    /* Ok, normally we would have to perform age tests, by scanning the special     * object, looking for new objects. But a special object can be really big,     * and can also contain some expanded objects, which should be traversed     * to see if they contain any new objects. Ok, that's enough! This is a     * GC problem and is normally performed by the GC. So, if the special object     * is old and contains some references, I am automatically inserting it     * in the remembered set. The GC will remove it from there at the next     * cycle, if necessary--RAM.     */    flags = HEADER(target)->ov_flags;    CHECK ("Not forwarded", !(HEADER (target)->ov_flags & B_FWD));    if ((flags & (EO_REF | EO_OLD | EO_REM)) == (EO_OLD | EO_REF))        /* May it hold new references? */        eremb(target);	/* Remember it, even if not needed, to fasten								copying process. */#endif /* ISE_GC */}

static void lynx_image_info(imgtool_image *img, char *string, const int len){	lynx_image *image=(lynx_image*)img;	char dostext_with_null[33]= { 0 };	char name_with_null[25]={ 0 };	strncpy(dostext_with_null, HEADER(image)->dostext, 32);	strncpy(name_with_null, HEADER(image)->description, 24);	sprintf(string,"%s/n%s/nversion:%.4x max entries:%d",			dostext_with_null,			name_with_null, 			GET_UWORD(HEADER(image)->version),			HEADER(image)->max_entries);}

/** * Initializes a DChat V1 structure containing all available and * supported headers of the DChat V1 protocol. * The given structure will be initialized with all headers * available. The header IDs and names will be set and function addresses * pointing to corresponding value parsers will be set too. * @param proto * @return 0 if structure has been initialized successfully, -1 otherwise */intinit_dchat_v1(dchat_v1_t* proto){    int temp_size;    int proto_size;    // available headers    dchat_header_t temp[] =    {        HEADER(HDR_ID_VER, HDR_NAME_VER, 1, ver_str_to_pdu, ver_pdu_to_str),        HEADER(HDR_ID_CTT, HDR_NAME_CTT, 1, ctt_str_to_pdu, ctt_pdu_to_str),        HEADER(HDR_ID_CTL, HDR_NAME_CTL, 1, ctl_str_to_pdu, ctl_pdu_to_str),        HEADER(HDR_ID_ONI, HDR_NAME_ONI, 1, oni_str_to_pdu, oni_pdu_to_str),        HEADER(HDR_ID_LNP, HDR_NAME_LNP, 1, lnp_str_to_pdu, lnp_pdu_to_str),        HEADER(HDR_ID_NIC, HDR_NAME_NIC, 0, nic_str_to_pdu, nic_pdu_to_str),        HEADER(HDR_ID_DAT, HDR_NAME_DAT, 0, dat_str_to_pdu, dat_pdu_to_str),        HEADER(HDR_ID_SRV, HDR_NAME_SRV, 0, srv_str_to_pdu, srv_pdu_to_str)    };    temp_size = sizeof(temp) / sizeof(temp[0]);    if (temp_size > HDR_AMOUNT)    {        return -1;    }    memset(proto, 0, sizeof(*proto));    memcpy(proto->header, &temp, sizeof(temp));    return 0;}

static gbooleantypelib_prolog(TreeState *state){    state->priv = calloc(1, sizeof(struct priv_data));    if (!state->priv)        return FALSE;    IFACES(state) = 0;    IFACE_MAP(state) = g_hash_table_new(g_str_hash, g_str_equal);    if (!IFACE_MAP(state)) {        /* XXX report error */        free(state->priv);        return FALSE;    }    /* find all interfaces, top-level and referenced by others */    IDL_tree_walk_in_order(state->tree, find_interfaces, state);    ARENA(state) = XPT_NewArena(1024, sizeof(double), "main xpidl arena");    HEADER(state) = XPT_NewHeader(ARENA(state), IFACES(state),                                   major_version, minor_version);    /* fill IDEs from hash table */    IFACES(state) = 0;    g_hash_table_foreach_remove(IFACE_MAP(state), fill_ide_table, state);    /* if any are left then we must have failed in fill_ide_table */    if (g_hash_table_size(IFACE_MAP(state)))        return FALSE;    /* sort the IDEs by IID order and store indices in the interface map */    sort_ide_block(state);    return TRUE;}

static int FUNC(extension_data)(CodedBitstreamContext *ctx, RWContext *rw,                                MPEG2RawExtensionData *current){    int err;    HEADER("Extension Data");    ui(8, extension_start_code);    ui(4, extension_start_code_identifier);    switch (current->extension_start_code_identifier) {    case 1:        return FUNC(sequence_extension)            (ctx, rw, &current->data.sequence);    case 2:        return FUNC(sequence_display_extension)            (ctx, rw, &current->data.sequence_display);    case 3:        return FUNC(quant_matrix_extension)            (ctx, rw, &current->data.quant_matrix);    case 7:        return FUNC(picture_display_extension)            (ctx, rw, &current->data.picture_display);    case 8:        return FUNC(picture_coding_extension)            (ctx, rw, &current->data.picture_coding);    default:        av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid extension ID %d./n",               current->extension_start_code_identifier);        return AVERROR_INVALIDDATA;    }}

static void deletefree(void *currblock) {  int listcounter = 0;  size_t size = GETSIZE(HEADER(currblock));    for (;(listcounter < LISTS - 1) && (size > 1); listcounter++) {    size >>= 1;  }    if (PREVFREE(currblock) != NULL) {    if (NEXTFREE(currblock) != NULL) {      SETPTR(NEXTPTR(PREVFREE(currblock)), NEXTFREE(currblock));      SETPTR(PREVPTR(NEXTFREE(currblock)), PREVFREE(currblock));    } else {      SETPTR(NEXTPTR(PREVFREE(currblock)), NULL);      free_lists[listcounter] = PREVFREE(currblock);    }  } else {    if (NEXTFREE(currblock) != NULL) {      SETPTR(PREVPTR(NEXTFREE(currblock)), NULL);    } else {      free_lists[listcounter] = NULL;    }  }    return;}

	void Connection::ReadPacket()	{		if(Errors())			return;						/** Handle Reading Packet Type Header. **/		if(SOCKET->available() > 0 && INCOMING->GetHeader() == 255)		{			std::vector<unsigned char> HEADER(1, 255);			if(Read(HEADER, 1) == 1)				INCOMING->SetHeader(HEADER[0]);								return;		}						if(INCOMING->GetHeader() != 255 && !INCOMING->Complete())		{						/** Handle Reading Packet Length Header. **/			if(SOCKET->available() >= 4 && INCOMING->GetLength() == 0)			{				std::vector<unsigned char> BYTES(4, 0);				if(Read(BYTES, 4) == 4)				{					INCOMING->SetLength(BYTES);					Event(0);				}									return;			}								/** Handle Reading Packet Data. **/			unsigned int nAvailable = SOCKET->available();			if(nAvailable > 0 && INCOMING->GetLength() > 0 && INCOMING->GetData().size() < INCOMING->GetLength())			{				std::vector<unsigned char> DATA( std::min(nAvailable, (unsigned int)(INCOMING->GetLength() - INCOMING->GetData().size())), 0);				unsigned int nRead = Read(DATA, DATA.size());									if(nRead == DATA.size())				{					std::vector<unsigned char> dta = INCOMING->GetData();					try					{						dta.insert(dta.end(), DATA.begin(), DATA.end());					}					catch(const std::exception e)					{						return;					}					INCOMING->SetData(dta);					Event(nRead);				}									return;			}		}	}

void *mm_realloc(void *currblock, size_t size){  void *new_currblock = currblock;   size_t new_size = size;   int remainder;    int extendsize;   int block_buffer;   if (size == 0)    return NULL;    if (new_size <= DSIZE) {    new_size = 2 * DSIZE;  } else {    new_size = DSIZE * ((new_size + (DSIZE) + (DSIZE - 1)) / DSIZE);  }    new_size += 16;    block_buffer = GETSIZE(HEADER(currblock)) - new_size;    if (block_buffer < 0) {    if (!FULL(HEADER(NEXT(currblock))) || !GETSIZE(HEADER(NEXT(currblock)))) {      remainder = GETSIZE(HEADER(currblock)) + GETSIZE(HEADER(NEXT(currblock))) - new_size;      if (remainder < 0) {        extendsize = ((-remainder)>CHUNKSIZE?(-remainder):CHUNKSIZE);        if (extend_heap(extendsize) == NULL)          return NULL;        remainder += extendsize;      }            deletefree(NEXT(currblock));            CLEARTAG(HEADER(currblock), PACK(new_size + remainder, 1)); // Block header       CLEARTAG(FOOTER(currblock), PACK(new_size + remainder, 1)); // Block footer     } else {      new_currblock = mm_malloc(new_size - DSIZE);      line_count--;      memmove(new_currblock, currblock,((size)<new_size?(size):new_size));      mm_free(currblock);      line_count--;    }    block_buffer = GETSIZE(HEADER(new_currblock)) - new_size;  }    if (block_buffer < 2 * 16)    SETRTAG(HEADER(NEXT(new_currblock)));    line_count++;   if (MMCHECK) {    mm_check('r', currblock, size);     }    return new_currblock;}

void		OvMemoryPool::free_memory_debug(void* _memory){	OvMemHeader*	k_mem_header = NULL;	k_mem_header			=	HEADER(_memory);	k_mem_header->m_iLine	=	-1;	k_mem_header->m_pBlock	=	NULL;	k_mem_header->mNext		=	m_pFreeMemoryList;	m_pFreeMemoryList		=	k_mem_header;}

rt_private EIF_REFERENCE spclone(EIF_REFERENCE source){    /* Clone an of Eiffel object `source'. Assumes that source     * is a special object.     */    EIF_GET_CONTEXT    EIF_REFERENCE result;		/* Clone pointer */    union overhead *zone;		/* Pointer on source header */    uint16 flags;				/* Source object flags */    EIF_TYPE_INDEX dtype, dftype;    if ((EIF_REFERENCE) 0 == source)        return (EIF_REFERENCE) 0;				/* Void source */    RT_GC_PROTECT(source);			/* Protection against GC */    zone = HEADER(source);				/* Allocation of a new object */    flags = zone->ov_flags;    dtype = zone->ov_dtype;    dftype = zone->ov_dftype;    result = spmalloc(RT_SPECIAL_COUNT(source), RT_SPECIAL_ELEM_SIZE(source), EIF_TEST(!(flags & EO_REF)));    /* Keep the reference flag and the composite one and the type */    HEADER(result)->ov_flags |= flags & (EO_REF | EO_COMP);    HEADER(result)->ov_dtype = dtype;    HEADER(result)->ov_dftype = dftype;    /* Keep the count and the element size */    RT_SPECIAL_COUNT(result) = RT_SPECIAL_COUNT(source);    RT_SPECIAL_ELEM_SIZE(result) = RT_SPECIAL_ELEM_SIZE(source);    RT_SPECIAL_CAPACITY(result) = RT_SPECIAL_COUNT(source);    if (!egc_has_old_special_semantic) {        /* If by default allocation does not clear the data of a SPECIAL,         * we actually need to do clear it otherwise we end up with a SPECIAL         * object that is susceptible to be manipulated by the GC while waiting to         * be filled. */        memset(result, 0, RT_SPECIAL_VISIBLE_SIZE(result));    }    RT_GC_WEAN(source);				/* Remove GC protection */    return result;}

static void placeblock(void *currblock, size_t asize){  size_t currblock_size = GETSIZE(HEADER(currblock));  size_t remainder = currblock_size - asize;    deletefree(currblock);    if (remainder >= 16) {    PUT(HEADER(currblock), PACK(asize, 1));    PUT(FOOTER(currblock), PACK(asize, 1));    CLEARTAG(HEADER(NEXT(currblock)), PACK(remainder, 0));    CLEARTAG(FOOTER(NEXT(currblock)), PACK(remainder, 0));      insertfree(NEXT(currblock), remainder);  } else {    PUT(HEADER(currblock), PACK(currblock_size, 1));    PUT(FOOTER(currblock), PACK(currblock_size, 1));  }  return;}

Symbol raw_Symbol(const wchar_t* input){    uns_int size   = wcslen(input) + 1;    Symbol result  = NEW_ARRAYED(struct Symbol_t, wchar_t[size]);    HEADER(result) = Symbol_Class;    result->hash   = wchar_hash(input, size);    wcsncpy(result->value, input, size);    result->size   = size - 1;    return result;}

/* * This is the core of secret sharing.  This computes the coefficients * used in Lagrange polynomial interpolation, returning the * vector of logarithms of b1(xtarget), b2(xtarget), ..., bn(xtarget). * Takes values from the "xCoordinate" header element, inserts the * results in the "lagrange" header element. * The interpolation values come from the headers of the "shares" array, * plus one additional value, xInput, which is the value we are going * to interpolate to. *  * Returns kPGPError_OK on success, error if not all x[i] are unique. */	static PGPErrorsInterp(PGPByte *shares, PGPSize bodySize, PGPByte xInput, PGPUInt32 nShares){	PGPUInt32		i, j;	PGPByte			xi, xj;	PGPUInt32		numer, denom;#if !PGP_STATIC_SHAMIR_ARRAYS	s_FSetup();#endif /* !PGP_STATIC_SHAMIR_ARRAYS */	/* First, accumulate the numerator, Prod(xInput-x[i],i=0..n) */	numer = 0;	for (i = 0; i < nShares; i++)	{		xi = HEADER(shares,bodySize,i)->xCoordinate;		numer += f_log[ f_sub(xi, xInput) ];	}	/* Preliminary partial reduction */	numer = (numer%FIELD_SIZE) + (numer/FIELD_SIZE);	/* Then, for each coefficient, compute the corresponding denominator */	for (i = 0; i < nShares; i++) {		xi = HEADER(shares,bodySize,i)->xCoordinate;		denom = 0;		for (j = 0; j < nShares; j++) {			xj = (i == j) ? xInput : HEADER(shares,bodySize,j)->xCoordinate;			if (xi == xj)				return -1;			denom += f_log[f_sub(xi,xj)];		}		denom = (denom%FIELD_SIZE)+(denom/FIELD_SIZE);		/* 0 <= denom < 2*FIELD_SIZE-1. */		/* Now find numer/denom.  In log form, that's a subtract. */		denom = numer + 2*FIELD_SIZE-2 - denom;		denom = (denom%FIELD_SIZE)+(denom/FIELD_SIZE);		denom = (denom%FIELD_SIZE)+(denom/FIELD_SIZE);		HEADER(shares,bodySize,i)->lagrange = (PGPByte)denom;	}	return kPGPError_NoErr;	/* Success */}

static void *extend_heap(size_t size){  void *currblock;            size_t words = size / WSIZE;  size_t asize;    asize = (words % 2) ? (words + 1) * WSIZE : words * WSIZE;  if ((long)(currblock = mem_sbrk(asize)) == -1)    return NULL;    CLEARTAG(HEADER(currblock), PACK(asize, 0));   CLEARTAG(FOOTER(currblock), PACK(asize, 0));  CLEARTAG(HEADER(NEXT(currblock)), PACK(0, 1));    insertfree(currblock, asize);  return coalesce(currblock);}

void *mm_malloc(size_t size){  size_t asize;   void *currblock = NULL;    int listcounter = 0;     size_t checksize = size; // Copy of request size    if (size == 0)    return NULL;    if (size <= DSIZE) {    asize = 2 * DSIZE;  } else {    asize = DSIZE * ((size + DSIZE + DSIZE - 1) / DSIZE);  }    size = asize;  for (;listcounter < LISTS; listcounter++) {    if ((listcounter == LISTS - 1) || ((asize <= 1) && (free_lists[listcounter] != NULL))) {      currblock = free_lists[listcounter];      while ((currblock != NULL) && ((size > GETSIZE(HEADER(currblock))) || (RTAG(HEADER(currblock))))) {        currblock = PREVFREE(currblock);      }      if (currblock != NULL)        break;    }       asize >>= 1;  }    if (currblock == NULL) {    currblock = extend_heap(size);  }    placeblock(currblock, size);    line_count++;  if(MMCHECK)    mm_check('a', currblock, checksize);    return currblock;}

Array new_Array_raw(uns_int c){    if (c == 0)    {        return empty_Array;    }    Array result = NEW_ARRAYED(struct Array_t, Optr[c]);    HEADER(result) = Array_Class;    SET_SIZE(result, c);    return result;}

void mm_free(void *currblock){  size_t size = GETSIZE(HEADER(currblock)); // Size of block     UNSETRTAG(HEADER(NEXT(currblock)));    PUT(HEADER(currblock), PACK(size, 0));  PUT(FOOTER(currblock), PACK(size, 0));    insertfree(currblock, size);    coalesce(currblock);    line_count++;  if (MMCHECK) {    mm_check('f', currblock, size);  }  return;}