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_FUNC
FT_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(®->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();
}
