void exportpath(char *canon, const char *host, const char *remote) { const char *xhost; char *copy; char tempname[FILENAME_MAX]; unsigned subscript; unsigned char number[MAX_DIGITS]; char *token, *out; static size_t range = UNIX_END_C - UNIX_START_C + 1; /* Determine unique number characters in the UNIX file names we are mapping */ size_t charsetsize; /* Number of allowed characters in MS-DOS file names */ #ifdef UDEBUG printmsg(5,"Exporting %s for %s", host, remote ); #endif /*--------------------------------------------------------------------*/ /* Define our character set */ /*--------------------------------------------------------------------*/ if ( E_charset == NULL ) E_charset = DOSCHARS; charsetsize = strlen( E_charset ); /*--------------------------------------------------------------------*/ /* Drop leading spool directory, if any */ /*--------------------------------------------------------------------*/ if (equalni(host, E_spooldir, strlen( E_spooldir ))) xhost = host + strlen( E_spooldir ) + 1; else xhost = host; copy = strdup( xhost ); checkref( copy ); /*--------------------------------------------------------------------*/ /* Drop the remote name */ /*--------------------------------------------------------------------*/ token = strtok( copy, "/"); if ((token == NULL) || !equaln( token, remote, strlen( token ))) { printmsg(0,"exportpath: Badly formed host name \"%s\"",xhost); panic(); } /*--------------------------------------------------------------------*/ /* Get the character leading the name */ /*--------------------------------------------------------------------*/ token = strtok( NULL, "/"); if ( (token == NULL) || (strlen(token) != 1)) { printmsg(0,"exportpath: Badly formed host name \"%s\"",xhost); panic(); } strcpy(canon, token); strcat(canon, "."); /*--------------------------------------------------------------------*/ /* Create a binary number which represents our file name */ /*--------------------------------------------------------------------*/ for (subscript = 0; subscript < MAX_DIGITS; subscript++ ) number[subscript] = 0; /* Initialize number to zero */ token = strtok( NULL, "/"); /* Get variable part of name */ while( (*token != '\0') && (*number == '\0')) { unsigned char digit; mult(number, charsetsize, MAX_DIGITS); /* Shift the number over */ digit = (unsigned char) (strchr( E_charset , *token++) - E_charset); add(number, digit , MAX_DIGITS); /* Add in new low order */ if (*token == '.') /* Next character a period? */ token ++; /* Yes --> Ignore it */ } /* while */ out = &tempname[FILENAME_MAX]; *--out = '\0'; /* Terminate the string we will build */ /*--------------------------------------------------------------------*/ /* Here's the loop to actually do the base conversion */ /*--------------------------------------------------------------------*/ while(adiv( number, range, &subscript, MAX_DIGITS)) *--out = (char) (subscript + UNIX_START_C); /*--------------------------------------------------------------------*/ /* We sort of lied above; the first character out of the */ /* conversion is not a character at all, but bits which say how */ /* many characters the remote and local file names get prefixed */ /* to the converted name. Retrieve that information now */ /*--------------------------------------------------------------------*/ subscript = (unsigned) (*out - UNIX_START_C); /* Convert back to pure number */ token = canon + strlen( canon ); /* Remember end of string */ if (subscript > HOSTLEN) { subscript /= HOSTLEN; strcat( canon, remote ); } else strcat( canon, E_nodename ); token[ subscript ] = '\0'; /* Only use the length we were told */ /*--------------------------------------------------------------------*/ /* Add in the variable name and we're done */ /*--------------------------------------------------------------------*/ strcat( canon, ++out ); free( copy ); /*--------------------------------------------------------------------*/ /* Check the result */ /*--------------------------------------------------------------------*/ importpath( tempname, canon, remote ); if ( !equal( tempname, xhost )) { printmsg(0, "exportpath: **mapping error** input \"%s\"," " result \"%s\", import \"%s\"", xhost, canon, tempname ); panic(); } /* if */ } /* exportpath */
int nopenline(char *name, BPS portSpeed, const KWBoolean direct ) { APIRET rc; USHORT com_error; #ifdef __OS2__ ULONG ParmLengthInOut; ULONG DataLengthInOut; ULONG action; #else USHORT action; #endif if (portActive) /* Was the port already active? */ closeline(); /* Yes --> Shutdown it before open */ #ifdef UDEBUG printmsg(15, "nopenline: %s, %lu", name, portSpeed); #endif /*--------------------------------------------------------------------*/ /* Validate the port format */ /*--------------------------------------------------------------------*/ if (!equaln(name, "COM", 3 )) { printmsg(0,"nopenline: Communications port begin with COM, was %s", name); panic(); } if ( commHandle == -1 ) { /*--------------------------------------------------------------------*/ /* Perform the open */ /*--------------------------------------------------------------------*/ rc = DosOpen( name, &commHandle, &action, 0L, 0 , FILE_OPEN , OPEN_FLAGS_FAIL_ON_ERROR | OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYREADWRITE, 0L ); /*--------------------------------------------------------------------*/ /* Check the open worked. */ /*--------------------------------------------------------------------*/ if ( rc ) { printOS2error( name, rc ); commHandle = -1; return KWTrue; } } /* if ( commHandle == -1 ) */ /*--------------------------------------------------------------------*/ /* Reset any errors on the communications port */ /*--------------------------------------------------------------------*/ #ifdef __OS2__ ParmLengthInOut = 0; DataLengthInOut = sizeof(com_error); rc = DosDevIOCtl( commHandle, IOCTL_ASYNC, ASYNC_GETCOMMERROR, NULL,0L,&ParmLengthInOut,(PVOID) &com_error,sizeof(com_error), &DataLengthInOut); #else rc = DosDevIOCtl( &com_error, FAR_NULL, ASYNC_GETCOMMERROR , IOCTL_ASYNC, commHandle); #endif if (rc) { ShowError( com_error ); printOS2error( "ASYNC_GETCOMMERROR", rc ); } /*if */ else if ( com_error ) ShowError( com_error ); /*--------------------------------------------------------------------*/ /* Set port speed */ /*--------------------------------------------------------------------*/ saveSpeed = GetSpeed(); /* Save original speed */ if ( portSpeed ) /* Don't set it we're a hot open */ SIOSpeed(portSpeed); /*--------------------------------------------------------------------*/ /* Set line attributes */ /*--------------------------------------------------------------------*/ #ifdef UDEBUG printmsg(15,"nopenline: Getting attributes"); #endif #ifdef __OS2__ ParmLengthInOut = 0; DataLengthInOut = sizeof(com_attrib); rc = DosDevIOCtl( commHandle, IOCTL_ASYNC, ASYNC_GETLINECTRL, NULL, 0L, &ParmLengthInOut, (PVOID) &com_attrib, sizeof(com_attrib), &DataLengthInOut); /* Get old attributes from device */ #else rc = DosDevIOCtl( &com_attrib, FAR_NULL, ASYNC_GETLINECTRL, IOCTL_ASYNC, commHandle); /* Get old attributes from device */ #endif if (rc) { printOS2error( "ASYNC_GETLINECTRL", rc ); panic(); } /*if */ memcpy( &save_com_attrib, &com_attrib, sizeof com_attrib ); /* Save the attributes */ com_attrib.bDataBits = 0x08; /* Use eight bit path for data */ com_attrib.bParity = 0x00; /* No parity */ com_attrib.bStopBits = 0x00; /* 1 Stop Bit */ #ifdef UDEBUG printmsg(15,"nopenline: Setting attributes"); #endif #ifdef __OS2__ ParmLengthInOut = sizeof(com_attrib); DataLengthInOut = 0; rc = DosDevIOCtl( commHandle, IOCTL_ASYNC, ASYNC_SETLINECTRL, (PVOID) &com_attrib, sizeof(com_attrib), &ParmLengthInOut, NULL, 0L, &DataLengthInOut); #else rc = DosDevIOCtl( FAR_NULL, &com_attrib, ASYNC_SETLINECTRL, IOCTL_ASYNC, commHandle); #endif if (rc) { printOS2error( "ASYNC_SETLINECTRL", rc ); panic(); } /*if */ /*--------------------------------------------------------------------*/ /* Disable software (XON/XOFF) flow control and enable */ /* hardware (CTS) for flow control */ /*--------------------------------------------------------------------*/ #ifdef UDEBUG printmsg(15,"nopenline: Getting flow control information"); #endif #ifdef __OS2__ ParmLengthInOut = 0; DataLengthInOut = sizeof(com_dcbinfo); rc = DosDevIOCtl( commHandle, IOCTL_ASYNC, ASYNC_GETDCBINFO, NULL, 0L, &ParmLengthInOut, (PVOID) &com_dcbinfo, sizeof(com_dcbinfo), &DataLengthInOut); /* Get old attributes from device */ #else rc = DosDevIOCtl( &com_dcbinfo, FAR_NULL, ASYNC_GETDCBINFO, IOCTL_ASYNC, commHandle); /* Get old attributes from device */ #endif if (rc) { printOS2error( "ASYNC_GETDCBINFO", rc ); panic(); } /*if */ memcpy( &save_com_dcbinfo, &com_dcbinfo, sizeof com_dcbinfo ); /* Save the DCB information */ com_dcbinfo.usWriteTimeout = 2999; /* Write timeout 30 seconds */ com_dcbinfo.usReadTimeout = 24; /* Read timeout .25 seconds */ com_dcbinfo.fbCtlHndShake = (BYTE) (MODE_DTR_CONTROL | (direct ? 0 : MODE_CTS_HANDSHAKE)); /* Always drop DTR at port close, only use CTS handshaking on requested ports. */ com_dcbinfo.fbFlowReplace = MODE_RTS_HANDSHAKE; /* Handshake on output */ com_dcbinfo.fbTimeout = MODE_READ_TIMEOUT | MODE_NO_WRITE_TIMEOUT; #ifdef UDEBUG printmsg(15,"nopenline: Setting dcb information"); #endif #ifdef __OS2__ ParmLengthInOut = sizeof(com_dcbinfo); DataLengthInOut = 0; rc = DosDevIOCtl( commHandle, IOCTL_ASYNC, ASYNC_SETDCBINFO, (PVOID) &com_dcbinfo, sizeof(com_dcbinfo), &ParmLengthInOut, NULL, 0L, &DataLengthInOut); #else rc = DosDevIOCtl( FAR_NULL, &com_dcbinfo, ASYNC_SETDCBINFO, IOCTL_ASYNC, commHandle); #endif if ( rc ) { printOS2error( "ASYNC_SETDCBINFO", rc ); panic(); } /*if */ /*--------------------------------------------------------------------*/ /* Raise Data Terminal Ready */ /*--------------------------------------------------------------------*/ com_signals.fbModemOn = DTR_ON; com_signals.fbModemOff = 0xff; #ifdef UDEBUG printmsg(15,"nopenline: Raising RTS/DTR"); #endif #ifdef __OS2__ ParmLengthInOut = sizeof(com_signals); DataLengthInOut = sizeof(com_error); rc = DosDevIOCtl( commHandle, IOCTL_ASYNC, ASYNC_SETMODEMCTRL, (PVOID)&com_signals, sizeof(com_signals), &ParmLengthInOut, (PVOID) &com_error, sizeof(com_error), &DataLengthInOut); #else rc = DosDevIOCtl( &com_error, &com_signals, ASYNC_SETMODEMCTRL, IOCTL_ASYNC, commHandle); #endif if (rc) { printOS2error( "ASYNC_SETMODEMCTRL", rc ); ShowError( com_error ); panic(); } /*if */ traceStart( name ); /* Enable logging */ portActive = KWTrue; /* record status for error handler */ carrierDetect = KWFalse; /* Modem is not connected */ /*--------------------------------------------------------------------*/ /* Wait for port to stablize */ /*--------------------------------------------------------------------*/ ddelay(500); /* Allow port to stablize */ return 0; } /* nopenline */
void importpath(char *local, const char *canon, const char *remote) { char *s, *out; size_t charsetsize; /* Number of allowed characters in MS-DOS file names */ out = local; /*--------------------------------------------------------------------*/ /* Verify our parameters */ /*--------------------------------------------------------------------*/ if (local == NULL) panic(); if (canon == NULL) panic(); /*--------------------------------------------------------------------*/ /* Define our character set */ /*--------------------------------------------------------------------*/ if (E_charset == NULL) E_charset = DOSCHARS; charsetsize = strlen(E_charset); /*--------------------------------------------------------------------*/ /* Determine if spool file directory */ /*--------------------------------------------------------------------*/ if ((s = strrchr(canon, '/')) == NULL) { /* File for spooling directory, use internal character set to avoid collisions */ static size_t range = UNIX_END_C - UNIX_START_C + 1; /* Determine unique number characters in the UNIX file names we are mapping */ size_t remlen = min(HOSTLEN, strlen(remote)); /* Length of the remote name passed in, shortened below to number of characters matched in name */ size_t nodelen = min(HOSTLEN, strlen(E_nodename)); /* Length of the local host name, shortened below to number of characters matched in name */ size_t subscript = 0; /* Value of UNIX character to be converted to MS-DOS character set */ char *next = local + remlen; char tempname[FILENAME_MAX]; unsigned char number[MAX_DIGITS]; /* Arbitary length number, for base conversions */ KWBoolean longname; if (bflag[F_LONGNAME] && advancedFS(E_spooldir)) longname = KWTrue; else longname = KWFalse; /*--------------------------------------------------------------------*/ /* Verify we have a remote name */ /*--------------------------------------------------------------------*/ if (remote == NULL) panic(); /*--------------------------------------------------------------------*/ /* Put the host name (up to six characters) at the beginning of */ /* the MS-DOS file name as a sub-directory name. */ /*--------------------------------------------------------------------*/ strncpy(local, remote, remlen); *next++ = '/'; /* Add in the sub-directory seperator */ s = (char *) canon; /* Get the beginnging of the UNIX name */ /*--------------------------------------------------------------------*/ /* Files in the spooling directory generally start with "D.", */ /* "C.", or "X."; strip off any upper case letter followed by a */ /* period into its own directory. */ /*--------------------------------------------------------------------*/ if ((s[0] >= 'A') && (s[0] <= 'Z') && (s[1] == '.')) { *next++ = *s; /* Copy the input character */ *next++ = '/'; /* Add the sub-directory indicator too */ s += 2; /* Step input string past the copied data */ } while (remlen > 0) { if (equaln(remote,s,remlen)) break; remlen--; } while (nodelen > 0) { if (equaln(E_nodename,s,nodelen)) break; nodelen--; } if (nodelen > remlen) { remlen = 0; s += nodelen; } else { nodelen = 0; s += remlen; } *next = '\0'; /* Terminate first part of host string */ /*--------------------------------------------------------------------*/ /* Create a binary number which represents our file name */ /*--------------------------------------------------------------------*/ for (subscript = 0; subscript < MAX_DIGITS; subscript++) number[subscript] = 0; /* Initialize number to zero */ add(number, nodelen + remlen * HOSTLEN, MAX_DIGITS); /* Append host name info to the front of the converted string */ while ((*s != '\0') && (*number == '\0')) { if (isspace(*s)) { printmsg(0,"importPath: Invalid file \"%s\" for %s, " "name contains whitespace", canon, remote); panic(); } mult(number, range, MAX_DIGITS); /* Shift the number over */ add(number, (unsigned) (*s++ - UNIX_START_C), MAX_DIGITS); /* Add in new low order */ } /* while */ /*--------------------------------------------------------------------*/ /* We now have stripped off the leading x. and host name, if any; */ /* now, convert the remaining characters in the name by doing a */ /* range to charset base conversion. */ /*--------------------------------------------------------------------*/ out = tempname + FILENAME_MAX; *--out = '\0'; /* Terminate the string we will build */ /*--------------------------------------------------------------------*/ /* Here's the loop to actually do the base conversion */ /*--------------------------------------------------------------------*/ while (adiv(number, charsetsize, &subscript, MAX_DIGITS)) *--out = E_charset[ subscript ]; /*--------------------------------------------------------------------*/ /* The conversion is done; now squeeze it into an 11 character */ /* MS-DOS name with period. */ /*--------------------------------------------------------------------*/ ImportName(next, out, charsetsize, longname); } else { /* Not file for spooling directory, convert it */ char *in = (char *) canon; KWBoolean longname ; longname = advancedFS(canon); if (ValidDOSName(canon, longname)) { strcpy(local, canon); return; } /*--------------------------------------------------------------------*/ /* Handle leading drive letter (ignore it, assuming valid) */ /*--------------------------------------------------------------------*/ if (isalpha(*in) && (in[1] == ':')) { *out++ = *in++; /* The drive letter */ *out++ = *in++; /* The colon making it a driver letter */ } /* if */ if (*in == '/') /* Absolute path name? */ *out++ = *in++; /* Yes, step past it */ while (*in == '/') /* Additional slashes? */ in++; /* Skip them, they mean nothing */ s = strchr(in, '/'); /* Get end of next path segment */ /*--------------------------------------------------------------------*/ /* Now convert each simple name in the path */ /*--------------------------------------------------------------------*/ while (*in) { if (s != NULL) *s = '\0'; /* Truncate input string to simple name */ ImportName(out, in, charsetsize, longname); if (s == NULL) break; out = out + strlen(out); *out++ = *s++ = '/'; /* Restore path to input and output */ in = s; /* Remember start of this simple name */ while (*in == '/') /* Additional slashes? */ in++; /* Skip them, they mean nothing */ s = strchr(in, '/'); } } /* else */ printmsg(equali(canon,local) ? 8 : 4, "ImportPath: Mapped %s to %s", canon, local); } /*importpath*/
static int yysimfac(int h) { int i, j; for (i = h; i < tos; i++) { p1 = stack[i]; for (j = h; j < tos; j++) { if (i == j) continue; p2 = stack[j]; // n! / n -> (n - 1)! if (car(p1) == symbol(FACTORIAL) && car(p2) == symbol(POWER) && isminusone(caddr(p2)) && equal(cadr(p1), cadr(p2))) { push(cadr(p1)); push(one); subtract(); factorial(); stack[i] = pop(); stack[j] = one; return 1; } // n / n! -> 1 / (n - 1)! { int a,b,c,d; a = car(p2) == symbol(POWER); b = isminusone(caddr(p2)); c = caadr(p2) == symbol(FACTORIAL); d = equal(p1, cadadr(p2)); if ( a && b && c && d){ push(p1); push_integer(-1); add(); factorial(); reciprocate(); stack[i] = pop(); stack[j] = one; return 1; } } // (n + 1) n! -> (n + 1)! if (car(p2) == symbol(FACTORIAL)) { push(p1); push(cadr(p2)); subtract(); p3 = pop(); if (isplusone(p3)) { push(p1); factorial(); stack[i] = pop(); stack[j] = one; return 1; } } // 1 / ((n + 1) n!) -> 1 / (n + 1)! if (car(p1) == symbol(POWER) && isminusone(caddr(p1)) && car(p2) == symbol(POWER) && isminusone(caddr(p2)) && caadr(p2) == symbol(FACTORIAL)) { push(cadr(p1)); // modified push(car(cdr(cadr(p2)))); subtract(); p3 = pop(); if (isplusone(p3)) { push(cadr(p1)); factorial(); reciprocate(); stack[i] = pop(); stack[j] = one; return 1; } } // (n + 1)! / n! -> n + 1 // n! / (n + 1)! -> 1 / (n + 1) if (car(p1) == symbol(FACTORIAL) && car(p2) == symbol(POWER) && isminusone(caddr(p2)) && caadr(p2) == symbol(FACTORIAL)) { push(cadr(p1)); push(car(cdr(cadr(p2)))); subtract(); p3 = pop(); if (isplusone(p3)) { stack[i] = cadr(p1); stack[j] = one; return 1; } if (isminusone(p3)) { push(car(cdr(cadr(p2)))); reciprocate(); stack[i] = pop(); stack[j] = one; return 1; } if (equaln(p3, 2)) { stack[i] = cadr(p1); push(cadr(p1)); push_integer(-1); add(); stack[j] = pop(); return 1; } if (equaln(p3, -2)) { push(car(cdr(cadr(p2)))); reciprocate(); stack[i] = pop(); push(car(cdr(cadr(p2)))); push_integer(-1); add(); reciprocate(); stack[j] = pop(); return 1; } } } } return 0; }
void run(char *s) { int i, n; /*if (strncmp(s, "selftest", 8) == 0) { selftest(); return; }*/ if (setjmp(stop_return)) return; init(); while (1) { n = scan(s); p1 = pop(); check_stack(); if (n == 0) break; // if debug mode then print the source text if (equaln(get_binding(symbol(TRACE)), 1)) { for (i = 0; i < n; i++) if (s[i] != '\r') printchar(s[i]); if (s[n - 1] != '\n') // n is not zero, see above printchar('\n'); } s += n; push(p1); top_level_eval(); p2 = pop(); check_stack(); if (p2 == symbol(NIL)) continue; // print string w/o quotes if (isstr(p2)) { printstr(p2->u.str); printstr("\n"); continue; } if (equaln(get_binding(symbol(TTY)), 1) || test_flag) // tty mode? printline(p2); else { //#ifdef LINUX display(p2); /*#else push(p2); cmdisplay(); #endif*/ } } }
int main(int ac, char *av[]) { int ret = 0; //strcpy(applnamebuf,av[0]); if(strrchr(av[0],SLASHC)) strcpy(applnamebuf, strrchr(av[0],SLASHC)+1); else strcpy(applnamebuf, av[0]); #ifdef _WIN32 { char *q; if((q=strrchr(applnamebuf, '.'))) if(!equal(q+1,"exe")) strcat(applnamebuf,".exe"); } #endif applname = applnamebuf; if(ac == 1) { USAGE(); return 0; } while(ac > 1) { if(equal(av[1],"-debug") || equal(av[1],"-d")) { ac--; av++; showme++; } else if(equal(av[1],"-csv")) { ac--; av++; csv = 1; } else if(equaln(av[1], "-t",2)) { if(av[1][2] == 0) { ac--; av++; nthreads = atoik(av[1]); } else { nthreads = atoik(&av[1][2]); } //if(nthreads > 1000) nthreads = 1000; if(nthreads < 2) nthreads = 2; ac--; av++; } else if(equaln(av[1], "-c",2)) { if(av[1][2] == 0) { ac--; av++; ncrits = atoik(av[1]); } else { ncrits = atoik(&av[1][2]); } ac--; av++; } else if(isdigit(av[1][0])) { maxcount = atoik(av[1]); ac--; av++; if(maxcount == 0) maxcount = 1; } } // // There has to be at least 1 more critical section than threads. // if(ncrits <= nthreads) ncrits = nthreads + 1; ret = do_threads(); return ret; }