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

  FT_EXPORT_DEF( FT_Error )  FT_Outline_New_Internal(                               FT_Memory    memory,                               FT_UInt      numPoints,                               FT_Int       numContours,                               FT_Outline  *anoutline )  {    FT_Error  error;    if ( !anoutline || !memory )      return FT_Err_Invalid_Argument;    *anoutline = null_outline;    if ( ALLOC_ARRAY( anoutline->points,   numPoints * 2L, FT_Pos    ) ||         ALLOC_ARRAY( anoutline->tags,     numPoints,      FT_Byte   ) ||         ALLOC_ARRAY( anoutline->contours, numContours,    FT_UShort ) )      goto Fail;    anoutline->n_points    = (FT_UShort)numPoints;    anoutline->n_contours  = (FT_Short)numContours;    anoutline->flags      |= ft_outline_owner;    return FT_Err_Ok;  Fail:    anoutline->flags |= ft_outline_owner;    FT_Outline_Done_Internal( memory, anoutline );    return error;  }

LOCAL_FUNCFT_Error TT_New_GlyphZone(FT_Memory memory,                          FT_UShort maxPoints,                          FT_Short maxContours,                          TT_GlyphZone  *zone){	FT_Error error;	if(maxPoints > 0)	{		maxPoints += 2;	}	MEM_Set(zone, 0, sizeof(*zone));	zone->memory = memory;	if(ALLOC_ARRAY(zone->org,      maxPoints * 2, FT_F26Dot6) ||	        ALLOC_ARRAY(zone->cur,      maxPoints * 2, FT_F26Dot6) ||	        ALLOC_ARRAY(zone->tags,     maxPoints,     FT_Byte) ||	        ALLOC_ARRAY(zone->contours, maxContours,   FT_UShort))	{		TT_Done_GlyphZone(zone);	}	return error;}

  TT_Error  Instance_Create( void*  _instance,                             void*  _face )  {    PInstance ins  = (PInstance)_instance;    PFace     face = (PFace)_face;    ttfMemory *mem = face->font->tti->ttf_memory;    PMaxProfile  maxp = &face->maxProfile;    Int       i;    ins->FDefs=NULL;    ins->IDefs=NULL;    ins->cvt=NULL;    ins->storage=NULL;    ins->face = face;    ins->valid = FALSE;    ins->numFDefs = maxp->maxFunctionDefs;    ins->numIDefs = maxp->maxInstructionDefs;    ins->countIDefs = 0;    if (maxp->maxInstructionDefs > 255)	maxp->maxInstructionDefs = 255;  /* Bug 689960 */    memset(ins->IDefPtr, (Byte)ins->numIDefs, sizeof(ins->IDefPtr));    if (ins->numFDefs < 50)	ins->numFDefs = 50; /* Bug 687858 */    ins->cvtSize  = face->cvtSize;    ins->metrics.pointSize    = 10 * 64;     /* default pointsize  = 10pts */    ins->metrics.x_resolution = 96;          /* default resolution = 96dpi */    ins->metrics.y_resolution = 96;    ins->metrics.x_ppem = 0;    ins->metrics.y_ppem = 0;    ins->metrics.rotated   = FALSE;    ins->metrics.stretched = FALSE;    ins->storeSize = maxp->maxStorage;    for ( i = 0; i < 4; i++ )      ins->metrics.compensations[i] = 0;     /* Default compensations */    if ( ALLOC_ARRAY( ins->FDefs, 0, ins->numFDefs, TDefRecord )  ||         ALLOC_ARRAY( ins->IDefs, 0, ins->numIDefs, TDefRecord )  ||         ALLOC_ARRAY( ins->cvt, 0, ins->cvtSize, Long )           ||         ALLOC_ARRAY( ins->storage, 0, ins->storeSize, Long )     )      goto Fail_Memory;    memset (ins->FDefs, 0, ins->numFDefs * sizeof(TDefRecord));    memset (ins->IDefs, 0, ins->numIDefs * sizeof(TDefRecord));    ins->GS = Default_GraphicsState;    return TT_Err_Ok;  Fail_Memory:    Instance_Destroy( ins );    return TT_Err_Out_Of_Memory;  }

