seg_allocator::HEADER* seg_allocator::reserveset( HEADER* p, uints count, uints chunk, bool keep, uchar set )
{
if(!p) {
p = allocset( count, chunk, set );
p->_count = 0;
}
else {
uints ocount = p->_count;
p = reallocset( p, count, chunk, keep, set );
p->_count = ocount < count ? ocount : count;
}
return p;
}
/*
- p_bracket - parse a bracketed character list
*
* Note a significant property of this code: if the allocset() did SETERROR,
* no set operations are done.
*/
static void
p_bracket(struct parse *p)
{
cset *cs;
int invert = 0;
/* Dept of Truly Sickening Special-Case Kludges */
if (p->next + 5 < p->end && strncmp(p->next, "[:<:]]", 6) == 0) {
EMIT(OBOW, 0);
NEXTn(6);
return;
}
if (p->next + 5 < p->end && strncmp(p->next, "[:>:]]", 6) == 0) {
EMIT(OEOW, 0);
NEXTn(6);
return;
}
if ((cs = allocset(p)) == NULL) {
/* allocset did set error status in p */
return;
}
if (EAT('^'))
invert++; /* make note to invert set at end */
if (EAT(']'))
CHadd(cs, ']');
else if (EAT('-'))
CHadd(cs, '-');
while (MORE() && PEEK() != ']' && !SEETWO('-', ']'))
p_b_term(p, cs);
if (EAT('-'))
CHadd(cs, '-');
MUSTEAT(']', REG_EBRACK);
if (p->error != 0) { /* don't mess things up further */
freeset(p, cs);
return;
}
if (p->g->cflags®_ICASE) {
int i;
int ci;
for (i = p->g->csetsize - 1; i >= 0; i--)
if (CHIN(cs, i) && isalpha(i)) {
ci = othercase(i);
if (ci != i)
CHadd(cs, ci);
}
if (cs->multis != NULL)
mccase(p, cs);
}
if (invert) {
int i;
for (i = p->g->csetsize - 1; i >= 0; i--)
if (CHIN(cs, i))
CHsub(cs, i);
else
CHadd(cs, i);
if (p->g->cflags®_NEWLINE)
CHsub(cs, '\n');
if (cs->multis != NULL)
mcinvert(p, cs);
}
assert(cs->multis == NULL); /* xxx */
if (nch(p, cs) == 1) { /* optimize singleton sets */
ordinary(p, firstch(p, cs));
freeset(p, cs);
} else
EMIT(OANYOF, freezeset(p, cs));
}
static int
_ti_readterm(TERMINAL *term, const char *cap, size_t caplen, int flags)
{
uint8_t ver;
uint16_t ind, num;
size_t len;
TERMUSERDEF *ud;
ver = *cap++;
/* Only read version 1 structures */
if (ver != 1) {
errno = EINVAL;
return -1;
}
if (allocset(&term->flags, 0, TIFLAGMAX + 1, sizeof(*term->flags)) == -1)
return -1;
if (allocset(&term->nums, -1, TINUMMAX + 1, sizeof(*term->nums)) == -1)
return -1;
if (allocset(&term->strs, 0, TISTRMAX + 1, sizeof(*term->strs)) == -1)
return -1;
if (term->_arealen != caplen) {
term->_arealen = caplen;
term->_area = realloc(term->_area, term->_arealen);
if (term->_area == NULL)
return -1;
}
memcpy(term->_area, cap, term->_arealen);
cap = term->_area;
len = le16dec(cap);
cap += sizeof(uint16_t);
term->name = cap;
cap += len;
len = le16dec(cap);
cap += sizeof(uint16_t);
if (len == 0)
term->_alias = NULL;
else {
term->_alias = cap;
cap += len;
}
len = le16dec(cap);
cap += sizeof(uint16_t);
if (len == 0)
term->desc = NULL;
else {
term->desc = cap;
cap += len;
}
num = le16dec(cap);
cap += sizeof(uint16_t);
if (num != 0) {
num = le16dec(cap);
cap += sizeof(uint16_t);
for (; num != 0; num--) {
ind = le16dec(cap);
cap += sizeof(uint16_t);
term->flags[ind] = *cap++;
if (flags == 0 && !VALID_BOOLEAN(term->flags[ind]))
term->flags[ind] = 0;
}
}
num = le16dec(cap);
cap += sizeof(uint16_t);
if (num != 0) {
num = le16dec(cap);
cap += sizeof(uint16_t);
for (; num != 0; num--) {
ind = le16dec(cap);
cap += sizeof(uint16_t);
term->nums[ind] = le16dec(cap);
if (flags == 0 && !VALID_NUMERIC(term->nums[ind]))
term->nums[ind] = ABSENT_NUMERIC;
cap += sizeof(uint16_t);
}
}
num = le16dec(cap);
cap += sizeof(uint16_t);
if (num != 0) {
num = le16dec(cap);
cap += sizeof(uint16_t);
for (; num != 0; num--) {
ind = le16dec(cap);
cap += sizeof(uint16_t);
len = le16dec(cap);
cap += sizeof(uint16_t);
if (len > 0)
term->strs[ind] = cap;
else if (flags == 0)
term->strs[ind] = ABSENT_STRING;
else
term->strs[ind] = CANCELLED_STRING;
cap += len;
}
}
num = le16dec(cap);
cap += sizeof(uint16_t);
if (num != 0) {
num = le16dec(cap);
cap += sizeof(uint16_t);
if (num != term->_nuserdefs) {
free(term->_userdefs);
term->_userdefs = NULL;
term->_nuserdefs = num;
}
if (allocset(&term->_userdefs, 0, term->_nuserdefs,
sizeof(*term->_userdefs)) == -1)
return -1;
for (num = 0; num < term->_nuserdefs; num++) {
ud = &term->_userdefs[num];
len = le16dec(cap);
cap += sizeof(uint16_t);
ud->id = cap;
cap += len;
ud->type = *cap++;
switch (ud->type) {
case 'f':
ud->flag = *cap++;
if (flags == 0 &&
!VALID_BOOLEAN(ud->flag))
ud->flag = 0;
ud->num = ABSENT_NUMERIC;
ud->str = ABSENT_STRING;
break;
case 'n':
ud->flag = ABSENT_BOOLEAN;
ud->num = le16dec(cap);
if (flags == 0 &&
!VALID_NUMERIC(ud->num))
ud->num = ABSENT_NUMERIC;
ud->str = ABSENT_STRING;
cap += sizeof(uint16_t);
break;
case 's':
ud->flag = ABSENT_BOOLEAN;
ud->num = ABSENT_NUMERIC;
len = le16dec(cap);
cap += sizeof(uint16_t);
if (len > 0)
ud->str = cap;
else if (flags == 0)
ud->str = ABSENT_STRING;
else
ud->str = CANCELLED_STRING;
cap += len;
break;
default:
errno = EINVAL;
return -1;
}
}
} else {
term->_nuserdefs = 0;
if (term->_userdefs) {
free(term->_userdefs);
term->_userdefs = NULL;
}
}
return 1;
}
