/*
* Closes the specified zip file object.
*/
void JNICALL
ZIP_Close(jzfile *zip)
{
MLOCK(zfiles_lock);
if (--zip->refs > 0) {
/* Still more references so just return */
MUNLOCK(zfiles_lock);
return;
}
/* No other references so close the file and remove from list */
if (zfiles == zip) {
zfiles = zfiles->next;
} else {
jzfile *zp;
for (zp = zfiles; zp->next != 0; zp = zp->next) {
if (zp->next == zip) {
zp->next = zip->next;
break;
}
}
}
MUNLOCK(zfiles_lock);
freeZip(zip);
return;
}
jzfile *
ZIP_Put_In_Cache0(const char *name, ZFILE zfd, char **pmsg, jlong lastModified,
jboolean usemmap)
{
static char errbuf[256];
jlong len;
jzfile *zip;
if ((zip = allocZip(name)) == NULL) {
return NULL;
}
#ifdef USE_MMAP
zip->usemmap = usemmap;
#endif
zip->refs = 1;
zip->lastModified = lastModified;
if (zfd == -1) {
if (pmsg && JVM_GetLastErrorString(errbuf, sizeof(errbuf)) > 0)
*pmsg = errbuf;
freeZip(zip);
return NULL;
}
len = zip->len = IO_Lseek(zfd, 0, SEEK_END); //获取当前jar/zip文件的长度
if (len <= 0) {
if (len == 0) { /* zip file is empty */
if (pmsg) {
*pmsg = "zip file is empty";
}
} else { /* error */
if (pmsg && JVM_GetLastErrorString(errbuf, sizeof(errbuf)) > 0)
*pmsg = errbuf;
}
ZFILE_Close(zfd);
freeZip(zip);
return NULL;
}
zip->zfd = zfd; //当前jar/zip文件的文件描述符
if (readCEN(zip, -1) < 0) {
/* An error occurred while trying to read the zip file */
if (pmsg != 0) {
/* Set the zip error message */
*pmsg = zip->msg;
}
freeZip(zip);
return NULL;
}
MLOCK(zfiles_lock);
zip->next = zfiles;
zfiles = zip;
MUNLOCK(zfiles_lock);
return zip;
}
/** Function dumps (stores in the internal string object) the given short_t.
* \param[in] pszName - name of the member variable of the dumped object
* \param[in] sValue - a short_t value to dump
*/
void dumpctx::dump(const tchar_t* pszName, const short_t sValue)
{
_sntprintf(m_szBuffer, max_dump, TSTRFMT _t(" (short_t):\n\t") SFMT _t(" (hex: ") SXFMT _t(")\n"), pszName, sValue, sValue);
m_szBuffer[max_dump-1]=_t('\0');
MLOCK(m_lock);
*m_pBuffer+=m_szBuffer;
MUNLOCK(m_lock);
}
/** Function dumps (stores in the internal string object) the given uchar_t.
* \param[in] pszName - name of the member variable of the dumped object
* \param[in] ucValue - an uchar_t value to dump
*/
void dumpctx::dump(const tchar_t* pszName, const uchar_t ucValue)
{
_sntprintf(m_szBuffer, max_dump, TSTRFMT _t(" (uchar_t):\n\t'") UCHARFMT _t("' (hex: ") UCXFMT _t(" / dec: ") UCFMT _t(")\n"), pszName, ucValue, (ushort_t)ucValue, (ushort_t)ucValue);
m_szBuffer[max_dump-1]=_t('\0');
MLOCK(m_lock);
*m_pBuffer+=m_szBuffer;
MUNLOCK(m_lock);
}
/** Function dumps (stores in the internal string object) the untyped pointer.
* \param[in] pszName - name of the member variable of the dumped object
* \param[in] pValue - an untyped pointer value to dump
*/
void dumpctx::dump(const tchar_t* pszName, const ptr_t pValue)
{
_sntprintf(m_szBuffer, max_dump, TSTRFMT _t(" (ptr_t):\n\t") PTRFMT _t("\n"), pszName, pValue);
m_szBuffer[max_dump-1]=_t('\0');
MLOCK(m_lock);
*m_pBuffer+=m_szBuffer;
MUNLOCK(m_lock);
}
/** Function dumps (stores in the internal string object) the ulonglong_t.
* \param[in] pszName - name of the member variable of the dumped object
* \param[in] ullValue - an ulonglong_t value to dump
*/
void dumpctx::dump(const tchar_t* pszName, const ulonglong_t ullValue)
{
_sntprintf(m_szBuffer, max_dump, TSTRFMT _t(" (ulonglong_t):\n\t") ULLFMT _t(" (hex: ") ULLXFMT _t(")\n"), pszName, ullValue, ullValue);
m_szBuffer[max_dump-1]=_t('\0');
MLOCK(m_lock);
*m_pBuffer+=m_szBuffer;
MUNLOCK(m_lock);
}
void
mvfs_rddir_cache_enter(
struct mfs_mnode *mnp,
struct mvfs_rce *entryp
)
{
MLOCK(mnp);
mvfs_rddir_cache_enter_mnlocked(mnp, entryp);
MUNLOCK(mnp);
}
int
mfs_ramdir_remove(
VNODE_T *dvp,
char *nm,
VNODE_T **vpp,
CALL_DATA_T *cd
)
{
register mfs_mnode_t *mnp;
register int vnum;
int error;
ASSERT(MFS_ISVIEWDIR(VTOM(dvp)));
mnp = VTOM(dvp);
MLOCK(mnp);
error = ENOENT;
for (vnum=0; vnum < mnp->mn_ramdir.hwm; vnum++) {
if (mnp->mn_ramdir.ents[vnum].nm == NULL) continue;
if (STRCMP(mnp->mn_ramdir.ents[vnum].nm, nm) == 0) {
if (MVFS_ISVTYPE(mnp->mn_ramdir.ents[vnum].vp, VDIR))
mnp->mn_ramdir.lnk_cnt--;
*vpp = mnp->mn_ramdir.ents[vnum].vp; /* return vnode */
mnp->mn_ramdir.ents[vnum].vp = NULL;
STRFREE(mnp->mn_ramdir.ents[vnum].nm);
mnp->mn_ramdir.mtime.tv_sec = MDKI_CTIME();
/* Update high water mark if required */
if (vnum == mnp->mn_ramdir.hwm-1) {
while (mnp->mn_ramdir.ents[--vnum].nm == NULL) {}
mnp->mn_ramdir.hwm = vnum+1;
}
error = 0;
MVFS_WRAP_UPDATE_ATTRS(dvp, cd);
break;
}
}
MUNLOCK(mnp);
if (error)
*vpp = NULL;
else
MVFS_RM_DCACHE(*vpp);
return(error);
}
void
mfs_ramdir_purgevp(
VNODE_T *dvp,
VNODE_T *vp,
CALL_DATA_T *cd
)
{
register mfs_mnode_t *mnp;
register int vnum;
int hwm;
ASSERT(MFS_ISVIEWDIR(VTOM(dvp)));
mnp = VTOM(dvp);
MLOCK(mnp);
/* Must continue scan to remove multiple links to same object. */
for (vnum=0; vnum < mnp->mn_ramdir.hwm; vnum++) {
if (mnp->mn_ramdir.ents[vnum].vp == vp) {
if (MVFS_ISVTYPE(vp, VDIR))
mnp->mn_ramdir.lnk_cnt--;
ATRIA_VN_RELE(vp, cd);
mnp->mn_ramdir.ents[vnum].vp = NULL;
ASSERT(mnp->mn_ramdir.ents[vnum].nm);
STRFREE(mnp->mn_ramdir.ents[vnum].nm);
mnp->mn_ramdir.mtime.tv_sec = MDKI_CTIME();
/* Update high water mark if releasing the highest slot */
if (vnum == mnp->mn_ramdir.hwm-1) {
hwm = vnum;
while (mnp->mn_ramdir.ents[--hwm].nm == NULL) {}
mnp->mn_ramdir.hwm = hwm+1;
}
}
}
MUNLOCK(mnp);
}
jzfile * ZIP_Get_From_Cache(const char *name, char **pmsg, jlong lastModified)
{
static char errbuf[256];
char buf[PATH_MAX];
jzfile *zip;
if (InitializeZip()) {
return NULL;
}
/* Clear zip error message */
if (pmsg != 0) {
*pmsg = NULL;
}
if (strlen(name) >= PATH_MAX) {
if (pmsg) {
*pmsg = "zip file name too long";
}
return NULL;
}
strcpy(buf, name);
JVM_NativePath(buf);
name = buf;
MLOCK(zfiles_lock);
for (zip = zfiles; zip != NULL; zip = zip->next) {
if (strcmp(name, zip->name) == 0
&& (zip->lastModified == lastModified || zip->lastModified == 0)
&& zip->refs < MAXREFS) {
zip->refs++;
break;
}
}
MUNLOCK(zfiles_lock);
return zip;
}
/*
#] Includes :
#[ FactorIn :
This routine tests for a factor in a dollar expression.
Note that unlike with regular active or hidden expressions we cannot
add memory as easily as dollars are rather volatile.
*/
int FactorIn(PHEAD WORD *term, WORD level)
{
GETBIDENTITY
WORD *t, *tstop, *m, *mm, *oldwork, *mstop, *n1, *n2, *n3, *n4, *n1stop, *n2stop;
WORD *r1, *r2, *r3, *r4, j, k, kGCD, kGCD2, kLCM, jGCD, kkLCM, jLCM, size;
UWORD *GCDbuffer, *GCDbuffer2, *LCMbuffer, *LCMb, *LCMc;
int fromwhere = 0, i;
DOLLARS d;
t = term; GETSTOP(t,tstop); t++;
while ( ( t < tstop ) && ( *t != FACTORIN || ( ( *t == FACTORIN )
&& ( t[FUNHEAD] != -DOLLAREXPRESSION || t[1] != FUNHEAD+2 ) ) ) ) t += t[1];
if ( t >= tstop ) {
MLOCK(ErrorMessageLock);
MesPrint("Internal error. Could not find proper factorin_ function.");
MUNLOCK(ErrorMessageLock);
return(-1);
}
oldwork = AT.WorkPointer;
d = Dollars + t[FUNHEAD+1];
#ifdef WITHPTHREADS
{
int nummodopt, dtype = -1;
if ( AS.MultiThreaded ) {
for ( nummodopt = 0; nummodopt < NumModOptdollars; nummodopt++ ) {
if ( t[FUNHEAD+1] == ModOptdollars[nummodopt].number ) break;
}
if ( nummodopt < NumModOptdollars ) {
dtype = ModOptdollars[nummodopt].type;
if ( dtype == MODLOCAL ) {
d = ModOptdollars[nummodopt].dstruct+AT.identity;
}
}
}
}
#endif
if ( d->type == DOLTERMS ) {
fromwhere = 1;
}
else if ( ( d = DolToTerms(BHEAD t[FUNHEAD+1]) ) == 0 ) {
/*
The variable cannot convert to an expression
We replace the function by 1.
*/
m = oldwork; n1 = term;
while ( n1 < t ) *m++ = *n1++;
n1 = t + t[1]; tstop = term + *term;
while ( n1 < tstop ) *m++ = *n1++;
*oldwork = m - oldwork;
AT.WorkPointer = m;
if ( Generator(BHEAD oldwork,level) ) return(-1);
AT.WorkPointer = oldwork;
return(0);
}
if ( d->where[0] == 0 ) {
if ( fromwhere == 0 ) {
if ( d->factors ) M_free(d->factors,"Dollar factors");
M_free(d,"Dollar in FactorIn_");
}
return(0);
}
/*
Now we have an expression in d->where. Find the symbolic factor that
divides the expression and the numerical factor that makes all
coefficients integer.
For the symbolic factor we make a copy of the first term, and then
go through all terms, scratching in the copy the objects that do not
occur in the terms.
*/
m = oldwork;
mm = d->where;
k = *mm - ABS((mm[*mm-1]));
for ( j = 0; j < k; j++ ) *m++ = *mm++;
mstop = m;
*oldwork = k;
/*
The copy is in place. Now search through the terms. Start at the second term
*/
mm = d->where + d->where[0];
while ( *mm ) {
m = oldwork+1;
r2 = mm+*mm;
r2 -= ABS(r2[-1]);
r1 = mm+1;
while ( m < mstop ) {
while ( r1 < r2 ) {
if ( *r1 != *m ) {
r1 += r1[1]; continue;
}
/*
Now the various cases
#[ SYMBOL :
*/
if ( *m == SYMBOL ) {
n1 = m+2; n1stop = m+m[1];
n2stop = r1+r1[1];
while ( n1 < n1stop ) {
n2 = r1+2;
while ( n2 < n2stop ) {
if ( *n1 != *n2 ) { n2 += 2; continue; }
if ( n1[1] > 0 ) {
if ( n2[1] < 0 ) { n2 += 2; continue; }
if ( n2[1] < n1[1] ) n1[1] = n2[1];
}
else {
if ( n2[1] > 0 ) { n2 += 2; continue; }
if ( n2[1] > n1[1] ) n1[1] = n2[1];
}
break;
}
if ( n2 >= n2stop ) { /* scratch symbol */
if ( m[1] == 4 ) goto scratch;
m[1] -= 2;
n3 = n1; n4 = n1+2;
while ( n4 < mstop ) *n3++ = *n4++;
*oldwork = n3 - oldwork;
mstop -= 2; n1stop -= 2;
continue;
}
n1 += 2;
}
break;
}
/*
#] SYMBOL :
#[ DOTPRODUCT :
*/
else if ( *m == DOTPRODUCT ) {
n1 = m+2; n1stop = m+m[1];
n2stop = r1+r1[1];
while ( n1 < n1stop ) {
n2 = r1+2;
while ( n2 < n2stop ) {
if ( *n1 != *n2 || n1[1] != n2[1] ) { n2 += 3; continue; }
if ( n1[2] > 0 ) {
if ( n2[2] < 0 ) { n2 += 3; continue; }
if ( n2[2] < n1[2] ) n1[2] = n2[2];
}
else {
if ( n2[2] > 0 ) { n2 += 3; continue; }
if ( n2[2] > n1[2] ) n1[2] = n2[2];
}
break;
}
if ( n2 >= n2stop ) { /* scratch symbol */
if ( m[1] == 5 ) goto scratch;
m[1] -= 3;
n3 = n1; n4 = n1+3;
while ( n4 < mstop ) *n3++ = *n4++;
*oldwork = n3 - oldwork;
mstop -= 3; n1stop -= 3;
continue;
}
n1 += 3;
}
break;
}
/*
#] DOTPRODUCT :
#[ VECTOR :
*/
else if ( *m == VECTOR ) {
/*
Here we have to be careful if there is more than
one of the same
*/
n1 = m+2; n1stop = m+m[1];
n2 = r1+2;n2stop = r1+r1[1];
while ( n1 < n1stop ) {
while ( n2 < n2stop ) {
if ( *n1 == *n2 && n1[1] == n2[1] ) {
n2 += 2; goto nextn1;
}
n2 += 2;
}
if ( n2 >= n2stop ) { /* scratch symbol */
if ( m[1] == 4 ) goto scratch;
m[1] -= 2;
n3 = n1; n4 = n1+2;
while ( n4 < mstop ) *n3++ = *n4++;
*oldwork = n3 - oldwork;
mstop -= 2; n1stop -= 2;
continue;
}
n2 = r1+2;
nextn1: n1 += 2;
}
break;
}
/*
#] VECTOR :
#[ REMAINDER :
*/
else {
/*
Again: watch for multiple occurrences of the same object
*/
if ( m[1] != r1[1] ) { r1 += r1[1]; continue; }
for ( j = 2; j < m[1]; j++ ) {
if ( m[j] != r1[j] ) break;
}
if ( j < m[1] ) { r1 += r1[1]; continue; }
r1 += r1[1]; /* to restart at the next potential match */
goto nextm; /* match */
}
/*
#] REMAINDER :
*/
}
if ( r1 >= r2 ) { /* no factor! */
scratch:;
r3 = m + m[1]; r4 = m;
while ( r3 < mstop ) *r4++ = *r3++;
*oldwork = r4 - oldwork;
if ( *oldwork == 1 ) goto nofactor;
mstop = r4;
r1 = mm + 1;
continue;
}
r1 = mm + 1;
nextm: m += m[1];
}
mm = mm + *mm;
}
nofactor:;
/*
For the coefficient we have to determine the LCM of the denominators
and the GCD of the numerators.
*/
GCDbuffer = NumberMalloc("FactorIn"); GCDbuffer2 = NumberMalloc("FactorIn");
LCMbuffer = NumberMalloc("FactorIn"); LCMb = NumberMalloc("FactorIn"); LCMc = NumberMalloc("FactorIn");
r1 = d->where;
/*
First take the first term to load up the LCM and the GCD
*/
r2 = r1 + *r1;
j = r2[-1];
r3 = r2 - ABS(j);
k = REDLENG(j);
if ( k < 0 ) k = -k;
while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
for ( kGCD = 0; kGCD < k; kGCD++ ) GCDbuffer[kGCD] = r3[kGCD];
k = REDLENG(j);
if ( k < 0 ) k = -k;
r3 += k;
while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
for ( kLCM = 0; kLCM < k; kLCM++ ) LCMbuffer[kLCM] = r3[kLCM];
r1 = r2;
/*
Now go through the rest of the terms in this dollar buffer.
*/
while ( *r1 ) {
r2 = r1 + *r1;
j = r2[-1];
r3 = r2 - ABS(j);
k = REDLENG(j);
if ( k < 0 ) k = -k;
while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
if ( ( ( GCDbuffer[0] == 1 ) && ( kGCD == 1 ) ) ) {
/*
GCD is already 1
*/
}
else if ( ( ( k != 1 ) || ( r3[0] != 1 ) ) ) {
if ( GcdLong(BHEAD GCDbuffer,kGCD,(UWORD *)r3,k,GCDbuffer2,&kGCD2) ) {
goto onerror;
}
kGCD = kGCD2;
for ( i = 0; i < kGCD; i++ ) GCDbuffer[i] = GCDbuffer2[i];
}
else {
kGCD = 1; GCDbuffer[0] = 1;
}
k = REDLENG(j);
if ( k < 0 ) k = -k;
r3 += k;
while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
if ( ( ( LCMbuffer[0] == 1 ) && ( kLCM == 1 ) ) ) {
for ( kLCM = 0; kLCM < k; kLCM++ )
LCMbuffer[kLCM] = r3[kLCM];
}
else if ( ( k != 1 ) || ( r3[0] != 1 ) ) {
if ( GcdLong(BHEAD LCMbuffer,kLCM,(UWORD *)r3,k,LCMb,&kkLCM) ) {
goto onerror;
}
DivLong((UWORD *)r3,k,LCMb,kkLCM,LCMb,&kkLCM,LCMc,&jLCM);
MulLong(LCMbuffer,kLCM,LCMb,kkLCM,LCMc,&jLCM);
for ( kLCM = 0; kLCM < jLCM; kLCM++ )
LCMbuffer[kLCM] = LCMc[kLCM];
}
else {} /* LCM doesn't change */
r1 = r2;
}
/*
Now put the factor together: GCD/LCM
*/
r3 = (WORD *)(GCDbuffer);
if ( kGCD == kLCM ) {
for ( jGCD = 0; jGCD < kGCD; jGCD++ )
r3[jGCD+kGCD] = LCMbuffer[jGCD];
k = kGCD;
}
else if ( kGCD > kLCM ) {
for ( jGCD = 0; jGCD < kLCM; jGCD++ )
r3[jGCD+kGCD] = LCMbuffer[jGCD];
for ( jGCD = kLCM; jGCD < kGCD; jGCD++ )
r3[jGCD+kGCD] = 0;
k = kGCD;
}
else {
for ( jGCD = kGCD; jGCD < kLCM; jGCD++ )
r3[jGCD] = 0;
for ( jGCD = 0; jGCD < kLCM; jGCD++ )
r3[jGCD+kLCM] = LCMbuffer[jGCD];
k = kLCM;
}
j = 2*k+1;
mm = m = oldwork + oldwork[0];
/*
Now compose the new term
*/
n1 = term;
while ( n1 < t ) *m++ = *n1++;
n1 += n1[1];
n2 = oldwork+1;
while ( n2 < mm ) *m++ = *n2++;
while ( n1 < tstop ) *m++ = *n1++;
/*
And the coefficient
*/
size = term[*term-1];
size = REDLENG(size);
if ( MulRat(BHEAD (UWORD *)tstop,size,(UWORD *)r3,k,
(UWORD *)m,&size) ) goto onerror;
size = INCLENG(size);
k = size < 0 ? -size: size;
m[k-1] = size;
m += k;
*mm = (WORD)(m - mm);
AT.WorkPointer = m;
if ( Generator(BHEAD mm,level) ) goto onerror;
AT.WorkPointer = oldwork;
if ( fromwhere == 0 ) {
if ( d->factors ) M_free(d->factors,"Dollar factors");
M_free(d,"Dollar in FactorIn");
}
NumberFree(GCDbuffer,"FactorIn"); NumberFree(GCDbuffer2,"FactorIn");
NumberFree(LCMbuffer,"FactorIn"); NumberFree(LCMb,"FactorIn"); NumberFree(LCMc,"FactorIn");
return(0);
onerror:
AT.WorkPointer = oldwork;
MLOCK(ErrorMessageLock);
MesCall("FactorIn");
MUNLOCK(ErrorMessageLock);
NumberFree(GCDbuffer,"FactorIn"); NumberFree(GCDbuffer2,"FactorIn");
NumberFree(LCMbuffer,"FactorIn"); NumberFree(LCMb,"FactorIn"); NumberFree(LCMc,"FactorIn");
return(-1);
}
int FactorInExpr(PHEAD WORD *term, WORD level)
{
GETBIDENTITY
WORD *t, *tstop, *m, *oldwork, *mstop, *n1, *n2, *n3, *n4, *n1stop, *n2stop;
WORD *r1, *r2, *r3, *r4, j, k, kGCD, kGCD2, kLCM, jGCD, kkLCM, jLCM, size, sign;
WORD *newterm, expr = 0;
WORD olddeferflag = AR.DeferFlag, oldgetfile = AR.GetFile, oldhold = AR.KeptInHold;
WORD newgetfile, newhold;
int i;
EXPRESSIONS e;
FILEHANDLE *file = 0;
POSITION position, oldposition, startposition;
WORD *oldcpointer = AR.CompressPointer;
UWORD *GCDbuffer, *GCDbuffer2, *LCMbuffer, *LCMb, *LCMc;
GCDbuffer = NumberMalloc("FactorInExpr"); GCDbuffer2 = NumberMalloc("FactorInExpr");
LCMbuffer = NumberMalloc("FactorInExpr"); LCMb = NumberMalloc("FactorInExpr"); LCMc = NumberMalloc("FactorInExpr");
t = term; GETSTOP(t,tstop); t++;
while ( t < tstop ) {
if ( *t == FACTORIN && t[1] == FUNHEAD+2 && t[FUNHEAD] == -EXPRESSION ) {
expr = t[FUNHEAD+1];
break;
}
t += t[1];
}
if ( t >= tstop ) {
MLOCK(ErrorMessageLock);
MesPrint("Internal error. Could not find proper factorin_ function.");
MUNLOCK(ErrorMessageLock);
NumberFree(GCDbuffer,"FactorInExpr"); NumberFree(GCDbuffer2,"FactorInExpr");
NumberFree(LCMbuffer,"FactorInExpr"); NumberFree(LCMb,"FactorInExpr"); NumberFree(LCMc,"FactorInExpr");
return(-1);
}
oldwork = AT.WorkPointer;
if ( AT.previousEfactor && ( expr == AT.previousEfactor[0] ) ) {
/*
We have a hit in the cache. Construct the new term.
At the moment AT.previousEfactor[1] is reserved for future flags
*/
goto PutTheFactor;
}
/*
No hit. We have to do the work. We start with constructing the factor
in the WorkSpace. Later we will move it to the cache.
Finally we will jump to PutTheFactor.
*/
e = Expressions + expr;
switch ( e->status ) {
case LOCALEXPRESSION:
case SKIPLEXPRESSION:
case DROPLEXPRESSION:
case GLOBALEXPRESSION:
case SKIPGEXPRESSION:
case DROPGEXPRESSION:
/*
Expression is to be found in the input Scratch file.
Set the file handle and the position.
The rest is done by GetTerm.
*/
newhold = 0;
newgetfile = 1;
file = AR.infile;
break;
case HIDDENLEXPRESSION:
case HIDDENGEXPRESSION:
case HIDELEXPRESSION:
case HIDEGEXPRESSION:
case DROPHLEXPRESSION:
case DROPHGEXPRESSION:
case UNHIDELEXPRESSION:
case UNHIDEGEXPRESSION:
/*
Expression is to be found in the hide Scratch file.
Set the file handle and the position.
The rest is done by GetTerm.
*/
newhold = 0;
newgetfile = 2;
file = AR.hidefile;
break;
case STOREDEXPRESSION:
/*
This is an 'illegal' case
*/
MLOCK(ErrorMessageLock);
MesPrint("Error: factorin_ cannot determine factors in stored expressions.");
MUNLOCK(ErrorMessageLock);
NumberFree(GCDbuffer,"FactorInExpr"); NumberFree(GCDbuffer2,"FactorInExpr");
NumberFree(LCMbuffer,"FactorInExpr"); NumberFree(LCMb,"FactorInExpr"); NumberFree(LCMc,"FactorInExpr");
return(-1);
case DROPPEDEXPRESSION:
/*
We replace the function by 1.
*/
m = oldwork; n1 = term;
while ( n1 < t ) *m++ = *n1++;
n1 = t + t[1]; tstop = term + *term;
while ( n1 < tstop ) *m++ = *n1++;
*oldwork = m - oldwork;
AT.WorkPointer = m;
if ( Generator(BHEAD oldwork,level) ) {
NumberFree(GCDbuffer,"FactorInExpr"); NumberFree(GCDbuffer2,"FactorInExpr");
NumberFree(LCMbuffer,"FactorInExpr"); NumberFree(LCMb,"FactorInExpr"); NumberFree(LCMc,"FactorInExpr");
return(-1);
}
AT.WorkPointer = oldwork;
NumberFree(GCDbuffer,"FactorInExpr"); NumberFree(GCDbuffer2,"FactorInExpr");
NumberFree(LCMbuffer,"FactorInExpr"); NumberFree(LCMb,"FactorInExpr"); NumberFree(LCMc,"FactorInExpr");
return(0);
default:
MLOCK(ErrorMessageLock);
MesPrint("Error: Illegal expression in factorinexpr.");
MUNLOCK(ErrorMessageLock);
NumberFree(GCDbuffer,"FactorInExpr"); NumberFree(GCDbuffer2,"FactorInExpr");
NumberFree(LCMbuffer,"FactorInExpr"); NumberFree(LCMb,"FactorInExpr"); NumberFree(LCMc,"FactorInExpr");
return(-1);
}
/*
Before we start with the file we set the buffers for the coefficient
For the coefficient we have to determine the LCM of the denominators
and the GCD of the numerators.
*/
position = AS.OldOnFile[expr];
AR.DeferFlag = 0; AR.KeptInHold = newhold; AR.GetFile = newgetfile;
SeekScratch(file,&oldposition);
SetScratch(file,&position);
if ( GetTerm(BHEAD oldwork) <= 0 ) {
MLOCK(ErrorMessageLock);
MesPrint("(5) Expression %d has problems in scratchfile",expr);
MUNLOCK(ErrorMessageLock);
NumberFree(GCDbuffer,"FactorInExpr"); NumberFree(GCDbuffer2,"FactorInExpr");
NumberFree(LCMbuffer,"FactorInExpr"); NumberFree(LCMb,"FactorInExpr"); NumberFree(LCMc,"FactorInExpr");
return(-1);
}
SeekScratch(file,&startposition);
SeekScratch(file,&position);
/*
Load the first term in the workspace
*/
if ( GetTerm(BHEAD oldwork) == 0 ) {
SetScratch(file,&oldposition); /* We still need this untill Processor is clean */
AR.DeferFlag = olddeferflag;
oldwork[0] = 4; oldwork[1] = 1; oldwork[2] = 1; oldwork[3] = 3;
goto Complete;
}
SeekScratch(file,&position);
AR.DeferFlag = olddeferflag; AR.KeptInHold = oldhold; AR.GetFile = oldgetfile;
r2 = m = oldwork + *oldwork;
j = m[-1];
m -= ABS(j);
*oldwork = (WORD)(m-oldwork);
AT.WorkPointer = newterm = mstop = m;
/*
Now take the coefficient of the first term to load up the LCM and the GCD
*/
r3 = m;
k = REDLENG(j);
if ( k < 0 ) { k = -k; sign = -1; }
else { sign = 1; }
while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
for ( kGCD = 0; kGCD < k; kGCD++ ) GCDbuffer[kGCD] = r3[kGCD];
k = REDLENG(j);
if ( k < 0 ) k = -k;
r3 += k;
while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
for ( kLCM = 0; kLCM < k; kLCM++ ) LCMbuffer[kLCM] = r3[kLCM];
/*
The copy and the coefficient are in place. Now search through the terms.
*/
for (;;) {
AR.DeferFlag = 0; AR.KeptInHold = newhold; AR.GetFile = newgetfile;
SetScratch(file,&position);
size = GetTerm(BHEAD newterm);
SeekScratch(file,&position);
AR.DeferFlag = olddeferflag; AR.KeptInHold = oldhold; AR.GetFile = oldgetfile;
if ( size == 0 ) break;
m = oldwork+1;
r2 = newterm + *newterm;
r2 -= ABS(r2[-1]);
r1 = newterm+1;
while ( m < mstop ) {
while ( r1 < r2 ) {
if ( *r1 != *m ) {
r1 += r1[1]; continue;
}
/*
Now the various cases
#[ SYMBOL :
*/
if ( *m == SYMBOL ) {
n1 = m+2; n1stop = m+m[1];
n2stop = r1+r1[1];
while ( n1 < n1stop ) {
n2 = r1+2;
while ( n2 < n2stop ) {
if ( *n1 != *n2 ) { n2 += 2; continue; }
if ( n1[1] > 0 ) {
if ( n2[1] < 0 ) { n2 += 2; continue; }
if ( n2[1] < n1[1] ) n1[1] = n2[1];
}
else {
if ( n2[1] > 0 ) { n2 += 2; continue; }
if ( n2[1] > n1[1] ) n1[1] = n2[1];
}
break;
}
if ( n2 >= n2stop ) { /* scratch symbol */
if ( m[1] == 4 ) goto scratch;
m[1] -= 2;
n3 = n1; n4 = n1+2;
while ( n4 < mstop ) *n3++ = *n4++;
*oldwork = n3 - oldwork;
mstop -= 2; n1stop -= 2;
continue;
}
n1 += 2;
}
break;
}
/*
#] SYMBOL :
#[ DOTPRODUCT :
*/
else if ( *m == DOTPRODUCT ) {
n1 = m+2; n1stop = m+m[1];
n2stop = r1+r1[1];
while ( n1 < n1stop ) {
n2 = r1+2;
while ( n2 < n2stop ) {
if ( *n1 != *n2 || n1[1] != n2[1] ) { n2 += 3; continue; }
if ( n1[2] > 0 ) {
if ( n2[2] < 0 ) { n2 += 3; continue; }
if ( n2[2] < n1[2] ) n1[2] = n2[2];
}
else {
if ( n2[2] > 0 ) { n2 += 3; continue; }
if ( n2[2] > n1[2] ) n1[2] = n2[2];
}
break;
}
if ( n2 >= n2stop ) { /* scratch dotproduct */
if ( m[1] == 5 ) goto scratch;
m[1] -= 3;
n3 = n1; n4 = n1+3;
while ( n4 < mstop ) *n3++ = *n4++;
*oldwork = n3 - oldwork;
mstop -= 3; n1stop -= 3;
continue;
}
n1 += 3;
}
break;
}
/*
#] DOTPRODUCT :
#[ VECTOR :
*/
else if ( *m == VECTOR ) {
/*
Here we have to be careful if there is more than
one of the same
*/
n1 = m+2; n1stop = m+m[1];
n2 = r1+2;n2stop = r1+r1[1];
while ( n1 < n1stop ) {
while ( n2 < n2stop ) {
if ( *n1 == *n2 && n1[1] == n2[1] ) {
n2 += 2; goto nextn1;
}
n2 += 2;
}
if ( n2 >= n2stop ) { /* scratch vector */
if ( m[1] == 4 ) goto scratch;
m[1] -= 2;
n3 = n1; n4 = n1+2;
while ( n4 < mstop ) *n3++ = *n4++;
*oldwork = n3 - oldwork;
mstop -= 2; n1stop -= 2;
continue;
}
n2 = r1+2;
nextn1: n1 += 2;
}
break;
}
/*
#] VECTOR :
#[ REMAINDER :
*/
else {
/*
Again: watch for multiple occurrences of the same object
*/
if ( m[1] != r1[1] ) { r1 += r1[1]; continue; }
for ( j = 2; j < m[1]; j++ ) {
if ( m[j] != r1[j] ) break;
}
if ( j < m[1] ) { r1 += r1[1]; continue; }
r1 += r1[1]; /* to restart at the next potential match */
goto nextm; /* match */
}
/*
#] REMAINDER :
*/
}
if ( r1 >= r2 ) { /* no factor! */
scratch:;
r3 = m + m[1]; r4 = m;
while ( r3 < mstop ) *r4++ = *r3++;
*oldwork = r4 - oldwork;
if ( *oldwork == 1 ) goto nofactor;
mstop = r4;
r1 = newterm + 1;
continue;
}
r1 = newterm + 1;
nextm: m += m[1];
}
nofactor:;
/*
Now the coefficient
*/
r2 = newterm + *newterm;
j = r2[-1];
r3 = r2 - ABS(j);
k = REDLENG(j);
if ( k < 0 ) k = -k;
while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
if ( ( ( GCDbuffer[0] == 1 ) && ( kGCD == 1 ) ) ) {
/*
GCD is already 1
*/
}
else if ( ( ( k != 1 ) || ( r3[0] != 1 ) ) ) {
if ( GcdLong(BHEAD GCDbuffer,kGCD,(UWORD *)r3,k,GCDbuffer2,&kGCD2) ) {
goto onerror;
}
kGCD = kGCD2;
for ( i = 0; i < kGCD; i++ ) GCDbuffer[i] = GCDbuffer2[i];
}
else {
kGCD = 1; GCDbuffer[0] = 1;
}
k = REDLENG(j);
if ( k < 0 ) k = -k;
r3 += k;
while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
if ( ( ( LCMbuffer[0] == 1 ) && ( kLCM == 1 ) ) ) {
for ( kLCM = 0; kLCM < k; kLCM++ )
LCMbuffer[kLCM] = r3[kLCM];
}
else if ( ( k != 1 ) || ( r3[0] != 1 ) ) {
if ( GcdLong(BHEAD LCMbuffer,kLCM,(UWORD *)r3,k,LCMb,&kkLCM) ) {
goto onerror;
}
DivLong((UWORD *)r3,k,LCMb,kkLCM,LCMb,&kkLCM,LCMc,&jLCM);
MulLong(LCMbuffer,kLCM,LCMb,kkLCM,LCMc,&jLCM);
for ( kLCM = 0; kLCM < jLCM; kLCM++ )
LCMbuffer[kLCM] = LCMc[kLCM];
}
else {} /* LCM doesn't change */
}
SetScratch(file,&oldposition); /* Needed until Processor is thread safe */
AR.DeferFlag = olddeferflag;
/*
Now put the term together in oldwork: GCD/LCM
We have already the algebraic contents there.
*/
r3 = (WORD *)(GCDbuffer);
r4 = (WORD *)(LCMbuffer);
r1 = oldwork + *oldwork;
if ( kGCD == kLCM ) {
for ( jGCD = 0; jGCD < kGCD; jGCD++ ) *r1++ = *r3++;
for ( jGCD = 0; jGCD < kGCD; jGCD++ ) *r1++ = *r4++;
k = 2*kGCD+1;
}
else if ( kGCD > kLCM ) {
for ( jGCD = 0; jGCD < kGCD; jGCD++ ) *r1++ = *r3++;
for ( jGCD = 0; jGCD < kLCM; jGCD++ ) *r1++ = *r4++;
for ( jGCD = kLCM; jGCD < kGCD; jGCD++ ) *r1++ = 0;
k = 2*kGCD+1;
}
else {
for ( jGCD = 0; jGCD < kGCD; jGCD++ ) *r1++ = *r3++;
for ( jGCD = kGCD; jGCD < kLCM; jGCD++ ) *r1++ = 0;
for ( jGCD = 0; jGCD < kLCM; jGCD++ ) *r1++ = *r4++;
k = 2*kLCM+1;
}
if ( sign < 0 ) *r1++ = -k;
else *r1++ = k;
*oldwork = (WORD)(r1-oldwork);
/*
Now put the new term in the cache
*/
Complete:;
if ( AT.previousEfactor ) M_free(AT.previousEfactor,"Efactor cache");
AT.previousEfactor = (WORD *)Malloc1((*oldwork+2)*sizeof(WORD),"Efactor cache");
AT.previousEfactor[0] = expr;
r1 = oldwork; r2 = AT.previousEfactor + 2; k = *oldwork;
NCOPY(r2,r1,k)
AT.previousEfactor[1] = 0;
/*
Now we construct the new term in the workspace.
*/
PutTheFactor:;
if ( AT.WorkPointer + AT.previousEfactor[2] >= AT.WorkTop ) {
MLOCK(ErrorMessageLock);
MesWork();
MesPrint("Called from factorin_");
MUNLOCK(ErrorMessageLock);
NumberFree(GCDbuffer,"FactorInExpr"); NumberFree(GCDbuffer2,"FactorInExpr");
NumberFree(LCMbuffer,"FactorInExpr"); NumberFree(LCMb,"FactorInExpr"); NumberFree(LCMc,"FactorInExpr");
return(-1);
}
n1 = oldwork; n2 = term; while ( n2 < t ) *n1++ = *n2++;
n2 = AT.previousEfactor+2; GETSTOP(n2,n2stop); n3 = n2 + *n2;
n2++; while ( n2 < n2stop ) *n1++ = *n2++;
n2 = t + t[1]; while ( n2 < tstop ) *n1++ = *n2++;
size = term[*term-1];
size = REDLENG(size);
k = n3[-1]; k = REDLENG(k);
if ( MulRat(BHEAD (UWORD *)tstop,size,(UWORD *)n2stop,k,
(UWORD *)n1,&size) ) goto onerror;
size = INCLENG(size);
k = size < 0 ? -size: size;
n1 += k; n1[-1] = size;
*oldwork = n1 - oldwork;
AT.WorkPointer = n1;
if ( Generator(BHEAD oldwork,level) ) {
NumberFree(GCDbuffer,"FactorInExpr"); NumberFree(GCDbuffer2,"FactorInExpr");
NumberFree(LCMbuffer,"FactorInExpr"); NumberFree(LCMb,"FactorInExpr"); NumberFree(LCMc,"FactorInExpr");
return(-1);
}
AT.WorkPointer = oldwork;
AR.CompressPointer = oldcpointer;
NumberFree(GCDbuffer,"FactorInExpr"); NumberFree(GCDbuffer2,"FactorInExpr");
NumberFree(LCMbuffer,"FactorInExpr"); NumberFree(LCMb,"FactorInExpr"); NumberFree(LCMc,"FactorInExpr");
return(0);
onerror:
AT.WorkPointer = oldwork;
AR.CompressPointer = oldcpointer;
MLOCK(ErrorMessageLock);
MesCall("FactorInExpr");
MUNLOCK(ErrorMessageLock);
NumberFree(GCDbuffer,"FactorInExpr"); NumberFree(GCDbuffer2,"FactorInExpr");
NumberFree(LCMbuffer,"FactorInExpr"); NumberFree(LCMb,"FactorInExpr"); NumberFree(LCMc,"FactorInExpr");
return(-1);
}
/*
* Lock a mutex (possibly interruptible), slowpath:
*/
static inline int __sched
__mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
struct lockdep_map *nest_lock, unsigned long ip)
{
struct task_struct *task = current;
struct mutex_waiter waiter;
unsigned long flags;
preempt_disable();
mutex_acquire_nest(&lock->dep_map, subclass, 0, nest_lock, ip);
#ifdef CONFIG_MUTEX_SPIN_ON_OWNER
/*
* Optimistic spinning.
*
* We try to spin for acquisition when we find that there are no
* pending waiters and the lock owner is currently running on a
* (different) CPU.
*
* The rationale is that if the lock owner is running, it is likely to
* release the lock soon.
*
* Since this needs the lock owner, and this mutex implementation
* doesn't track the owner atomically in the lock field, we need to
* track it non-atomically.
*
* We can't do this for DEBUG_MUTEXES because that relies on wait_lock
* to serialize everything.
*
* The mutex spinners are queued up using MCS lock so that only one
* spinner can compete for the mutex. However, if mutex spinning isn't
* going to happen, there is no point in going through the lock/unlock
* overhead.
*/
if (!mutex_can_spin_on_owner(lock))
goto slowpath;
for (;;) {
struct task_struct *owner;
struct mspin_node node;
/*
* If there's an owner, wait for it to either
* release the lock or go to sleep.
*/
mspin_lock(MLOCK(lock), &node);
owner = ACCESS_ONCE(lock->owner);
if (owner && !mutex_spin_on_owner(lock, owner)) {
mspin_unlock(MLOCK(lock), &node);
break;
}
if ((atomic_read(&lock->count) == 1) &&
(atomic_cmpxchg(&lock->count, 1, 0) == 1)) {
lock_acquired(&lock->dep_map, ip);
mutex_set_owner(lock);
mspin_unlock(MLOCK(lock), &node);
preempt_enable();
return 0;
}
mspin_unlock(MLOCK(lock), &node);
/*
* When there's no owner, we might have preempted between the
* owner acquiring the lock and setting the owner field. If
* we're an RT task that will live-lock because we won't let
* the owner complete.
*/
if (!owner && (need_resched() || rt_task(task)))
break;
/*
* The cpu_relax() call is a compiler barrier which forces
* everything in this loop to be re-loaded. We don't need
* memory barriers as we'll eventually observe the right
* values at the cost of a few extra spins.
*/
arch_mutex_cpu_relax();
}
slowpath:
#endif
spin_lock_mutex(&lock->wait_lock, flags);
debug_mutex_lock_common(lock, &waiter);
debug_mutex_add_waiter(lock, &waiter, task_thread_info(task));
/* add waiting tasks to the end of the waitqueue (FIFO): */
list_add_tail(&waiter.list, &lock->wait_list);
waiter.task = task;
if (MUTEX_SHOW_NO_WAITER(lock) && (atomic_xchg(&lock->count, -1) == 1))
goto done;
lock_contended(&lock->dep_map, ip);
for (;;) {
/*
* Lets try to take the lock again - this is needed even if
* we get here for the first time (shortly after failing to
* acquire the lock), to make sure that we get a wakeup once
* it's unlocked. Later on, if we sleep, this is the
* operation that gives us the lock. We xchg it to -1, so
* that when we release the lock, we properly wake up the
* other waiters:
*/
if (MUTEX_SHOW_NO_WAITER(lock) &&
(atomic_xchg(&lock->count, -1) == 1))
break;
/*
* got a signal? (This code gets eliminated in the
* TASK_UNINTERRUPTIBLE case.)
*/
if (unlikely(signal_pending_state(state, task))) {
mutex_remove_waiter(lock, &waiter,
task_thread_info(task));
mutex_release(&lock->dep_map, 1, ip);
spin_unlock_mutex(&lock->wait_lock, flags);
debug_mutex_free_waiter(&waiter);
preempt_enable();
return -EINTR;
}
__set_task_state(task, state);
/* didn't get the lock, go to sleep: */
spin_unlock_mutex(&lock->wait_lock, flags);
schedule_preempt_disabled();
spin_lock_mutex(&lock->wait_lock, flags);
}
done:
lock_acquired(&lock->dep_map, ip);
/* got the lock - rejoice! */
mutex_remove_waiter(lock, &waiter, current_thread_info());
mutex_set_owner(lock);
/* set it to 0 if there are no waiters left: */
if (likely(list_empty(&lock->wait_list)))
atomic_set(&lock->count, 0);
spin_unlock_mutex(&lock->wait_lock, flags);
debug_mutex_free_waiter(&waiter);
preempt_enable();
return 0;
}
/*-------------------------------------------------------------------*/
DLL_EXPORT int impl(int argc, char *argv[])
{
char *cfgfile; /* -> Configuration filename */
char pathname[MAX_PATH]; /* work area for filenames */
#if defined ( OPTION_LOCK_CONFIG_FILE )
int fd_cfg = -1; /* fd for config file */
#if !defined ( _MSVC_ )
struct flock fl_cfg; /* file lock for conf file */
#endif
#endif
int c; /* Work area for getopt */
int arg_error = 0; /* 1=Invalid arguments */
char *msgbuf; /* */
int msgnum; /* */
int msgcnt; /* */
TID rctid; /* RC file thread identifier */
TID logcbtid; /* RC file thread identifier */
int rc;
#if defined(EXTERNALGUI)
int e_gui = FALSE; /* EXTERNALGUI parm */
#endif
#if defined(OPTION_DYNAMIC_LOAD)
#define MAX_DLL_TO_LOAD 50
char *dll_load[MAX_DLL_TO_LOAD]; /* Pointers to modnames */
int dll_count; /* index into array */
#endif
/* Seed the pseudo-random number generator */
srand( time(NULL) );
/* Clear the system configuration block */
memset( &sysblk, 0, sizeof( SYSBLK ) );
VERIFY( MLOCK( &sysblk, sizeof( SYSBLK )) == 0);
#if defined (_MSVC_)
_setmaxstdio(2048);
#endif
/* Initialize EYE-CATCHERS for SYSBLK */
memset(&sysblk.blknam,SPACE,sizeof(sysblk.blknam));
memset(&sysblk.blkver,SPACE,sizeof(sysblk.blkver));
memset(&sysblk.blkend,SPACE,sizeof(sysblk.blkend));
sysblk.blkloc = swap_byte_U64((U64)((uintptr_t)&sysblk));
memcpy(sysblk.blknam,HDL_NAME_SYSBLK,strlen(HDL_NAME_SYSBLK));
memcpy(sysblk.blkver,HDL_VERS_SYSBLK,strlen(HDL_VERS_SYSBLK));
sysblk.blksiz = swap_byte_U32((U32)sizeof(SYSBLK));
{
char buf[32];
MSGBUF( buf, "END%13.13s", HDL_NAME_SYSBLK );
memcpy(sysblk.blkend, buf, sizeof(sysblk.blkend));
}
/* Initialize SETMODE and set user authority */
SETMODE(INIT);
#if defined(OPTION_DYNAMIC_LOAD)
for ( dll_count = 0; dll_count < MAX_DLL_TO_LOAD; dll_count++ )
dll_load[dll_count] = NULL;
dll_count = -1;
#endif
SET_THREAD_NAME("impl");
/* Initialize 'hostinfo' BEFORE display_version is called */
init_hostinfo( &hostinfo );
#ifdef _MSVC_
/* Initialize sockets package */
VERIFY( socket_init() == 0 );
#endif
/* Ensure hdl_shut is called in case of shutdown
hdl_shut will ensure entries are only called once */
atexit(hdl_shut);
if ( argc > 0 )
{
int i,len;
for (len = 0, i = 0; i < argc; i++ )
len += (int)strlen( (char *)argv[i] ) + 1;
sysblk.hercules_cmdline = (char *)malloc( len );
strlcpy( sysblk.hercules_cmdline, argv[0], len );
for ( i = 1; i < argc; i++ )
{
strlcat( sysblk.hercules_cmdline, " ", len );
strlcat( sysblk.hercules_cmdline, argv[i], len );
}
}
/* Set program name */
if ( argc > 0 )
{
if ( strlen(argv[0]) == 0 )
{
sysblk.hercules_pgmname = strdup("hercules");
sysblk.hercules_pgmpath = strdup("");
}
else
{
char path[MAX_PATH];
#if defined( _MSVC_ )
GetModuleFileName( NULL, path, MAX_PATH );
#else
strncpy(path,argv[0],sizeof(path)-1);
#endif
sysblk.hercules_pgmname = strdup(basename(path));
#if !defined( _MSVC_ )
strncpy(path,argv[0],sizeof(path)-1);
#endif
sysblk.hercules_pgmpath = strdup(dirname(path));
}
}
else
{
sysblk.hercules_pgmname = strdup("hercules");
sysblk.hercules_pgmpath = strdup("");
}
#if defined( OPTION_CONFIG_SYMBOLS )
/* These were moved from console.c to make them available sooner */
set_symbol( "VERSION", VERSION);
set_symbol( "BDATE", __DATE__ );
set_symbol( "BTIME", __TIME__ );
{
char num_procs[64];
if ( hostinfo.num_packages != 0 &&
hostinfo.num_physical_cpu != 0 &&
hostinfo.num_logical_cpu != 0 )
{
MSGBUF( num_procs, "LP=%d, Cores=%d, CPUs=%d", hostinfo.num_logical_cpu,
hostinfo.num_physical_cpu, hostinfo.num_packages );
}
else
{
if ( hostinfo.num_procs > 1 )
MSGBUF( num_procs, "MP=%d", hostinfo.num_procs );
else if ( hostinfo.num_procs == 1 )
strlcpy( num_procs, "UP", sizeof(num_procs) );
else
strlcpy( num_procs, "", sizeof(num_procs) );
}
set_symbol( "HOSTNAME", hostinfo.nodename );
set_symbol( "HOSTOS", hostinfo.sysname );
set_symbol( "HOSTOSREL", hostinfo.release );
set_symbol( "HOSTOSVER", hostinfo.version );
set_symbol( "HOSTARCH", hostinfo.machine );
set_symbol( "HOSTNUMCPUS", num_procs );
}
set_symbol( "MODNAME", sysblk.hercules_pgmname );
set_symbol( "MODPATH", sysblk.hercules_pgmpath );
#endif // defined( OPTION_CONFIG_SYMBOLS )
sysblk.sysgroup = DEFAULT_SYSGROUP;
sysblk.msglvl = DEFAULT_MLVL; /* Defaults to TERSE and DEVICES */
/* set default console port address */
sysblk.cnslport = strdup("3270");
/* set default tape autoinit value to OFF */
sysblk.noautoinit = TRUE;
/* default for system dasd cache is on */
sysblk.dasdcache = TRUE;
#if defined(OPTION_MSGCLR) || defined(OPTION_MSGHLD)
/* set default error message display (emsg) */
sysblk.emsg = EMSG_ON;
#endif
#if defined( OPTION_SHUTDOWN_CONFIRMATION )
/* set default quit timeout value (also ssd) */
sysblk.quitmout = QUITTIME_PERIOD;
#endif
/* Default command separator to off (NULL) */
sysblk.cmdsep = NULL;
#if defined(_FEATURE_SYSTEM_CONSOLE)
/* set default for scpecho to TRUE */
sysblk.scpecho = TRUE;
/* set fault for scpimply to FALSE */
sysblk.scpimply = FALSE;
#endif
/* set default system state to reset */
sysblk.sys_reset = TRUE;
/* set default SHCMDOPT enabled */
sysblk.shcmdopt = SHCMDOPT_ENABLE + SHCMDOPT_DIAG8;
/* Save process ID */
sysblk.hercules_pid = getpid();
/* Save thread ID of main program */
sysblk.impltid = thread_id();
/* Save TOD of when we were first IMPL'ed */
time( &sysblk.impltime );
/* Set to LPAR mode with LPAR 1, LPAR ID of 01, and CPUIDFMT 0 */
sysblk.lparmode = 1; /* LPARNUM 1 # LPAR ID 01 */
sysblk.lparnum = 1; /* ... */
sysblk.cpuidfmt = 0; /* CPUIDFMT 0 */
sysblk.operation_mode = om_mif; /* Default to MIF operaitons */
/* set default CPU identifier */
sysblk.cpumodel = 0x0586;
sysblk.cpuversion = 0xFD;
sysblk.cpuserial = 0x000001;
sysblk.cpuid = createCpuId(sysblk.cpumodel, sysblk.cpuversion,
sysblk.cpuserial, 0);
/* set default Program Interrupt Trace to NONE */
sysblk.pgminttr = OS_NONE;
sysblk.timerint = DEF_TOD_UPDATE_USECS;
/* set default thread priorities */
sysblk.hercprio = DEFAULT_HERCPRIO;
sysblk.todprio = DEFAULT_TOD_PRIO;
sysblk.cpuprio = DEFAULT_CPU_PRIO;
sysblk.devprio = DEFAULT_DEV_PRIO;
sysblk.srvprio = DEFAULT_SRV_PRIO;
/* Cap the default priorities at zero if setuid not available */
#if !defined( _MSVC_ )
#if !defined(NO_SETUID)
if (sysblk.suid)
#endif
{
if (sysblk.hercprio < 0)
sysblk.hercprio = 0;
if (sysblk.todprio < 0)
sysblk.todprio = 0;
if (sysblk.cpuprio < 0)
sysblk.cpuprio = 0;
if (sysblk.devprio < 0)
sysblk.devprio = 0;
if (sysblk.srvprio < 0)
sysblk.srvprio = 0;
}
#endif
/* set default console keep alive values */
sysblk.kaidle = KEEPALIVE_IDLE_TIME;
sysblk.kaintv = KEEPALIVE_PROBE_INTERVAL;
sysblk.kacnt = KEEPALIVE_PROBE_COUNT;
#if defined(_FEATURE_ECPSVM)
sysblk.ecpsvm.available = 0;
sysblk.ecpsvm.level = 20;
#endif
#ifdef PANEL_REFRESH_RATE
sysblk.panrate = PANEL_REFRESH_RATE_SLOW;
#endif
#if defined( OPTION_SHUTDOWN_CONFIRMATION )
/* Set the quitmout value */
sysblk.quitmout = QUITTIME_PERIOD; /* quit timeout value */
#endif
#if defined(OPTION_SHARED_DEVICES)
sysblk.shrdport = 0;
#endif
#ifdef OPTION_MSGHLD
/* Set the default timeout value */
sysblk.keep_timeout_secs = 120;
#endif
#if defined(OPTION_CONFIG_SYMBOLS) && defined(OPTION_BUILTIN_SYMBOLS)
/* setup defaults for BUILTIN symbols */
{
char buf[8];
set_symbol("LPARNAME", str_lparname());
set_symbol("LPARNUM", "1");
set_symbol("CPUIDFMT", "0");
MSGBUF( buf, "%06X", sysblk.cpuserial );
set_symbol( "CPUSERIAL", buf );
MSGBUF( buf, "%04X", sysblk.cpumodel );
set_symbol( "CPUMODEL", buf );
}
#endif /* defined(OPTION_CONFIG_SYMBOLS) && defined(OPTION_BUILTIN_SYMBOLS */
#if defined(_FEATURE_CMPSC_ENHANCEMENT_FACILITY)
sysblk.zpbits = DEF_CMPSC_ZP_BITS;
#endif
/* Initialize locks, conditions, and attributes */
initialize_lock (&sysblk.config);
initialize_lock (&sysblk.todlock);
initialize_lock (&sysblk.mainlock);
sysblk.mainowner = LOCK_OWNER_NONE;
initialize_lock (&sysblk.intlock);
initialize_lock (&sysblk.iointqlk);
sysblk.intowner = LOCK_OWNER_NONE;
initialize_lock (&sysblk.sigplock);
initialize_lock (&sysblk.mntlock);
initialize_lock (&sysblk.scrlock);
initialize_lock (&sysblk.crwlock);
initialize_lock (&sysblk.ioqlock);
initialize_condition (&sysblk.ioqcond);
#if defined(OPTION_CMDSER)
initialize_lock (&sysblk.cmdlock);
initialize_condition (&sysblk.cmdcond);
#endif /*defined(OPTION_CMDSER)*/
#ifdef FEATURE_MESSAGE_SECURITY_ASSIST_EXTENSION_3
/* Initialize the wrapping key registers lock */
initialize_rwlock(&sysblk.wklock);
#endif
/* Initialize thread creation attributes so all of hercules
can use them at any time when they need to create_thread
*/
initialize_detach_attr (DETACHED);
initialize_join_attr (JOINABLE);
initialize_condition (&sysblk.cpucond);
{
int i;
for (i = 0; i < MAX_CPU_ENGINES; i++)
initialize_lock (&sysblk.cpulock[i]);
}
initialize_condition (&sysblk.sync_cond);
initialize_condition (&sysblk.sync_bc_cond);
/* Copy length for regs */
sysblk.regs_copy_len = (int)((uintptr_t)&sysblk.dummyregs.regs_copy_end
- (uintptr_t)&sysblk.dummyregs);
/* Set the daemon_mode flag indicating whether we running in
background/daemon mode or not (meaning both stdout/stderr
are redirected to a non-tty device). Note that this flag
needs to be set before logger_init gets called since the
logger_logfile_write function relies on its setting.
*/
sysblk.daemon_mode = !isatty(STDERR_FILENO) && !isatty(STDOUT_FILENO);
/* Initialize the logmsg pipe and associated logger thread.
This causes all subsequent logmsg's to be redirected to
the logger facility for handling by virtue of stdout/stderr
being redirected to the logger facility.
*/
logger_init();
/*
Setup the initial codepage
*/
set_codepage(NULL);
/* Now display the version information again after logger_init
has been called so that either the panel display thread or the
external gui can see the version which was previously possibly
only displayed to the actual physical screen the first time we
did it further above (depending on whether we're running in
daemon_mode (external gui mode) or not). This it the call that
the panel thread or the one the external gui actually "sees".
The first call further above wasn't seen by either since it
was issued before logger_init was called and thus got written
directly to the physical screen whereas this one will be inter-
cepted and handled by the logger facility thereby allowing the
panel thread or external gui to "see" it and thus display it.
*/
display_version (stdout, "Hercules", TRUE);
#ifdef EXTERNALGUI
if (argc >= 1 && strncmp(argv[argc-1],"EXTERNALGUI",11) == 0)
{
e_gui = TRUE;
argc--;
}
#endif
#if !defined(WIN32) && !defined(HAVE_STRERROR_R)
strerror_r_init();
#endif
#if defined(OPTION_SCSI_TAPE)
initialize_lock ( &sysblk.stape_lock );
initialize_condition ( &sysblk.stape_getstat_cond );
InitializeListHead ( &sysblk.stape_mount_link );
InitializeListHead ( &sysblk.stape_status_link );
#endif /* defined(OPTION_SCSI_TAPE) */
/* Get name of configuration file or default to hercules.cnf */
if(!(cfgfile = getenv("HERCULES_CNF")))
cfgfile = "hercules.cnf";
/* Process the command line options */
{
#define HERCULES_BASE_OPTS "hf:r:db:v"
#define HERCULES_SYM_OPTS ""
#define HERCULES_HDL_OPTS ""
#if defined(OPTION_CONFIG_SYMBOLS)
#undef HERCULES_SYM_OPTS
#define HERCULES_SYM_OPTS "s:"
#endif
#if defined(OPTION_DYNAMIC_LOAD)
#undef HERCULES_HDL_OPTS
#define HERCULES_HDL_OPTS "p:l:"
#endif
#define HERCULES_OPTS_STRING HERCULES_BASE_OPTS HERCULES_SYM_OPTS HERCULES_HDL_OPTS
#if defined(HAVE_GETOPT_LONG)
static struct option longopts[] =
{
{ "help", no_argument, NULL, 'h' },
{ "config", required_argument, NULL, 'f' },
{ "rcfile", required_argument, NULL, 'r' },
{ "daemon", no_argument, NULL, 'd' },
{ "herclogo", required_argument, NULL, 'b' },
{ "verbose", no_argument, NULL, 'v' },
#if defined(OPTION_CONFIG_SYMBOLS)
{ "defsym", required_argument, NULL, 's' },
#endif
#if defined(OPTION_DYNAMIC_LOAD)
{ "modpath", required_argument, NULL, 'p' },
{ "ldmod", required_argument, NULL, 'l' },
#endif
{ NULL, 0, NULL, 0 }
};
while ((c = getopt_long( argc, argv, HERCULES_OPTS_STRING, longopts, NULL )) != EOF)
#else
while ((c = getopt( argc, argv, HERCULES_OPTS_STRING )) != EOF)
#endif
{
switch (c) {
case 'h':
arg_error = 1;
break;
case 'f':
cfgfile = optarg;
break;
case 'r':
rcname = optarg;
break;
#if defined(OPTION_CONFIG_SYMBOLS)
case 's':
{
char *sym = NULL;
char *value = NULL;
char *strtok_str = NULL;
if ( strlen( optarg ) >= 3 )
{
sym = strtok_r( optarg, "=", &strtok_str);
value = strtok_r( NULL, "=", &strtok_str);
if ( sym != NULL && value != NULL )
{
int j;
for( j = 0; j < (int)strlen( sym ); j++ )
if ( islower( sym[j] ) )
{
sym[j] = toupper( sym[j] );
}
set_symbol(sym, value);
}
else
WRMSG(HHC01419, "E" );
}
else
WRMSG(HHC01419, "E");
}
break;
#endif /* defined(OPTION_CONFIG_SYMBOLS) */
#if defined(OPTION_DYNAMIC_LOAD)
case 'p':
if(optarg)
hdl_setpath(strdup(optarg), FALSE);
break;
case 'l':
{
char *dllname, *strtok_str = NULL;
for(dllname = strtok_r(optarg,", ",&strtok_str);
dllname;
dllname = strtok_r(NULL,", ",&strtok_str))
{
if (dll_count < MAX_DLL_TO_LOAD - 1)
dll_load[++dll_count] = strdup(dllname);
else
{
WRMSG(HHC01406, "W", MAX_DLL_TO_LOAD);
break;
}
}
}
break;
#endif /* defined(OPTION_DYNAMIC_LOAD) */
case 'b':
sysblk.logofile = optarg;
break;
case 'v':
sysblk.msglvl |= MLVL_VERBOSE;
break;
case 'd':
sysblk.daemon_mode = 1;
break;
default:
arg_error = 1;
} /* end switch(c) */
} /* end while */
} /* end Process the command line options */
/* Treat filename None as special */
if(!strcasecmp(cfgfile,"None"))
cfgfile = NULL;
if (optind < argc)
arg_error = 1;
/* Terminate if invalid arguments were detected */
if (arg_error)
{
char pgm[MAX_PATH];
char* strtok_str = NULL;
strncpy(pgm, sysblk.hercules_pgmname, sizeof(pgm));
/* Show them all of our command-line arguments... */
WRMSG (HHC01414, "S", ""); // (blank line)
WRMSG (HHC01414, "S", ""); // (blank line)
#if defined(OPTION_DYNAMIC_LOAD)
// "Usage: %s [-f config-filename] [-d] [-b logo-filename] [-s sym=val]%s [> logfile]"
WRMSG (HHC01407, "S", strtok_r(pgm,".",&strtok_str),
" [-p dyn-load-dir] [[-l dynmod-to-load]...]");
#else
WRMSG (HHC01407, "S", strtok_r(pgm,".", &strtok_str), "");
#endif /* defined(OPTION_DYNAMIC_LOAD) */
WRMSG (HHC01414, "S", ""); // (blank line)
WRMSG (HHC01414, "S", ""); // (blank line)
fflush(stderr);
fflush(stdout);
usleep(100000);
return(1);
}
/* Initialize runtime opcode tables */
init_opcode_tables();
#if defined(OPTION_DYNAMIC_LOAD)
/* Initialize the hercules dynamic loader */
hdl_main();
/* Load modules requested at startup */
if (dll_count >= 0)
{
int hl_err = FALSE;
for ( dll_count = 0; dll_count < MAX_DLL_TO_LOAD; dll_count++ )
{
if (dll_load[dll_count] != NULL)
{
if (hdl_load(dll_load[dll_count], HDL_LOAD_DEFAULT) != 0)
{
hl_err = TRUE;
}
free(dll_load[dll_count]);
}
else
break;
}
if (hl_err)
{
usleep(10000); // give logger time to issue error message
WRMSG(HHC01408, "S");
delayed_exit(-1);
return(1);
}
}
#endif /* defined(OPTION_DYNAMIC_LOAD) */
#ifdef EXTERNALGUI
/* Set GUI flag if specified as final argument */
if (e_gui)
{
#if defined(OPTION_DYNAMIC_LOAD)
if (hdl_load("dyngui",HDL_LOAD_DEFAULT) != 0)
{
usleep(10000); /* (give logger thread time to issue
preceding HHC01516E message) */
WRMSG(HHC01409, "S");
delayed_exit(-1);
return(1);
}
#endif /* defined(OPTION_DYNAMIC_LOAD) */
}
#endif /*EXTERNALGUI*/
/* Register the SIGINT handler */
if ( signal (SIGINT, sigint_handler) == SIG_ERR )
{
WRMSG(HHC01410, "S", "SIGINT", strerror(errno));
delayed_exit(-1);
return(1);
}
/* Register the SIGTERM handler */
if ( signal (SIGTERM, sigterm_handler) == SIG_ERR )
{
WRMSG(HHC01410, "S", "SIGTERM", strerror(errno));
delayed_exit(-1);
return(1);
}
#if defined( _MSVC_ )
/* Register the Window console ctrl handlers */
if (!IsDebuggerPresent())
{
if (!SetConsoleCtrlHandler( console_ctrl_handler, TRUE ))
{
WRMSG( HHC01410, "S", "Console-ctrl", strerror( errno ));
delayed_exit(-1);
return(1);
}
}
#endif
#if defined(HAVE_DECL_SIGPIPE) && HAVE_DECL_SIGPIPE
/* Ignore the SIGPIPE signal, otherwise Hercules may terminate with
Broken Pipe error if the printer driver writes to a closed pipe */
if ( signal (SIGPIPE, SIG_IGN) == SIG_ERR )
{
WRMSG(HHC01411, "E", strerror(errno));
}
#endif
{
int fds[2];
initialize_lock(&sysblk.cnslpipe_lock);
initialize_lock(&sysblk.sockpipe_lock);
sysblk.cnslpipe_flag=0;
sysblk.sockpipe_flag=0;
VERIFY( create_pipe(fds) >= 0 );
sysblk.cnslwpipe=fds[1];
sysblk.cnslrpipe=fds[0];
VERIFY( create_pipe(fds) >= 0 );
sysblk.sockwpipe=fds[1];
sysblk.sockrpipe=fds[0];
}
#if !defined(NO_SIGABEND_HANDLER)
{
struct sigaction sa;
sa.sa_sigaction = (void*)&sigabend_handler;
#ifdef SA_NODEFER
sa.sa_flags = SA_NODEFER;
#else
sa.sa_flags = 0;
#endif
if( sigaction(SIGILL, &sa, NULL)
|| sigaction(SIGFPE, &sa, NULL)
|| sigaction(SIGSEGV, &sa, NULL)
|| sigaction(SIGBUS, &sa, NULL)
|| sigaction(SIGUSR1, &sa, NULL)
|| sigaction(SIGUSR2, &sa, NULL) )
{
WRMSG(HHC01410, "S", "SIGILL/FPE/SEGV/BUS/USR", strerror(errno));
delayed_exit(-1);
return(1);
}
}
#endif /*!defined(NO_SIGABEND_HANDLER)*/
if(cfgfile)
{
/* attempt to get lock on config file */
hostpath(pathname, cfgfile, sizeof(pathname));
#if defined( OPTION_LOCK_CONFIG_FILE )
/* Test that we can get a read the file */
if ( ( fd_cfg = HOPEN( pathname, O_RDONLY, S_IRUSR | S_IRGRP ) ) < 0 )
{
if ( errno == EACCES )
{
WRMSG( HHC01453, "S", cfgfile, strerror( errno ) );
delayed_exit(-1);
return(1);
}
}
else
{
if ( lseek(fd_cfg, 0L, 2) < 0 )
{
if ( errno == EACCES )
{
WRMSG( HHC01453, "S", cfgfile, strerror( errno ) );
delayed_exit(-1);
return(1);
}
}
close( fd_cfg );
}
/* File was not lock, therefore we can proceed */
#endif // OPTION_LOCK_CONFIG_FILE
}
/* System initialisation time */
sysblk.todstart = hw_clock() << 8;
#if !defined(NO_SIGABEND_HANDLER)
/* Start the watchdog */
rc = create_thread (&sysblk.wdtid, DETACHED,
watchdog_thread, NULL, "watchdog_thread");
if (rc)
{
WRMSG(HHC00102, "E", strerror(rc));
delayed_exit(-1);
return(1);
}
#endif /*!defined(NO_SIGABEND_HANDLER)*/
if(log_callback)
{
// 'herclin' called us. IT'S in charge. Create its requested
// logmsg intercept callback function and return back to it.
rc = create_thread(&logcbtid,DETACHED,
log_do_callback,NULL,"log_do_callback");
if (rc)
WRMSG(HHC00102, "E", strerror(rc));
return(0);
}
hdl_adsc("release_config", release_config, NULL);
/* Build system configuration */
if ( build_config (cfgfile) )
{
delayed_exit(-1);
return(1);
}
/* Start up the RC file processing thread */
rc = create_thread(&rctid,DETACHED,
process_rc_file,NULL,"process_rc_file");
if (rc)
WRMSG(HHC00102, "E", strerror(rc));
#if defined( OPTION_LOCK_CONFIG_FILE )
if(cfgfile)
{
if ( ( fd_cfg = HOPEN( pathname, O_RDONLY, S_IRUSR | S_IRGRP ) ) < 0 )
{
WRMSG( HHC01432, "S", pathname, "open()", strerror( errno ) );
delayed_exit(-1);
return(1);
}
else
{
#if defined( _MSVC_ )
if( ( rc = _locking( fd_cfg, _LK_NBRLCK, 1L ) ) < 0 )
{
int rc = errno;
WRMSG( HHC01454, "S", pathname, "_locking()", strerror( errno ) );
delayed_exit(-1);
return(1);
}
#else
fl_cfg.l_type = F_RDLCK;
fl_cfg.l_whence = SEEK_SET;
fl_cfg.l_start = 0;
fl_cfg.l_len = 1;
if ( fcntl(fd_cfg, F_SETLK, &fl_cfg) == -1 )
{
if (errno == EACCES || errno == EAGAIN)
{
WRMSG( HHC01432, "S", pathname, "fcntl()", strerror( errno ) );
delayed_exit(-1);
return(1);
}
}
#endif
}
}
#endif // OPTION_LOCK_CONFIG_FILE
//---------------------------------------------------------------
// The below functions will not return until Hercules is shutdown
//---------------------------------------------------------------
/* Activate the control panel */
if(!sysblk.daemon_mode)
panel_display ();
else
{
#if defined(OPTION_DYNAMIC_LOAD)
if(daemon_task)
daemon_task ();
else
#endif /* defined(OPTION_DYNAMIC_LOAD) */
{
/* Tell RC file and HAO threads they may now proceed */
sysblk.panel_init = 1;
/* Retrieve messages from logger and write to stderr */
while (1)
if((msgcnt = log_read(&msgbuf, &msgnum, LOG_BLOCK)))
if(isatty(STDERR_FILENO))
fwrite(msgbuf,msgcnt,1,stderr);
}
}
// -----------------------------------------------------
// *** Hercules has been shutdown (PAST tense) ***
// -----------------------------------------------------
#if defined( OPTION_LOCK_CONFIG_FILE )
if(cfgfile)
close( fd_cfg ); // release config file lock
#endif // OPTION_LOCK_CONFIG_FILE
ASSERT( sysblk.shutdown ); // (why else would we be here?!)
#ifdef _MSVC_
SetConsoleCtrlHandler(console_ctrl_handler, FALSE);
socket_deinit();
#endif
#if defined(OPTION_MSGCLR) || defined(OPTION_MSGHLD)
if ( sysblk.emsg & EMSG_TEXT )
fprintf(stdout, HHC01412 );
else
#endif
fprintf(stdout, MSG(HHC01412, "I"));
fflush(stdout);
usleep(10000);
return 0;
} /* end function impl */
WORD DoIfStatement(PHEAD WORD *ifcode, WORD *term)
{
GETBIDENTITY
WORD *ifstop, *ifp;
UWORD *coef1 = 0, *coef2, *coef3, *cc;
WORD ncoef1, ncoef2, ncoef3, i = 0, first, *r, acoef, ismul1, ismul2, j;
UWORD *Spac1, *Spac2;
ifstop = ifcode + ifcode[1];
ifp = ifcode + 3;
if ( ifp >= ifstop ) return(1);
if ( ( ifp + ifp[1] ) >= ifstop ) {
switch ( *ifp ) {
case LONGNUMBER:
if ( ifp[2] ) return(1);
else return(0);
case MATCH:
case TYPEIF:
if ( HowMany(BHEAD ifp,term) ) return(1);
else return(0);
case TYPEFINDLOOP:
if ( Lus(term,ifp[3],ifp[4],ifp[5],ifp[6],ifp[2]) ) return(1);
else return(0);
case TYPECOUNT:
if ( CountDo(term,ifp) ) return(1);
else return(0);
case COEFFI:
case MULTIPLEOF:
return(1);
case IFDOLLAR:
{
DOLLARS d = Dollars + ifp[2];
#ifdef WITHPTHREADS
int nummodopt, dtype = -1;
if ( AS.MultiThreaded ) {
for ( nummodopt = 0; nummodopt < NumModOptdollars; nummodopt++ ) {
if ( ifp[2] == ModOptdollars[nummodopt].number ) break;
}
if ( nummodopt < NumModOptdollars ) {
dtype = ModOptdollars[nummodopt].type;
if ( dtype == MODLOCAL ) {
d = ModOptdollars[nummodopt].dstruct+AT.identity;
}
}
}
dtype = d->type;
#else
int dtype = d->type; /* We use dtype to make the operation atomic */
#endif
if ( dtype == DOLZERO ) return(0);
if ( dtype == DOLUNDEFINED ) {
if ( AC.UnsureDollarMode == 0 ) {
MesPrint("$%s is undefined",AC.dollarnames->namebuffer+d->name);
Terminate(-1);
}
}
}
return(1);
case IFEXPRESSION:
r = ifp+2; j = ifp[1] - 2;
while ( --j >= 0 ) {
if ( *r == AR.CurExpr ) return(1);
r++;
}
return(0);
case IFISFACTORIZED:
r = ifp+2; j = ifp[1] - 2;
if ( j == 0 ) {
if ( ( Expressions[AR.CurExpr].vflags & ISFACTORIZED ) != 0 )
return(1);
else
return(0);
}
while ( --j >= 0 ) {
if ( ( Expressions[*r].vflags & ISFACTORIZED ) == 0 ) return(0);
r++;
}
return(1);
case IFOCCURS:
{
WORD *OccStop = ifp + ifp[1];
ifp += 2;
while ( ifp < OccStop ) {
if ( FindVar(ifp,term) == 1 ) return(1);
if ( *ifp == DOTPRODUCT ) ifp += 3;
else ifp += 2;
}
}
return(0);
default:
/*
Now we have a subexpression. Test first for one with a single item.
*/
if ( ifp[3] == ( ifp[1] + 3 ) ) return(DoIfStatement(BHEAD ifp,term));
ifstop = ifp + ifp[1];
ifp += 3;
break;
}
}
/*
Here is the composite condition.
*/
coef3 = NumberMalloc("DoIfStatement");
Spac1 = NumberMalloc("DoIfStatement");
Spac2 = (UWORD *)(TermMalloc("DoIfStatement"));
ncoef1 = 0; first = 1; ismul1 = 0;
do {
if ( !first ) {
ifp += 2;
if ( ifp[-2] == ORCOND && ncoef1 ) {
coef1 = Spac1;
ncoef1 = 1; coef1[0] = coef1[1] = 1;
goto SkipCond;
}
if ( ifp[-2] == ANDCOND && !ncoef1 ) goto SkipCond;
}
coef2 = Spac2;
ncoef2 = 1;
ismul2 = 0;
switch ( *ifp ) {
case LONGNUMBER:
ncoef2 = ifp[2];
j = 2*(ABS(ncoef2));
cc = (UWORD *)(ifp + 3);
for ( i = 0; i < j; i++ ) coef2[i] = cc[i];
break;
case MATCH:
case TYPEIF:
coef2[0] = HowMany(BHEAD ifp,term);
coef2[1] = 1;
if ( coef2[0] == 0 ) ncoef2 = 0;
break;
case TYPECOUNT:
acoef = CountDo(term,ifp);
coef2[0] = ABS(acoef);
coef2[1] = 1;
if ( acoef == 0 ) ncoef2 = 0;
else if ( acoef < 0 ) ncoef2 = -1;
break;
case TYPEFINDLOOP:
acoef = Lus(term,ifp[3],ifp[4],ifp[5],ifp[6],ifp[2]);
coef2[0] = ABS(acoef);
coef2[1] = 1;
if ( acoef == 0 ) ncoef2 = 0;
else if ( acoef < 0 ) ncoef2 = -1;
break;
case COEFFI:
r = term + *term;
ncoef2 = r[-1];
i = ABS(ncoef2);
cc = (UWORD *)(r - i);
if ( ncoef2 < 0 ) ncoef2 = (ncoef2+1)>>1;
else ncoef2 = (ncoef2-1)>>1;
i--; for ( j = 0; j < i; j++ ) coef2[j] = cc[j];
break;
case SUBEXPR:
ncoef2 = coef2[0] = DoIfStatement(BHEAD ifp,term);
coef2[1] = 1;
break;
case MULTIPLEOF:
ncoef2 = 1;
coef2[0] = ifp[2];
coef2[1] = 1;
ismul2 = 1;
break;
case IFDOLLAREXTRA:
break;
case IFDOLLAR:
{
/*
We need to abstract a long rational in coef2
with length ncoef2. What if that cannot be done?
*/
DOLLARS d = Dollars + ifp[2];
#ifdef WITHPTHREADS
int nummodopt, dtype = -1;
if ( AS.MultiThreaded ) {
for ( nummodopt = 0; nummodopt < NumModOptdollars; nummodopt++ ) {
if ( ifp[2] == ModOptdollars[nummodopt].number ) break;
}
if ( nummodopt < NumModOptdollars ) {
dtype = ModOptdollars[nummodopt].type;
if ( dtype == MODLOCAL ) {
d = ModOptdollars[nummodopt].dstruct+AT.identity;
}
else {
LOCK(d->pthreadslockread);
}
}
}
#endif
/*
We have to pick up the IFDOLLAREXTRA pieces for [1], [$y] etc.
*/
if ( ifp+3 < ifstop && ifp[3] == IFDOLLAREXTRA ) {
if ( d->nfactors == 0 ) {
MLOCK(ErrorMessageLock);
MesPrint("Attempt to use a factor of an unfactored $-variable");
MUNLOCK(ErrorMessageLock);
Terminate(-1);
} {
WORD num = GetIfDollarNum(ifp+3,ifstop);
WORD *w;
while ( ifp+3 < ifstop && ifp[3] == IFDOLLAREXTRA ) ifp += 3;
if ( num > d->nfactors ) {
MLOCK(ErrorMessageLock);
MesPrint("Dollar factor number %s out of range",num);
MUNLOCK(ErrorMessageLock);
Terminate(-1);
}
if ( num == 0 ) {
ncoef2 = 1; coef2[0] = d->nfactors; coef2[1] = 1;
break;
}
w = d->factors[num-1].where;
if ( w == 0 ) {
if ( d->factors[num-1].value < 0 ) {
ncoef2 = -1; coef2[0] = -d->factors[num-1].value; coef2[1] = 1;
}
else {
ncoef2 = 1; coef2[0] = d->factors[num-1].value; coef2[1] = 1;
}
break;
}
if ( w[*w] == 0 ) {
r = w + *w - 1;
i = ABS(*r);
if ( i == ( *w-1 ) ) {
ncoef2 = (i-1)/2;
if ( *r < 0 ) ncoef2 = -ncoef2;
i--; cc = coef2; r = w + 1;
while ( --i >= 0 ) *cc++ = (UWORD)(*r++);
break;
}
}
goto generic;
}
}
else {
switch ( d->type ) {
case DOLUNDEFINED:
if ( AC.UnsureDollarMode == 0 ) {
#ifdef WITHPTHREADS
if ( dtype > 0 && dtype != MODLOCAL ) { UNLOCK(d->pthreadslockread); }
#endif
MLOCK(ErrorMessageLock);
MesPrint("$%s is undefined",AC.dollarnames->namebuffer+d->name);
MUNLOCK(ErrorMessageLock);
Terminate(-1);
}
ncoef2 = 0; coef2[0] = 0; coef2[1] = 1;
break;
case DOLZERO:
ncoef2 = coef2[0] = 0; coef2[1] = 1;
break;
case DOLSUBTERM:
if ( d->where[0] != INDEX || d->where[1] != 3
|| d->where[2] < 0 || d->where[2] >= AM.OffsetIndex ) {
if ( AC.UnsureDollarMode == 0 ) {
#ifdef WITHPTHREADS
if ( dtype > 0 && dtype != MODLOCAL ) { UNLOCK(d->pthreadslockread); }
#endif
MLOCK(ErrorMessageLock);
MesPrint("$%s is of wrong type",AC.dollarnames->namebuffer+d->name);
MUNLOCK(ErrorMessageLock);
Terminate(-1);
}
ncoef2 = 0; coef2[0] = 0; coef2[1] = 1;
break;
}
d->index = d->where[2];
case DOLINDEX:
if ( d->index == 0 ) {
ncoef2 = coef2[0] = 0; coef2[1] = 1;
}
else if ( d->index > 0 && d->index < AM.OffsetIndex ) {
ncoef2 = 1; coef2[0] = d->index; coef2[1] = 1;
}
else if ( AC.UnsureDollarMode == 0 ) {
#ifdef WITHPTHREADS
if ( dtype > 0 && dtype != MODLOCAL ) { UNLOCK(d->pthreadslockread); }
#endif
MLOCK(ErrorMessageLock);
MesPrint("$%s is of wrong type",AC.dollarnames->namebuffer+d->name);
MUNLOCK(ErrorMessageLock);
Terminate(-1);
}
ncoef2 = coef2[0] = 0; coef2[1] = 1;
break;
case DOLWILDARGS:
if ( d->where[0] <= -FUNCTION ||
( d->where[0] < 0 && d->where[2] != 0 )
|| ( d->where[0] > 0 && d->where[d->where[0]] != 0 )
) {
if ( AC.UnsureDollarMode == 0 ) {
#ifdef WITHPTHREADS
if ( dtype > 0 && dtype != MODLOCAL ) { UNLOCK(d->pthreadslockread); }
#endif
MLOCK(ErrorMessageLock);
MesPrint("$%s is of wrong type",AC.dollarnames->namebuffer+d->name);
MUNLOCK(ErrorMessageLock);
Terminate(-1);
}
ncoef2 = coef2[0] = 0; coef2[1] = 1;
break;
}
case DOLARGUMENT:
if ( d->where[0] == -SNUMBER ) {
if ( d->where[1] == 0 ) {
ncoef2 = coef2[0] = 0;
}
else if ( d->where[1] < 0 ) {
ncoef2 = -1;
coef2[0] = -d->where[1];
}
else {
ncoef2 = 1;
coef2[0] = d->where[1];
}
coef2[1] = 1;
}
else if ( d->where[0] == -INDEX
&& d->where[1] >= 0 && d->where[1] < AM.OffsetIndex ) {
if ( d->where[1] == 0 ) {
ncoef2 = coef2[0] = 0; coef2[1] = 1;
}
else {
ncoef2 = 1; coef2[0] = d->where[1];
coef2[1] = 1;
}
}
else if ( d->where[0] > 0
&& d->where[ARGHEAD] == (d->where[0]-ARGHEAD)
&& ABS(d->where[d->where[0]-1]) ==
(d->where[0] - ARGHEAD-1) ) {
i = d->where[d->where[0]-1];
ncoef2 = (ABS(i)-1)/2;
if ( i < 0 ) { ncoef2 = -ncoef2; i = -i; }
i--; cc = coef2; r = d->where + ARGHEAD+1;
while ( --i >= 0 ) *cc++ = (UWORD)(*r++);
}
else {
if ( AC.UnsureDollarMode == 0 ) {
#ifdef WITHPTHREADS
if ( dtype > 0 && dtype != MODLOCAL ) { UNLOCK(d->pthreadslockread); }
#endif
MLOCK(ErrorMessageLock);
MesPrint("$%s is of wrong type",AC.dollarnames->namebuffer+d->name);
MUNLOCK(ErrorMessageLock);
Terminate(-1);
}
ncoef2 = 0; coef2[0] = 0; coef2[1] = 1;
}
break;
case DOLNUMBER:
case DOLTERMS:
if ( d->where[d->where[0]] == 0 ) {
r = d->where + d->where[0]-1;
i = ABS(*r);
if ( i == ( d->where[0]-1 ) ) {
ncoef2 = (i-1)/2;
if ( *r < 0 ) ncoef2 = -ncoef2;
i--; cc = coef2; r = d->where + 1;
while ( --i >= 0 ) *cc++ = (UWORD)(*r++);
break;
}
}
generic:;
if ( AC.UnsureDollarMode == 0 ) {
#ifdef WITHPTHREADS
if ( dtype > 0 && dtype != MODLOCAL ) { UNLOCK(d->pthreadslockread); }
#endif
MLOCK(ErrorMessageLock);
MesPrint("$%s is of wrong type",AC.dollarnames->namebuffer+d->name);
MUNLOCK(ErrorMessageLock);
Terminate(-1);
}
ncoef2 = 0; coef2[0] = 0; coef2[1] = 1;
break;
}
}
#ifdef WITHPTHREADS
if ( dtype > 0 && dtype != MODLOCAL ) { UNLOCK(d->pthreadslockread); }
#endif
}
break;
case IFEXPRESSION:
r = ifp+2; j = ifp[1] - 2; ncoef2 = 0;
while ( --j >= 0 ) {
if ( *r == AR.CurExpr ) { ncoef2 = 1; break; }
r++;
}
coef2[0] = ncoef2;
coef2[1] = 1;
break;
case IFISFACTORIZED:
r = ifp+2; j = ifp[1] - 2;
if ( j == 0 ) {
ncoef2 = 0;
if ( ( Expressions[AR.CurExpr].vflags & ISFACTORIZED ) != 0 ) {
ncoef2 = 1;
}
}
else {
ncoef2 = 1;
while ( --j >= 0 ) {
if ( ( Expressions[*r].vflags & ISFACTORIZED ) == 0 ) {
ncoef2 = 0;
break;
}
r++;
}
}
coef2[0] = ncoef2;
coef2[1] = 1;
break;
case IFOCCURS:
{
WORD *OccStop = ifp + ifp[1], *ifpp = ifp+2;
ncoef2 = 0;
while ( ifpp < OccStop ) {
if ( FindVar(ifpp,term) == 1 ) {
ncoef2 = 1; break;
}
if ( *ifpp == DOTPRODUCT ) ifp += 3;
else ifpp += 2;
}
coef2[0] = ncoef2;
coef2[1] = 1;
}
break;
default:
break;
}
if ( !first ) {
if ( ifp[-2] != ORCOND && ifp[-2] != ANDCOND ) {
if ( ( ifp[-2] == EQUAL || ifp[-2] == NOTEQUAL ) &&
( ismul2 || ismul1 ) ) {
if ( ismul1 && ismul2 ) {
if ( coef1[0] == coef2[0] ) i = 1;
else i = 0;
}
else {
if ( ismul1 ) {
if ( ncoef2 )
Divvy(BHEAD coef2,&ncoef2,coef1,ncoef1);
cc = coef2; ncoef3 = ncoef2;
}
else {
if ( ncoef1 )
Divvy(BHEAD coef1,&ncoef1,coef2,ncoef2);
cc = coef1; ncoef3 = ncoef1;
}
if ( ncoef3 < 0 ) ncoef3 = -ncoef3;
if ( ncoef3 == 0 ) {
if ( ifp[-2] == EQUAL ) i = 1;
else i = 0;
}
else if ( cc[ncoef3] != 1 ) {
if ( ifp[-2] == EQUAL ) i = 0;
else i = 1;
}
else {
for ( j = 1; j < ncoef3; j++ ) {
if ( cc[ncoef3+j] != 0 ) break;
}
if ( j < ncoef3 ) {
if ( ifp[-2] == EQUAL ) i = 0;
else i = 1;
}
else if ( ifp[-2] == EQUAL ) i = 1;
else i = 0;
}
}
goto donemul;
}
else if ( AddRat(BHEAD coef1,ncoef1,coef2,-ncoef2,coef3,&ncoef3) ) {
NumberFree(coef3,"DoIfStatement"); NumberFree(Spac1,"DoIfStatement"); TermFree(Spac2,"DoIfStatement");
MesCall("DoIfStatement"); return(-1);
}
switch ( ifp[-2] ) {
case GREATER:
if ( ncoef3 > 0 ) i = 1;
else i = 0;
break;
case GREATEREQUAL:
if ( ncoef3 >= 0 ) i = 1;
else i = 0;
break;
case LESS:
if ( ncoef3 < 0 ) i = 1;
else i = 0;
break;
case LESSEQUAL:
if ( ncoef3 <= 0 ) i = 1;
else i = 0;
break;
case EQUAL:
if ( ncoef3 == 0 ) i = 1;
else i = 0;
break;
case NOTEQUAL:
if ( ncoef3 != 0 ) i = 1;
else i = 0;
break;
}
donemul: if ( i ) { ncoef2 = 1; coef2 = Spac2; coef2[0] = coef2[1] = 1; }
else ncoef2 = 0;
ismul1 = ismul2 = 0;
}
}
else {
first = 0;
}
coef1 = Spac1;
i = 2*ABS(ncoef2);
for ( j = 0; j < i; j++ ) coef1[j] = coef2[j];
ncoef1 = ncoef2;
SkipCond:
ifp += ifp[1];
} while ( ifp < ifstop );
WORD GetIfDollarNum(WORD *ifp, WORD *ifstop)
{
DOLLARS d;
WORD num, *w;
if ( ifp[2] < 0 ) { return(-ifp[2]-1); }
d = Dollars+ifp[2];
if ( ifp+3 < ifstop && ifp[3] == IFDOLLAREXTRA ) {
if ( d->nfactors == 0 ) {
MLOCK(ErrorMessageLock);
MesPrint("Attempt to use a factor of an unfactored $-variable");
MUNLOCK(ErrorMessageLock);
Terminate(-1);
}
num = GetIfDollarNum(ifp+3,ifstop);
if ( num > d->nfactors ) {
MLOCK(ErrorMessageLock);
MesPrint("Dollar factor number %s out of range",num);
MUNLOCK(ErrorMessageLock);
Terminate(-1);
}
if ( num == 0 ) {
return(d->nfactors);
}
w = d->factors[num-1].where;
if ( w == 0 ) return(d->factors[num].value);
getnumber:;
if ( *w == 0 ) return(0);
if ( *w == 4 && w[3] == 3 && w[2] == 1 && w[1] < MAXPOSITIVE && w[4] == 0 ) {
return(w[1]);
}
if ( ( w[w[0]] != 0 ) || ( ABS(w[w[0]-1]) != w[0]-1 ) ) {
MLOCK(ErrorMessageLock);
MesPrint("Dollar factor number expected but found expression");
MUNLOCK(ErrorMessageLock);
Terminate(-1);
}
else {
MLOCK(ErrorMessageLock);
MesPrint("Dollar factor number out of range");
MUNLOCK(ErrorMessageLock);
Terminate(-1);
}
return(0);
}
/*
Now we have just a dollar and should evaluate that into a short number
*/
if ( d->type == DOLZERO ) {
return(0);
}
else if ( d->type == DOLNUMBER || d->type == DOLTERMS ) {
w = d->where; goto getnumber;
}
else {
MLOCK(ErrorMessageLock);
MesPrint("Dollar factor number is wrong type");
MUNLOCK(ErrorMessageLock);
Terminate(-1);
return(0);
}
}
jzfile *
ZIP_Put_In_Cache0(const char *name, ZFILE zfd, char **pmsg, jlong lastModified,
jboolean usemmap)
{
char errbuf[256];
jlong len;
jzfile *zip;
if ((zip = allocZip(name)) == NULL) {
return NULL;
}
#ifdef USE_MMAP
zip->usemmap = usemmap;
#endif
zip->refs = 1;
zip->lastModified = lastModified;
if (zfd == -1) {
if (pmsg && getLastErrorString(errbuf, sizeof(errbuf)) > 0)
*pmsg = strdup(errbuf);
freeZip(zip);
return NULL;
}
// Assumption, zfd refers to start of file. Trivially, reuse errbuf.
if (readFully(zfd, errbuf, 4) != -1) { // errors will be handled later
zip->locsig = LOCSIG_AT(errbuf) ? JNI_TRUE : JNI_FALSE;
}
len = zip->len = IO_Lseek(zfd, 0, SEEK_END);
if (len <= 0) {
if (len == 0) { /* zip file is empty */
if (pmsg) {
*pmsg = strdup("zip file is empty");
}
} else { /* error */
if (pmsg && getLastErrorString(errbuf, sizeof(errbuf)) > 0)
*pmsg = strdup(errbuf);
}
ZFILE_Close(zfd);
freeZip(zip);
return NULL;
}
zip->zfd = zfd;
if (readCEN(zip, -1) < 0) {
/* An error occurred while trying to read the zip file */
if (pmsg != 0) {
/* Set the zip error message */
if (zip->msg != NULL)
*pmsg = strdup(zip->msg);
}
freeZip(zip);
return NULL;
}
MLOCK(zfiles_lock);
zip->next = zfiles;
zfiles = zip;
MUNLOCK(zfiles_lock);
return zip;
}
/** Function opens the dump. It means initializing the internal string
* that will contain the dump result and locking the class (using mutex).
* \note Always call the close() member if you have opened the dump.
*/
void dumpctx::open(const tchar_t* pszObject)
{
MLOCK(m_lock);
*m_pBuffer=pszObject;
*m_pBuffer+=_t("\n");
}
int
mfs_ramdir_add(
VNODE_T *dvp,
char *nm,
VNODE_T *vp,
int *num, /* returned slot used */
CALL_DATA_T *cd
)
{
register mfs_mnode_t *mnp;
register int vnum;
int freevnum;
int error;
ASSERT(MFS_ISVIEWDIR(VTOM(dvp)));
mnp = VTOM(dvp);
MLOCK(mnp);
*num = 0;
/* Must scan for duplicates and first hole to put
element into */
freevnum = -1;
for (vnum=0; vnum < mnp->mn_ramdir.hwm; vnum++) {
if (mnp->mn_ramdir.ents[vnum].nm == NULL) {
if (freevnum == -1) freevnum = vnum;
continue;
}
if (STRCMP(mnp->mn_ramdir.ents[vnum].nm, nm) == 0) {
MUNLOCK(mnp);
return(EEXIST);
}
}
/* If no free slot found, try pushing the highwater mark */
if (freevnum == -1 && (mnp->mn_ramdir.hwm < mnp->mn_ramdir.max))
freevnum = mnp->mn_ramdir.hwm++;
/* If have a slot, fill it in. Otherwise return an error */
if (freevnum != -1) {
mnp->mn_ramdir.ents[freevnum].nm = STRDUP(nm);
if (mnp->mn_ramdir.ents[freevnum].nm == NULL) error = ENOMEM;
else {
mnp->mn_ramdir.ents[freevnum].vp = vp;
mnp->mn_ramdir.mtime.tv_sec = MDKI_CTIME();
if (MVFS_ISVTYPE(vp, VDIR))
mnp->mn_ramdir.lnk_cnt++;
*num = freevnum; /* Return slot number used */
error = 0;
MVFS_WRAP_UPDATE_ATTRS(dvp, cd);
}
} else {
error = ENOSPC;
}
MUNLOCK(mnp);
return(error);
}
