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

int add_defined (struct fsm *net, char *string) {  struct defined *defined, *defined_prev;  int redefine;  redefine = 0;  if (net == NULL) { return 0; }  fsm_count(net);  if (defines == NULL) {    defined = xxmalloc(sizeof(struct defined));    defines = defined;    defined->next = NULL;  } else {    for (defined = defines; defined != NULL; defined = defined->next) {      defined_prev = defined;      if (strcmp(defined->name, string) == 0) {	redefine = 1;	break;      }    }    if (redefine == 0) {      defined_prev->next = xxmalloc(sizeof(struct defined));      defined = defined_prev->next;      defined->next = NULL;    }  }  if (redefine) {      fsm_destroy(defined->net);      xxfree(defined->name);  }  defined->name = xxstrdup(string);  defined->net = net;  return(redefine);}

struct apply_handle *apply_init(struct fsm *net) {    struct apply_handle *h;    srand((unsigned int) time(NULL));    h = malloc(sizeof(struct apply_handle));    /* Init */    h->iterate_old = 0;    h->iterator = 0;    h->instring = NULL;    h->flag_list = NULL;    h->flag_lookup = NULL;    h->last_net = net;    h->outstring = xxmalloc(sizeof(char)*DEFAULT_OUTSTRING_SIZE);    h->outstringtop = DEFAULT_OUTSTRING_SIZE;    *(h->outstring) = '/0';    h->gstates = net->states;    h->gsigma = net->sigma;    h->printcount = 1;    apply_create_statemap(h, net);    h->searchstack = xxmalloc(sizeof(struct searchstack) * DEFAULT_STACK_SIZE);    h->apply_stack_top = DEFAULT_STACK_SIZE;    apply_stack_clear(h);    apply_create_sigarray(h, net);    return(h);}

  static void * my_memalign_hook (size_t size, size_t alignment, const void *) {    // Check for non power-of-two alignment, or mistake in size.    if ((alignment == 0) ||	(alignment & (alignment - 1)))      {	return NULL;      }    // Try to just allocate an object of the requested size.    // If it happens to be aligned properly, just return it.    void * ptr = xxmalloc (size);    if (((size_t) ptr & (alignment - 1)) == (size_t) ptr) {      // It is already aligned just fine; return it.      return ptr;    }    // It was not aligned as requested: free the object.    xxfree (ptr);    // Now get a big chunk of memory and align the object within it.    // NOTE: this REQUIRES that the underlying allocator be able    // to free the aligned object, or ignore the free request.    void * buf = xxmalloc (2 * alignment + size);    void * alignedPtr = (void *) (((size_t) buf + alignment - 1) & ~(alignment - 1));    return alignedPtr;  }

static void sigma_to_pairs(struct fsm *net) {    int i, j, x, y, z, next_x = 0;  struct fsm_state *fsm;  fsm = net->states;  epsilon_symbol = -1;   maxsigma = sigma_max(net->sigma);  maxsigma++;  single_sigma_array = xxmalloc(2*maxsigma*maxsigma*sizeof(int));  double_sigma_array = xxmalloc(maxsigma*maxsigma*sizeof(int));    for (i=0; i < maxsigma; i++) {    for (j=0; j< maxsigma; j++) {      *(double_sigma_array+maxsigma*i+j) = -1;    }  }    /* f(x) -> y,z sigma pair */  /* f(y,z) -> x simple entry */  /* if exists f(n) <-> EPSILON, EPSILON, save n */  /* symbol(x) x>=1 */  /* Forward mapping: */  /* *(double_sigma_array+maxsigma*in+out) */  /* Backmapping: */  /* *(single_sigma_array+(symbol*2) = in(symbol) */  /* *(single_sigma_array+(symbol*2+1) = out(symbol) */  /* Table for checking whether a state is final */  x = 0;  net->arity = 1;  for (i=0; (fsm+i)->state_no != -1; i++) {    y = (fsm+i)->in;    z = (fsm+i)->out;    if ((y == -1) || (z == -1))      continue;    if (y != z || y == UNKNOWN || z == UNKNOWN)        net->arity = 2;    if (*(double_sigma_array+maxsigma*y+z) == -1) {      *(double_sigma_array+maxsigma*y+z) = x;      *(single_sigma_array+next_x) = y;      next_x++;      *(single_sigma_array+next_x) = z;      next_x++;      if (y == EPSILON && z == EPSILON) {	epsilon_symbol = x;      }      x++;    }  }  num_symbols = x;}

static void memoize_e_closure(struct fsm_state *fsm) {        int i, state, laststate, *redcheck;    struct e_closure_memo *ptr;        e_closure_memo = xxcalloc(num_states,sizeof(struct e_closure_memo));    marktable = xxcalloc(num_states,sizeof(int));    /* Table for avoiding redundant epsilon arcs in closure */    redcheck = xxmalloc(num_states*sizeof(int));    for (i=0; i < num_states; i++) {        ptr = e_closure_memo+i;        ptr->state = i;        ptr->target = NULL;        *(redcheck+i) = -1;    }    laststate = -1;    for (i=0; ;i++) {                state = (fsm+i)->state_no;                if (state != laststate) {            if (!int_stack_isempty()) {                                deterministic = 0;                ptr = e_closure_memo+laststate;                ptr->target = e_closure_memo+int_stack_pop();                while (!int_stack_isempty()) {                    ptr->next = xxmalloc(sizeof(struct e_closure_memo));                    ptr->next->state = laststate;                    ptr->next->target = e_closure_memo+int_stack_pop();                    ptr->next->next = NULL;                    ptr = ptr->next;                }            }        }        if (state == -1) {            break;        }        if ((fsm+i)->target == -1) {            continue;        }        /* Check if we have a redundant epsilon arc */        if ((fsm+i)->in == EPSILON && (fsm+i)->out == EPSILON) {            if (*(redcheck+((fsm+i)->target)) != (fsm+i)->state_no) {                if ((fsm+i)->target != (fsm+i)->state_no) {                    int_stack_push((fsm+i)->target);                    *(redcheck+((fsm+i)->target)) = (fsm+i)->state_no;                }            }            laststate = state;        }    }    xxfree(redcheck);}

void apply_create_sigarray(struct apply_handle *h, struct fsm *net) {    struct sigma *sig;    struct fsm_state *fsm;        int i, maxsigma;        fsm = net->states;    maxsigma = sigma_max(net->sigma);    // Default size created at init, resized later if necessary    h->sigmatch_array = xxcalloc(1024,sizeof(struct sigmatch_array));    h->sigmatch_array_size = 1024;    h->sigs = xxmalloc(sizeof(char **)*(maxsigma+1));    h->has_flags = 0;    h->flag_list = NULL;    /* Malloc first array of trie and store trie ptrs to free later */    h->sigma_trie = xxcalloc(256,sizeof(struct sigma_trie));    h->sigma_trie_arrays = xxmalloc(sizeof(struct sigma_trie_arrays));    h->sigma_trie_arrays->arr = h->sigma_trie;    h->sigma_trie_arrays->next = NULL;    for (i=0;i<256;i++)	(h->sigma_trie+i)->next = NULL;    for (sig = h->gsigma; sig != NULL && sig->number != -1; sig = sig->next) {	if (flag_check(sig->symbol)) {	    h->has_flags = 1;	    apply_add_flag(h, flag_get_name(sig->symbol));	}	*(h->sigs+(sig->number)) = sig->symbol;	/* Add sigma entry to trie */	if (sig->number > IDENTITY) {	    apply_add_sigma_trie(h, sig->number, sig->symbol);	}    }    if (h->has_flags) {	h->flag_lookup = xxmalloc(sizeof(struct flag_lookup)*(maxsigma+1));	for (i=0; i <= maxsigma; i++) {	    (h->flag_lookup+i)->type = 0;	    (h->flag_lookup+i)->name = NULL;	    (h->flag_lookup+i)->value = NULL;	}	for (sig = h->gsigma; sig != NULL ; sig = sig->next) {	    if (flag_check(sig->symbol)) {		(h->flag_lookup+sig->number)->type = flag_get_type(sig->symbol);		(h->flag_lookup+sig->number)->name = flag_get_name(sig->symbol);		(h->flag_lookup+sig->number)->value = flag_get_value(sig->symbol);			    }	}    }}

  static void * my_realloc_hook (void * ptr, size_t sz, const void *) {    // NULL ptr = malloc.    if (ptr == NULL) {      return xxmalloc(sz);    }    if (sz == 0) {      xxfree (ptr);#if defined(__APPLE__)      // 0 size = free. We return a small object.  This behavior is      // apparently required under Mac OS X and optional under POSIX.      return xxmalloc(1);#else      // For POSIX, don't return anything.      return NULL;#endif    }    size_t objSize = xxmalloc_usable_size(ptr);    #if 0    // Custom logic here to ensure we only do a logarithmic number of    // reallocations (with a constant space overhead).    // Don't change size if the object is shrinking by less than half.    if ((objSize / 2 < sz) && (sz <= objSize)) {      // Do nothing.      return ptr;    }    // If the object is growing by less than 2X, double it.    if ((objSize < sz) && (sz < objSize * 2)) {      sz = objSize * 2;    }#endif    void * buf = xxmalloc(sz);    if (buf != NULL) {      // Successful malloc.      // Copy the contents of the original object      // up to the size of the new block.      size_t minSize = (objSize < sz) ? objSize : sz;      memcpy (buf, ptr, minSize);      xxfree (ptr);    }    // Return a pointer to the new one.    return buf;  }

struct nvpair *nvpair_create(){	struct nvpair *n;	n = xxmalloc(sizeof(*n));	n->table = hash_table_create(7, hash_string);	return n;}

void pfs_resolve_add_entry( const char *prefix, const char *redirect, mode_t mode ){	assert(prefix);	assert(redirect);	char real_redirect[PFS_PATH_MAX];	struct pfs_mount_entry *ns = pfs_process_current_ns();	if (!ns) ns = mount_list;	assert(ns);	debug(D_RESOLVE,"resolving %s in parent ns",redirect);	switch (pfs_resolve_ns(find_parent_ns(ns), redirect, real_redirect, mode, 0)) {	case PFS_RESOLVE_CHANGED:	case PFS_RESOLVE_UNCHANGED:		break;	default:		debug(D_NOTICE,"couldn't resolve redirect %s",prefix);		return;	}	struct pfs_mount_entry *m = (struct pfs_mount_entry *) xxmalloc(sizeof(*m));	memcpy(m, ns, sizeof(*m));	memset(ns, 0, sizeof(*ns));	strcpy(ns->prefix, prefix);	strcpy(ns->redirect, real_redirect);	ns->mode = mode;	ns->next = m;	ns->refcount = m->refcount;	m->refcount = 1;	pfs_resolve_cache_flush();}

struct work_queue_master *duplicate_work_queue_master(struct work_queue_master *master){	struct work_queue_master *m;	m = xxmalloc(sizeof(struct work_queue_master));	if(!m) return NULL;	strncpy(m->addr, master->addr, LINK_ADDRESS_MAX);	strncpy(m->proj, master->proj, WORK_QUEUE_NAME_MAX);	m->port = master->port;	m->priority = master->priority;	m->capacity = master->capacity;	m->tasks_waiting = master->tasks_waiting; 	m->tasks_running = master->tasks_running; 	m->tasks_complete = master-> tasks_complete; 	m->total_tasks_dispatched = master-> total_tasks_dispatched; 	m->workers_init = master->workers_init; 	m->workers_ready = master->workers_ready; 	m->workers_busy = master->workers_busy; 	m->workers_full = master->workers_full; 	m->workers = master->workers; 	if(master->workers_by_pool) {		m->workers_by_pool = xxstrdup(master->workers_by_pool);	} else {		m->workers_by_pool = NULL;	}	strncpy(m->owner, master->owner, USERNAME_MAX);	return m;}

int add_defined(struct defined_networks *def, struct fsm *net, char *string) {    struct defined_networks *d;    if (net == NULL)	return 0;    fsm_count(net);    for (d = def; d != NULL; d = d->next) {	if (d->name != NULL && strcmp(d->name, string) == 0) {	    xxfree(d->net);	    xxfree(d->name);	    d->net = net;	    d->name = xxstrdup(string);	    return 1;	}    }    if (def->name == NULL) {	d = def;    } else {	d = xxmalloc(sizeof(struct defined_networks));	d->next = def->next;	def->next = d;    }    d->name = xxstrdup(string);    d->net = net;    return 0;}

char *chirp_ticket_tostring(struct chirp_ticket *ct){	size_t n;	const char *s;	char *result;	buffer_t *B;	B = buffer_create();	buffer_printf(B, "subject /"%s/"/n", ct->subject);	buffer_printf(B, "ticket /"%s/"/n", ct->ticket);	buffer_printf(B, "expiration /"%lu/"/n", (unsigned long) ct->expiration);	for(n = 0; n < ct->nrights; n++) {		buffer_printf(B, "rights /"%s/" /"%s/"/n", ct->rights[n].directory, ct->rights[n].acl);	}	s = buffer_tostring(B, &n);	result = xxmalloc(n + 1);	memset(result, 0, n + 1);	memcpy(result, s, n);	buffer_delete(B);	return result;}

void fsm_construct_add_arc(struct fsm_construct_handle *handle, int source, int target, char *in, char *out) {    struct fsm_state_list *sl;    struct fsm_trans_list *tl;    int symin, symout;    fsm_construct_check_size(handle, source);    fsm_construct_check_size(handle, target);    if (source > handle->maxstate)        handle->maxstate = source;    if (target > handle->maxstate)        handle->maxstate = target;    sl = (handle->fsm_state_list)+target;    sl->used = 1;    sl = (handle->fsm_state_list)+source;    sl->used = 1;    tl = xxmalloc(sizeof(struct fsm_trans_list));    tl->next = sl->fsm_trans_list;    sl->fsm_trans_list = tl;    if ((symin = fsm_construct_check_symbol(handle,in)) == -1)        symin = fsm_construct_add_symbol(handle,in);    if ((symout = fsm_construct_check_symbol(handle,out)) == -1)        symout = fsm_construct_add_symbol(handle,out);    tl->in = symin;    tl->out = symout;    tl->target = target;}

static int ticket_translate(const char *name, char *ticket_subject){	char command[PATH_MAX * 2 + 4096];	const char *dummy;	if(chirp_ticket_isticketsubject(name, &dummy)) {		strcpy(ticket_subject, name);		return 1;	}	char *pk = xxmalloc(65536); /* max size of public key */	sprintf(command, "sed '/^//s*#/d' < '%s' | openssl rsa -pubout 2> /dev/null", name);	FILE *pkf = popen(command, "r");	int length = fread(pk, sizeof(char), 65536, pkf);	if(length <= 0) {		pclose(pkf);		return 0;	}	pk[length] = 0;	pclose(pkf);	/* load the digest */	const char *digest = chirp_ticket_digest(pk);	sprintf(ticket_subject, "ticket:%s", digest);	return 1;}

static INT64_T do_ticket_get(int argc, char **argv){	char *subject;	char *ticket;	time_t duration;	char **rights;	INT64_T result = chirp_reli_ticket_get(current_host, argv[1], &subject, &ticket, &duration, &rights, stoptime);	if(result == 0) {		printf("%s/n", subject);		free(subject);		/* base64 encode the ticket so it fits on one line */		char *bticket = xxmalloc(sizeof(char) * strlen(ticket) * 2 + 10);	/* double is more than 4/3 needed */		b64_encode(ticket, strlen(ticket), bticket, strlen(ticket) * 2 + 10);		printf("%s/n", bticket);		free(bticket);		free(ticket);		printf("%llu/n", (unsigned long long) duration);		char **tmp = rights;		for(; tmp && tmp[0] && tmp[1]; tmp += 2) {			printf("%s %s/n", tmp[0], tmp[1]);			free(tmp[0]);			free(tmp[1]);		}		free(rights);	}	return result;}

buffer_t *buffer_create(void){	buffer_t *b = xxmalloc(sizeof(buffer_t));	b->buf = NULL;	b->size = 0;	return b;}

char *file_to_mem(char *name) {    FILE    *infile;    size_t    numbytes;    char *buffer;    infile = fopen(name, "r");    if(infile == NULL) {        printf("Error opening file '%s'/n",name);        return NULL;    }    fseek(infile, 0L, SEEK_END);    numbytes = ftell(infile);    fseek(infile, 0L, SEEK_SET);    buffer = (char*)xxmalloc((numbytes+1) * sizeof(char));    if(buffer == NULL) {        printf("Error reading file '%s'/n",name);        return NULL;    }    if (fread(buffer, sizeof(char), numbytes, infile) != numbytes) {        printf("Error reading file '%s'/n",name);        return NULL;    }    fclose(infile);    *(buffer+numbytes)='/0';    return(buffer);}

struct io_buf_handle *io_init() {    struct io_buf_handle *iobh;    iobh = xxmalloc(sizeof(struct io_buf_handle));    (iobh->io_buf) = NULL;    (iobh->io_buf_ptr) = NULL;    return(iobh);}

static int ast_do_simple( int line, int argc, char **argv, int fds[3], time_t stoptime ){	char *cmd;	int length=0;	int i;	for( i=0; i<argc; i++ ) {		length+=strlen(argv[i])+1;	}	cmd = xxmalloc(length+1);	cmd[0] = 0;	for( i=0; i<argc; i++ ) {		strcat(cmd,argv[i]);		strcat(cmd," ");	}	ftsh_error(FTSH_ERROR_COMMAND,line,"%s",cmd);	free(cmd);	if(hash_table_lookup(ftable,argv[0]) || builtin_lookup(argv[0]) ) {		return ast_do_internal(line,argc,argv,fds,stoptime);	} else {		return ast_do_external(line,argc,argv,fds,stoptime);	}}

struct list *get_workload_specs(const char *path) {		struct list *specs = list_create();	if(!specs) {		fprintf(stderr, "Cannot allocate memory for creating list!/n");		return NULL;	}	// Read in new configuration from file	FILE *fp;	fp = fopen(path, "r");	if(!fp) {		fprintf(stderr, "Failed to open workload specification file at %s./n", path);		return NULL;	}	char *line;	int line_count = 0;	while((line = get_line(fp))) {		line_count++;		string_chomp(line);		if(string_isspace(line)) { // skip empty lines			continue;		}		if(line[0] == '#') { // skip comment lines			continue;		}				int submit, input, exe, output, num;		if(sscanf(line, "%d %d %d %d %d", &submit, &input, &exe, &output, &num) == 5) {			if(submit < 0 || input <=0 || exe <=0 || output <=0 || num <=0) {				fprintf(stderr, "Other than the submit_time field, every other field should be greater than 0./n");				goto fail;			}			struct task_series *ts = (struct task_series *)xxmalloc(sizeof(struct task_series));			ts->submit_time = submit;			ts->input_size = input;			ts->execution_time = exe;			ts->output_size = output;			ts->num_of_tasks = num;			list_push_priority(specs, ts, ts->submit_time);		} else {			fprintf(stderr, "Line %d is invalid: %s/n", line_count, line);			goto fail;		}	}	fclose(fp);	return specs;fail:	// delete list	list_free(specs);	list_delete(specs);	fclose(fp);	return NULL;}

void apply_add_sigma_trie(struct apply_handle *h, int number, char *symbol, int len) {    /* Create a trie of sigma symbols (prefixes) so we can    */    /* quickly (in O(n)) tokenize an arbitrary string into    */    /* integer sequences representing symbols, using longest- */    /* leftmost factorization.                                */    int i;    struct sigma_trie *st;    struct sigma_trie_arrays *sta;    st = h->sigma_trie;    for (i = 0; i < len; i++) {	st = st+(unsigned char)*(symbol+i);	if (i == (len-1)) {	    st->signum = number;	} else {	    if (st->next == NULL) {		st->next = xxcalloc(256,sizeof(struct sigma_trie));				st = st->next;		/* store these arrays to free them later */		sta = xxmalloc(sizeof(struct sigma_trie_arrays));		sta->arr = st;		sta->next = h->sigma_trie_arrays;		h->sigma_trie_arrays = sta;	    } else {		st = st->next;	    }	}    }}

void apply_add_sigma_trie(struct apply_handle *h, int number, char *symbol) {    int i, len;    struct sigma_trie *st;    struct sigma_trie_arrays *sta;    len = strlen(symbol);    st = h->sigma_trie;    for (i = 0; i < len; i++) {	st = st+(unsigned char)*(symbol+i);	if (i == (len-1)) {	    st->signum = number;	} else {	    if (st->next == NULL) {		st->next = xxcalloc(256,sizeof(struct sigma_trie));				st = st->next;		/* store these arrays to free them later */		sta = xxmalloc(sizeof(struct sigma_trie_arrays));		sta->arr = st;		sta->next = h->sigma_trie_arrays;		h->sigma_trie_arrays = sta;	    } else {		st = st->next;	    }	}    }}

static int nhash_insert(int hashval, int *set, int setsize) {   struct nhash_list *tableptr;    int i, fs = 0;  current_setnum++;  tableptr = table+hashval;  nhash_load++;  for (i = 0; i < setsize; i++) {      if (finals[*(set+i)])          fs = 1;  }  if (tableptr->size == 0) {          tableptr->set_offset = move_set(set, setsize);      tableptr->size = setsize;      tableptr->setnum = current_setnum;            add_T_ptr(current_setnum, setsize, tableptr->set_offset, fs);      return(current_setnum);  }    tableptr = xxmalloc(sizeof(struct nhash_list));  tableptr->next = (table+hashval)->next;  (table+hashval)->next = tableptr;  tableptr->setnum = current_setnum;  tableptr->size = setsize;  tableptr->set_offset = move_set(set, setsize);    add_T_ptr(current_setnum, setsize, tableptr->set_offset, fs);  return(current_setnum);}

int sigma_sort(struct fsm *net) {#ifdef ORIGINAL  int(*comp)() = ssortcmp;#else  int(*comp)(const void*, const void*) = ssortcmp;#endif  int size, i, max, *replacearray;  struct ssort *ssort;  struct sigma *sigma;  struct fsm_state *fsm_state;    size = sigma_max(net->sigma);  if (size < 0) { return 1; }  ssort = xxmalloc(sizeof(struct ssort)*size);  for (i=0, sigma=net->sigma; sigma != NULL; sigma=sigma->next) {    if (sigma->number > IDENTITY) {      ssort[i].symbol = (char *)sigma->symbol;      ssort[i].number = sigma->number;      i++;    }  }  max = i;  qsort(ssort, max, sizeof(struct ssort), comp);  replacearray = xxmalloc(sizeof(int)*(size+3));  for (i=0; i<max; i++)      replacearray[(ssort+i)->number] = i+3;  /* Replace arcs */  for(i=0, fsm_state = net->states; (fsm_state+i)->state_no != -1; i++) {    if ((fsm_state+i)->in > IDENTITY)      (fsm_state+i)->in = replacearray[(fsm_state+i)->in];    if ((fsm_state+i)->out > IDENTITY)      (fsm_state+i)->out = replacearray[(fsm_state+i)->out];  }  /* Replace sigma */  for (i=0, sigma=net->sigma; sigma != NULL; sigma=sigma->next) {    if (sigma->number > IDENTITY) {      sigma->number = i+3;      sigma->symbol = (ssort+i)->symbol;      i++;    }  }  xxfree(replacearray);  xxfree(ssort);  return(1);}

void sigma_cleanup (struct fsm *net, int force) {    int i,j,first,maxsigma,*attested;    struct fsm_state *fsm;    struct sigma *sig, *sig_prev, *sign;        if (force == 0) {        if (sigma_find_number(IDENTITY, net->sigma) != -1)            return;        if (sigma_find_number(UNKNOWN, net->sigma) != -1)            return;    }    maxsigma = sigma_max(net->sigma);    if (maxsigma < 0) { return; }    attested = xxmalloc(sizeof(int)*(maxsigma+1));    for (i=0; i<=maxsigma; i++)        *(attested+i) = 0;    fsm = net->states;    for (i=0; (fsm+i)->state_no != -1; i++) {        if ((fsm+i)->in >=0)            *(attested+(fsm+i)->in) = 1;        if ((fsm+i)->out >=0)            *(attested+(fsm+i)->out) = 1;    }    for (i=3,j=3; i<=maxsigma;i++ ) {        if (*(attested+i)) {            *(attested+i) = j;            j++;        }    }    for (i=0; (fsm+i)->state_no != -1; i++) {                if ((fsm+i)->in > 2)            (fsm+i)->in = *(attested+(fsm+i)->in);        if ((fsm+i)->out > 2)            (fsm+i)->out = *(attested+(fsm+i)->out);    }    sig_prev = NULL;    for (sig = net->sigma; sig != NULL && sig->number != -1; sig = sign) {        first = 1;	sign = sig->next;        if (!*(attested+(sig->number))) {	    xxfree(sig->symbol);	    xxfree(sig);            if (sig_prev != NULL) {                sig_prev->next = sign;                first = 0;            } else {                first = 0;                net->sigma = sign;            }        } else {            sig->number = sig->number >= 3 ? *(attested+(sig->number)) : sig->number;        }        if (first)            sig_prev = sig;    }    xxfree(attested);    return;}

void apply_create_statemap(struct apply_handle *h, struct fsm *net) {    int i;    struct fsm_state *fsm;    fsm = net->states;    h->statemap = xxmalloc(sizeof(int)*net->statecount);    h->marks = xxmalloc(sizeof(int)*net->statecount);    for (i=0; i < net->statecount; i++) {	*(h->statemap+i) = -1;	*(h->marks+i) = 0;    }    for (i=0; (fsm+i)->state_no != -1; i++) {	if (*(h->statemap+(fsm+i)->state_no) == -1) {	    *(h->statemap+(fsm+i)->state_no) = i;	}    }}

static void add_mount_entry( const char *prefix, const char *redirect ){	struct mount_entry * m = xxmalloc(sizeof(*m));	strcpy(m->prefix,prefix);	strcpy(m->redirect,redirect);	m->next = mount_list;	mount_list = m;}

void debug_config_fatal(void (*callback) ()){	struct fatal_callback *f;	f = xxmalloc(sizeof(*f));	f->callback = callback;	f->next = fatal_callback_list;	fatal_callback_list = f;}

struct sigma *sigma_create() {  struct sigma *sigma;  sigma = xxmalloc(sizeof(struct sigma));  sigma->number = -1; /*Empty sigma*/  sigma->next = NULL;  sigma->symbol = NULL;  return(sigma);}

void * operator new (size_t sz) throw (std::bad_alloc){  void * ptr = xxmalloc (sz);  if (ptr == NULL) {    throw std::bad_alloc();  } else {    return ptr;  }}