/* Inserts strings into a set in each possible order, then
removes them in reverse order, up to a specified maximum
size. */
static void
test_insert_any_remove_reverse (void)
{
const int max_elems = 7;
int cnt;
for (cnt = 0; cnt <= max_elems; cnt++)
{
int *insertions, *deletions;
unsigned int permutation_cnt;
int i;
insertions = xnmalloc (cnt, sizeof *insertions);
deletions = xnmalloc (cnt, sizeof *deletions);
for (i = 0; i < cnt; i++)
insertions[i] = i;
for (permutation_cnt = 0;
permutation_cnt == 0 || next_permutation (insertions, cnt);
permutation_cnt++)
{
memcpy (deletions, insertions, sizeof *insertions * cnt);
reverse (deletions, cnt);
test_insert_delete (insertions, deletions, cnt);
}
check (permutation_cnt == factorial (cnt));
free (insertions);
free (deletions);
}
}
struct _xstring* xstring_init(void)
{
struct _xstring *p = (struct _xstring *) xnmalloc(sizeof(struct _xstring));
bzero(p, sizeof(struct _xstring));
p->cur_size = INIT_STRING_LENGTH;
p->content = (char *) xnmalloc(p->cur_size * sizeof(char));
p->keycode = (KeyCode *) xnmalloc(p->cur_size * sizeof(KeyCode));
p->keycode_modifiers = (int *) xnmalloc(p->cur_size * sizeof(int));
bzero(p->content, p->cur_size * sizeof(char));
bzero(p->keycode, p->cur_size * sizeof(KeyCode));
bzero(p->keycode_modifiers, p->cur_size * sizeof(int));
// Functions mapping
p->clear = xstring_clear;
p->is_space_last = xstring_is_space_last;
p->set_key_code = xstring_set_key_code;
p->set_content = xstring_set_content;
p->changecase_content = xstring_changecase_content;
p->add_symbol = xstring_add_symbol;
p->del_symbol = xstring_del_symbol;
p->uninit = xstring_uninit;
return p;
}
/* Inserts and removes strings in a set, in random order. */
static void
test_random_sequence (void)
{
const int max_elems = 64;
const int max_trials = 8;
int cnt;
for (cnt = 0; cnt <= max_elems; cnt += 2)
{
int *insertions, *deletions;
int trial;
int i;
insertions = xnmalloc (cnt, sizeof *insertions);
deletions = xnmalloc (cnt, sizeof *deletions);
for (i = 0; i < cnt; i++)
insertions[i] = i;
for (i = 0; i < cnt; i++)
deletions[i] = i;
for (trial = 0; trial < max_trials; trial++)
{
random_shuffle (insertions, cnt, sizeof *insertions);
random_shuffle (deletions, cnt, sizeof *deletions);
test_insert_delete (insertions, deletions, cnt);
}
free (insertions);
free (deletions);
}
}
struct _xkeymap* xkeymap_init(void)
{
struct _xkeymap *p = (struct _xkeymap *) xnmalloc(sizeof(struct _xkeymap));
bzero(p, sizeof(struct _xkeymap));
p->latin_group = 0;
p->latin_group_mask = 0; // Define latin group mask
p->alphabet = xnmalloc(1);
if (!xkeymap_init_keymaps(p))
return NULL;
if (!xkeymap_locale_create(p))
return NULL;
if (!xkeymap_define_latin_group(p))
return NULL;
p->get_ascii = xkeymap_get_ascii;
p->get_cur_ascii_char = xkeymap_get_cur_ascii_char;
p->convert_text_to_ascii = xkeymap_convert_text_to_ascii;
p->store_keymaps = xkeymap_store_keymaps;
p->char_to_keycode = xkeymap_char_to_keycode;
return p;
}
void
relation_transpose (relation *R_arg, relation_node n)
{
relation r = *R_arg;
/* The result. */
relation new_R = xnmalloc (n, sizeof *new_R);
/* END_R[I] -- next entry of NEW_R[I]. */
relation end_R = xnmalloc (n, sizeof *end_R);
/* NEDGES[I] -- total size of NEW_R[I]. */
size_t *nedges = xcalloc (n, sizeof *nedges);
relation_node i;
relation_node j;
if (trace_flag & trace_sets)
{
fputs ("relation_transpose: input\n", stderr);
relation_print (r, n, stderr);
}
/* Count. */
for (i = 0; i < n; i++)
if (r[i])
for (j = 0; r[i][j] != END_NODE; ++j)
++nedges[r[i][j]];
/* Allocate. */
for (i = 0; i < n; i++)
{
relation_node *sp = NULL;
if (nedges[i] > 0)
{
sp = xnmalloc (nedges[i] + 1, sizeof *sp);
sp[nedges[i]] = END_NODE;
}
new_R[i] = sp;
end_R[i] = sp;
}
/* Store. */
for (i = 0; i < n; i++)
if (r[i])
for (j = 0; r[i][j] != END_NODE; ++j)
*end_R[r[i][j]]++ = i;
free (nedges);
free (end_R);
/* Free the input: it is replaced with the result. */
for (i = 0; i < n; i++)
free (r[i]);
free (r);
if (trace_flag & trace_sets)
{
fputs ("relation_transpose: output\n", stderr);
relation_print (new_R, n, stderr);
}
*R_arg = new_R;
}
static void xkeymap_store_keymaps(struct _xkeymap *p, int group)
{
int min_keycode, max_keycode, keysyms_per_keycode;
KeySym *keymap;
XDisplayKeycodes (main_window->display, &min_keycode, &max_keycode);
keymap = XGetKeyboardMapping (main_window->display, min_keycode, max_keycode - min_keycode + 1, &keysyms_per_keycode);
p->min_keycode = min_keycode;
p->max_keycode = max_keycode;
if (p->total_key_arrays < group)
p->total_key_arrays = group;
p->alphabet = xnrealloc(p->alphabet, (group + 1) * sizeof(struct _xkeymap_alpha));
p->alphabet[group] = xnmalloc((max_keycode + 1) * sizeof(struct _xkeymap_alpha));
for (int i = min_keycode; i <= max_keycode; i++)
{
int j;
p->alphabet[group][i].lower_sym = xnmalloc(1);
p->alphabet[group][i].lower_sym[0] = NULLSYM;
p->alphabet[group][i].upper_sym = xnmalloc(1);
p->alphabet[group][i].upper_sym[0] = NULLSYM;
for (j = group*2; j <= group*2 + 1; j++)
{
KeySym ks = keymap[j];
int groups[4] = {0x00000000, 0x00002000, 0x00004000, 0x00006000};
if (ks != NoSymbol)
{
XEvent event = create_basic_event();
event.xkey.keycode = i;
event.xkey.state = groups[group];
if (j == group*2 + 1)
event.xkey.state |= ShiftMask;
int nbytes;
char str[256+1];
nbytes = XLookupString ((XKeyEvent *) &event, str, 256, &ks, NULL);
if (nbytes > 0)
{
if (j == group*2)
{
p->alphabet[group][i].lower_sym = xnmalloc(nbytes+1);
strncpy(p->alphabet[group][i].lower_sym, str, nbytes+1);
p->alphabet[group][i].lower_sym[nbytes] = NULLSYM;
}
else
{
p->alphabet[group][i].upper_sym = xnmalloc(nbytes+1);
strncpy(p->alphabet[group][i].upper_sym, str, nbytes+1);
p->alphabet[group][i].upper_sym[nbytes] = NULLSYM;
}
}
}
}
keymap += keysyms_per_keycode;
}
}
ER cre_mbx(ID mbxid, T_CMBX *pk_cmbx)
{
uimbx_t *mbx;
T_MSG **ring;
if (xnpod_asynch_p())
return EN_CTXID;
if (mbxid <= 0 || mbxid > uITRON_MAX_MBXID)
return E_ID;
if (pk_cmbx->bufcnt <= 0)
return E_PAR;
if (pk_cmbx->mbxatr & TA_MPRI)
return E_RSATR;
mbx = xnmalloc(sizeof(*mbx));
if (!mbx)
return E_NOMEM;
ring = xnmalloc(sizeof(T_MSG *) * pk_cmbx->bufcnt);
if (!ring) {
xnfree(mbx);
return E_NOMEM;
}
mbxid = xnmap_enter(ui_mbx_idmap, mbxid, mbx);
if (mbxid <= 0) {
xnfree(mbx);
return E_OBJ;
}
xnsynch_init(&mbx->synchbase,
(pk_cmbx->mbxatr & TA_TPRI) ? XNSYNCH_PRIO : XNSYNCH_FIFO);
mbx->id = mbxid;
mbx->exinf = pk_cmbx->exinf;
mbx->mbxatr = pk_cmbx->mbxatr;
mbx->bufcnt = pk_cmbx->bufcnt;
mbx->rdptr = 0;
mbx->wrptr = 0;
mbx->mcount = 0;
mbx->ring = ring;
#ifdef CONFIG_XENO_OPT_REGISTRY
sprintf(mbx->name, "mbx%d", mbxid);
xnregistry_enter(mbx->name, mbx, &mbx->handle, &__mbx_pnode);
#endif /* CONFIG_XENO_OPT_REGISTRY */
xnarch_memory_barrier();
mbx->magic = uITRON_MBX_MAGIC;
return E_OK;
}
size_t
readtokens (FILE *stream,
size_t projected_n_tokens,
const char *delim,
size_t n_delim,
char ***tokens_out,
size_t **token_lengths)
{
token_buffer tb, *token = &tb;
char **tokens;
size_t *lengths;
size_t sz;
size_t n_tokens;
if (projected_n_tokens == 0)
projected_n_tokens = 64;
else
projected_n_tokens++; /* add one for trailing NULL pointer */
sz = projected_n_tokens;
tokens = xnmalloc (sz, sizeof *tokens);
lengths = xnmalloc (sz, sizeof *lengths);
n_tokens = 0;
init_tokenbuffer (token);
for (;;)
{
char *tmp;
size_t token_length = readtoken (stream, delim, n_delim, token);
if (n_tokens >= sz)
{
tokens = x2nrealloc (tokens, &sz, sizeof *tokens);
lengths = xnrealloc (lengths, sz, sizeof *lengths);
}
if (token_length == (size_t) -1)
{
/* don't increment n_tokens for NULL entry */
tokens[n_tokens] = NULL;
lengths[n_tokens] = 0;
break;
}
tmp = xnmalloc (token_length + 1, sizeof *tmp);
lengths[n_tokens] = token_length;
tokens[n_tokens] = memcpy (tmp, token->buffer, token_length + 1);
n_tokens++;
}
free (token->buffer);
*tokens_out = tokens;
if (token_lengths != NULL)
*token_lengths = lengths;
else
free (lengths);
return n_tokens;
}
static void
allocate_storage (void)
{
allocate_itemsets ();
shiftset = xnmalloc (nsyms, sizeof *shiftset);
redset = xnmalloc (nrules, sizeof *redset);
state_hash_new ();
shift_symbol = xnmalloc (nsyms, sizeof *shift_symbol);
}
static void
nonterminals_reduce (void)
{
/* Map the nonterminals to their new index: useful first, useless
afterwards. Kept for later report. */
symbol_number *nontermmap = xnmalloc (nvars, sizeof *nontermmap);
symbol_number n = ntokens;
symbol_number i;
for (i = ntokens; i < nsyms; i++)
if (bitset_test (V, i))
nontermmap[i - ntokens] = n++;
for (i = ntokens; i < nsyms; i++)
if (!bitset_test (V, i))
{
nontermmap[i - ntokens] = n++;
if (symbols[i]->status != used)
complain (&symbols[i]->location, Wother,
_("nonterminal useless in grammar: %s"),
symbols[i]->tag);
}
/* Shuffle elements of tables indexed by symbol number. */
{
symbol **symbols_sorted = xnmalloc (nvars, sizeof *symbols_sorted);
for (i = ntokens; i < nsyms; i++)
symbols[i]->number = nontermmap[i - ntokens];
for (i = ntokens; i < nsyms; i++)
symbols_sorted[nontermmap[i - ntokens] - ntokens] = symbols[i];
for (i = ntokens; i < nsyms; i++)
symbols[i] = symbols_sorted[i - ntokens];
free (symbols_sorted);
}
{
rule_number r;
for (r = 0; r < nrules; ++r)
{
item_number *rhsp;
for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
if (ISVAR (*rhsp))
*rhsp = symbol_number_as_item_number (nontermmap[*rhsp
- ntokens]);
}
accept->number = nontermmap[accept->number - ntokens];
}
nsyms -= nuseless_nonterminals;
nvars -= nuseless_nonterminals;
free (nontermmap);
}
void
derives_compute (void)
{
symbol_number i;
rule_number r;
rule **q;
/* DSET[NTERM - NTOKENS] -- A linked list of the numbers of the rules
whose LHS is NTERM. */
rule_list **dset = xcalloc (nvars, sizeof *dset);
/* DELTS[RULE] -- There are NRULES rule number to attach to nterms.
Instead of performing NRULES allocations for each, have an array
indexed by rule numbers. */
rule_list *delts = xnmalloc (nrules, sizeof *delts);
for (r = nrules - 1; r >= 0; --r)
{
symbol_number lhs = rules[r].lhs->number;
rule_list *p = &delts[r];
/* A new LHS is found. */
p->next = dset[lhs - ntokens];
p->value = &rules[r];
dset[lhs - ntokens] = p;
}
/* DSET contains what we need under the form of a linked list. Make
it a single array. */
derives = xnmalloc (nvars, sizeof *derives);
q = xnmalloc (nvars + nrules, sizeof *q);
for (i = ntokens; i < nsyms; i++)
{
rule_list *p = dset[i - ntokens];
derives[i - ntokens] = q;
while (p)
{
*q++ = p->value;
p = p->next;
}
*q++ = NULL;
}
if (trace_flag & trace_sets)
print_derives ();
free (dset);
free (delts);
}
/* sets a pattern to override the severity stated by the program
* or application for an error. The pattern is applied to the event text
* each time _send() is called. Each override will take some space
* so unused ones should be discarded with _rmoverride().
* returns 1 if successfully added to list, or 0 if unable to add.
*/
int elog_setoverride(enum elog_severity severity, /* severity level */
char *re_pattern /* reg exp pattern */ )
{
int r;
char errbuf[ELOG_STRLEN];
struct elog_overridedat *over;
elog_checkinit();
/* severity in range? */
if (severity >= ELOG_NSEVERITIES || severity < 0)
return 0;
over = xnmalloc(sizeof(struct elog_overridedat));
if ((r = regcomp(&over->pattern, re_pattern, (REG_EXTENDED|REG_NOSUB)))) {
regerror(r, &over->pattern, errbuf, ELOG_STRLEN);
elog_printf(ERROR, "elog_setoverride() problem with key "
"pattern: %s\nError is %s\n", re_pattern, errbuf);
nfree(over);
return 0;
}
over->severity = severity;
tree_add(elog_override, xnstrdup(re_pattern), over);
return 1;
}
char* get_file_content(const char *file_name)
{
struct stat sb;
if (stat(file_name, &sb) != 0 || sb.st_size < 0)
return NULL;
FILE *stream = fopen(file_name, "rb");
if (stream == NULL)
return NULL;
unsigned int file_len = sb.st_size;
char *content = (char *) xnmalloc((file_len + 2) * sizeof(char)); // + 1 '\n' + 1 '\0'
if (fread(content, 1, file_len, stream) != file_len)
{
free(content);
fclose(stream);
return NULL;
}
content[file_len] = '\n';
content[file_len + 1] = '\0';
fclose(stream);
return content;
}
/* Inserts strings into a map in ascending order, then delete in ascending
order. */
static void
test_insert_ordered (void)
{
const int max_elems = 64;
int *values;
struct string_map map;
int i;
string_map_init (&map);
values = xnmalloc (max_elems, sizeof *values);
for (i = 0; i < max_elems; i++)
{
values[i] = i | random_value (i, 4);
string_map_insert_nocopy (&map, xstrdup (make_key (values[i])),
xstrdup (make_value (values[i])));
check_string_map (&map, values, i + 1);
}
for (i = 0; i < max_elems; i++)
{
string_map_delete (&map, make_key (i));
check_string_map (&map, values + i + 1, max_elems - i - 1);
}
string_map_destroy (&map);
free (values);
}
char* convert_text_to_translit(const char *text)
{
int i, j, len = strlen(text);
char *trans_text = (char *)xnmalloc((len * 3 + 1) * sizeof(char));
for(i = 0, j = 0; i < len; i++)
{
if (isascii(text[i]))
{
trans_text[j++] = text[i];
continue;
}
const char *new_symbol = get_translit(&text[i]);
for(; i < len - 1; i++)
{
if (isascii(text[i + 1]))
break;
if (get_translit(&text[i + 1]) != NULLSYM)
break;
}
while (*new_symbol != NULLSYM)
{
trans_text[j++] = *new_symbol;
new_symbol++;
}
}
trans_text[j] = NULLSYM;
return trans_text;
}
void backtrace_log(int retval, const char *fn,
const char *file, int lineno)
{
struct backtrace_data *btd;
struct error_frame *ef;
btd = pthread_getspecific(btkey);
if (btd == NULL)
btd = &main_btd;
ef = xnmalloc(sizeof(*ef));
if (ef == NULL)
return;
ef->retval = retval;
ef->lineno = lineno;
ef->fn = fn;
ef->file = file;
write_lock(&btd->lock);
if (btd->inner == NULL)
/* Fire the hook for the inner trace. */
error_hook(ef);
ef->next = btd->inner;
btd->inner = ef;
write_unlock(&btd->lock);
}
/* Inserts strings into a set in each possible order, then removes them in the
same order, up to a specified maximum size. */
static void
test_insert_any_remove_same (void)
{
const int max_elems = 7;
int cnt;
for (cnt = 0; cnt <= max_elems; cnt++)
{
int *values;
unsigned int permutation_cnt;
int i;
values = xnmalloc (cnt, sizeof *values);
for (i = 0; i < cnt; i++)
values[i] = i;
for (permutation_cnt = 0;
permutation_cnt == 0 || next_permutation (values, cnt);
permutation_cnt++)
test_insert_delete (values, values, cnt);
check (permutation_cnt == factorial (cnt));
free (values);
}
}
/**
* Set name attribute.
*
* This service set to @a name, the value of the @a name attribute in the
* attribute object @a attr.
*
* The @a name attribute is the name under which a thread created with the
* attribute object @a attr will appear under /proc/xenomai/sched.
*
* If @a name is @a NULL, a unique default name will be used.
*
* This service is a non-portable extension of the POSIX interface.
*
* @param attr attribute object;
*
* @param name value of the @a name attribute.
*
* @return 0 on success;
* @return an error number if:
* - EINVAL, @a attr is invalid;
* - ENOMEM, insufficient memory exists in the system heap to duplicate the name
* string, increase CONFIG_XENO_OPT_SYS_HEAPSZ.
*
* @par Valid contexts:
* - kernel module initialization or cleanup routine;
* - Xenomai kernel-space thread.
*/
int pthread_attr_setname_np(pthread_attr_t * attr, const char *name)
{
char *old_name, *new_name;
spl_t s;
if (name) {
new_name = xnmalloc(strlen(name) + 1);
if (!new_name)
return ENOMEM;
strcpy(new_name, name);
} else
new_name = NULL;
xnlock_get_irqsave(&nklock, s);
if (!pse51_obj_active(attr, PSE51_THREAD_ATTR_MAGIC, pthread_attr_t)) {
xnlock_put_irqrestore(&nklock, s);
if (name)
xnfree(new_name);
return EINVAL;
}
old_name = attr->name;
attr->name = new_name;
xnlock_put_irqrestore(&nklock, s);
if (old_name)
xnfree(old_name);
return 0;
}
ER cre_flg(ID flgid, T_CFLG *pk_cflg)
{
uiflag_t *flag;
if (xnpod_asynch_p())
return EN_CTXID;
if (flgid <= 0 || flgid > uITRON_MAX_MBXID)
return E_ID;
flag = xnmalloc(sizeof(*flag));
if (!flag)
return E_NOMEM;
flgid = xnmap_enter(ui_flag_idmap, flgid, flag);
if (flgid <= 0) {
xnfree(flag);
return E_OBJ;
}
xnsynch_init(&flag->synchbase, XNSYNCH_FIFO, NULL);
flag->id = flgid;
flag->exinf = pk_cflg->exinf;
flag->flgatr = pk_cflg->flgatr;
flag->flgvalue = pk_cflg->iflgptn;
sprintf(flag->name, "flg%d", flgid);
xnregistry_enter(flag->name, flag, &flag->handle, &__flag_pnode.node);
xnarch_memory_barrier();
flag->magic = uITRON_FLAG_MAGIC;
return E_OK;
}
void
conflicts_solve (void)
{
state_number i;
/* List of lookahead tokens on which we explicitly raise a syntax error. */
symbol **errors = xnmalloc (ntokens + 1, sizeof *errors);
conflicts = xcalloc (nstates, sizeof *conflicts);
shift_set = bitset_create (ntokens, BITSET_FIXED);
lookahead_set = bitset_create (ntokens, BITSET_FIXED);
obstack_init (&solved_conflicts_obstack);
obstack_init (&solved_conflicts_xml_obstack);
for (i = 0; i < nstates; i++)
{
set_conflicts (states[i], errors);
/* For uniformity of the code, make sure all the states have a valid
`errs' member. */
if (!states[i]->errs)
states[i]->errs = errs_new (0, 0);
}
free (errors);
}
static void
prepare_symbols (void)
{
MUSCLE_INSERT_INT ("tokens_number", ntokens);
MUSCLE_INSERT_INT ("nterms_number", nvars);
MUSCLE_INSERT_INT ("symbols_number", nsyms);
MUSCLE_INSERT_INT ("undef_token_number", undeftoken->number);
MUSCLE_INSERT_INT ("user_token_number_max", max_user_token_number);
muscle_insert_symbol_number_table ("translate",
token_translations,
token_translations[0],
1, max_user_token_number + 1);
/* tname -- token names. */
{
int i;
/* We assume that the table will be output starting at column 2. */
int j = 2;
struct quoting_options *qo = clone_quoting_options (0);
set_quoting_style (qo, c_quoting_style);
set_quoting_flags (qo, QA_SPLIT_TRIGRAPHS);
for (i = 0; i < nsyms; i++)
{
char *cp = quotearg_alloc (symbols[i]->tag, -1, qo);
/* Width of the next token, including the two quotes, the
comma and the space. */
int width = strlen (cp) + 2;
if (j + width > 75)
{
obstack_sgrow (&format_obstack, "\n ");
j = 1;
}
if (i)
obstack_1grow (&format_obstack, ' ');
obstack_escape (&format_obstack, cp);
free (cp);
obstack_1grow (&format_obstack, ',');
j += width;
}
free (qo);
obstack_sgrow (&format_obstack, " ]b4_null[");
/* Finish table and store. */
muscle_insert ("tname", obstack_finish0 (&format_obstack));
}
/* Output YYTOKNUM. */
{
int i;
int *values = xnmalloc (ntokens, sizeof *values);
for (i = 0; i < ntokens; ++i)
values[i] = symbols[i]->user_token_number;
muscle_insert_int_table ("toknum", values,
values[0], 1, ntokens);
free (values);
}
}
MSG_Q_ID msgQCreate(int nb_msgs, int length, int flags)
{
static unsigned long msgq_ids;
wind_msgq_t *queue;
xnflags_t bflags = 0;
int i, msg_size;
char *msgs_mem;
spl_t s;
check_NOT_ISR_CALLABLE(return 0);
error_check(nb_msgs <= 0, S_msgQLib_INVALID_QUEUE_TYPE, return 0);
error_check(flags & ~WIND_MSG_Q_OPTION_MASK,
S_msgQLib_INVALID_QUEUE_TYPE, return 0);
error_check(length < 0, S_msgQLib_INVALID_MSG_LENGTH, return 0);
msgs_mem = xnmalloc(sizeof(wind_msgq_t) +
nb_msgs * (sizeof(wind_msg_t) + length));
error_check(msgs_mem == NULL, S_memLib_NOT_ENOUGH_MEMORY, return 0);
queue = (wind_msgq_t *)msgs_mem;
msgs_mem += sizeof(wind_msgq_t);
queue->magic = WIND_MSGQ_MAGIC;
queue->msg_length = length;
queue->free_list = NULL;
initq(&queue->msgq);
inith(&queue->rlink);
queue->rqueue = &wind_get_rholder()->msgQq;
/* init of the synch object : */
if (flags & MSG_Q_PRIORITY)
bflags |= XNSYNCH_PRIO;
xnsynch_init(&queue->synchbase, bflags, NULL);
msg_size = sizeof(wind_msg_t) + length;
for (i = 0; i < nb_msgs; ++i, msgs_mem += msg_size)
free_msg(queue, (wind_msg_t *)msgs_mem);
xnlock_get_irqsave(&nklock, s);
appendq(queue->rqueue, &queue->rlink);
xnlock_put_irqrestore(&nklock, s);
sprintf(queue->name, "mq%lu", msgq_ids++);
if (xnregistry_enter(queue->name, queue,
&queue->handle, &msgq_pnode)) {
wind_errnoset(S_objLib_OBJ_ID_ERROR);
msgQDelete((MSG_Q_ID)queue);
return 0;
}
return (MSG_Q_ID)queue;
}
static void
prepare_symbols (void)
{
MUSCLE_INSERT_BOOL ("token_table", token_table_flag);
MUSCLE_INSERT_INT ("tokens_number", ntokens);
MUSCLE_INSERT_INT ("nterms_number", nvars);
MUSCLE_INSERT_INT ("undef_token_number", undeftoken->number);
MUSCLE_INSERT_INT ("user_token_number_max", max_user_token_number);
muscle_insert_symbol_number_table ("translate",
token_translations,
token_translations[0],
1, max_user_token_number + 1);
/* tname -- token names. */
{
int i;
/* We assume that the table will be output starting at column 2. */
int j = 2;
for (i = 0; i < nsyms; i++)
{
char const *cp = quotearg_style (c_quoting_style, symbols[i]->tag);
/* Width of the next token, including the two quotes, the
comma and the space. */
int width = strlen (cp) + 2;
if (j + width > 75)
{
obstack_sgrow (&format_obstack, "\n ");
j = 1;
}
if (i)
obstack_1grow (&format_obstack, ' ');
MUSCLE_OBSTACK_SGROW (&format_obstack, cp);
obstack_1grow (&format_obstack, ',');
j += width;
}
/* Add a NULL entry to list of tokens (well, 0, as NULL might not be
defined). */
obstack_sgrow (&format_obstack, " 0");
/* Finish table and store. */
obstack_1grow (&format_obstack, 0);
muscle_insert ("tname", obstack_finish (&format_obstack));
}
/* Output YYTOKNUM. */
{
int i;
int *values = xnmalloc (ntokens, sizeof *values);
for (i = 0; i < ntokens; ++i)
values[i] = symbols[i]->user_token_number;
muscle_insert_int_table ("toknum", values,
values[0], 1, ntokens);
free (values);
}
}
struct dynvec *
make_dynvec (int n)
{
struct dynvec *dv = xmalloc (sizeof *dv);
dv->dv_vec = xnmalloc (n, sizeof *dv->dv_vec);
dv->dv_capacity = n;
dv->dv_fill = 0;
return dv;
}
static int __sc_tecreate(struct task_struct *curr, struct pt_regs *regs)
{
xncompletion_t __user *u_completion;
struct vrtx_arg_bulk bulk;
int prio, mode, tid, err;
vrtxtask_t *task;
if (!__xn_access_ok
(curr, VERIFY_READ, __xn_reg_arg1(regs), sizeof(bulk)))
return -EFAULT;
if (!__xn_access_ok
(curr, VERIFY_WRITE, __xn_reg_arg2(regs), sizeof(tid)))
return -EFAULT;
__xn_copy_from_user(curr, &bulk, (void __user *)__xn_reg_arg1(regs),
sizeof(bulk));
/* Suggested task id. */
tid = bulk.a1;
/* Task priority. */
prio = bulk.a2;
/* Task mode. */
mode = bulk.a3 | 0x100;
/* Completion descriptor our parent thread is pending on. */
u_completion = (xncompletion_t __user *)__xn_reg_arg3(regs);
task = xnmalloc(sizeof(*task));
if (!task) {
err = ER_TCB;
goto done;
}
xnthread_clear_state(&task->threadbase, XNZOMBIE);
tid =
sc_tecreate_inner(task, NULL, tid, prio, mode, 0, 0, NULL, 0, &err);
if (tid < 0) {
if (u_completion)
xnshadow_signal_completion(u_completion, err);
} else {
__xn_copy_to_user(curr, (void __user *)__xn_reg_arg2(regs),
&tid, sizeof(tid));
err = xnshadow_map(&task->threadbase, u_completion);
}
if (err && !xnthread_test_state(&task->threadbase, XNZOMBIE))
xnfree(task);
done:
return err;
}
char* lower_word(const char *word, int len)
{
char *ret = (char *) xnmalloc(len + 1);
int i;
for (i = 0; i < len; i++)
ret[i] = tolower(word[i]);
ret[len] = NULLSYM;
return ret;
}
static void
allocate_itemsets (void)
{
symbol_number i;
rule_number r;
item_number *rhsp;
/* Count the number of occurrences of all the symbols in RITEMS.
Note that useless productions (hence useless nonterminals) are
browsed too, hence we need to allocate room for _all_ the
symbols. */
size_t count = 0;
size_t *symbol_count = xcalloc (nsyms + nuseless_nonterminals,
sizeof *symbol_count);
for (r = 0; r < nrules; ++r)
for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
{
count++;
symbol_count[*rhsp]++;
}
/* See comments before new_itemsets. All the vectors of items
live inside KERNEL_ITEMS. The number of active items after
some symbol S cannot be more than the number of times that S
appears as an item, which is SYMBOL_COUNT[S].
We allocate that much space for each symbol. */
kernel_base = xnmalloc (nsyms, sizeof *kernel_base);
kernel_items = xnmalloc (count, sizeof *kernel_items);
count = 0;
for (i = 0; i < nsyms; i++)
{
kernel_base[i] = kernel_items + count;
count += symbol_count[i];
}
free (symbol_count);
kernel_size = xnmalloc (nsyms, sizeof *kernel_size);
}
/* Inserts strings into a map in each possible order, then removes them in each
possible order, up to a specified maximum size. */
static void
test_insert_any_remove_any (void)
{
const int basis = 0;
const int max_elems = 5;
int cnt;
for (cnt = 0; cnt <= max_elems; cnt++)
{
int *insertions, *deletions;
unsigned int ins_perm_cnt;
int i;
insertions = xnmalloc (cnt, sizeof *insertions);
deletions = xnmalloc (cnt, sizeof *deletions);
for (i = 0; i < cnt; i++)
insertions[i] = i | random_value (i, basis);
for (ins_perm_cnt = 0;
ins_perm_cnt == 0 || next_permutation (insertions, cnt);
ins_perm_cnt++)
{
unsigned int del_perm_cnt;
int i;
for (i = 0; i < cnt; i++)
deletions[i] = i | random_value (i, basis);
for (del_perm_cnt = 0;
del_perm_cnt == 0 || next_permutation (deletions, cnt);
del_perm_cnt++)
test_insert_delete (insertions, deletions, cnt);
check (del_perm_cnt == factorial (cnt));
}
check (ins_perm_cnt == factorial (cnt));
free (insertions);
free (deletions);
}
}
/*
Allocate a linreg and return a pointer to it. n is the number of
cases, p is the number of independent variables.
*/
linreg *
linreg_alloc (const struct variable *depvar, const struct variable **indep_vars,
double n, size_t p)
{
linreg *c;
size_t i;
c = xmalloc (sizeof (*c));
c->depvar = depvar;
c->indep_vars = xnmalloc (p, sizeof (*indep_vars));
c->dependent_column = p;
for (i = 0; i < p; i++)
{
c->indep_vars[i] = indep_vars[i];
}
c->indep_means = gsl_vector_alloc (p);
c->indep_std = gsl_vector_alloc (p);
c->ss_indeps = gsl_vector_alloc (p); /* Sums of squares for the
model parameters.
*/
c->n_obs = n;
c->n_indeps = p;
c->n_coeffs = p;
c->coeff = xnmalloc (p, sizeof (*c->coeff));
c->cov = gsl_matrix_calloc (c->n_coeffs + 1, c->n_coeffs + 1);
c->dft = n - 1;
c->dfm = p;
c->dfe = c->dft - c->dfm;
c->intercept = 0.0;
c->depvar_mean = 0.0;
c->depvar_std = 0.0;
/*
Default settings.
*/
c->method = LINREG_SWEEP;
c->pred = NULL;
c->resid = NULL;
return c;
}
struct _xwindow* xwindow_init(void)
{
struct _xwindow *p = (struct _xwindow *) xnmalloc(sizeof(struct _xwindow));
bzero(p, sizeof(struct _xwindow));
// Function mapping
p->create = xwindow_create;
p->destroy = xwindow_destroy;
p->move_window = xwindow_move_window;
return p;
}
