/*
* Release a single client from a barrier at a time.
*/
static void
release_client(int sock, struct in_addr ipaddr, int istcp, int result)
{
int err;
if (istcp) {
if ((err = writeall(sock, &result, sizeof(result))) <= 0) {
if (err < 0) {
errorc("writing to TCP client");
}
error("write to TCP client aborted");
}
tcpsockets[sock].barrier = NULL;
close(sock);
}
else {
struct sockaddr_in client;
client.sin_addr = ipaddr;
client.sin_family = AF_INET;
client.sin_port = htons(portnum);
while( ((err = sendto(sock, &result, sizeof(result), 0,
(struct sockaddr *)&client,
sizeof(client))) < 0) &&
(errno == EINTR) )
{
// Nothing to do...
}
if (err < 0)
errorc("writing to UDP client");
}
}
Alias<ISource> CountSource::inputCommand(symbolGB &) {
errorc(__LINE__);
if(d_count<=0) errorc(__LINE__);
--d_count;
if(d_count==0) d_eoi = true;
return *(Alias<ISource> *)0;
};
void GrbSource::get(Term& x) {
char c;
d_so.peekCharacter(c,"\n *");
if(c=='+') {
d_so.passCharacter();
d_so.peekCharacter(c,"\n *");
};
if(c=='-' || ('0'<=c && c <= '9')) {
// have a number first
get(x.Coefficient());
get(x.MonomialPart());
} else if('a'<=c && c <= 'z') {
x.Coefficient().setToOne();
get(x.MonomialPart());
} else if('A'<=c && c <= 'Z') {
x.Coefficient().setToOne();
get(x.MonomialPart());
} else if(c=='(') {
d_so.getCharacter(c,"\n *");
if(c!='1') errorc(__LINE__);
d_so.getCharacter(c,"\n *");
if(c!=')') errorc(__LINE__);
x.Coefficient().setToOne();
x.MonomialPart().setToOne();
} else errorc(__LINE__);
d_eoi = d_so.eof();
};
UCHAR PASCAL CODESIZE
popoperator (
register struct ar *p
){
register char op;
if (!p->lastitem) {
errorc( E_OPR ); /* expected operator */
return( (char)OPPLUS ); /* use '+' as default */
}
else {
if (p->lastitem->itype != OPERATOR) {
errorc( E_OPR ); /* expected operator */
return( (char)OPPLUS ); /* use '+' as default */
}
else {
/* Return OPERATOR number */
op = p->lastitem->dsckind.opr.oidx;
/* Pop OPERATOR off stack */
itemptr = p->lastitem;
p->lastitem = p->lastitem->previtem;
return (op);
}
}
}
VOID PASCAL CODESIZE
signadjust (
UCHAR minus,
register struct exprec *p
){
register struct psop *psol; /* parse stack operand structure */
register struct psop *psor; /* parse stack operand structure */
DSCREC *t;
OFFSET maxInt;
char fOverflow = FALSE;
maxInt = (fArth32)? OFFSETMAX: 0xffff;
psor = &(p->valright->dsckind.opnd);
psol = &(p->valleft->dsckind.opnd);
if (psol->s) /* arthmethic on data size item - NEAR/FAR */
errorc(E_TIL);
if (minus)
psor->dsign = !psor->dsign;
if (psol->dsegment || psol->dflag == XTERNAL ||
(M_FLTSTACK & psol->dtype)) {
/* Want to preserve Left operand */
t = p->valleft;
p->valleft = p->valright;
p->valright = t;
p->right = p->left;
p->left = p->valleft->dsckind.opnd.doffset;
psor = &(p->valright->dsckind.opnd);
psol = &(p->valleft->dsckind.opnd);
}
if (psol->dflag == UNDEFINED)
psor->dtype = M_CODE | M_FORTYPE;
if (psor->dflag == UNDEFINED && !(psol->dtype & M_PTRSIZE))
psol->dsize = 0;
if (psol->dsign == psor->dsign) {
/* Signs are same */
fOverflow = (((maxInt - p->right) + 1) == p->left);
p->right = p->right + p->left;
} else if (p->right > p->left)
/* Different signs */
p->right = p->right - p->left;
else {
p->right = p->left - p->right;
psor->dsign = !psor->dsign;
}
if (p->right == 0 && !fOverflow)
psor->dsign = FALSE;
if (psor->dsign && (psor->dtype & M_SEGRESULT))
errorc (E_OSA);
psor->doffset = p->right;
}
void Polynomial::addNewLastTerm(const Term & t) {
PolynomialIterator w(begin());
const int sz = numberOfTerms();
if(sz>0) {
for(int i=1;i<sz;++i,++w) {};
const Monomial & m = (*w).MonomialPart();
if(AdmissibleOrder::s_getCurrent().monomialGreater(t.MonomialPart(),m)) {
errorc(__LINE__);
};
if(t.MonomialPart()==m) {
errorc(__LINE__);
};
};
addTermToEnd(t);
};
void Polynomial::doubleProduct(const Field & f,const Monomial & x,
const Polynomial & poly,const Monomial & y) {
if(&poly==this) errorc(__LINE__);
#ifdef CHECK_FOR_ZERO_COEFFICIENTS
GBStream << "MXS:doubleProduct:poly:" << poly << '\n';
GBStream << "MXS:doubleProduct:aTerm:" << aTerm << '\n';
GBStream << "MXS:doubleProduct:bTerm:" << bTerm << '\n';
#endif
setToZero();
if(!f.zero()) {
const int sz = poly.numberOfTerms();
PolynomialIterator w = poly.begin();
Term t;
for(int i=1;i<=sz;++i,++w) {
t = *w;
t.Coefficient() *= f;
Monomial & m = t.MonomialPart();
Monomial result(x);
result *= m;
result *= y;
m = result;
addTermToEnd(t);
}
}
};
void MmaSink::put(const Holder& h) {
s_table.executeconst(*this,h);
#else
void MmaSink::put(const Holder&) {
errorc(__LINE__);
#endif
};
bool AdmWithLevels::variableLess(const Variable & x,const Variable & y) const {
bool result = false;
bool done = false;
int n1 = level(x), n2 = level(y);
if(x==y) {
done = true;
} else if(n1!=n2) {
result = n1<n2;
done = true;
} else {
const vector<Variable> & V = monomialsAtLevel(n1);
vector<Variable>::const_iterator w = V.begin(), e = V.end();
while(w!=e) {
const Variable & v = *w;
if(v==x) {
done = true;
result = true;
break;
} else if(v==y) {
done = true;
result = false;
break;
};
++w;
};
};
if(!done) errorc(__LINE__);
return result;
};
void AdmissibleOrder::s_setCurrentAdopt(AdmissibleOrder * p) {
if(p==s_Current_p) errorc(__LINE__);
if(s_Current_p) {
RECORDHERE(delete s_Current_p;)
}
s_Current_p = p;
};
void subMonomial::error2(int newstart) const {
GBStream << "The start of an subMonomial was set to "
<< newstart << " and there are only "
<< _mono.numberOfFactors() << " factors .\n";
GBStream << "The length was set to " << _length << '\n';
errorc(__LINE__);
};
void subMonomial::error5() const {
GBStream << "The start of an subMonomial was set to "
<< _start+1 << " and there are only "
<< _mono.numberOfFactors() << "factors.\n";
GBStream << "The length was set to " << _length << "\n";
errorc(__LINE__);
};
Alias<ISource> CountSource::inputNamedFunction(const char * x) {
if(d_count<=0) errorc(__LINE__);
--d_count;
Alias<ISource> result(d_source.inputNamedFunction(x));
if(d_count==0) d_eoi = true;
return result;
};
Alias<ISource> CountSource::inputFunction(symbolGB & x) {
if(d_count<=0) errorc(__LINE__);
--d_count;
Alias<ISource> result(d_source.inputFunction(x));
if(d_count==0) d_eoi = true;
return result;
};
void Polynomial::setToOne() {
setToZero();
operator =(Term::s_TERM_ONE);
if(AdmissibleOrder::s_getCurrentP()==0) {
GBStream << "Invalid order pointer.\n";
errorc(__LINE__);
}
};
VOID PASCAL CODESIZE
valconst (
register DSCREC *arg
){
if (!(M_RCONST & arg->dsckind.opnd.dtype) ||
arg->dsckind.opnd.dsegment ||
arg->dsckind.opnd.dflag == XTERNAL)
/* Not constant */
errorc (E_CXP);
}
void MmaSink::noOutput() {
#ifdef DEBUG_MMASINK
GBStream << "sink:null" << this << '\n';
#endif
if(!MLPutSymbol(d_mlink,"Null")) errorc(__LINE__);
#ifdef DEBUG_MMASINK
checkforerror();
#endif
++d_count;
};
Alias<ISink> MmaSink::outputFunction(const char* x,long L) {
if(!MLPutFunction(d_mlink,x,L)) errorc(__LINE__);
++d_count;
// DO NOT INCLUDE d_count -= L; since this will be done by the new MmaSink
Alias<ISink> al(new MmaSink(*this),Adopt::s_dummy);
#ifdef DEBUG_MMASINK
checkforerror();
#endif
return al;
};
int Polynomial::compareTwoMonomials(const Monomial & m1,
const Monomial & m2) const {
int cmp;
if(m1==m2) {
cmp = 0;
} else {
bool flag = false; // false to prevent warnings from the compiler
if(false) {
} else if(isPD()) {
if(AdmissibleOrder::s_getCurrentP()==0) {
GBStream << "Invalid order pointer." << '\n';
errorc(__LINE__);
}
flag = AdmissibleOrder::s_getCurrent().monomialGreater(m1,m2);
} else errorc(__LINE__);
cmp = flag ? 1 : -1;
}
return cmp;
};
VOID PASCAL CODESIZE
valerror (
register struct ar *p
){
DSCREC *oldlast;
/* Operand was expected */
errorc (E_OPN);
/* save expr stack */
oldlast = p->lastitem;
p->lastitem = defaultdsc ();
/* Point to rest */
p->lastitem->previtem = oldlast;
}
USHORT PASCAL CODESIZE
valuesize (
register DSCREC *arg
){
if (!fArth32)
arg->dsckind.opnd.doffset = (long) (SHORT) arg->dsckind.opnd.doffset;
if (arg->dsckind.opnd.doffset == 0) {
/* 0 means no size */
errorc (E_OHS);
return (0);
}
else if (arg->dsckind.opnd.doffset >= CSFAR_LONG)
return (xltsymtoresult[PROC]);
else
return (xltsymtoresult[DVAR]);
}
void Polynomial::doubleProduct(const Monomial & x,
const Polynomial & poly,const Monomial & y) {
if(&poly==this) errorc(__LINE__);
#ifdef CHECK_FOR_ZERO_COEFFICIENTS
GBStream << "MXS:doubleProduct:poly:" << poly << '\n';
GBStream << "MXS:doubleProduct:aTerm:" << aTerm << '\n';
GBStream << "MXS:doubleProduct:bTerm:" << bTerm << '\n';
#endif
setToZero();
const int sz = poly.numberOfTerms();
PolynomialIterator w = poly.begin();
Term result;
for(int i=1;i<=sz;++i,++w) {
result.assign(x);
result *= (*w);
result *= y;
addTermToEnd(result);
}
};
OFFSET PASCAL CODESIZE
shiftoper (
register struct exprec *p
){
register OFFSET argl;
register USHORT argr;
argl = p->valleft->dsckind.opnd.doffset;
if (p->valleft->dsckind.opnd.dsign)
argl = -argl;
argr = p->valright->dsckind.opnd.doffset;
if (p->valright->dsckind.opnd.dsign) {
errorc (E_SCN);
return (argl);
}
else if (sizeof(OFFSET)*8 < argr)
return (0);
else if (p->stkoper == OPSHL)
return (argl << argr);
else
return (argl >> argr);
}
void GrbSource::get(Holder&) {
errorc(__LINE__);
};
Alias<ISource> GrbSource::inputNamedFunction(const char *) {
errorc(__LINE__);
d_eoi = d_so.eof();
return *(Alias<ISource> *) 0;
};
Alias<ISource> GrbSource::inputFunction(symbolGB &) {
errorc(__LINE__);
d_eoi = d_so.eof();
return *(Alias<ISource> *) 0;
};
void GrbSource::passString() {
errorc(__LINE__);
d_eoi = d_so.eof();
};
void GrbSource::get(symbolGB &) {
errorc(__LINE__);
d_eoi = d_so.eof();
};
void GrbSource::get(asStringGB &) {
errorc(__LINE__);
d_eoi = d_so.eof();
};
int GrbSource::getType() const {
errorc(__LINE__);
return -1;
};
