static Format2_0 *read2_0(Card32 left)
{
IntX i;
Card8 *end;
Card8 *name;
IntX nameSize;
Format2_0 *format = memNew(sizeof(Format2_0));
IN1(format->numberGlyphs);
/* Read index */
format->glyphNameIndex =
memNew(sizeof(format->glyphNameIndex[0]) * format->numberGlyphs);
for (i = 0; i < format->numberGlyphs; i++)
IN1(format->glyphNameIndex[i]);
/* Read name table */
nameSize =
left - (sizeof(format->numberGlyphs) +
sizeof(format->glyphNameIndex[0]) * format->numberGlyphs);
format->names = memNew(nameSize + 1);
IN_BYTES(nameSize, format->names);
/* Count names in table */
nNames = 0;
end = format->names + nameSize;
for (name = format->names; name < end; name += *name + 1)
if (*name == '\0')
break;
else
nNames++;
return format;
}
//----------------------- RefPropSPthPH -----------------------------
// dv_dP = v/P * dlog10(v)_dlog10(P)
// A constant added to y does not propagate through the derivative.
double RefPropSPthPH::dy_dx1(int prop,double P,double h)
{
#ifdef REFPROP_LOG10_2D
double y,dydx1,dydx2;
Evaluate_y_dy(prop,IN1(P),IN2(h),2,&y,&dydx1,&dydx2);
return pow(10,y)/P*dydx1;
#else
return 1e-3*Evaluate_dydx1(prop,IN1(P),IN2(h));
#endif
}
// dv_dh = v/(h+1e6) * dlog10(v)_dlog10(h+1e6)
// A constant added to y does not propagate through the derivative.
double RefPropSPthPH::dy_dx2(int prop,double P,double h)
{
#ifdef REFPROP_LOG10_2D
double y,dydx1,dydx2;
Evaluate_y_dy(prop,IN1(P),IN2(h),3,&y,&dydx1,&dydx2);
return pow(10,y)/(h+1e6)*dydx2;
#else
return Evaluate_dydx2(prop,IN1(P),IN2(h));
#endif
}
static Format2_5 *read2_5(void)
{
IntX i;
Format2_5 *format = memNew(sizeof(Format2_5));
IN1(format->numberGlyphs);
format->offset = memNew(sizeof(format->offset[0]) * format->numberGlyphs);
for (i = 0; i < format->numberGlyphs; i++)
IN1(format->offset[i]);
return format;
}
/* Process AppleSingle/Double format data. */
static void doASDFormats(ctlTag magic)
{
long junk;
long i;
Card16 entryCount = 0;
struct /* AppleSingle/Double data */
{
unsigned long magic;/* Magic #, 00051600-single, 00051607-double */
unsigned long version;/* Format version */
da_DCL(EntryDesc, entries);/* Entry descriptors */
} asd;
asd.magic = magic;
IN1(asd.version);
/* Skip filler of 16 bytes*/
IN1(junk);
IN1(junk);
IN1(junk);
IN1(junk);
/* Read number of entries */
IN1(entryCount);
da_INIT(asd.entries, entryCount,10);
/* Read entry descriptors */
for (i = 0; i < entryCount; i++)
{
EntryDesc *entry = da_INDEX(asd.entries,i);
IN1(entry->id);
IN1(entry->offset);
IN1(entry->length);
}
for (i = 0; i < entryCount; i++)
{
EntryDesc *entry = da_INDEX(asd.entries,i);
if (entry->length > 0)
switch (entry->id)
{
case 1:
/* Data fork (AppleSingle); see if it's an sfnt */
sfntRead(entry->offset + 4, -1); /* Read plain sfnt file */
sfntDump();
sfntFree(1);
break;
case 2:
/* Resource fork (AppleSingle/Double) */
fileSeek(entry->offset, 0);
resRead(entry->offset); /* Read and dump Macintosh resource file */
break;
}
}
}
/* Allocate and read hybrid value */
static FWord *hybridRead(void) {
IntX i;
FWord *hybrid = memNew(sizeof(hybrid[0]) * nMasters);
for (i = 0; i < nMasters; i++)
IN1(hybrid[i]);
return hybrid;
}
static Format1 *readFormat1(void) {
IntX i;
Format1 *format = memNew(sizeof(Format1));
format->format = 1;
IN1(format->count);
format->glyphId = memNew(sizeof(format->glyphId[0]) * format->count);
for (i = 0; i < format->count; i++)
IN1(format->glyphId[i]);
format->code = memNew(sizeof(format->code[0]) * format->count);
for (i = 0; i < format->count; i++)
IN1(format->code[i]);
return format;
}
void ENCORead(LongN start, Card32 length) {
IntX i;
if (loaded)
return;
ENCO = (ENCOTbl *)memNew(sizeof(ENCOTbl));
if (FNAMGetNEncodings(&nEncodings, ENCO_))
return;
SEEK_ABS(start);
IN1(ENCO->version);
ENCO->offset = memNew(sizeof(ENCO->offset[0]) * (nEncodings + 1));
for (i = 0; i < nEncodings + 1; i++)
IN1(ENCO->offset[i]);
ENCO->encoding = memNew(sizeof(ENCO->encoding[0]) * nEncodings);
for (i = 0; i < nEncodings; i++) {
Card16 format;
SEEK_ABS(ENCO->offset[i] + start);
IN1(format);
switch (format) {
case ENCO_STANDARD:
ENCO->encoding[i] = readFormat0();
break;
case ENCO_SPARSE:
ENCO->encoding[i] = readFormat1();
break;
case ENCO_DENSE:
ENCO->encoding[i] = readFormat2();
break;
default:
warning(SPOT_MSG_ENCOUNKENCOD, format);
}
}
loaded = 1;
}
static Format2 *readFormat2(void) {
IntX i;
Format2 *format = memNew(sizeof(Format2));
format->format = 2;
for (i = 0; i < 256; i++)
IN1(format->glyphId[i]);
return format;
}
double RefPropSPthPH::T(double P,double h)
{
double T = OUT_T(Evaluate_y(0,IN1(P),IN2(h)));
if(errorLog.IsError()) {
char str[128];
sprintf(str,"T(P=%lf,h=%lf)=%lf (%s)",P,h,T,filename);
errorLog.Add("RefPropSPthPH::T",str);
return 0;
}
return T;
}
void MMFXRead(LongN start, Card32 length)
{
IntX i;
Card32 lenstr;
if (loaded)
return;
MMFX = (MMFXTbl *)memNew(sizeof(MMFXTbl));
SEEK_ABS(start);
IN1(MMFX->version);
IN1(MMFX->nMetrics);
IN1(MMFX->offSize);
MMFX->offset = memNew(sizeof(Int32) * (MMFX->nMetrics + 1));
for (i = 0; i < MMFX->nMetrics; i++)
{
if (MMFX->offSize == 2)
{
Int16 tmp;
IN1(tmp);
MMFX->offset[i] = tmp;
}
else
{
IN1(MMFX->offset[i]);
}
if (MMFX->offset[i] < (Int32)minoffset) minoffset = MMFX->offset[i];
if (MMFX->offset[i] > (Int32)maxoffset) maxoffset = MMFX->offset[i];
}
lenstr = (start + length) - TELL();
MMFX->offset[MMFX->nMetrics] = lenstr + 1;
MMFX->cstrs = memNew(sizeof(Card8) * (lenstr + 1));
SEEK_ABS(start + minoffset);
IN_BYTES(lenstr, MMFX->cstrs);
loaded = 1;
}
void MMVRRead(LongN start, Card32 length)
{
IntX i;
if (loaded)
return;
MMVR = (MMVRTbl *)memNew(sizeof(MMVRTbl));
SEEK_ABS(start);
IN1(MMVR->Version);
IN1(MMVR->Flags);
IN1(MMVR->AxisCount);
MMVR->axis = memNew(sizeof(Axis) * MMVR->AxisCount);
for (i = 0; i < MMVR->AxisCount; i++)
{
Axis *axis = &MMVR->axis[i];
IN1(axis->Tag);
IN1(axis->Default);
IN1(axis->Scale);
}
loaded = 1;
}
void WDTHRead(LongN start, Card32 length)
{
IntX i;
IntX size;
IntX nElements;
IntX nOffsets;
if (loaded)
return;
WDTH = (WDTHTbl *)memNew(sizeof(WDTHTbl));
SEEK_ABS(start);
IN1(WDTH->version);
IN1(WDTH->flags);
IN1(WDTH->nMasters);
IN1(WDTH->nRanges);
size = (WDTH->flags & LONG_OFFSETS) ? sizeof(Card32) : sizeof(Card16);
nElements = WDTH->nRanges + 1;
/* Read first glyphs */
WDTH->firstGlyph = memNew(sizeof(GlyphId) * nElements);
for (i = 0; i < nElements; i++)
IN1(WDTH->firstGlyph[i]);
/* Read offsets */
if (WDTH->flags & LONG_OFFSETS)
{
Card32 *offset = WDTH->offset = memNew(sizeof(Card32) * nElements);
for (i = 0; i < nElements; i++)
IN1(offset[i]);
nOffsets = offset[WDTH->nRanges] - offset[0];
}
else
{
Card16 *offset = WDTH->offset = memNew(sizeof(Card16) * nElements);
for (i = 0; i < nElements; i++)
IN1(offset[i]);
nOffsets = offset[WDTH->nRanges] - offset[0];
}
/* Read widths */
WDTH->width = memNew(sizeof(uFWord) * WDTH->nMasters * nOffsets);
for (i = 0; i < nOffsets; i++)
IN1(WDTH->width[i]);
loaded = 1;
}
void postRead(LongN start, Card32 length)
{
if (loaded)
return;
post = (postTbl *)memNew(sizeof(postTbl));
SEEK_ABS(start);
/* Read header */
IN1(post->version);
IN1(post->italicAngle);
IN1(post->underlinePosition);
IN1(post->underlineThickness);
IN1(post->isFixedPitch);
IN1(post->minMemType42);
IN1(post->maxMemType42);
IN1(post->minMemType1);
IN1(post->maxMemType1);
switch (post->version)
{
case VERSION(1,0):
break;
case VERSION(2,0):
post->format = read2_0(length - TBL_HDR_SIZE);
break;
case VERSION(2,5):
post->format = read2_5();
break;
case VERSION(3,0):
break;
case VERSION(4,0):
post->format = read4_0(start);
break;
default:
warning(SPOT_MSG_postBADVERS, VERSION_ARG(post->version));
return;
}
loaded = 1;
}
void RefPropSPthPH::rhoPlusDerivatives(double P,double h,double* rho,double* drho_dP,double* drho_dh)
{
Evaluate_y_dy(4,IN1(P),IN2(h),3,rho,drho_dP,drho_dh);
if(errorLog.IsError()) {
char str[128];
sprintf(str,"rhoPlusDerivatives(P=%lf,h=%lf) (%s)",P,h,filename);
errorLog.Add("RefPropSPthPH::rhoPlusDerivatives",str);
}
printf("drho_dP=%le,drho_dh=%le\n",*drho_dP,*drho_dh);
#ifdef REFPROP_LOG10_2D
(*drho_dP) *= pow(10,*rho)/P;
(*drho_dh) *= pow(10,*rho)/(h+1e6);
(*rho) = OUT(*rho);
#else
(*drho_dP) *= 1e-3;
#endif
}
void HFMXRead(LongN start, Card32 length) {
if (loaded)
return;
HFMX = (HFMXTbl *)memNew(sizeof(HFMXTbl));
nMasters = BLNDGetNMasters();
SEEK_ABS(start);
IN1(HFMX->Version);
HFMX->Ascent = hybridRead();
HFMX->Descent = hybridRead();
HFMX->LineGap = hybridRead();
HFMX->CaretSlopeRise = hybridRead();
HFMX->CaretSlopeRun = hybridRead();
HFMX->CaretOffset = hybridRead();
loaded = 1;
}
void CID_Read(LongN start, Card32 length) {
if (loaded)
return;
CID_ = (CID_Tbl *)memNew(sizeof(CID_Tbl));
SEEK_ABS(start);
IN1(CID_->Version);
IN1(CID_->Flags);
IN1(CID_->CIDCount);
IN1(CID_->TotalLength);
IN1(CID_->AsciiLength);
IN1(CID_->BinaryLength);
IN1(CID_->FDCount);
loaded = 1;
}
void BBOXRead(LongN start, Card32 length) {
IntX i;
if (loaded)
return;
BBOX = (BBOXTbl *)memNew(sizeof(BBOXTbl));
SEEK_ABS(start);
IN1(BBOX->version);
IN1(BBOX->flags);
IN1(BBOX->nGlyphs);
IN1(BBOX->nMasters);
BBOX->bbox = memNew(sizeof(BBox) * BBOX->nGlyphs);
for (i = 0; i < BBOX->nGlyphs; i++) {
IntX j;
BBox *bbox = &BBOX->bbox[i];
bbox->left = memNew(sizeof(FWord) * BBOX->nMasters);
for (j = 0; j < BBOX->nMasters; j++)
IN1(bbox->left[j]);
bbox->bottom = memNew(sizeof(FWord) * BBOX->nMasters);
for (j = 0; j < BBOX->nMasters; j++)
IN1(bbox->bottom[j]);
bbox->right = memNew(sizeof(FWord) * BBOX->nMasters);
for (j = 0; j < BBOX->nMasters; j++)
IN1(bbox->right[j]);
bbox->top = memNew(sizeof(FWord) * BBOX->nMasters);
for (j = 0; j < BBOX->nMasters; j++)
IN1(bbox->top[j]);
}
loaded = 1;
}
static Format4_0 *read4_0(LongN start)
{
IntX i;
Format4_0 *format;
if (maxpGetNGlyphs(&nGlyphs, post_))
{
warning(SPOT_MSG_postNONGLYPH);
return NULL;
}
format = memNew(sizeof(Format4_0));
format->code = memNew(sizeof(format->code[0]) * nGlyphs );
SEEK_ABS(start + TBL_HDR_SIZE);
for (i = 0; i < nGlyphs; i++)
IN1(format->code[i]);
return format;
}
void hdmxRead(LongN start, Card32 length)
{
IntX i;
LongN recordOffset = start + TBL_HDR_SIZE;
if (loaded)
return;
hdmx = (hdmxTbl *)memNew(sizeof(hdmxTbl));
if (maxpGetNGlyphs(&nGlyphs, hdmx_))
return;
SEEK_ABS(start);
IN1(hdmx->version);
IN1(hdmx->nRecords);
IN1(hdmx->recordSize);
hdmx->record = memNew(sizeof(DeviceRecord) * hdmx->nRecords);
for (i = 0; i < hdmx->nRecords; i++)
{
IntX j;
DeviceRecord *rec = &hdmx->record[i];
IN1(rec->pixelsPerEm);
IN1(rec->maxWidth);
rec->widths = memNew(sizeof(rec->widths[0]) * nGlyphs);
for (j = 0; j < nGlyphs; j++)
IN1(rec->widths[j]);
recordOffset += hdmx->recordSize;
SEEK_ABS(recordOffset);
}
loaded = 1;
}
void wilson_dslash_trick(double *outf, double *in0, double *in1, double *in2, double *in3,
double sign, int accum)
{
int c;
if(accum == 0) {
for(c=0;c<3;c++){
/* trick into spin component 0*/
OUTF(0,c,0) = IN0(0,c,0) + IN1(0,c,0) + IN2(0,c,0) + IN3(0,c,0);
OUTF(1,c,0) = IN0(1,c,0) + IN1(1,c,0) + IN2(1,c,0) + IN3(1,c,0);
/* trick into spin component 1*/
OUTF(0,c,1) = IN0(0,c,1) + IN1(0,c,1) + IN2(0,c,1) + IN3(0,c,1);
OUTF(1,c,1) = IN0(1,c,1) + IN1(1,c,1) + IN2(1,c,1) + IN3(1,c,1);
/* trick into spin component 2*/
OUTF(0,c,2) = sign * ( IN0(1,c,1) + IN1(0,c,1) + IN2(1,c,0) + IN3(0,c,0) );
OUTF(1,c,2) = sign * (-IN0(0,c,1) + IN1(1,c,1) - IN2(0,c,0) + IN3(1,c,0) );
/* trick into spin component 3*/
OUTF(0,c,3) = sign * ( IN0(1,c,0) - IN1(0,c,0) - IN2(1,c,1) + IN3(0,c,1) );
OUTF(1,c,3) = sign * (-IN0(0,c,0) - IN1(1,c,0) + IN2(0,c,1) + IN3(1,c,1) );
}
} else {
for(c=0;c<3;c++){
/* trick and accumulate into spin component 0*/
OUTF(0,c,0) = OUTF(0,c,0) + IN0(0,c,0) + IN1(0,c,0) + IN2(0,c,0) + IN3(0,c,0);
OUTF(1,c,0) = OUTF(1,c,0) + IN0(1,c,0) + IN1(1,c,0) + IN2(1,c,0) + IN3(1,c,0);
/* trick and accumulate into spin component 1*/
OUTF(0,c,1) = OUTF(0,c,1) + IN0(0,c,1) + IN1(0,c,1) + IN2(0,c,1) + IN3(0,c,1);
OUTF(1,c,1) = OUTF(1,c,1) + IN0(1,c,1) + IN1(1,c,1) + IN2(1,c,1) + IN3(1,c,1);
/* trick and accumulate into spin component 2*/
OUTF(0,c,2) = OUTF(0,c,2) + sign * ( IN0(1,c,1) + IN1(0,c,1) + IN2(1,c,0) + IN3(0,c,0) );
OUTF(1,c,2) = OUTF(1,c,2) + sign * (-IN0(0,c,1) + IN1(1,c,1) - IN2(0,c,0) + IN3(1,c,0) );
/* trick and accumulate into spin component 3*/
OUTF(0,c,3) = OUTF(0,c,3) + sign * ( IN0(1,c,0) - IN1(0,c,0) - IN2(1,c,1) + IN3(0,c,1) );
OUTF(1,c,3) = OUTF(1,c,3) + sign * (-IN0(0,c,0) - IN1(1,c,0) + IN2(0,c,1) + IN3(1,c,1) );
}
}
}
void FORTE_F_SUB_DATE_DATE::executeEvent(int pa_nEIID){
if(scm_nEventREQID == pa_nEIID){
OUT() = SUB_DATE_DATE(IN1(), IN2());
sendOutputEvent(scm_nEventCNFID);
}
}
void FORTE_F_INSERT::executeEvent(int pa_nEIID){
if (scm_nEventREQID == pa_nEIID) {
anyStringFBHelper<FORTE_F_INSERT>(IN1().getDataTypeID(), *this);
sendOutputEvent(scm_nEventCNFID);
}
}
void FORTE_F_MUL::executeEvent(int pa_nEIID){
if (scm_nEventREQID == pa_nEIID) {
anyMagnitudeFBHelper<FORTE_F_MUL>(IN1().getDataTypeID(), *this);
sendOutputEvent(scm_nEventCNFID);
}
}
void FORTE_F_MIN::executeEvent(int pa_nEIID) {
if (scm_nEventREQID == pa_nEIID) {
anyElementaryFBHelper<FORTE_F_MIN>(IN1().getDataTypeID(), *this);
sendOutputEvent(scm_nEventCNFID);
}
}
void FB_ADD_INT::alg_REQ(void){
OUT() = static_cast<TForteInt16>(IN1()+IN2());
}
void FORTE_F_ADD_TOD_TIME::executeEvent(int pa_nEIID){
if(scm_nEventREQID == pa_nEIID){
OUT() = ADD_TOD_TIME(IN1(), IN2());
sendOutputEvent(scm_nEventCNFID);
}
}
void FB_MUL_REAL::alg_REQ(void){
OUT() = IN1()*IN2();
}
void FB_ADD_LREAL::alg_REQ(void){
OUT() = IN1()+IN2();
}
