Blk*
getdec(Blk *p, int sc)
{
int cc;
Blk *q, *t, *s;
rewind(p);
if(length(p)*2 < sc) {
q = copy(p,length(p));
return(q);
}
q = salloc(length(p));
while(sc >= 1) {
sputc(q,sgetc(p));
sc -= 2;
}
if(sc != 0) {
t = mult(q,tenptr);
s = salloc(cc = length(q));
release(q);
rewind(t);
while(cc-- > 0)
sputc(s,sgetc(t));
sputc(s,0);
release(t);
t = div(s,tenptr);
release(s);
release(rem);
return(t);
}
return(q);
}
struct blk *
removr(struct blk *p,int n)
{
int nn;
register struct blk *q,*s,*r;
rewind(p);
nn = (n+1)/2;
q = salloc(nn);
while(n>1){
sputc(q,sgetc(p));
n -= 2;
}
r = salloc(2);
while(sfeof(p) == 0)sputc(r,sgetc(p));
release(p);
if(n == 1){
s = dcdiv(r,tenptr);
release(r);
rewind(rem);
if(sfeof(rem) == 0)sputc(q,sgetc(rem));
release(rem);
irem = q;
return(s);
}
irem = q;
return(r);
}
/**
* If connection was broken, return NULL. If the read timed out, return
* (char *)-1.
* @param buf Buffer to get
* @param len Length
* @param s Socket
* @return buffer
*/
char *sgets(char *buf, int len, ano_socket_t s)
{
int c = 0;
struct timeval tv;
fd_set fds;
char *ptr = buf;
flush_write_buffer(0);
if (len == 0)
return NULL;
FD_SET(s, &fds);
tv.tv_sec = ReadTimeout;
tv.tv_usec = 0;
while (read_buffer_len() == 0 &&
(c = select(s + 1, &fds, NULL, NULL, &tv)) < 0) {
if (ano_sockgeterr() != EINTR)
break;
flush_write_buffer(0);
}
if (read_buffer_len() == 0 && c == 0)
return (char *) -1;
c = sgetc(s);
while (--len && (*ptr++ = c) != '\n' && (c = sgetc(s)) >= 0);
if (c < 0)
return NULL;
*ptr = 0;
return buf;
}
Blk*
mult(Blk *p, Blk *q)
{
Blk *mp, *mq, *mr;
int sign, offset, carry;
int cq, cp, mt, mcr;
offset = sign = 0;
fsfile(p);
mp = p;
if(sfbeg(p) == 0) {
if(sbackc(p)<0) {
mp = copy(p,length(p));
chsign(mp);
sign = ~sign;
}
}
fsfile(q);
mq = q;
if(sfbeg(q) == 0){
if(sbackc(q)<0) {
mq = copy(q,length(q));
chsign(mq);
sign = ~sign;
}
}
mr = salloc(length(mp)+length(mq));
zero(mr);
rewind(mq);
while(sfeof(mq) == 0) {
cq = sgetc(mq);
rewind(mp);
rewind(mr);
mr->rd += offset;
carry=0;
while(sfeof(mp) == 0) {
cp = sgetc(mp);
mcr = sfeof(mr)?0:slookc(mr);
mt = cp*cq + carry + mcr;
carry = mt/100;
salterc(mr,mt%100);
}
offset++;
if(carry != 0) {
mcr = sfeof(mr)?0:slookc(mr);
salterc(mr,mcr+carry);
}
}
if(sign < 0) {
chsign(mr);
}
if(mp != p)
release(mp);
if(mq != q)
release(mq);
return(mr);
}
Blk*
add(Blk *a1, Blk *a2)
{
Blk *p;
int carry, n, size, c, n1, n2;
size = length(a1)>length(a2)?length(a1):length(a2);
p = salloc(size);
rewind(a1);
rewind(a2);
carry=0;
while(--size >= 0) {
n1 = sfeof(a1)?0:sgetc(a1);
n2 = sfeof(a2)?0:sgetc(a2);
n = n1 + n2 + carry;
if(n>=100) {
carry=1;
n -= 100;
} else
if(n<0) {
carry = -1;
n += 100;
} else
carry = 0;
sputc(p,n);
}
if(carry != 0)
sputc(p,carry);
fsfile(p);
if(sfbeg(p) == 0) {
c = 0;
while(sfbeg(p) == 0 && (c = sbackc(p)) == 0)
;
if(c != 0)
salterc(p,c);
truncate(p);
}
fsfile(p);
if(sfbeg(p) == 0 && sbackc(p) == -1) {
while((c = sbackc(p)) == 99) {
if(c == -1)
break;
}
skipc(p);
salterc(p,-1);
truncate(p);
}
return(p);
}
int main(void)
{
FILE *fout;
int i, fserial;
fout = fopen("rom56.bin", "w");
if (fout == NULL)
{
fprintf(stderr, "can't open rom56.bin for writing\n");
exit(1);
}
fserial = sopen("/dev/ttyS0", B19200);
if (fserial == -1)
{
fprintf(stderr, "can't open serial port\n");
exit(1);
}
for (i=0; i<0x1000; i++)
{
fputc(sgetc(fserial), fout);
printf(".");
}
fclose(fout);
sclose(fserial);
return 0;
}
int
readc(void)
{
loop:
if((readptr != &readstk[0]) && (*readptr != 0)) {
if(sfeof(*readptr) == 0)
return(lastchar = sgetc(*readptr));
release(*readptr);
readptr--;
goto loop;
}
lastchar = Bgetc(curfile);
if(lastchar != -1)
return(lastchar);
if(readptr != &readptr[0]) {
readptr--;
if(*readptr == 0)
curfile = &bin;
goto loop;
}
if(curfile != &bin) {
Bterm(curfile);
curfile = &bin;
goto loop;
}
exits(0);
return 0; /* shut up ken */
}
/*
* Read a byte from a stream
*/
int
sfgetc(stream *s)
{
int code = sgetc(s);
return code >= 0 ? code : EOF;
}
/* <file> read -false- */
static int
zread(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
stream *s;
int ch;
check_read_file(s, op);
/* We 'push' first in case of ostack block overflow and the */
/* usual case is we will need to push anyway. If we get EOF */
/* we will need to 'pop' and decrement the 'op' pointer. */
/* This is required since the 'push' macro might return with*/
/* stackoverflow which will result in another stack block */
/* added on, then the operator being retried. We can't read */
/* (sgetc) prior to having a place on the ostack to return */
/* the character. */
push(1);
ch = sgetc(s);
if (ch >= 0) {
make_int(op - 1, ch);
make_bool(op, 1);
} else {
pop(1); /* Adjust ostack back from preparatory 'pop' */
op--;
if (ch == EOFC)
make_bool(op, 0);
else
return handle_read_status(i_ctx_p, ch, op, NULL, zread);
}
return 0;
}
static int
playagain(void)
{
int j;
ship_t *ss;
for (ss = cpuship; ss < cpuship + SHIPTYPES; ss++)
for (j = 0; j < ss->length; j++) {
cgoto(ss->y + j * yincr[ss->dir], ss->x + j * xincr[ss->dir]);
(void) addch((chtype) ss->symbol);
}
if (awinna())
++cpuwon;
else
++plywon;
j = 18 + (int) strlen(name);
if (plywon >= 10)
++j;
if (cpuwon >= 10)
++j;
(void) mvprintw(1, (COLWIDTH - j) / 2,
"%s: %d Computer: %d", name, plywon, cpuwon);
prompt(2, (awinna())? "Want to be humiliated again, %s [yn]? "
: "Going to give me a chance for revenge, %s [yn]? ", name);
return (sgetc("YN") == 'Y');
}
Blk*
removr(Blk *p, int n)
{
int nn, neg;
Blk *q, *s, *r;
fsfile(p);
neg = sbackc(p);
if(neg < 0)
chsign(p);
rewind(p);
nn = (n+1)/2;
q = salloc(nn);
while(n>1) {
sputc(q,sgetc(p));
n -= 2;
}
r = salloc(2);
while(sfeof(p) == 0)
sputc(r,sgetc(p));
release(p);
if(n == 1){
s = div(r,tenptr);
release(r);
rewind(rem);
if(sfeof(rem) == 0)
sputc(q,sgetc(rem));
release(rem);
if(neg < 0){
chsign(s);
chsign(q);
irem = q;
return(s);
}
irem = q;
return(s);
}
if(neg < 0) {
chsign(r);
chsign(q);
irem = q;
return(r);
}
irem = q;
return(r);
}
Blk*
dcexp(Blk *base, Blk *ex)
{
Blk *r, *e, *p, *e1, *t, *cp;
int temp, c, n;
r = salloc(1);
sputc(r,1);
p = copy(base,length(base));
e = copy(ex,length(ex));
fsfile(e);
if(sfbeg(e) != 0)
goto edone;
temp=0;
c = sbackc(e);
if(c<0) {
temp++;
chsign(e);
}
while(length(e) != 0) {
e1=div(e,sqtemp);
release(e);
e = e1;
n = length(rem);
release(rem);
if(n != 0) {
e1=mult(p,r);
release(r);
r = e1;
}
t = copy(p,length(p));
cp = mult(p,t);
release(p);
release(t);
p = cp;
}
if(temp != 0) {
if((c = length(base)) == 0) {
goto edone;
}
if(c>1)
create(r);
else {
rewind(base);
if((c = sgetc(base))<=1) {
create(r);
sputc(r,c);
} else
create(r);
}
}
edone:
release(p);
release(e);
return(r);
}
char pgetc(parser *p) {
char c = sgetc(p->f);
if (is_newline(c)) {
p->current_location.column = 1;
p->current_location.line++;
} else {
p->current_location.column++;
}
return c;
}
void FileContainer::read(char& character)
{
if (sgetc() != EOF)
{
character = sbumpc();
}
else
{
// Error EOF
}
}
int
streambuf::snextc()
{
#if defined(OS_INCLUDE_STREAMBUF_BUFFERS)
if (sbumpc() == traits::eof())
{
return traits::eof();
}
#endif
return sgetc();
}
streambuf::int_type streambuf::_M_snextc_underflow()
{
if (__M_gnext == __M_gend)
{
return (uflow() == EOF) ? EOF : sgetc();
}
else
{
__M_gnext = __M_gend;
return underflow();
}
}
struct blk *
removc(struct blk *p,int n)
{
register struct blk *q,*r;
rewind(p);
while(n>1){
sgetc(p);
n -= 2;
}
q = salloc(2);
while(sfeof(p) == 0)sputc(q,sgetc(p));
if(n == 1){
r = dcdiv(q,tenptr);
release(q);
release(rem);
q = r;
}
release(p);
return(q);
}
void
bigot(Blk *p, int flg)
{
Blk *t, *q;
int neg, l;
if(flg == 1) {
t = salloc(0);
l = 0;
} else {
t = strptr;
l = length(strptr)+fw-1;
}
neg=0;
if(length(p) != 0) {
fsfile(p);
if(sbackc(p)<0) {
neg=1;
chsign(p);
}
while(length(p) != 0) {
q = div(p,tenptr);
release(p);
p = q;
rewind(rem);
sputc(t,sfeof(rem)?'0':sgetc(rem)+'0');
release(rem);
}
}
release(p);
if(flg == 1) {
l = fw1-length(t);
if(neg != 0) {
l--;
sputc(strptr,'-');
}
fsfile(t);
while(l-- > 0)
sputc(strptr,'0');
while(sfbeg(t) == 0)
sputc(strptr,sbackc(t));
release(t);
} else {
l -= length(strptr);
while(l-- > 0)
sputc(strptr,'0');
if(neg != 0) {
sclobber(strptr);
sputc(strptr,'-');
}
}
sputc(strptr,' ');
}
void
bigot(struct blk *p,int flg,int putspc)
{
register struct blk *t,*q;
register int l = 0;
int neg;
if(flg == 1)t = salloc(0);
else{
t = strptr;
l = length(strptr)+fw-1;
}
neg=0;
if(length(p) != 0){
fsfile(p);
if(sbackc(p)<0){
neg=1;
chsign(p);
}
while(length(p) != 0){
q = dcdiv(p,tenptr);
release(p);
p = q;
rewind(rem);
sputc(t,sfeof(rem)?'0':sgetc(rem)+'0');
release(rem);
}
}
release(p);
if(flg == 1){
l = fw1-length(t);
if(neg != 0){
l--;
sputc(strptr,'-');
}
fsfile(t);
while(l-- > 0)sputc(strptr,'0');
while(sfbeg(t) == 0)sputc(strptr,sbackc(t));
release(t);
}
else{
l -= length(strptr);
while(l-- > 0)sputc(strptr,'0');
if(neg != 0){
sunputc(strptr);
sputc(strptr,'-');
}
}
if (putspc)
sputc(strptr,' ');
return;
}
int main(void)
{
struct stream *i = sopen_fd("stdin", 0);
struct stream *o = sopen_fd("stdout", 1);
int c, d, nl = 1;
c = sgetc(i);
for (;;)
{
if (c == '/')
{
if ((d = sgetc(i)) == '/')
{
// skipping a comment...
while ((c = sgetc(i)) >= 0 && c != '\n')
;
if (nl)
{
c = sgetc(i);
continue;
}
}
else
{
sputc(o, c);
c = d;
}
}
if (c < 0)
break;
sputc(o, c);
nl = (c == '\n');
c = sgetc(i);
}
sclose(o);
sclose(i);
return 0;
}
int readUint24( INOUT STREAM *stream )
{
int status;
assert( isWritePtr( stream, sizeof( STREAM ) ) );
status = sgetc( stream );
if( cryptStatusError( status ) )
return( status );
if( status != 0 )
return( sSetError( stream, CRYPT_ERROR_BADDATA ) );
return( readUint16( stream ) );
}
static int processSNI( INOUT SSL_HANDSHAKE_INFO *handshakeInfo,
INOUT STREAM *stream,
IN_LENGTH_SHORT_Z const int extLength,
const BOOLEAN isServer )
{
BYTE nameBuffer[ MAX_DNS_SIZE + 8 ];
int listLen, nameLen, status;
assert( isWritePtr( handshakeInfo, sizeof( SSL_HANDSHAKE_INFO ) ) );
assert( isWritePtr( stream, sizeof( STREAM ) ) );
REQUIRES( extLength >= 0 && extLength < MAX_INTLENGTH_SHORT );
/* If we're the client then the server should have sent us an empty
extension */
if( !isServer )
return( ( extLength != 0 ) ? CRYPT_ERROR_BADDATA : CRYPT_OK );
/* Remember that we've seen the server-name extension so that we can
send a zero-length reply to the client */
handshakeInfo->needSNIResponse = TRUE;
/* Read the extension wrapper */
status = listLen = readUint16( stream );
if( cryptStatusError( status ) )
return( status );
if( listLen != extLength - UINT16_SIZE || \
listLen < 1 + UINT16_SIZE || \
listLen >= MAX_INTLENGTH_SHORT )
return( CRYPT_ERROR_BADDATA );
/* Read the name type and length */
if( sgetc( stream ) != 0 ) /* Name type 0 = hostname */
return( CRYPT_ERROR_BADDATA );
status = nameLen = readUint16( stream );
if( cryptStatusError( status ) )
return( status );
if( nameLen != listLen - ( 1 + UINT16_SIZE ) || \
nameLen < MIN_DNS_SIZE || nameLen > MAX_DNS_SIZE )
return( CRYPT_ERROR_BADDATA );
/* Read the SNI and hash it */
status = sread( stream, nameBuffer, nameLen );
if( cryptStatusError( status ) )
return( status );
hashData( handshakeInfo->hashedSNI, KEYID_SIZE, nameBuffer, nameLen );
handshakeInfo->hashedSNIpresent = TRUE;
return( CRYPT_OK );
}
/* Get a matrix from a stream. */
int
sget_matrix(stream *s, gs_matrix *pmat)
{
int b = sgetc(s);
float coeff[6];
int i;
int status;
uint nread;
if (b < 0)
return b;
for (i = 0; i < 4; i += 2, b <<= 2)
if (!(b & 0xc0))
coeff[i] = coeff[i ^ 3] = 0.0;
else {
float value;
status = sgets(s, (byte *)&value, sizeof(value), &nread);
if (status < 0 && status != EOFC)
return_error(gs_error_ioerror);
coeff[i] = value;
switch ((b >> 6) & 3) {
case 1:
coeff[i ^ 3] = value;
break;
case 2:
coeff[i ^ 3] = -value;
break;
case 3:
status = sgets(s, (byte *)&coeff[i ^ 3],
sizeof(coeff[0]), &nread);
if (status < 0 && status != EOFC)
return_error(gs_error_ioerror);
}
}
for (; i < 6; ++i, b <<= 1)
if (b & 0x80) {
status = sgets(s, (byte *)&coeff[i], sizeof(coeff[0]), &nread);
if (status < 0 && status != EOFC)
return_error(gs_error_ioerror);
} else
coeff[i] = 0.0;
pmat->xx = coeff[0];
pmat->xy = coeff[1];
pmat->yx = coeff[2];
pmat->yy = coeff[3];
pmat->tx = coeff[4];
pmat->ty = coeff[5];
return 0;
}
/* Get a variable-length uint from a stream. */
int
sget_variable_uint(stream *s, uint *pw)
{
uint w = 0;
int shift = 0;
int ch;
for (; (ch = sgetc(s)) >= 0x80; shift += 7)
w += (ch & 0x7f) << shift;
if (ch < 0)
return_error(gs_error_ioerror);
*pw = w + (ch << shift);
return 0;
}
//
// Older single character based sgets function
//
// Returns buffer pointer for success
// Returns 0 for failure
//
// info->fi_reply = 800 for timeout
// info->fi_reply = 700 for control-D abort
//
static char *sgets( struct ftp_info *info, char *iobuf, int bytes, int skt, int checkabort_time )
{
char *retval, *p;
int c;
if (bytes < 1)
return NULL;
retval = p = iobuf;
do
{
// Buffer full?
if (p - iobuf == bytes - 1)
break;
// Read a character
c = sgetc( info, skt, checkabort_time );
// EOF or error?
if (c == -1)
{
retval = 0;
break;
}
// Timeout?
else if (c == -2)
{
info->fi_reply = 800;
retval = 0;
break;
}
// Aborted?
else if (c == -3)
{
info->fi_reply = 700;
retval = 0;
break;
}
*p++ = c;
} while (c != '\n');
// Null terminate
*p = 0;
return retval;
}
int OTStringXML::read(void* buffer, unsigned sizeToRead)
{
if (buffer && sizeToRead && Exists())
{
char * pBuf = (char *) buffer;
int nBytesToCopy = (sizeToRead > GetLength() ? GetLength() : sizeToRead);
int i;
for (i = 0; i < nBytesToCopy; i++) {
pBuf[i] = sgetc();
}
return i;
}
else
{
return 0;
}
}
void
hexot(struct blk *p,int flg,int unused)
{
register int c;
rewind(p);
if(sfeof(p) != 0){
sputc(strptr,'0');
release(p);
return;
}
c = sgetc(p);
release(p);
if(c >= 16){
printf("hex digit > 16");
return;
}
sputc(strptr,c<10?c+'0':c-10+'A');
return;
}
int tfont_width(char const *code)
{
if(code == NULL) {
return 0;
}
while(*code)
{
char c = sgetc(&code);
switch(c)
{
case 0:
case -1:
return 0;
case 'a':
return scalex(sgetn(&code));
}
}
return 0;
}
int sgetn(char const **code)
{
int factor = 1;
while(true)
{
char c = sgetc(code);
if(c == '-') {
factor = -1;
}
if(c >= '0' && c <= '9') {
return factor * (c - '0');
}
if(c >= 'A' && c <= 'F') {
return factor * (10 + c - 'A');
}
if(c >= 'a' && c <= 'f') {
return factor * (10 + c - 'a');
}
}
}
void
hexot(Blk *p, int flg)
{
int c;
USED(flg);
rewind(p);
if(sfeof(p) != 0) {
sputc(strptr,'0');
release(p);
return;
}
c = sgetc(p);
release(p);
if(c >= 16) {
Bprint(&bout,"hex digit > 16");
return;
}
sputc(strptr,c<10?c+'0':c-10+'a');
}
