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'); }