static void get_correspondences(struct string_list *a, struct string_list *b,				int creation_factor){	int n = a->nr + b->nr;	int *cost, c, *a2b, *b2a;	int i, j;	ALLOC_ARRAY(cost, st_mult(n, n));	ALLOC_ARRAY(a2b, n);	ALLOC_ARRAY(b2a, n);	for (i = 0; i < a->nr; i++) {		struct patch_util *a_util = a->items[i].util;		for (j = 0; j < b->nr; j++) {			struct patch_util *b_util = b->items[j].util;			if (a_util->matching == j)				c = 0;			else if (a_util->matching < 0 && b_util->matching < 0)				c = diffsize(a_util->diff, b_util->diff);			else				c = COST_MAX;			cost[i + n * j] = c;		}		c = a_util->matching < 0 ?			a_util->diffsize * creation_factor / 100 : COST_MAX;		for (j = b->nr; j < n; j++)			cost[i + n * j] = c;	}	for (j = 0; j < b->nr; j++) {		struct patch_util *util = b->items[j].util;		c = util->matching < 0 ?			util->diffsize * creation_factor / 100 : COST_MAX;		for (i = a->nr; i < n; i++)			cost[i + n * j] = c;	}	for (i = a->nr; i < n; i++)		for (j = b->nr; j < n; j++)			cost[i + n * j] = 0;	compute_assignment(n, n, cost, a2b, b2a);	for (i = 0; i < a->nr; i++)		if (a2b[i] >= 0 && a2b[i] < b->nr) {			struct patch_util *a_util = a->items[i].util;			struct patch_util *b_util = b->items[a2b[i]].util;			a_util->matching = a2b[i];			b_util->matching = i;		}	free(cost);	free(a2b);	free(b2a);}

G_MODULE_EXPORT const XLOPER* sumAndProduct(const XLOPER*m){	XLOPER*r=NULL;	if ( NULL!=m ) {		r=ALLOC_ARRAY(XLOPER,1);		r->xltype=xltypeMulti|xlbitDLLFree;		r->val.array.rows=1;		r->val.array.columns=2;		r->val.array.lparray=ALLOC_ARRAY(XLOPER,2);		r->val.array.lparray[0].xltype=xltypeNum;		r->val.array.lparray[0].val.num = 0;		r->val.array.lparray[1].xltype=xltypeNum;		r->val.array.lparray[1].val.num = 1;		if ((m->xltype&xltypeType)==xltypeMulti){			int i,j;			for (i=0;i<m->val.array.columns;++i){				for (j=0;j<m->val.array.rows;++j){					const double x = m->val.array.lparray[i*m->val.array.rows+j].val.num;					r->val.array.lparray[0].val.num += x;					r->val.array.lparray[1].val.num *= x;				}			}		}	}	return r;}

struct git_graph *graph_init(struct rev_info *opt){	struct git_graph *graph = xmalloc(sizeof(struct git_graph));	if (!column_colors) {		char *string;		if (git_config_get_string("log.graphcolors", &string)) {			/* not configured -- use default */			graph_set_column_colors(column_colors_ansi,						column_colors_ansi_max);		} else {			static struct argv_array custom_colors = ARGV_ARRAY_INIT;			argv_array_clear(&custom_colors);			parse_graph_colors_config(&custom_colors, string);			free(string);			/* graph_set_column_colors takes a max-index, not a count */			graph_set_column_colors(custom_colors.argv,						custom_colors.argc - 1);		}	}	graph->commit = NULL;	graph->revs = opt;	graph->num_parents = 0;	graph->expansion_row = 0;	graph->state = GRAPH_PADDING;	graph->prev_state = GRAPH_PADDING;	graph->commit_index = 0;	graph->prev_commit_index = 0;	graph->num_columns = 0;	graph->num_new_columns = 0;	graph->mapping_size = 0;	/*	 * Start the column color at the maximum value, since we'll	 * always increment it for the first commit we output.	 * This way we start at 0 for the first commit.	 */	graph->default_column_color = column_colors_max - 1;	/*	 * Allocate a reasonably large default number of columns	 * We'll automatically grow columns later if we need more room.	 */	graph->column_capacity = 30;	ALLOC_ARRAY(graph->columns, graph->column_capacity);	ALLOC_ARRAY(graph->new_columns, graph->column_capacity);	ALLOC_ARRAY(graph->mapping, 2 * graph->column_capacity);	ALLOC_ARRAY(graph->new_mapping, 2 * graph->column_capacity);	/*	 * The diff output prefix callback, with this we can make	 * all the diff output to align with the graph lines.	 */	opt->diffopt.output_prefix = diff_output_prefix_callback;	opt->diffopt.output_prefix_data = graph;	return graph;}

