static inline void
fetch_Lookup (int i)
{
FT_ULong Lookup_ptr = Lookup_List[i].ptr;
if (Lookup_ptr && !Lookup_List[i].entry)
{
Lookup_Item *entry = Lookup_List[i].entry = mycalloc (1, sizeof(Lookup_Item));
Boolean is_ext = False;
FT_UShort val;
int j;
#ifdef DEBUG
warning("Lookup[%d] at 0x%04x.", i, Lookup_ptr);
#endif
GSUB_ptr = Lookup_ptr;
/*
* Read Lookup Item
*/
need(6);
val = get_UShort();
if (val == 7)
is_ext = True;
else if (val != 1)
oops("Lookup[%d] at 0x%04x: bad Type=%d.", i, Lookup_ptr, val);
get_UShort(); /* Ignore Lookup Flag */
entry->count = get_UShort();
entry->list = mycalloc (entry->count, sizeof(Single_Item));
need(2 * entry->count);
for (j = 0; j < entry->count; j++)
entry->list[j].ptr = Lookup_ptr + get_UShort();
if (is_ext)
for (j = 0; j < entry->count; j++)
{
GSUB_ptr = entry->list[j].ptr;
need(8);
val = get_UShort();
if (val != 1)
oops("Lookup[%d] Extension[%d] at 0x%04x: bad Format=%d.", i, j, entry->list[j].ptr, val);
val = get_UShort();
if (val != 1)
oops("Lookup[%d] Extension[%d] at 0x%04x: bad Type=%d.", i, j, entry->list[j].ptr, val);
entry->list[j].ptr += get_ULong();
}
for (j = 0; j < entry->count; j++)
fetch_Single (&entry->list[j]);
}
}
void process_fill()
{
char sz = 'b';
int64_t count;
int64_t val;
int64_t nn;
if (*inptr=='.') {
inptr++;
if (strchr("bchwBCHW",*inptr)) {
sz = tolower(*inptr);
inptr++;
}
else
printf("Illegal fill size.\r\n");
}
SkipSpaces();
NextToken();
count = expr();
prevToken();
need(',');
NextToken();
val = expr();
prevToken();
for (nn = 0; nn < count; nn++)
switch(sz) {
case 'b': emitByte(val); break;
case 'c': emitChar(val); break;
case 'h': emitHalf(val); break;
case 'w': emitWord(val); break;
}
}
void dirDEFPAGE(string &line, RawSource *) {
int firstpage, lastpage, org, size, val;
if (!ParseExpression(line,firstpage)) { error("Syntax error",ERRREP); return; }
if (labelnotfound) error("Forward reference");
if (firstpage<0 || firstpage>255) { error("Illegal pagenumber"); return; }
if (need(line,"..")) {
if (!ParseExpression(line,lastpage)) { error("Syntax error",ERRREP); return; }
if (labelnotfound) error("Forward reference");
if (lastpage<0 || firstpage>lastpage) { error("Illegal pagenumber"); return; }
} else lastpage=firstpage;
if (comma(line)) {
if (sbcneed(line,'*')) {
val=-1;
} else {
if (!ParseExpression(line,val)) { error("Syntax error",ERRREP); return; }
if (labelnotfound) error("Forward reference");
if (val<0) { val=0; error("Negative origin"); }
}
prevorg=val;
if (comma(line)) {
if (sbcneed(line,'*')) {
val=-1;
} else {
if (!ParseExpression(line,val)) { error("Syntax error",ERRREP); return; }
if (labelnotfound) error("Forward reference");
if (val<0) { val=0; error("Negative size"); }
}
prevsize=val;
}
}
org=prevorg; size=prevsize;
for (val=firstpage;val<=lastpage;++val) output[onr]->defpage(val,org,size);
checkjunk(line);
}
string minWindow(string s, string t) {
int m = s.size(), n = t.size();
vector<int> need(128,0);
for(char c : t) ++need[c];
int needCnt = n;
vector<int> have(128,0);
int idx = 0;
int minLen = m + 1;
string res;
for(int i = 0, startIdx = 0; i < m; ++i)
{
char c = s[i];
++have[c];
if(have[c] <= need[c]) --needCnt;
while(needCnt == 0)
{
if(i - startIdx + 1 < minLen)
{
idx = startIdx;
minLen = i - startIdx + 1;
}
char c = s[startIdx];
--have[c];
if(have[c] < need[c]) ++needCnt;
++startIdx;
}
}
return minLen == m + 1 ? "" : s.substr(idx, minLen);
}
static inline FT_UShort
fetch_Coverage (Coverage_Item *coverage)
{
FT_UShort res = 0;
GSUB_ptr = coverage->ptr;
need(4);
coverage->format = get_UShort();
coverage->count = res = get_UShort();
switch (coverage->format)
{
case 1:
coverage->data.glyphs = mymalloc (res * sizeof(FT_UShort));
#ifdef DEBUG
warning("Coverage Format=1 with %d Glyphs at 0x%04x.", res, coverage->ptr);
#endif
fetch_Glyphs (res, coverage->data.glyphs);
break;
case 2:
coverage->data.ranges = mymalloc (res * sizeof(Range_Record));
#ifdef DEBUG
warning("Coverage Format=1 with %d Ranges at 0x%04x.", res, coverage->ptr);
#endif
res = fetch_Ranges (res, coverage->data.ranges);
break;
default:
oops("Coverage at 0x%04x: bad Format=%d.", coverage->ptr, coverage->format);
}
return res;
}
/*
* addbcf() adds a bytecoded font control character to a rendered page
*/
void
addbcf(char c)
{
linestart();
need(2);
PAGE[PAGELEN++] = bcfID;
PAGE[PAGELEN++] = c;
}
void
fmt_build(stringvec_t *v, int len, char *fmt, ...) {
va_list ap;
need(v, len);
va_start(ap, fmt);
v->off += fmt_vsfmt(&(v->base)[v->off], len, fmt, ap);
va_end(ap);
}
/*
** READ_ARG -- Read a single argument from pipe
**
** An argument can be as simple as an integer, or as complex
** as a query tree.
**
** Parameters:
** ppb -- the pipe block to read from.
** pparm -- the parameter descripter to put the
** argument in.
**
** Returns:
** none.
**
** Side Effects:
** May allocate space from Qbuf for trees, etc.
**
** Called By:
** readinput
**
** Trace Flags:
** 10.6 - 10.7
*/
int
read_arg(register pb_t *ppb, register paramv_t *pparm)
{
char ptype;
short plen;
register int i;
register char *p;
qtree_t *q;
/* get the parameter type */
i = pb_get(ppb, &ptype, 1);
if (i == 0) {
pparm->pv_type = PV_EOF;
pparm->pv_val.pv_str = NULL;
return (PV_EOF);
}
i = pb_get(ppb, (char *) &plen, 2);
if (i < 2)
syserr("readarg: pb_get %d", i);
/* figure out the type */
switch (ptype) {
case PV_INT:
#ifdef xCM_DEBUG
if (plen != sizeof(pparm->pv_val.pv_int))
syserr("readinput: PV_INT %d", plen);
#endif
pb_get(ppb, (char *) &pparm->pv_val.pv_int, plen);
break;
case PV_STR:
case PV_TUPLE:
p = need(Qbuf, plen);
pb_get(ppb, p, plen);
pparm->pv_val.pv_str = p;
break;
case PV_QTREE:
q = readqry(pb_get, (int) ppb, TRUE);
pparm->pv_val.pv_qtree = q;
break;
case PV_EOF:
/* this case is allowed for the mon-par interface */
break;
default:
syserr("readinput: type %d len %d", ptype, plen);
}
/* save the type & length */
pparm->pv_type = ptype;
pparm->pv_len = plen;
return (ptype);
}
static inline void
fetch_Single (Single_Item *item)
{
int i;
FT_UShort val;
item->coverage = mycalloc (1, sizeof(Coverage_Item));
GSUB_ptr = item->ptr;
need(6);
item->format = get_UShort();
item->coverage->ptr = item->ptr + get_UShort();
switch (item->format)
{
case 1:
val = get_Short();
item->data.delta = mycalloc (1, sizeof(FT_UShort));
*item->data.delta = val;
#ifdef DEBUG
warning("Single Substitution Format=1 with Delta=%d at 0x%04x.", val, item->ptr);
#endif
fetch_Coverage (item->coverage);
break;
case 2:
val = get_UShort();
need(2 * val);
item->data.array = mycalloc (1, sizeof(Glyph_Array));
item->data.array->count = val;
item->data.array->glyphs = mycalloc (val, sizeof(FT_UShort));
for (i = 0; i < val; i++)
item->data.array->glyphs[i] = get_UShort();
#ifdef DEBUG
warning("Single Substitution Format=2 with %d Glyphs at 0x%04x.", val, item->ptr);
#endif
val = fetch_Coverage (item->coverage);
if (val != item->data.array->count)
oops("Coverage at 0x%04x: covers %d glyphs (should be %d).", item->ptr, val, item->data.array->count);
break;
default:
oops("Single Substitution at 0x%04x: bad Format=%d.", item->ptr, item->format);
}
add_Single (item);
}
void BioStruct3DSettingsDialog::setGlassesColorScheme(int num)
{
if (num<=0 || num>glassesColorSchemes.size())
return;
GlassesColorScheme need(glassesColorSchemes.at(num));
setLeftEyeColor(need.leftEyeColor);
setRightEyeColor(need.rightEyeColor);
}
int calculateMinimumHP(vector<vector<int>>& dungeon) {
int row = dungeon.size(), col = dungeon[0].size();
vector<int> need(col+1, INT_MAX);
need[col-1] = 1;
for (int i = row - 1; i >= 0; i--) {
for (int j = col - 1; j >= 0; j--) {
need[j] = max(1, min(need[j], need[j+1]) - dungeon[i][j]);
}
}
return need[0];
}
static inline void
fetch_Glyphs (FT_UShort count, FT_UShort *glyphs)
{
int i;
need(2 * count);
for (i = 0; i < count; i++)
glyphs[i] = get_UShort();
for (i = 1; i < count; i++)
if (glyphs[i] <= glyphs[i - 1])
oops("Glyph[%d]=%d and Glyph[%d]=%d: out of order.", i - 1, glyphs[i - 1], i, glyphs[i]);
}
double cRooms::getSpHeating(void)
{
// Update dMaxDiff and dMaxSp
need();
double t1 = (TempOutside.get()/(320-4*TempOutside.get()));
double t2 = pow(dMaxSp,t1);
double swhk = 0.55*dsteil*t2*(-TempOutside.get()+20)*2+dMaxSp+dkh+dMaxDiff*dverst;
double swhkLimit = min(max(swhk,dminvl),dmaxvl);
return swhkLimit;
}
/*
* addbct() is a local that actually adds a bct to a rendered page
*/
static void
addbct(char c, char *s)
{
linestart();
need(strlen(s)+3);
PAGE[PAGELEN++] = bctID;
PAGE[PAGELEN++] = c;
while (*s)
PAGE[PAGELEN++] = *s++;
PAGE[PAGELEN++] = bctID;
}
static inline void
fetch_Feature (int i)
{
FT_ULong Feature_ptr = Feature_List[i].ptr;
if (Feature_ptr && !Feature_List[i].entry)
{
Feature_Item *entry = Feature_List[i].entry = mycalloc (1, sizeof(Feature_Item));
FT_UShort val;
int j;
#ifdef DEBUG
warning("Feature[%d] '%c%c%c%c' at 0x%04x.", i, print_Tag(Feature_List[i].tag), Feature_ptr);
#endif
GSUB_ptr = Feature_ptr;
/*
* Read Feature Item
*/
need(4);
val = get_UShort();
if (val)
oops("Feature[%d] at 0x%04x: bad FeaturParams 0x%04x.", Feature_ptr, i, val);
entry->count = get_UShort();
entry->list = mycalloc (entry->count, sizeof(FT_UShort));
need(2*entry->count);
for (j = 0; j < entry->count; j++) {
entry->list[j] = get_UShort();
if (entry->list[j] >= Lookup_Count)
oops("Feature[%d] at 0x%04x: bad Lookup Index[%d]=%d.", i, Feature_ptr, j, entry->list[j]);
}
for (j = 0; j < entry->count; j++)
fetch_Lookup (entry->list[j]);
}
}
bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
vector<set<int>> need(numCourses);
vector<set<int>> go(numCourses);
set<int>::iterator it;
set<int>::iterator j;
queue<int> ha;
int size=prerequisites.size();
for(int i=0;i<size;i++)
{
//go to go list check which class can be finish;
int a=prerequisites[i].second,b=prerequisites[i].first;
go[a].insert(b);
need[b].insert(a);
}
for(int i=0;i<numCourses;i++)
{
if(need[i].size()==0)
{
ha.push(i);
}
}
while(!ha.empty())
{
int index=ha.front();
for(j=go[index].begin();j!=go[index].end();j++)
{
int classes=*j;
it=need[classes].find(index);
if(it!=need[classes].end())
need[classes].erase(it);
if(need[classes].size()==0)
{
ha.push(classes);
}
}
ha.pop();
}
for(int i=0;i<numCourses;i++)
{
if(need[i].size()!=0)
{
return false;
}
}
return true;
}
void cRooms::getData( JsonObject& root )
{
JsonArray& RoomsIsTemps = root.createNestedArray("RTi");
JsonArray& RoomsSPTemps = root.createNestedArray("RTs");
for (int i = 0; i<nRooms;i++){
RoomsIsTemps.add(Room[i].IsTemp.get());
RoomsSPTemps.add(Room[i].getSpTemp());
}
root["Toutside"] = TempOutside.get();
root["Rn"] = need();
root["RTsHeating"] = getSpHeating();
root["RTitoR"] = IsTempHeatingLead.get();
root["RTitoSys"] = IsTempHeatingReturn.get();
root["RP"] = Pump.get();
root["RM"] = Mixer.get();
}
qtree_t *
makezero(int typ)
{
register int l;
register qtree_t *s;
int symbuf[(sizeof(*s)) / sizeof(l)];
/*word aligned*/
l = 0;
s = (qtree_t *) symbuf;
s->sym.type = typ;
switch (typ) {
case INT_CONST:
s->sym.len = l = 2;
s->sym.value.sym_data.i2type = 0;
break;
case FLOAT_CONST:
s->sym.len = l = 4;
s->sym.value.sym_data.f4type = 0.0;
break;
case CHAR_CONST:
s->sym.len = l = 2;
memset(&s->sym.value.sym_data.i2type, ' ', 2); /* (2 spaces) */
break;
default:
syserr("makezero: typ %d", typ);
}
/* duplicate the node into Qbuf */
l += 2 + 2 * QT_HDR_SIZ; /* size of type + len + left + right */
s = (qtree_t *) need(Qbuf, l);
bmove(symbuf, s, l);
return (s);
}
void
runout(void)
{
int i;
if (boxflg || allflg || dboxflg) need();
if (ctrflg)
{
fprintf(tabout, ".nr #I \\n(.i\n");
fprintf(tabout, ".in +(\\n(.lu-\\n(TWu-\\n(.iu)/2u\n");
}
fprintf(tabout, ".fc %c %c\n", F1, F2);
fprintf(tabout, ".nr #T 0-1\n");
deftail();
for(i=0; i<nlin; i++)
putline(i,i);
if (leftover)
yetmore();
fprintf(tabout, ".fc\n");
fprintf(tabout, ".nr T. 1\n");
fprintf(tabout, ".T# 1\n");
if (ctrflg)
fprintf(tabout, ".in \\n(#Iu\n");
}
string minWindow(string s, string t) {
int m=s.length(), n=t.length();
if(m<n) return "";
vector<int> need(256, 0);
vector<int> has(256,0);
for(int i=0; i<n;i++)
need[t[i]]++;
int start=0, end= 0;
int count=0;
int minLen=INT_MAX, minStart=0;
for(; end< m; end++){
if(need[s[end]] ==0 ) continue;
if(has[s[end]]< need[s[end]])
count++;
has[s[end]] ++;
if(count == n){
while(start <= end){
if(need[s[start]] ==0)
start++;
else if(has[s[start]] > need[s[start]]){
has[s[start]]--;
start++;
}
else
break;
}
if(minLen > end-start+1){
minLen= end-start +1;
minStart = start;
}
}
}
if(minLen ==INT_MAX) return "";
return s.substr(minStart, minLen);
}
static inline FT_UShort
fetch_Ranges (FT_UShort count, Range_Record *ranges)
{
int i;
FT_UShort ndx = 0;
need(6 * count);
for (i = 0; i < count; i++)
{
ranges[i].start = get_UShort();
ranges[i].end = get_UShort();
if (ranges[i].start > ranges[i].end)
oops("Range[%d]: bad range=%d..%d.", i, ranges[i].start, ranges[i].end);
ranges[i].start_Index = get_UShort();
if (ranges[i].start_Index != ndx)
oops("Range[%d]: bad start_Index=%d (should be %d).", i, ranges[i].start_Index, ndx);
ndx += (ranges[i].end - ranges[i].start) + 1;
}
for (i = 1; i < count; i++)
if (ranges[i].start <= ranges[i-1].end)
oops("Range[%d]=%d..%d and Range[%d]=%d..%d: out of order.",
i - 1, ranges[i - 1].start, ranges[i - 1].end, i, ranges[i].start, ranges[i].end);
return ndx;
}
/*
* addchar() adds a single character to a rendered page
*/
static void
addchar(char c)
{
need(1);
PAGE[PAGELEN++] = c;
}
/*******************************************************************************
This function evaluates an expression. It is passed a pointer to an expression
node to evaluate (results are also put here), and it evaluates the expression
tree.
Note: the argument stack is used for user function calls. Even though it looks
cumbersome, indices have been used instead of stack pointers. This is because
this is a recursive function, and it is neccessary to save previous stack
information AND the stack is dynamically resizable - that is - it can move at
any time. Hence, any pointers saved on previous invocations of this function
would be pointing to where the stack USED to be, not where it NOW is.
*******************************************************************************/
void
evalexpr(Exprnode *exprptr)
{
extern Field *aggrfldtbl, *fldtbl;
extern Opmode opmode; /* report or selrej mode */
extern Statsinfofld *statsinfofldtbl;
Exprnode lresult, rresult;
Exprptrlistnode *exprptrlistptr;
int tmpidx, argctr, intval, savebotargstkidx;
float floatval;
switch (exprptr->typ) {
case INTEGER: case FLOAT: case STRING:
break;
case FIELD:
if (opmode == REPORTMODE) {
if (curfldvalptrtbl[exprptr->arg.ival] == NULL) {
fprintf(stderr, "field `%s'",
aggrfldtbl[exprptr->arg.ival].name);
fatalerrlin(" is referenced outside a foreach loop");
}
exprptr->typ = aggrfldtbl[exprptr->arg.ival].typ;
switch (exprptr->typ) {
case STRING:
exprptr->arg.sval =
curfldvalptrtbl[exprptr->arg.ival]->arg.sval;
break;
case INTEGER:
exprptr->arg.ival =
curfldvalptrtbl[exprptr->arg.ival]->arg.ival;
break;
case FLOAT:
exprptr->arg.fval =
curfldvalptrtbl[exprptr->arg.ival]->arg.fval;
break;
default: fatalerror("evalexpr: SNARK!");
break;
}
} else { /* selrej mode */
evalselrejfld(exprptr);
}
break;
case UFNCCALLEXPR:
argctr = exprptr->arg.ufnc.argctr;
if (argstkctr + argctr > maxargstkctr) { /* enlarge stk if nec */
maxargstkctr = MAX(maxargstkctr*ARGSTKMULTFACTOR,
argstkctr+argctr);
argstk = (Exprnode*)realloc((void*)argstk,
(size_t)maxargstkctr*sizeof(Exprnode));
}
/* eval all args & push them on the stk */
exprptrlistptr = exprptr->arg.ufnc.exprptrlistptr;
while (exprptrlistptr != NULL) { /* eval all args */
lresult = *exprptrlistptr->exprptr;
evalexpr(&lresult);
*(argstk+argstkctr++) = lresult; /* & push on stk */
exprptrlistptr = exprptrlistptr->next;
}
savebotargstkidx = botargstkidx;
botargstkidx = argstkctr-argctr;
tmpidx = exprptr->arg.ufnc.begstmtidx; /* call user func */
*exprptr = doblock(tmpidx+1, stmts[tmpidx].s.ufncdef.endstmtidx);
argstkctr -= argctr;
botargstkidx = savebotargstkidx;
break;
case UFNCPARAMEXPR:
if (botargstkidx+exprptr->arg.ival >= argstkctr)
fatalerror(STKERRMSG);
*exprptr = *(&argstk[botargstkidx]+exprptr->arg.ival);
break;
case UNARYOPEXPR:
lresult = *(exprptr->leftptr); evalexpr(&lresult);
switch (lresult.typ) {
case INTEGER:
exprptr->arg.ival =
iunaryop(exprptr->arg.optyp, lresult.arg.ival);
break;
case FLOAT:
exprptr->arg.fval =
funaryop(exprptr->arg.optyp, lresult.arg.fval);
break;
default:
fatalerrlin("evalexpr: unary operation on illegal type");
break;
}
exprptr->typ = lresult.typ;
break;
case BINARYOPEXPR:
lresult = *(exprptr->leftptr); evalexpr(&lresult);
rresult = *(exprptr->rightptr); evalexpr(&rresult);
if ((lresult.typ == INTEGER)&&(rresult.typ == INTEGER)) {
exprptr->arg.ival = ibinop(lresult.arg.ival,
exprptr->arg.optyp, rresult.arg.ival);
exprptr->typ = INTEGER;
} else if (lresult.typ == INTEGER && rresult.typ == FLOAT) {
if ((exprptr->typ=fbinop((float)lresult.arg.ival,
exprptr->arg.optyp, rresult.arg.fval,
&floatval, &intval)) == FLOAT)
exprptr->arg.fval = floatval;
else
exprptr->arg.ival = intval;
} else if (lresult.typ == FLOAT && rresult.typ == INTEGER) {
if ((exprptr->typ=fbinop(lresult.arg.fval,
exprptr->arg.optyp, (float)rresult.arg.ival,
&floatval, &intval)) == FLOAT)
exprptr->arg.fval = floatval;
else
exprptr->arg.ival = intval;
} else if (lresult.typ == FLOAT && rresult.typ == FLOAT) {
if ((exprptr->typ=fbinop(lresult.arg.fval,
exprptr->arg.optyp, rresult.arg.fval,
&floatval, &intval)) == FLOAT)
exprptr->arg.fval = floatval;
else
exprptr->arg.ival = intval;
} else if (lresult.typ == STRING && rresult.typ == STRING) {
sbinop(lresult.arg.sval, rresult.arg.sval, exprptr);
} else {
fatalerrlin( "evalexpr: illegal binary op argument type(s)");
}
break;
case COUNT:
if (exprptr->arg.tdbfnc.maxdepth != INVALIDFLDIDX) {
chk4badflds(exprptr->arg.tdbfnc.fldbits,
exprptr->arg.tdbfnc.maxdepth);
exprptr->arg.ival = getcount(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
exprptr->arg.tdbfnc.maxdepth);
} else {
exprptr->arg.ival = getcount(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0, 0);
}
exprptr->typ = INTEGER;
break;
case NUMBER:
chk4badflds(exprptr->arg.tdbfnc.fldbits,
exprptr->arg.tdbfnc.maxdepth);
exprptr->arg.ival = getnumber(datarootptr,
exprptr->arg.tdbfnc.fldbits,
exprptr->arg.tdbfnc.depth, exprptr->arg.tdbfnc.maxdepth);
exprptr->typ = INTEGER;
break;
case SUM:
intval = statsinfofldtbl[exprptr->arg.tdbfnc.depth].typ;
switch (intval) {
case INTEGER:
if (exprptr->arg.tdbfnc.maxdepth != INVALIDFLDIDX) {
chk4badflds(exprptr->arg.tdbfnc.fldbits,
exprptr->arg.tdbfnc.maxdepth);
exprptr->arg.ival = getintsum(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
exprptr->arg.tdbfnc.maxdepth,
exprptr->arg.tdbfnc.depth);
} else {
exprptr->arg.ival = getintsum(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
0, exprptr->arg.tdbfnc.depth);
}
break;
case FLOAT:
if (exprptr->arg.tdbfnc.maxdepth != INVALIDFLDIDX) {
chk4badflds(exprptr->arg.tdbfnc.fldbits,
exprptr->arg.tdbfnc.maxdepth);
exprptr->arg.fval = getfltsum(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
exprptr->arg.tdbfnc.maxdepth,
exprptr->arg.tdbfnc.depth);
} else {
exprptr->arg.fval = getfltsum(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
0, exprptr->arg.tdbfnc.depth);
}
break;
default:
fatalerrlin("evalexpr: illegal SUM field type");
break;
}
exprptr->typ = intval;
break;
case SUMSQRD:
intval = statsinfofldtbl[exprptr->arg.tdbfnc.depth].typ;
switch (intval) {
case INTEGER:
if (exprptr->arg.tdbfnc.maxdepth != INVALIDFLDIDX) {
chk4badflds(exprptr->arg.tdbfnc.fldbits,
exprptr->arg.tdbfnc.maxdepth);
exprptr->arg.ival = getintsumsqrd(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
exprptr->arg.tdbfnc.maxdepth,
exprptr->arg.tdbfnc.depth);
} else {
exprptr->arg.ival = getintsumsqrd(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
0, exprptr->arg.tdbfnc.depth);
}
break;
case FLOAT:
if (exprptr->arg.tdbfnc.maxdepth != INVALIDFLDIDX) {
chk4badflds(exprptr->arg.tdbfnc.fldbits,
exprptr->arg.tdbfnc.maxdepth);
exprptr->arg.fval = getfltsumsqrd(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
exprptr->arg.tdbfnc.maxdepth,
exprptr->arg.tdbfnc.depth);
} else {
exprptr->arg.fval = getfltsumsqrd(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
0, exprptr->arg.tdbfnc.depth);
}
break;
default:
fatalerrlin("evalexpr: illegal SUM field type");
break;
}
exprptr->typ = intval;
break;
case TYPE:
lresult = *(exprptr->leftptr); evalexpr(&lresult);
switch (lresult.typ) {
case INTEGER: /* we've got an integer, make a ... */
if (exprptr->arg.casttyp == FLOAT) {
exprptr->arg.fval = (float)lresult.arg.ival;
exprptr->typ = FLOAT;
} else { /* an integer */
exprptr->arg.ival = lresult.arg.ival;
exprptr->typ = INTEGER;
}
break;
case FLOAT: /* we've got a float, make an ... */
if (exprptr->arg.casttyp == FLOAT) {
exprptr->arg.fval = lresult.arg.fval;
exprptr->typ = FLOAT;
} else { /* an integer */
exprptr->arg.ival = (int)lresult.arg.fval;
exprptr->typ = INTEGER;
}
break;
default:
fatalerrlin("evalexpr: illegal type cast");
break;
}
break;
case REPORTDT: /* get the report date or time */
exprptr->arg.ival = getreportdt(exprptr->arg.ival);
exprptr->typ = INTEGER;
break;
case FORMATDT: /* format a date or time */
lresult = *(exprptr->leftptr); evalexpr(&lresult);
rresult = *(exprptr->rightptr); evalexpr(&rresult);
exprptr->arg.sval = formatdt(exprptr->arg.ival, &lresult, &rresult);
exprptr->typ = STRING;
break;
case STRFUNCEXPR:
strfunc(exprptr);
break;
case ATOI:
lresult = *(exprptr->leftptr); evalexpr(&lresult);
if (lresult.typ != STRING)
fatalerrlin("evalexpr: atoi of non-string expression");
exprptr->arg.ival = atoi(lresult.arg.sval);
exprptr->typ = INTEGER;
break;
case ATOF:
lresult = *(exprptr->leftptr); evalexpr(&lresult);
if (lresult.typ != STRING)
fatalerrlin("evalexpr: atof of non-string expression");
exprptr->arg.fval = (float) atof(lresult.arg.sval);
exprptr->typ = FLOAT;
break;
case MATHFUNC:
lresult = *(exprptr->leftptr); evalexpr(&lresult);
switch (lresult.typ) {
case INTEGER:
exprptr->arg.fval =
mathfunc(exprptr->arg.optyp, (double)lresult.arg.ival);
break;
case FLOAT:
exprptr->arg.fval =
mathfunc(exprptr->arg.optyp, (double)lresult.arg.fval);
break;
default:
fatalerrlin("evalexpr: math function on illegal type");
break;
}
exprptr->typ = FLOAT;
break;
case ARRAYVAREXPR:
evalarrvar(exprptr);
break;
case NEED:
lresult = *(exprptr->leftptr); evalexpr(&lresult);
exprptr->typ = INTEGER;
exprptr->arg.ival = need(&lresult);
break;
case UNDEFVAREXPR:
fprintf(stderr, "evalexpr: variable `%s'",exprptr->varptr->name);
fatalerrlin(" is undefined");
break;
case NORETVALEXPR:
fatalerrlin("function returns no value (one is required)");
break;
default:
fatalerrlin("evalexpr: illegal expr type");
break;
}
}
int pregetmacro(string &line, bool icase, RawSource *rs, bool list, bool recursive) {
Macro mac;
mac._list=list;
mac._recursive=recursive;
string d,name=getid(line);
if (name.empty()) {
error1("Illegal macroname");
return 0;
}
while('>') {
skipblanks(line);
if (!line[0]) break;
if (isalpha(line[0])) {
d=getid(line);
mac._namParam.push_back(d);
if (sbcneed(line,'+')) mac._greedy=true;
if (sbcneed(line,':')) {
d=getargument(line,mac._greedy);
} else d="\01";
mac._namDefaults.push_back(d);
if (mac._greedy) break;
if (comma(line)) continue;
break;
}
if (isdigit(line[0])) {
if (!getConstant(line,mac._minnum)) {
error1("constant expected");
return 0;
}
if (need(line,"..")) {
skipblanks(line);
if (sbcneed(line,'*'))
mac._maxnum=BIGVALUE;
else {
if (!getConstant(line,mac._maxnum)) {
error1("constant expected");
return 0;
}
}
} else mac._maxnum=mac._minnum;
if (mac._minnum<0 || mac._maxnum<mac._minnum) {
error1("Illegal parameter");
return 0;
}
if (sbcneed(line,'+'))
if (mac._maxnum<BIGVALUE) mac._greedy=true;
else error1("No greedy stars allowed!");
break;
}
if (sbcneed(line,'*')) {
mac._minnum=0;
mac._maxnum=BIGVALUE;
if (sbcneed(line,'+')) error1("No greedy stars allowed!");
break;
}
error1("Syntax error");
break;
}
if (mac._maxnum>mac._minnum && line[0]) {
int i=mac._maxnum-mac._minnum;
bool gr=false;
while (i--) {
if (!line[0]) break;
if (!i) gr=mac._greedy;
d=getargument(line,gr);
mac._numDefaults.push_back(d);
}
}
if (mac._minnum)
mac._minparam=(int)mac._namParam.size()+mac._minnum;
else {
int i=(int)mac._namParam.size();
mac._minparam=0;
while (i--) if (mac._namDefaults[i]=="\01") {
mac._minparam=i+1;
break;
}
}
if (mac._greedy || mac._maxnum==BIGVALUE) mac._maxparam=BIGVALUE;
else mac._maxparam=(int)mac._namParam.size()+mac._maxnum;
if (listopt._macroname.empty()) mac._line=curlin;
else mac._line=listopt._macrocurlin;
mac._filename=listopt._filename;
mac._body=rs->ReadUntil(macronl,macroel,"macro");
if (!listopt._macroname.empty()) listopt._macrocurlin+=(int)mac._body.size()+1;
mactab.add(name,icase,mac);
return 1;
}
static inline void
fetch_GSUB (void)
{
FT_Error error;
int i, j;
FT_ULong Script_List_ptr, Feature_List_ptr, Lookup_List_ptr;
/*
* Fetch GSUB table
*/
if ((error = FT_Load_Sfnt_Table(face, TTAG_GSUB, 0, NULL, &GSUB_length)))
{
#ifdef DEBUG
warning("No GSUB data available for vertical glyph presentation forms.");
#endif
return;
}
GSUB_table = mymalloc(GSUB_length);
if ((error = FT_Load_Sfnt_Table(face, TTAG_GSUB, 0, GSUB_table, &GSUB_length)))
{
warning("Cannot load GSUB table (error code = 0x%x).", error);
return;
}
/*
* Read GSUB header
*/
need(10);
if (get_ULong() != 0x00010000)
oops("GSUB: Bad version.");
Script_List_ptr = get_UShort();
Feature_List_ptr = get_UShort();
Lookup_List_ptr = get_UShort();
/*
* Read Script_List
*/
GSUB_ptr = Script_List_ptr;
need(2);
Script_Count = get_UShort();
#ifdef DEBUG
warning("GSUB: Script List with %d entries at 0x%04x.", Script_Count, Script_List_ptr);
#endif
Script_List = mycalloc (Script_Count, sizeof(Script_Record));
need (6 * Script_Count);
for (i = 0; i < Script_Count; i++)
{
FT_Tag tag = get_ULong();
FT_ULong ptr = Script_List_ptr + get_UShort();
for (j = 0; j < num_Script_Lang; j++)
if (tag == Script_Lang[j].script)
{
Script_List[i].tag = tag;
Script_List[i].ltag = Script_Lang[j].language;
Script_List[i].ptr = ptr;
}
}
/*
* Read Feature_List
*/
GSUB_ptr = Feature_List_ptr;
need(2);
Feature_Count = get_UShort();
#ifdef DEBUG
warning("GSUB: Feature List with %d entries at 0x%04x.", Feature_Count, Feature_List_ptr);
#endif
Feature_List = mycalloc (Feature_Count, sizeof(Feature_Record));
need (6 * Feature_Count);
for (i = 0; i < Feature_Count; i++)
{
FT_Tag tag = get_ULong();
FT_ULong ptr = Feature_List_ptr + get_UShort();
if (tag == FEATURE_vert || tag == FEATURE_vrt2)
{
Feature_List[i].tag = tag;
Feature_List[i].ptr = ptr;
}
}
/*
* Read Lookup_List
*/
GSUB_ptr = Lookup_List_ptr;
need(2);
Lookup_Count = get_UShort();
#ifdef DEBUG
warning("GSUB: Lookup List with %d entries at 0x%04x.", Lookup_Count, Lookup_List_ptr);
#endif
Lookup_List = mycalloc (Lookup_Count, sizeof(Lookup_Record));
need (2 * Lookup_Count);
for (i = 0; i < Lookup_Count; i++)
Lookup_List[i].ptr = Lookup_List_ptr + get_UShort();
/*
* Read Script_List entries
*/
for (i = 0; i < Script_Count && !has_gsub; i++)
fetch_Script (i);
}
