static DerivErrInfo *
new_DerrMblock(Edaginfo *I, size_t len)
{
DerivErrInfo *D;
DerrMblock *M, **Mp;
char *s;
int nlco;
size_t L, L1;
len = len < 4096
? 4096
: (len + sizeof(real) - 1) & ~(sizeof(real) - 1);
if (!(D = I->Derrs)) {
if ((D = I->Derrs0)) {
I->Derrs = D;
M = D->curmb;
if (M->len >= len)
return D;
}
else {
nlco = I->nlc_ + I->nlo_;
L = sizeof(DerivErrInfo)
+ nlco*(sizeof(int) + sizeof(DerrRecord*));
L = (L + sizeof(real) - 1) & ~(sizeof(real) - 1);
L1 = L + (sizeof(DerrMblock) - sizeof(real)) + len;
D = (DerivErrInfo*)M1alloc_ASL(I, L1);
memset(D, 0, L);
I->Derrs = I->Derrs0 = D;
D->R = (DerrRecord**)(D+1);
D->busy = (int*)(D->R + nlco);
M = (DerrMblock*)((char*)D + L);
M->len = len;
goto have_M;
}
}
for(Mp = &D->freemb;; Mp = &M->next) {
if (!(M = *Mp)) {
M = (DerrMblock*)M1alloc_ASL(I, (sizeof(DerrMblock) - sizeof(real)) + len);
M->len = len;
break;
}
if (M->len >= len) {
*Mp = M->next;
break;
}
}
have_M:
M->next = D->curmb;
D->curmb = M;
D->mbnext = s = (char*)M->align;
D->mblast = s + M->len;
return D;
}
M1zapalloc_ASL(Edaginfo *I, size_t n)
#endif
{
Char *rv;
memset(rv = M1alloc_ASL(I, n), 0, n);
return rv;
}
void *
M1zapalloc_ASL(Edaginfo *I, size_t n)
{
void *rv;
memset(rv = M1alloc_ASL(I, n), 0, n);
return rv;
}
static term *
new_term(Static *S, ograd *o)
{
term *rv;
if ((rv = freeterm))
freeterm = (term *)rv->Q;
else {
if (!term_ntogo) {
term_block = (term *)M1alloc_ASL(&S->asl->i,
GULP*sizeof(term));
term_ntogo = GULP;
}
rv = term_block++;
--term_ntogo;
}
rv->L = rv->Le = o;
rv->Q = rv->Qe = 0;
return rv;
}
static ograd *
new_og(Static *S, ograd *next, int i, real v)
{
ograd *rv;
if ((rv = freeog))
freeog = rv->next;
else {
if (!ograd_ntogo) {
ograd_block = (ograd *)M1alloc_ASL(&S->asl->i,
GULP*sizeof(ograd));
ograd_ntogo = GULP;
}
rv = ograd_block++;
--ograd_ntogo;
}
rv->next = next;
rv->varno = i;
rv->coef = v;
return rv;
}
static dyad *
new_dyad(Static *S, dyad *next, ograd *L, ograd *R, int permute)
{
dyad *rv;
ograd *t;
if (permute) {
if (L == R) {
count(S, &L);
R = L;
}
else if (count(S, &L) > count(S, &R)) {
t = L;
L = R;
R = t;
}
if (!L) /* e.g., 0*x*x from <<0;0,0>>x*x */
/* with AMPL version < 20000216. */
return next;
}
if ((rv = freedyad))
freedyad = rv->next;
else {
if (!dyad_ntogo) {
dyad_block = (dyad *)M1alloc_ASL(&S->asl->i,
GULP*sizeof(dyad));
dyad_ntogo = GULP;
}
rv = dyad_block++;
--dyad_ntogo;
}
rv->next = next;
rv->Lq = L;
rv->Rq = R;
return rv;
}
