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

cs_err M680X_instprinter_init(cs_struct *ud){#ifndef CAPSTONE_DIET	if (M680X_REG_ENDING != ARR_SIZE(s_reg_names)) {		fprintf(stderr, "Internal error: Size mismatch in enum "			"m680x_reg and s_reg_names/n");		return CS_ERR_MODE;	}	if (M680X_INS_ENDING != ARR_SIZE(s_instruction_names)) {		fprintf(stderr, "Internal error: Size mismatch in enum "			"m680x_insn and s_instruction_names/n");		return CS_ERR_MODE;	}	if (M680X_GRP_ENDING != ARR_SIZE(s_group_names)) {		fprintf(stderr, "Internal error: Size mismatch in enum "			"m680x_group_type and s_group_names/n");		return CS_ERR_MODE;	}#endif	return CS_ERR_OK;}

// given internal insn id, return public instruction infovoid Sparc_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id){	unsigned short i;	i = insn_find(insns, ARR_SIZE(insns), id, &h->insn_cache);	if (i != 0) {		insn->id = insns[i].mapid;		if (h->detail) {#ifndef CAPSTONE_DIET			memcpy(insn->detail->regs_read, insns[i].regs_use, sizeof(insns[i].regs_use));			insn->detail->regs_read_count = (uint8_t)count_positive(insns[i].regs_use);			memcpy(insn->detail->regs_write, insns[i].regs_mod, sizeof(insns[i].regs_mod));			insn->detail->regs_write_count = (uint8_t)count_positive(insns[i].regs_mod);			memcpy(insn->detail->groups, insns[i].groups, sizeof(insns[i].groups));			insn->detail->groups_count = (uint8_t)count_positive8(insns[i].groups);			if (insns[i].branch || insns[i].indirect_branch) {				// this insn also belongs to JUMP group. add JUMP group				insn->detail->groups[insn->detail->groups_count] = SPARC_GRP_JUMP;				insn->detail->groups_count++;			}#endif			// hint code			for (i = 0; i < ARR_SIZE(insn_hints); i++) {				if (id == insn_hints[i].id) {					insn->detail->sparc.hint = insn_hints[i].hints;					break;				}			}		}	}}

// given internal insn id, return public instruction infovoid Mips_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id){	unsigned int i;	// consider alias insn first	for (i = 0; i < ARR_SIZE(alias_insns); i++) {		if (alias_insns[i].id == id) {			insn->id = alias_insns[i].mapid;			if (h->detail) {#ifndef CAPSTONE_DIET				memcpy(insn->detail->regs_read, alias_insns[i].regs_use, sizeof(alias_insns[i].regs_use));				insn->detail->regs_read_count = (uint8_t)count_positive(alias_insns[i].regs_use);				memcpy(insn->detail->regs_write, alias_insns[i].regs_mod, sizeof(alias_insns[i].regs_mod));				insn->detail->regs_write_count = (uint8_t)count_positive(alias_insns[i].regs_mod);				memcpy(insn->detail->groups, alias_insns[i].groups, sizeof(alias_insns[i].groups));				insn->detail->groups_count = (uint8_t)count_positive8(alias_insns[i].groups);				if (alias_insns[i].branch || alias_insns[i].indirect_branch) {					// this insn also belongs to JUMP group. add JUMP group					insn->detail->groups[insn->detail->groups_count] = MIPS_GRP_JUMP;					insn->detail->groups_count++;				}#endif			}			return;		}	}	i = insn_find(insns, ARR_SIZE(insns), id, &h->insn_cache);	if (i != 0) {		insn->id = insns[i].mapid;		if (h->detail) {#ifndef CAPSTONE_DIET			memcpy(insn->detail->regs_read, insns[i].regs_use, sizeof(insns[i].regs_use));			insn->detail->regs_read_count = (uint8_t)count_positive(insns[i].regs_use);			memcpy(insn->detail->regs_write, insns[i].regs_mod, sizeof(insns[i].regs_mod));			insn->detail->regs_write_count = (uint8_t)count_positive(insns[i].regs_mod);			memcpy(insn->detail->groups, insns[i].groups, sizeof(insns[i].groups));			insn->detail->groups_count = (uint8_t)count_positive8(insns[i].groups);			if (insns[i].branch || insns[i].indirect_branch) {				// this insn also belongs to JUMP group. add JUMP group				insn->detail->groups[insn->detail->groups_count] = MIPS_GRP_JUMP;				insn->detail->groups_count++;			}#endif		}	}}

/* * FormCmsTopn copies current count-min sketch and new top-n array into a new * CmsTopn. This function is called only when there is an update in top-n and it * only copies ArrayType part if allocated memory is enough for new ArrayType. * Otherwise, it allocates new memory and copies all CmsTopn. */static CmsTopn *FormCmsTopn(CmsTopn *cmsTopn, ArrayType *newTopnArray){	Size staticSize = sizeof(CmsTopn);	Size sketchSize = cmsTopn->sketchDepth * cmsTopn->sketchWidth * sizeof(Frequency);	Size sizeWithoutTopnArray = staticSize + sketchSize;	Size topnArrayReservedSize = VARSIZE(cmsTopn) - sizeWithoutTopnArray;	Size newTopnArraySize = ARR_SIZE(newTopnArray);	Size newCmsTopnSize = 0;	char *newCmsTopn = NULL;	char *topnArrayOffset = NULL;	/*	 * Check whether we have enough memory for new top-n array. If not, we need	 * to allocate more memory and copy CmsTopn and new top-n array.	 */	if (newTopnArraySize > topnArrayReservedSize)	{		Size newItemsReservedSize = 0;		Size newTopnArrayReservedSize = 0;		uint32 topnItemCount = cmsTopn->topnItemCount;		/*		 * Calculate average top-n item size in the new top-n array and use		 * two times of it for each top-n item while allocating new memory.		 */		Size averageTopnItemSize = (Size) (newTopnArraySize / topnItemCount);		Size topnItemSize = averageTopnItemSize * 2;		cmsTopn->topnItemSize = topnItemSize;		newItemsReservedSize = topnItemCount * topnItemSize;		newTopnArrayReservedSize = TOPN_ARRAY_OVERHEAD + newItemsReservedSize;		newCmsTopnSize = sizeWithoutTopnArray + newTopnArrayReservedSize;		newCmsTopn = palloc0(newCmsTopnSize);		/* first copy until to top-n array */		memcpy(newCmsTopn, (char *)cmsTopn, sizeWithoutTopnArray);		/* set size of new CmsTopn */		SET_VARSIZE(newCmsTopn, newCmsTopnSize);	}	else	{		newCmsTopn = (char *)cmsTopn;	}	/* finally copy new top-n array */	topnArrayOffset = ((char *) newCmsTopn) + sizeWithoutTopnArray;	memcpy(topnArrayOffset, newTopnArray, ARR_SIZE(newTopnArray));	return (CmsTopn *) newCmsTopn;}

int main(void){	int	array[] = {4,2,56,32,7,2,6,8,6,3,5,7};	int j, k, incr, n, tmp;	n = ARR_SIZE(array);	incr =  n / 2;	PRINT_OUT(array, k, n)	while( incr > 0 ) {		//printf("-/n");		for(j=incr; j<n; j++) {			k = j - incr;			//printf("+ k = %d k + incr = %d/n", k, k + incr);			while( k>=0 ) {				if ( array[k] > array[k + incr]) {					SWAP(array[k], array[k + incr], tmp)					k = k - incr;					//`printf("=/n");				} else {					k = -1;				}			}		} // for(i=incr+1; i<n; i++)		incr = incr / 2;	} // while( incr > 0 )	PRINT_OUT(array, k, n)	return 0;}

static void update_strategy(){  if (!showing_time){    Layer *root_window = window_get_root_layer(window_strategy);    srand(time(0));    char* text = strategies[rand() % ARR_SIZE(strategies)];    GRect bounds = layer_get_bounds(root_window);    text_layer = text_layer_create((GRect) { .origin = { 0, 0}, .size = { bounds.size.w, bounds.size.h } });

bool HTTPSourceMMIExtensionEventHandler::HTTPMMIEventQManager<T>::Peek( T& eventToRead){  bool bOk = false;  //Check if the queue is already empty, if not get the event from  //the queue  if (IsQEmpty())  {    QTV_MSG_PRIO( QTVDIAG_STREAMING, QTVDIAG_PRIO_MEDIUM,                  "MMIEventQManager - MMI event queue empty" );  }  else  {    (void)MM_CriticalSection_Enter(m_hEventQLock);    if (m_nEventReadIndex < ARR_SIZE(m_eventQ))    {      bOk = true;      eventToRead = m_eventQ[m_nEventReadIndex];      QTV_MSG_PRIO2( QTVDIAG_STREAMING, QTVDIAG_PRIO_MEDIUM,                     "MMIEventQManager - Peeked event from index %u, "                     "%u events remain", m_nEventReadIndex, m_nOutstandingEvents );    }    (void)MM_CriticalSection_Leave(m_hEventQLock);  }  return bOk;}

LRESULT CViewHexEdit::OnWmCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){     uMsg, wParam, lParam, bHandled; 	HRESULT hr = E_FAIL;    CREATESTRUCT * pCreateStruct = reinterpret_cast<CREATESTRUCT *>(lParam);     LRESULT lRet = S_OK;     lRet = DefWindowProc(uMsg, wParam, lParam);     {         CComPtr<IUnknown> punkCtrl;         CComVariant v;         OLECHAR szGUID[MAX_PATH] = { 0 };         StringFromGUID2(__uuidof(HexEditor::HexEdit), szGUID, ARR_SIZE(szGUID));         // Create the AX host window. And Create the HexEdit control using its GUID.         HWND hHost = m_wndAxHost.Create ( m_hWnd, rcDefault, szGUID, WS_CHILD | WS_VISIBLE ,             0, ID_DISPATCH_HEXEDIT ); 		hr = m_wndAxHost.QueryControl(&m_spHexEdit);		ATLASSERT( SUCCEEDED(hr) );        // Begin sinking events         AtlAdviseSinkMap ( this, true );     }     bHandled = FALSE;     return lRet; } 

void lcd_Redraw(){	uint_t i, nBus;	__packed uint32_t *pData, *pEnd;	uint32_t nData;	p_dev_spi p;	p = spi_Get(GUI_LCD_COMID, OS_TMO_FOREVER);	spi_Config(p, SPI_SCKIDLE_LOW, SPI_LATCH_1EDGE, 0);#if SPI_SEL_ENABLE	spi_CsSel(p, GUI_LCD_CSID);#endif	spi_Start(p);	sys_GpioSet(tbl_bspLcdCtrl[0] + 2, 0);	for (i = 0; i < ARR_SIZE(uc1698_tblParam); i++)		spi_SendChar(p, uc1698_tblParam[i]);	spi_SendChar(p, UC1698_SetBR | UC1698_Bias_10);	spi_SendChar(p, UC1698_SetPM);	spi_SendChar(p, 192);		sys_GpioSet(tbl_bspLcdCtrl[0] + 2, 1);	pData = (__packed uint32_t *)&gui_aBuf[0][0];	pEnd = (__packed uint32_t *)ARR_ENDADR(gui_aBuf);	for (; pData < pEnd; pData = (__packed uint32_t *)((uint8_t *)pData + 3)) {		nData = *pData;		for (i = 0; i < 24; i += 3, nData >>= 3) {			nBus = uc1698_tbl_map[nData & 0x07];			spi_SendChar(p, nBus >> 8);			spi_SendChar(p, nBus);		}	}	spi_End(p);	spi_Release(p);}

void ARM_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id){	int i = insn_find(insns, ARR_SIZE(insns), id, &h->insn_cache);	//printf(">> id = %u/n", id);	if (i != 0) {		insn->id = insns[i].mapid;		if (h->detail) {#ifndef CAPSTONE_DIET			cs_struct handle;			handle.detail = h->detail;			memcpy(insn->detail->regs_read, insns[i].regs_use, sizeof(insns[i].regs_use));			insn->detail->regs_read_count = (uint8_t)count_positive(insns[i].regs_use);			memcpy(insn->detail->regs_write, insns[i].regs_mod, sizeof(insns[i].regs_mod));			insn->detail->regs_write_count = (uint8_t)count_positive(insns[i].regs_mod);			memcpy(insn->detail->groups, insns[i].groups, sizeof(insns[i].groups));			insn->detail->groups_count = (uint8_t)count_positive8(insns[i].groups);			insn->detail->arm.update_flags = cs_reg_write((csh)&handle, insn, ARM_REG_CPSR);			if (insns[i].branch || insns[i].indirect_branch) {				// this insn also belongs to JUMP group. add JUMP group				insn->detail->groups[insn->detail->groups_count] = ARM_GRP_JUMP;				insn->detail->groups_count++;			}#endif		}	}}

// Hacky: enable all features for disassemblerstatic uint64_t Mips_getFeatureBits(int mode){	int i;	uint64_t Bits = 0;	for (i = 0; i < ARR_SIZE(MipsFeatureKV); i++) {		Bits |= MipsFeatureKV[i].Value;	}	// ref: MipsGenDisassemblerTables.inc::checkDecoderPredicate()	if (mode & CS_MODE_16) {		Bits -= Mips_FeatureMips32r2;		Bits -= Mips_FeatureMips32;		Bits -= Mips_FeatureFPIdx;		Bits -= Mips_FeatureBitCount;		Bits -= Mips_FeatureSwap;		Bits -= Mips_FeatureSEInReg;		Bits -= Mips_FeatureMips64r2;		// Bits -= Mips_FeatureFP64Bit;	// FIXME???	} else if (mode & CS_MODE_32) {		Bits -= Mips_FeatureMips16;		Bits -= Mips_FeatureMicroMips;		Bits -= Mips_FeatureFP64Bit;	} else if (mode & CS_MODE_64) {		Bits -= Mips_FeatureMips16;		Bits -= Mips_FeatureMicroMips;	}	return Bits;}

// map internal raw register to 'public' registersparc_reg Sparc_map_register(unsigned int r){	static const unsigned int map[] = { 0,		SPARC_REG_ICC, SPARC_REG_Y, SPARC_REG_F0, SPARC_REG_F2, SPARC_REG_F4,		SPARC_REG_F6, SPARC_REG_F8, SPARC_REG_F10, SPARC_REG_F12, SPARC_REG_F14,		SPARC_REG_F16, SPARC_REG_F18, SPARC_REG_F20, SPARC_REG_F22, SPARC_REG_F24,		SPARC_REG_F26, SPARC_REG_F28, SPARC_REG_F30, SPARC_REG_F32, SPARC_REG_F34,		SPARC_REG_F36, SPARC_REG_F38, SPARC_REG_F40, SPARC_REG_F42, SPARC_REG_F44,		SPARC_REG_F46, SPARC_REG_F48, SPARC_REG_F50, SPARC_REG_F52, SPARC_REG_F54,		SPARC_REG_F56, SPARC_REG_F58, SPARC_REG_F60, SPARC_REG_F62, SPARC_REG_F0,		SPARC_REG_F1, SPARC_REG_F2, SPARC_REG_F3, SPARC_REG_F4, SPARC_REG_F5,		SPARC_REG_F6, SPARC_REG_F7, SPARC_REG_F8, SPARC_REG_F9, SPARC_REG_F10,		SPARC_REG_F11, SPARC_REG_F12, SPARC_REG_F13, SPARC_REG_F14, SPARC_REG_F15,		SPARC_REG_F16, SPARC_REG_F17, SPARC_REG_F18, SPARC_REG_F19, SPARC_REG_F20,		SPARC_REG_F21, SPARC_REG_F22, SPARC_REG_F23, SPARC_REG_F24, SPARC_REG_F25,		SPARC_REG_F26, SPARC_REG_F27, SPARC_REG_F28, SPARC_REG_F29, SPARC_REG_F30,		SPARC_REG_F31, SPARC_REG_FCC0, SPARC_REG_FCC1, SPARC_REG_FCC2, SPARC_REG_FCC3,		SPARC_REG_G0, SPARC_REG_G1, SPARC_REG_G2, SPARC_REG_G3, SPARC_REG_G4,		SPARC_REG_G5, SPARC_REG_G6, SPARC_REG_G7, SPARC_REG_I0, SPARC_REG_I1,		SPARC_REG_I2, SPARC_REG_I3, SPARC_REG_I4, SPARC_REG_I5, SPARC_REG_FP,		SPARC_REG_I7, SPARC_REG_L0, SPARC_REG_L1, SPARC_REG_L2, SPARC_REG_L3,		SPARC_REG_L4, SPARC_REG_L5, SPARC_REG_L6, SPARC_REG_L7, SPARC_REG_O0,		SPARC_REG_O1, SPARC_REG_O2, SPARC_REG_O3, SPARC_REG_O4, SPARC_REG_O5,		SPARC_REG_SP, SPARC_REG_O7, SPARC_REG_F0, SPARC_REG_F4, SPARC_REG_F8,		SPARC_REG_F12, SPARC_REG_F16, SPARC_REG_F20, SPARC_REG_F24, SPARC_REG_F28,		SPARC_REG_F32, SPARC_REG_F36, SPARC_REG_F40, SPARC_REG_F44, SPARC_REG_F48,		SPARC_REG_F52, SPARC_REG_F56, SPARC_REG_F60,	};	if (r < ARR_SIZE(map))		return map[r];	// cannot find this register	return 0;}

const char *M680X_group_name(csh handle, unsigned int id){#ifndef CAPSTONE_DIET	return id2name(s_group_names, ARR_SIZE(s_group_names), id);#else	return NULL;#endif}

sparc_cc Sparc_map_FCC(const char *name){	unsigned int i;	i = name2id(alias_fcc_maps, ARR_SIZE(alias_fcc_maps), name);	return (i != -1)? i : SPARC_CC_INVALID;}

const char *BPF_group_name(csh handle, unsigned int id){#ifndef CAPSTONE_DIET	return id2name(group_name_maps, ARR_SIZE(group_name_maps), id);#else	return NULL;#endif}

void servo_setup(){	unsigned int idx;	for (idx = 0; idx < ARR_SIZE(servoPins); idx++) {		pinMode(servoPins[idx], OUTPUT);		pulseWidth[idx] = minPulse;	}}

// map instruction name to instruction ID (public)sparc_reg Sparc_map_insn(const char *name){	unsigned int i;	// NOTE: skip first NULL name in insn_name_maps	i = name2id(&insn_name_maps[1], ARR_SIZE(insn_name_maps) - 1, name);	return (i != -1)? i : SPARC_REG_INVALID;}

// given internal insn id, return operand access infouint8_t *ARM_get_op_access(cs_struct *h, unsigned int id){	int i = insn_find(insns, ARR_SIZE(insns), id, &h->insn_cache);	if (i != 0) {		return insn_ops[i].access;	}	return NULL;}

static void lcd_SetPara(){	uint_t i;	for (i = 0; i < ARR_SIZE(uc1698_tblParam); i++)		lcd_WriteCmd(uc1698_tblParam[i]);	lcd_SetBR(0x80);	lcd_SetPM(0);}

/* * get_flat_size method for expanded arrays */static SizeEA_get_flat_size(ExpandedObjectHeader *eohptr){	ExpandedArrayHeader *eah = (ExpandedArrayHeader *) eohptr;	int			nelems;	int			ndims;	Datum	   *dvalues;	bool	   *dnulls;	Size		nbytes;	int			i;	Assert(eah->ea_magic == EA_MAGIC);	/* Easy if we have a valid flattened value */	if (eah->fvalue)		return ARR_SIZE(eah->fvalue);	/* If we have a cached size value, believe that */	if (eah->flat_size)		return eah->flat_size;	/*	 * Compute space needed by examining dvalues/dnulls.  Note that the result	 * array will have a nulls bitmap if dnulls isn't NULL, even if the array	 * doesn't actually contain any nulls now.	 */	nelems = eah->nelems;	ndims = eah->ndims;	Assert(nelems == ArrayGetNItems(ndims, eah->dims));	dvalues = eah->dvalues;	dnulls = eah->dnulls;	nbytes = 0;	for (i = 0; i < nelems; i++)	{		if (dnulls && dnulls[i])			continue;		nbytes = att_addlength_datum(nbytes, eah->typlen, dvalues[i]);		nbytes = att_align_nominal(nbytes, eah->typalign);		/* check for overflow of total request */		if (!AllocSizeIsValid(nbytes))			ereport(ERROR,					(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),					 errmsg("array size exceeds the maximum allowed (%d)",							(int) MaxAllocSize)));	}	if (dnulls)		nbytes += ARR_OVERHEAD_WITHNULLS(ndims, nelems);	else		nbytes += ARR_OVERHEAD_NONULLS(ndims);	/* cache for next time */	eah->flat_size = nbytes;	return nbytes;}

bool BufDemuxer::Demux(MpegPlayer& plyr){    io::stream& strm = *plyr.inpStrm;    int cnt = strm.raw_read(rawBuf, ARR_SIZE(rawBuf));    // пока поток (файл) не закончился    bool res = strm;    if( res )        res = Demux((uint8_t*)rawBuf, (uint8_t*)rawBuf+cnt, plyr) ? false : true ;    return res;}

// map instruction name to public instruction IDmips_reg Mips_map_insn(const char *name){	// handle special alias first	unsigned int i;	// NOTE: skip first NULL name in insn_name_maps	i = name2id(&insn_name_maps[1], ARR_SIZE(insn_name_maps) - 1, name);	return (i != -1)? i : MIPS_REG_INVALID;}

INST_NAME get_inst_name(const u8 opcode){    size_t i;    for (i = 0; i < ARR_SIZE(inst_table); i++) {        if (inst_table[i].opcode == opcode) {            return inst_table[i].name;        }    }    return INVALID_OPCODE;}

inst get_instruction(const u8 opcode){    size_t i;    for (i = 0; i < ARR_SIZE(inst_table); i++) {        if (inst_table[i].opcode == opcode)            return inst_table[i];    }    return (inst) {        INVALID_OPCODE, "InvalidOp", opcode, NULL};	// TODO INVALID INSTRUCTION}