void xdiff_set_find_func(xdemitconf_t *xecfg, const char *value, int cflags){	int i;	struct ff_regs *regs;	xecfg->find_func = ff_regexp;	regs = xecfg->find_func_priv = xmalloc(sizeof(struct ff_regs));	for (i = 0, regs->nr = 1; value[i]; i++)		if (value[i] == '/n')			regs->nr++;	ALLOC_ARRAY(regs->array, regs->nr);	for (i = 0; i < regs->nr; i++) {		struct ff_reg *reg = regs->array + i;		const char *ep = strchr(value, '/n'), *expression;		char *buffer = NULL;		reg->negate = (*value == '!');		if (reg->negate && i == regs->nr - 1)			die("Last expression must not be negated: %s", value);		if (*value == '!')			value++;		if (ep)			expression = buffer = xstrndup(value, ep - value);		else			expression = value;		if (regcomp(&reg->re, expression, cflags))			die("Invalid regexp to look for hunk header: %s", expression);		free(buffer);		value = ep + 1;	}}

*/	void Init_Ports(void)/***		Initialize port scheme related subsystems.****	In order to add a port scheme:****		In mezz-ports.r add a make-scheme.**		Add an Init_*_Scheme() here.**		Be sure host-devices.c has the device enabled.*************************************************************************/{	Scheme_Actions = ALLOC_ARRAY(SCHEME_ACTIONS, MAX_SCHEMES);	CLEAR(Scheme_Actions, MAX_SCHEMES * sizeof(SCHEME_ACTIONS));	Init_Console_Scheme();	Init_File_Scheme();	Init_Dir_Scheme();	Init_Event_Scheme();	Init_TCP_Scheme();	Init_UDP_Scheme();	Init_DNS_Scheme();#ifdef TO_WINDOWS	Init_Clipboard_Scheme();#endif#if defined(TO_LINUX) || defined(TO_WINDOWS)	Init_Serial_Scheme();#endif#ifdef HAS_POSIX_SIGNAL	Init_Signal_Scheme();#endif}

G_MODULE_EXPORT const XLOPER* arrangeInSquareMatrix(const XLOPER*a,const XLOPER*b,const XLOPER*c,const XLOPER*d){	XLOPER*r=NULL;	if ( NULL!=a && NULL!=b && NULL!=c && NULL!=d ) {		r=ALLOC_ARRAY(XLOPER,1);		r->xltype=xltypeMulti|xlbitDLLFree;		r->val.array.rows=2;		r->val.array.columns=2;		r->val.array.lparray=ALLOC_ARRAY(XLOPER,4);		copy_construct_xloper(r->val.array.lparray  ,a);		copy_construct_xloper(r->val.array.lparray+1,b);		copy_construct_xloper(r->val.array.lparray+2,c);		copy_construct_xloper(r->val.array.lparray+3,d);	}	return r;}

int transport_fetch_refs(struct transport *transport, struct ref *refs){	int rc;	int nr_heads = 0, nr_alloc = 0, nr_refs = 0;	struct ref **heads = NULL;	struct ref *rm;	for (rm = refs; rm; rm = rm->next) {		nr_refs++;		if (rm->peer_ref &&		    !is_null_oid(&rm->old_oid) &&		    !oidcmp(&rm->peer_ref->old_oid, &rm->old_oid))			continue;		ALLOC_GROW(heads, nr_heads + 1, nr_alloc);		heads[nr_heads++] = rm;	}	if (!nr_heads) {		/*		 * When deepening of a shallow repository is requested,		 * then local and remote refs are likely to still be equal.		 * Just feed them all to the fetch method in that case.		 * This condition shouldn't be met in a non-deepening fetch		 * (see builtin/fetch.c:quickfetch()).		 */		ALLOC_ARRAY(heads, nr_refs);		for (rm = refs; rm; rm = rm->next)			heads[nr_heads++] = rm;	}	rc = transport->fetch(transport, nr_heads, heads);	free(heads);	return rc;}

static int fetch_dumb(int nr_heads, struct ref **to_fetch){	struct walker *walker;	char **targets;	int ret, i;	ALLOC_ARRAY(targets, nr_heads);	if (options.depth)		die("dumb http transport does not support --depth");	for (i = 0; i < nr_heads; i++)		targets[i] = xstrdup(oid_to_hex(&to_fetch[i]->old_oid));	walker = get_http_walker(url.buf);	walker->get_all = 1;	walker->get_tree = 1;	walker->get_history = 1;	walker->get_verbosely = options.verbosity >= 3;	walker->get_recover = 0;	ret = walker_fetch(walker, nr_heads, targets, NULL, NULL);	walker_free(walker);	for (i = 0; i < nr_heads; i++)		free(targets[i]);	free(targets);	return ret ? error("fetch failed.") : 0;}

/* * Allocate an array of size 'n'. */array_t *allocate_array P1(int, n){    array_t *p;    if (n < 0 || n > max_array_size)	error("Illegal array size./n");    if (n == 0) {	return null_array();    }    num_arrays++;    total_array_size += sizeof(array_t) + sizeof(svalue_t) *	(n - 1);    p = ALLOC_ARRAY(n);    p->ref = 1;    p->size = n;#ifdef PACKAGE_MUDLIB_STATS    if (current_object) {	assign_stats(&p->stats, current_object);	add_array_size(&p->stats, n);    } else {	null_stats(&p->stats);    }#endif    while (n--)	p->item[n] = const0;    return p;}

/* Display COL_COLUMN or COL_ROW */static void display_table(const struct string_list *list,			  unsigned int colopts,			  const struct column_options *opts){	struct column_data data;	int x, y, i, initial_width;	char *empty_cell;	memset(&data, 0, sizeof(data));	data.list = list;	data.colopts = colopts;	data.opts = *opts;	ALLOC_ARRAY(data.len, list->nr);	for (i = 0; i < list->nr; i++)		data.len[i] = item_length(colopts, list->items[i].string);	layout(&data, &initial_width);	if (colopts & COL_DENSE)		shrink_columns(&data);	empty_cell = xmallocz(initial_width);	memset(empty_cell, ' ', initial_width);	for (y = 0; y < data.rows; y++) {		for (x = 0; x < data.cols; x++)			if (display_cell(&data, initial_width, empty_cell, x, y))				break;	}	free(data.len);	free(data.width);	free(empty_cell);}

  static TT_Error  Subtable_Load_0( TT_Kern_0*  kern0,                   PFace       input )  {    DEFINE_LOAD_LOCALS( input->stream );    UShort  num_pairs, n;    if ( ACCESS_Frame( 8L ) )      return error;    num_pairs            = GET_UShort();    kern0->nPairs        = 0;    kern0->searchRange   = GET_UShort();    kern0->entrySelector = GET_UShort();    kern0->rangeShift    = GET_UShort();    /* we only set kern0->nPairs if the subtable has been loaded */    FORGET_Frame();    if ( ALLOC_ARRAY( kern0->pairs, num_pairs, TT_Kern_0_Pair ) )      return error;    if ( ACCESS_Frame( num_pairs * 6L ) )      goto Fail;    for ( n = 0; n < num_pairs; n++ )    {      kern0->pairs[n].left  = GET_UShort();      kern0->pairs[n].right = GET_UShort();      kern0->pairs[n].value = GET_UShort();      if ( kern0->pairs[n].left >= input->numGlyphs ||           kern0->pairs[n].right >= input->numGlyphs )      {        FORGET_Frame();        error = TT_Err_Invalid_Kerning_Table;        goto Fail;      }    }    FORGET_Frame();    /* we're ok, set the pairs count */    kern0->nPairs = num_pairs;    /* the spec says that the kerning pairs must be sorted,       but some brain damaged font producers don't do that correctly.. (JvR 3/4/2000) */    if ( !is_sorted( kern0->pairs, num_pairs ) )      sort_kern_pairs( kern0->pairs, num_pairs );    return TT_Err_Ok;    Fail:      FREE( kern0->pairs );      return error;  }

struct git_graph *graph_init(struct rev_info *opt){	struct git_graph *graph = xmalloc(sizeof(struct git_graph));	if (!column_colors)		graph_set_column_colors(column_colors_ansi,					column_colors_ansi_max);	graph->commit = NULL;	graph->revs = opt;	graph->num_parents = 0;	graph->expansion_row = 0;	graph->state = GRAPH_PADDING;	graph->prev_state = GRAPH_PADDING;	graph->commit_index = 0;	graph->prev_commit_index = 0;	graph->num_columns = 0;	graph->num_new_columns = 0;	graph->mapping_size = 0;	/*	 * Start the column color at the maximum value, since we'll	 * always increment it for the first commit we output.	 * This way we start at 0 for the first commit.	 */	graph->default_column_color = column_colors_max - 1;	/*	 * Allocate a reasonably large default number of columns	 * We'll automatically grow columns later if we need more room.	 */	graph->column_capacity = 30;	ALLOC_ARRAY(graph->columns, graph->column_capacity);	ALLOC_ARRAY(graph->new_columns, graph->column_capacity);	ALLOC_ARRAY(graph->mapping, 2 * graph->column_capacity);	ALLOC_ARRAY(graph->new_mapping, 2 * graph->column_capacity);	/*	 * The diff output prefix callback, with this we can make	 * all the diff output to align with the graph lines.	 */	opt->diffopt.output_prefix = diff_output_prefix_callback;	opt->diffopt.output_prefix_data = graph;	opt->diffopt.output_prefix_length = 0;	return graph;}

  FT_EXPORT_DEF( FT_Error )  FTC_ChunkSet_New( FTC_Chunk_Cache  cache,                                               FT_Pointer       type,                                               FTC_ChunkSet    *aset )  {    FT_Error      error;    FT_Memory     memory  = cache->root.memory;    FTC_Manager   manager = cache->root.manager;    FTC_ChunkSet  cset    = 0;    FTC_Chunk_Cache_Class*  ccache_class;    FTC_ChunkSet_Class*     clazz;    ccache_class = (FTC_Chunk_Cache_Class*)cache->root.clazz;    clazz        = ccache_class->cset_class;    *aset = 0;    if ( ALLOC( cset, clazz->cset_byte_size ) )      goto Exit;    cset->cache   = cache;    cset->manager = manager;    cset->memory  = memory;    cset->clazz   = clazz;    /* now compute element_max, element_count and element_size */    error = clazz->sizes( cset, type );    if ( error )      goto Exit;    /* compute maximum number of nodes */    cset->num_chunks = ( cset->element_max + cset->element_count - 1 ) /                       cset->element_count;    /* allocate chunk pointers table */    if ( ALLOC_ARRAY( cset->chunks, cset->num_chunks, FTC_ChunkNode ) )      goto Exit;    /* initialize set by type if needed */    if ( clazz->init )    {      error = clazz->init( cset, type );      if ( error )        goto Exit;    }    *aset = cset;  Exit:    if ( error && cset )    {      FREE( cset->chunks );      FREE( cset );    }    return error;  }

G_MODULE_EXPORT const XLOPER* convertAstronomicalUnitsToKilometers(const XLOPER*x){	XLOPER*r=NULL;	if ( NULL!=x && (x->xltype&xltypeType)==xltypeNum ) {		r=ALLOC_ARRAY(XLOPER,1);		r->xltype=xltypeNum|xlbitDLLFree;		r->val.num=x->val.num*149600000.;	}	return r;}

G_MODULE_EXPORT const XLOPER* multiplyTwoNumbers(const XLOPER*x,const XLOPER*y){	XLOPER*r=NULL;	if ( NULL!=x && (x->xltype&xltypeType)==xltypeNum && NULL!=y && (y->xltype&xltypeType)==xltypeNum ) {		r=ALLOC_ARRAY(XLOPER,1);		r->xltype=xltypeNum|xlbitDLLFree;		r->val.num=x->val.num*y->val.num;	}	return r;}

/** * Build the initial type index for the packfile */void bitmap_writer_build_type_index(struct packing_data *to_pack,				    struct pack_idx_entry **index,				    uint32_t index_nr){	uint32_t i;	writer.commits = ewah_new();	writer.trees = ewah_new();	writer.blobs = ewah_new();	writer.tags = ewah_new();	ALLOC_ARRAY(to_pack->in_pack_pos, to_pack->nr_objects);	for (i = 0; i < index_nr; ++i) {		struct object_entry *entry = (struct object_entry *)index[i];		enum object_type real_type;		oe_set_in_pack_pos(to_pack, entry, i);		switch (oe_type(entry)) {		case OBJ_COMMIT:		case OBJ_TREE:		case OBJ_BLOB:		case OBJ_TAG:			real_type = oe_type(entry);			break;		default:			real_type = oid_object_info(to_pack->repo,						    &entry->idx.oid, NULL);			break;		}		switch (real_type) {		case OBJ_COMMIT:			ewah_set(writer.commits, i);			break;		case OBJ_TREE:			ewah_set(writer.trees, i);			break;		case OBJ_BLOB:			ewah_set(writer.blobs, i);			break;		case OBJ_TAG:			ewah_set(writer.tags, i);			break;		default:			die("Missing type information for %s (%d/%d)",			    oid_to_hex(&entry->idx.oid), real_type,			    oe_type(entry));		}	}}

void NETSpeedTest(uint iterations, uint inputLength, uint layersCount, uint neuronsCountInEachLayer, ActivationFunctionPtr actFunction){		uint* layersParams;		uint i;		double* inputVector;		MultilayerNET* NET;		StopWatch stopWatch;		TimeInterval timeInterval;		inputVector = ALLOC_ARRAY(double, inputLength);		for(i = 0; i < inputLength; i++)		{			inputVector[i] = i;		}		layersParams = ALLOC_ARRAY(uint, layersCount);		for(i = 0; i < layersCount; i++)		{			layersParams[i] = neuronsCountInEachLayer;		}		NET = CreateNewMultilayerNET(layersCount, inputLength, actFunction, layersParams);		if(NET == NULL)		{			printf("ERROR/n");			return;		}		Reset(&stopWatch);		Start(&stopWatch);		for(i = 0; i < iterations; i++)		{			ComputeNETOutput(NET, inputVector, inputLength);		}		Stop(&stopWatch);		CalcElapsedMilliSeconds(&stopWatch);		ToTimeIntervalStruct(&stopWatch, &timeInterval);		printf("NET SPEED TEST:/nPARAMETRS:/n iterations: %d/n input length: %d/n layers's count: %d/n Count of neurons in each layer: %d/n",			iterations, inputLength, layersCount, neuronsCountInEachLayer);		printf("ELAPSED TIME:/n");		printf(" milliseconds: %d/n", timeInterval.Miliseconds);		printf(" seconds: %d/n", timeInterval.Seconds);		printf(" minets: %d/n", timeInterval.Minets);		printf(" hours: %d/n", timeInterval.Hours);		printf("/n");		free(layersParams);		free(inputVector);		DisposeNET(NET);}

static void deduplicate_islands(struct repository *r){	struct remote_island *island, *core = NULL, **list;	unsigned int island_count, dst, src, ref, i = 0;	island_count = kh_size(remote_islands);	ALLOC_ARRAY(list, island_count);	kh_foreach_value(remote_islands, island, {		list[i++] = island;	});

int cmd_merge_base(int argc, const char **argv, const char *prefix){	struct commit **rev;	int rev_nr = 0;	int show_all = 0;	int cmdmode = 0;	struct option options[] = {		OPT_BOOL('a', "all", &show_all, N_("output all common ancestors")),		OPT_CMDMODE(0, "octopus", &cmdmode,			    N_("find ancestors for a single n-way merge"), 'o'),		OPT_CMDMODE(0, "independent", &cmdmode,			    N_("list revs not reachable from others"), 'r'),		OPT_CMDMODE(0, "is-ancestor", &cmdmode,			    N_("is the first one ancestor of the other?"), 'a'),		OPT_CMDMODE(0, "fork-point", &cmdmode,			    N_("find where <commit> forked from reflog of <ref>"), 'f'),		OPT_END()	};	git_config(git_default_config, NULL);	argc = parse_options(argc, argv, prefix, options, merge_base_usage, 0);	if (cmdmode == 'a') {		if (argc < 2)			usage_with_options(merge_base_usage, options);		if (show_all)			die("--is-ancestor cannot be used with --all");		return handle_is_ancestor(argc, argv);	}	if (cmdmode == 'r' && show_all)		die("--independent cannot be used with --all");	if (cmdmode == 'o')		return handle_octopus(argc, argv, show_all);	if (cmdmode == 'r')		return handle_independent(argc, argv);	if (cmdmode == 'f') {		if (argc < 1 || 2 < argc)			usage_with_options(merge_base_usage, options);		return handle_fork_point(argc, argv);	}	if (argc < 2)		usage_with_options(merge_base_usage, options);	ALLOC_ARRAY(rev, argc);	while (argc-- > 0)		rev[rev_nr++] = get_commit_reference(*argv++);	return show_merge_base(rev, rev_nr, show_all);}

struct ewah_bitmap *ewah_new(void){	struct ewah_bitmap *self;	self = xmalloc(sizeof(struct ewah_bitmap));	self->alloc_size = 32;	ALLOC_ARRAY(self->buffer, self->alloc_size);	ewah_clear(self);	return self;}

*/	void Init_Pools(REBINT scale)/***		Initialize memory pool array.*************************************************************************/{	REBCNT n;	REBINT unscale = 1;#ifndef NDEBUG	const char *env_always_malloc = NULL;	env_always_malloc = getenv("R3_ALWAYS_MALLOC");	if (env_always_malloc != NULL) {		Debug_Str(			"**/n"			"** R3_ALWAYS_MALLOC is TRUE in environment variable!/n"			"** Memory allocations aren't pooled, expect slowness.../n"			"**/n"		);		PG_Always_Malloc = (atoi(env_always_malloc) != 0);	}#endif	if (scale == 0) scale = 1;	else if (scale < 0) unscale = -scale, scale = 1;	// Copy pool sizes to new pool structure:	Mem_Pools = ALLOC_ARRAY(REBPOL, MAX_POOLS);	for (n = 0; n < MAX_POOLS; n++) {		Mem_Pools[n].wide = Mem_Pool_Spec[n].wide;		Mem_Pools[n].units = (Mem_Pool_Spec[n].units * scale) / unscale;		if (Mem_Pools[n].units < 2) Mem_Pools[n].units = 2;	}	// For pool lookup. Maps size to pool index. (See Find_Pool below)	PG_Pool_Map = ALLOC_ARRAY(REBYTE, (4 * MEM_BIG_SIZE) + 4); // extra	n = 9;  // sizes 0 - 8 are pool 0	for (; n <= 16 * MEM_MIN_SIZE; n++) PG_Pool_Map[n] = MEM_TINY_POOL     + ((n-1) / MEM_MIN_SIZE);	for (; n <= 32 * MEM_MIN_SIZE; n++) PG_Pool_Map[n] = MEM_SMALL_POOLS-4 + ((n-1) / (MEM_MIN_SIZE * 4));	for (; n <=  4 * MEM_BIG_SIZE; n++) PG_Pool_Map[n] = MEM_MID_POOLS     + ((n-1) / MEM_BIG_SIZE);}

static FT_Error  Load_LigGlyph( HB_LigGlyph*  lg,				FT_Stream      stream ){  FT_Memory memory = stream->memory;  FT_Error  error;  FT_UShort        n, m, count;  FT_ULong         cur_offset, new_offset, base_offset;  HB_CaretValue*  cv;  base_offset = FILE_Pos();  if ( ACCESS_Frame( 2L ) )    return error;  count = lg->CaretCount = GET_UShort();  FORGET_Frame();  lg->CaretValue = NULL;  if ( ALLOC_ARRAY( lg->CaretValue, count, HB_CaretValue ) )    return error;  cv = lg->CaretValue;  for ( n = 0; n < count; n++ )  {    if ( ACCESS_Frame( 2L ) )      goto Fail;    new_offset = GET_UShort() + base_offset;    FORGET_Frame();    cur_offset = FILE_Pos();    if ( FILE_Seek( new_offset ) ||	 ( error = Load_CaretValue( &cv[n], stream ) ) != FT_Err_Ok )      goto Fail;    (void)FILE_Seek( cur_offset );  }  return FT_Err_Ok;Fail:  for ( m = 0; m < n; m++ )    Free_CaretValue( &cv[m], memory );  FREE( cv );  return error;}

  static TT_Error  Subtable_Load_0( TT_Kern_0*  kern0,                                    PFace       input )  {    DEFINE_LOAD_LOCALS( input->stream );    UShort  num_pairs, n;    if ( ACCESS_Frame( 8L ) )      return error;    num_pairs            = GET_UShort();    kern0->nPairs        = 0;    kern0->searchRange   = GET_UShort();    kern0->entrySelector = GET_UShort();    kern0->rangeShift    = GET_UShort();    /* we only set kern0->nPairs if the subtable has been loaded */    FORGET_Frame();    if ( ALLOC_ARRAY( kern0->pairs, num_pairs, TT_Kern_0_Pair ) )      return error;    if ( ACCESS_Frame( num_pairs * 6L ) )      goto Fail;    for ( n = 0; n < num_pairs; n++ )    {      kern0->pairs[n].left  = GET_UShort();      kern0->pairs[n].right = GET_UShort();      kern0->pairs[n].value = GET_UShort();      if ( kern0->pairs[n].left >= input->numGlyphs ||           kern0->pairs[n].right >= input->numGlyphs )      {        FORGET_Frame();        error = TT_Err_Invalid_Kerning_Table;        goto Fail;      }    }    FORGET_Frame();    /* we're ok, set the pairs count */    kern0->nPairs = num_pairs;    return TT_Err_Ok;    Fail:      FREE( kern0->pairs );      return error;  }

int split_cmdline(char *cmdline, const char ***argv){	int src, dst, count = 0, size = 16;	char quoted = 0;	ALLOC_ARRAY(*argv, size);	/* split alias_string */	(*argv)[count++] = cmdline;	for (src = dst = 0; cmdline[src];) {		char c = cmdline[src];		if (!quoted && isspace(c)) {			cmdline[dst++] = 0;			while (cmdline[++src]					&& isspace(cmdline[src]))				; /* skip */			ALLOC_GROW(*argv, count + 1, size);			(*argv)[count++] = cmdline + dst;		} else if (!quoted && (c == '/'' || c == '"')) {			quoted = c;			src++;		} else if (c == quoted) {			quoted = 0;			src++;		} else {			if (c == '//' && quoted != '/'') {				src++;				c = cmdline[src];				if (!c) {					free(*argv);					*argv = NULL;					return -SPLIT_CMDLINE_BAD_ENDING;				}			}			cmdline[dst++] = c;			src++;		}	}	cmdline[dst] = 0;	if (quoted) {		free(*argv);		*argv = NULL;		return -SPLIT_CMDLINE_UNCLOSED_QUOTE;	}	ALLOC_GROW(*argv, count + 1, size);	(*argv)[count] = NULL;	return count;}

static inline struct llist_item *llist_item_get(void){	struct llist_item *new_item;	if ( free_nodes ) {		new_item = free_nodes;		free_nodes = free_nodes->next;	} else {		int i = 1;		ALLOC_ARRAY(new_item, BLKSIZE);		for (; i < BLKSIZE; i++)			llist_item_put(&new_item[i]);	}	return new_item;}

struct attr_check *attr_check_dup(const struct attr_check *check){	struct attr_check *ret;	if (!check)		return NULL;	ret = attr_check_alloc();	ret->nr = check->nr;	ret->alloc = check->alloc;	ALLOC_ARRAY(ret->items, ret->nr);	COPY_ARRAY(ret->items, check->items, ret->nr);	return ret;}

  FT_LOCAL_DEF  FT_Error  TT_Load_Locations( TT_Face    face,                               FT_Stream  stream )  {    FT_Error   error;    FT_Memory  memory = stream->memory;    FT_Short   LongOffsets;    FT_ULong   table_len;    FT_TRACE2(( "Locations " ));    LongOffsets = face->header.Index_To_Loc_Format;    error = face->goto_table( face, TTAG_loca, stream, &table_len );    if ( error )    {      error = TT_Err_Locations_Missing;      goto Exit;    }    if ( LongOffsets != 0 )    {      face->num_locations = (FT_UShort)( table_len >> 2 );      FT_TRACE2(( "(32bit offsets): %12d ", face->num_locations ));      if ( ALLOC_ARRAY( face->glyph_locations,                        face->num_locations,                        FT_Long ) )        goto Exit;      if ( ACCESS_Frame( face->num_locations * 4L ) )        goto Exit;      {        FT_Long*  loc   = face->glyph_locations;        FT_Long*  limit = loc + face->num_locations;        for ( ; loc < limit; loc++ )          *loc = GET_Long();      }      FORGET_Frame();    }