/** * @returns The size of the input sequence. The value is equal to that * calculated for @c s in the following code: * @code * size_t s = 0; * const_buffers_type bufs = data(); * const_buffers_type::const_iterator i = bufs.begin(); * while (i != bufs.end()) * { * const_buffer buf(*i++); * s += buffer_size(buf); * } * @endcode */ std::size_t size() const { return pptr() - gptr(); }
/** * @returns An object of type @c const_buffers_type that satisfies * ConstBufferSequence requirements, representing all character arrays in the * input sequence. * * @note The returned object is invalidated by any @c basic_streambuf member * function that modifies the input sequence or output sequence. */ const_buffers_type data() const { return asio::buffer(asio::const_buffer(gptr(), (pptr() - gptr()) * sizeof(char_type))); }
inttoktype yylex() { register ptrall bufptr; register inttoktype val; register struct exp *locxp; /* * No local variables to be allocated; this saves * one piddling instruction.. */ static int Lastjxxx; bufptr = tokptr; /*copy in the global value*/ top: if (bufptr < tokub){ gtoken(val, bufptr); switch(yylval = val){ case PARSEEOF: yylval = val = PARSEEOF; break; case BFINT: case INT: if (xp >= &explist[NEXP]) yyerror("Too many expressions; try simplyfing"); else locxp = xp++; locxp->e_number = Znumber; locxp->e_number.num_tag = TYPL; glong(locxp->e_xvalue, bufptr); makevalue: locxp->e_xtype = XABS; locxp->e_xloc = 0; locxp->e_xname = NULL; yylval = (int)locxp; break; case BIGNUM: if (xp >= &explist[NEXP]) yyerror("Too many expressions; try simplyfing"); else locxp = xp++; gnumber(locxp->e_number, bufptr); goto makevalue; case NAME: gptr(yylval, bufptr); lastnam = (struct symtab *)yylval; break; case SIZESPEC: case REG: gchar(yylval, bufptr); break; case INSTn: case INST0: gopcode(yyopcode, bufptr); break; case IJXXX: gopcode(yyopcode, bufptr); /* We can't cast Lastjxxx into (int *) here.. */ gptr(Lastjxxx, bufptr); lastjxxx = (struct symtab *)Lastjxxx; break; case ILINESKIP: gint(yylval, bufptr); lineno += yylval; goto top; case SKIP: eatskiplg(bufptr); goto top; case VOID: goto top; case STRING: case ISTAB: case ISTABSTR: case ISTABNONE: case ISTABDOT: case IALIGN: gptr(yylval, bufptr); break; } #ifdef DEBUG if (toktrace){ char *tok_to_name(); printf("P: %d T#: %4d, %s ", passno, bufptr - firsttoken, tok_to_name(val)); switch(val){ case INT: printf("val %d", ((struct exp *)yylval)->e_xvalue); break; case BFINT: printf("val %d", ((struct exp *)yylval)->e_xvalue); break; case BIGNUM: bignumprint(((struct exp*)yylval)->e_number); break; case NAME: printf("\"%.8s\"", FETCHNAME((struct symtab *)yylval)); break; case REG: printf(" r%d", yylval); break; case IJXXX: case INST0: case INSTn: if (ITABCHECK(yyopcode)) printf("%.8s", FETCHNAME(ITABFETCH(yyopcode))); else printf("IJXXX or INST0 or INSTn can't get into the itab\n"); break; case STRING: printf("length %d, seekoffset %d, place 0%o ", ((struct strdesc *)yylval)->sd_strlen, ((struct strdesc *)yylval)->sd_stroff, ((struct strdesc *)yylval)->sd_place ); if (((struct strdesc *)yylval)->sd_place & STR_CORE) printf("value\"%*s\"", ((struct strdesc *)yylval)->sd_strlen, ((struct strdesc *)yylval)->sd_string); break; } /*end of the debug switch*/ printf("\n"); } #endif DEBUG } else { /* start a new buffer */ if (useVM){ if (passno == 2){ tok_temp = emptybuf->tok_next; emptybuf->tok_next = tok_free; tok_free = emptybuf; emptybuf = tok_temp; } else { emptybuf = emptybuf->tok_next; } bufno += 1; if (emptybuf == 0){ struct tokbufdesc *newdallop; int i; if (passno == 2) goto badread; emptybuf = newdallop = (struct tokbufdesc *) Calloc(TOKDALLOP, sizeof (struct tokbufdesc)); for (i=0; i < TOKDALLOP; i++){ buftail->tok_next = newdallop; buftail = newdallop; newdallop += 1; } buftail->tok_next = 0; } /*end of need to get more buffers*/ (bytetoktype *)bufptr = &(emptybuf->toks[0]); if (passno == 1) scan_dot_s(emptybuf); } else { /*don't use VM*/ bufno ^= 1; emptybuf = &tokbuf[bufno]; ((bytetoktype *)bufptr) = &(emptybuf->toks[0]); if (passno == 1){ /* * First check if there are things to write * out at all */ if (emptybuf->tok_count >= 0){ if (writeTEST((char *)emptybuf, sizeof *emptybuf, 1, tokfile)){ yyerror("Unexpected end of file writing the interpass tmp file"); exit(2); } } scan_dot_s(emptybuf); } else { /*pass 2*/ if (readTEST((char *)emptybuf, sizeof *emptybuf, 1, tokfile)){ badread: yyerror("Unexpected end of file while reading the interpass tmp file"); exit(1); } } } /*end of using a real live file*/ (char *)tokub = (char *)bufptr + emptybuf->tok_count; #ifdef DEBUG firsttoken = bufptr; if (debug) printf("created buffernumber %d with %d tokens\n", bufno, emptybuf->tok_count); #endif DEBUG goto top; } /*end of reading/creating a new buffer*/ tokptr = bufptr; /*copy back the global value*/ return(val); } /*end of yylex*/
::std::size_t size() const { return (pptr() - gptr()); }
streamsize CConn_Streambuf::showmanyc(void) { static const STimeout kZeroTmo = {0, 0}; _ASSERT(gptr() >= egptr()); if (!m_Conn) return -1L; // flush output buffer, if tied up to it if (m_Tie) x_sync(); const STimeout* tmo; const STimeout* timeout = CONN_GetTimeout(m_Conn, eIO_Read); if (timeout == kDefaultTimeout) { // HACK * HACK * HACK tmo = ((SMetaConnector*) m_Conn)->default_timeout; } else tmo = timeout; size_t x_read; bool backup = false; if (m_BufSize > 1) { if (eback() < gptr()) { x_Buf = gptr()[-1]; backup = true; } if (!tmo) _VERIFY(CONN_SetTimeout(m_Conn, eIO_Read, &kZeroTmo)==eIO_Success); m_Status = CONN_Read(m_Conn, m_ReadBuf + 1, m_BufSize - 1, &x_read, eIO_ReadPlain); if (!tmo) _VERIFY(CONN_SetTimeout(m_Conn, eIO_Read, timeout) ==eIO_Success); _ASSERT(x_read > 0 || m_Status != eIO_Success); } else { m_Status = CONN_Wait(m_Conn, eIO_Read, tmo ? tmo : &kZeroTmo); x_read = 0; } if (!x_read) { switch (m_Status) { case eIO_Success: _ASSERT(m_BufSize <= 1); return 1L; // can read at least 1 byte case eIO_Timeout: if (!tmo || !(tmo->sec | tmo->usec)) break; /*FALLTHRU*/ case eIO_Closed: return -1L; // EOF default: break; } return 0; // no data available immediately } m_ReadBuf[0] = x_Buf; _ASSERT(m_BufSize > 1); setg(m_ReadBuf + !backup, m_ReadBuf + 1, m_ReadBuf + 1 + x_read); x_GPos += x_read; return x_read; }
// gptr as unsigned pointer uint8_t const * uptr() const { return reinterpret_cast<uint8_t const *>(gptr()); }
int streambuf::sync() { __lock_it( __b_lock ); return( (gptr() < egptr()) || (pptr() > pbase()) ? EOF : __NOT_EOF ); }
strstreambuf::pos_type strstreambuf::seekoff(off_type off, ios_base::seekdir dir, ios_base::openmode mode) { bool do_get = false; bool do_put = false; if ((mode & (ios_base::in | ios_base::out)) == (ios_base::in | ios_base::out) && (dir == ios_base::beg || dir == ios_base::end)) do_get = do_put = true; else if (mode & ios_base::in) do_get = true; else if (mode & ios_base::out) do_put = true; // !gptr() is here because, according to D.7.1 paragraph 4, the seekable // area is undefined if there is no get area. if ((!do_get && !do_put) || (do_put && !pptr()) || !gptr()) return pos_type(off_type(-1)); char* seeklow = eback(); char* seekhigh = epptr() ? epptr() : egptr(); off_type newoff; switch(dir) { case ios_base::beg: newoff = 0; break; case ios_base::end: newoff = seekhigh - seeklow; break; case ios_base::cur: newoff = do_put ? pptr() - seeklow : gptr() - seeklow; break; default: return pos_type(off_type(-1)); } off += newoff; if (off < 0 || off > seekhigh - seeklow) return pos_type(off_type(-1)); if (do_put) { if (seeklow + __STATIC_CAST(ptrdiff_t, off) < pbase()) { setp(seeklow, epptr()); pbump((int)off); } else { setp(pbase(), epptr()); pbump((int)(off - (pbase() - seeklow))); } } if (do_get) { if (off <= egptr() - seeklow) setg(seeklow, seeklow + __STATIC_CAST(ptrdiff_t, off), egptr()); else if (off <= pptr() - seeklow) setg(seeklow, seeklow + __STATIC_CAST(ptrdiff_t, off), pptr()); else setg(seeklow, seeklow + __STATIC_CAST(ptrdiff_t, off), epptr()); } return pos_type(newoff); }
std::streamsize Socket::showmanyc() { #ifdef WIN32 unsigned long result = -1; if(ioctlsocket(handle, FIONREAD, &result)) { #else int result = -1; if(ioctl(handle, FIONREAD, &result)) { #endif disconnect(); throw Exception(Exception::ERROR_IOCTL); }else return result; } std::streamsize Socket::advanceInputBuffer() { if(inputIntermediateSize == 0) //No input buffer return 0; std::streamsize inAvail; if(type == UDP_PEER) inAvail = 0; else{ inAvail = egptr()-gptr(); memmove(eback(), gptr(), inAvail); } try { inAvail += receive(eback()+inAvail, inputIntermediateSize-inAvail); } catch(Exception err) { } setg(eback(), eback(), eback()+inAvail); return inAvail; } std::streamsize Socket::receive(char_type* buffer, std::streamsize size) { size = std::min(size, showmanyc()); if(size == 0) return 0; switch(type) { case UDP_PEER: { struct sockaddr_storage remoteAddr; #ifdef WIN32 int addrSize = sizeof(remoteAddr); #else unsigned int addrSize = sizeof(remoteAddr); #endif int result = recvfrom(handle, (char*)buffer, size, 0, reinterpret_cast<struct sockaddr*>(&remoteAddr), &addrSize); if(result == -1) { portRemote = 0; hostRemote = ""; throw Exception(Exception::ERROR_READ); }else readSockaddr(&remoteAddr, hostRemote, portRemote); return result; } case TCP_CLIENT: case TCP_SERVERS_CLIENT: { int result = recv(handle, (char*)buffer, size, 0); if(result == -1) throw Exception(Exception::ERROR_READ); return result; } default: case NONE: case TCP_SERVER: throw Exception(Exception::BAD_TYPE); } }
std::streambuf::int_type icryptostreambuf::underflow() { if (!ctx) { // closed crypto stream return traits_type::eof(); } // return character pointed to by gptr() // without advancing it if charactes are available // if there are no charactes return EOF if (gptr() < egptr()) { return traits_type::to_int_type(*gptr()); } if (eback() == NULL) // NULL indicates 1st time { // TODO: put back buffer handling // basically done by moving // last few bytes to front of the buffer // so buffer is always putback+buffer } // read from underlying buffer, we should loop until stream is // at an end or encrypt/decrypt returns at least some bytes, // but there is no need to worry about filling out buffer completely int out_len = 0; while (out_len == 0 && input.sgetc() != traits_type::eof()) { int in_len = input.sgetn(in.data(), in.size()); int outl = 0; if (1 != EVP_CipherUpdate(ctx, (uint8_t*)out.data()+out_len, &outl, (uint8_t*)in.data(), in_len) ) { EVP_CIPHER_CTX_free(ctx); ctx = NULL; return traits_type::eof(); } out_len += outl; } // finalise if underlying streambuf is at an end if (input.sgetc() == traits_type::eof()) { int outl = 0; EVP_CipherFinal_ex(ctx, (uint8_t*)out.data()+out_len, &outl); EVP_CIPHER_CTX_free(ctx); ctx = NULL; out_len += outl; } // zero out here means we don't have any // bytes even after possible finalize, must be // at an end of stream.. if (out_len == 0) { return traits_type::eof(); } // set buffer pointers char *start = out.data(); // TODO: + putback_size // eback, gptr, egptr setg(out.data(), start, start + out_len); return traits_type::to_int_type(*gptr()); }
ClientSocket::StreamBuf::int_type ClientSocket::StreamBuf::underflow() { const size_t got = conn->read(inBuffer, sizeof(inBuffer)); setg(inBuffer, inBuffer, inBuffer + got); return traits_type::to_int_type(*gptr()); }
streammarker::~streammarker() { if (saving()) { // Unlink from sb's chain. register streammarker **ptr = &((backupbuf*)_sbuf)->_markers; for (; ; ptr = &(*ptr)->_next) if (*ptr == NULL) break; else if (*ptr == this) { *ptr = _next; return; } } #if 0 if _sbuf has a backup area that is no longer needed, should we delete it now, or wait until underflow()? #endif } #define BAD_DELTA EOF int streammarker::delta(streammarker& other_mark) { if (_sbuf != other_mark._sbuf) return BAD_DELTA; if (saving() && other_mark.saving()) return _pos - other_mark._pos; else if (!saving() && !other_mark.saving()) return _spos - other_mark._spos; else return BAD_DELTA; } int streammarker::delta() { if (_sbuf == NULL) return BAD_DELTA; if (saving()) { int cur_pos; if (_sbuf->in_backup()) cur_pos = _sbuf->_gptr - _sbuf->_egptr; else cur_pos = _sbuf->_gptr - _sbuf->_eback; return _pos - cur_pos; } else { if (_spos == EOF) return BAD_DELTA; int cur_pos = _sbuf->seekoff(0, ios::cur); if (cur_pos == EOF) return BAD_DELTA; return _pos - cur_pos; } } int streambuf::seekmark(streammarker& mark, int delta /* = 0 */) { if (mark._sbuf != this) return EOF; if (!mark.saving()) { return seekpos(mark._spos, ios::in); } else if (mark._pos >= 0) { if (in_backup()) switch_to_main_get_area(); _gptr = _eback + mark._pos; } else { if (!in_backup()) switch_to_backup_area(); _gptr = _egptr + mark._pos; } return 0; } void streambuf::unsave_markers() { register streammarker *mark =_markers; if (_markers) { streampos offset = seekoff(0, ios::cur, ios::in); if (offset != EOF) { offset += eGptr() - Gbase(); for ( ; mark != NULL; mark = mark->_next) mark->set_streampos(mark->_pos + offset); } else { for ( ; mark != NULL; mark = mark->_next) mark->set_streampos(EOF); } _markers = 0; } free_backup_area(); } int backupbuf::pbackfail(int c) { if (_gptr <= _eback) { // Need to handle a filebuf in write mode (switch to read mode). FIXME! if (have_backup() && !in_backup()) { switch_to_backup_area(); } if (!have_backup()) { // No backup buffer: allocate one. // Use short buffer, if unused? (probably not) FIXME int backup_size = 128; _other_gbase = new char [backup_size]; _other_egptr = _other_gbase + backup_size; _aux_limit = _other_egptr; switch_to_backup_area(); } else if (gptr() <= eback()) { // Increase size of existing backup buffer. size_t new_size; size_t old_size = egptr() - eback(); new_size = 2 * old_size; char* new_buf = new char [new_size]; memcpy(new_buf+(new_size-old_size), eback(), old_size); delete [] eback(); setg(new_buf, new_buf+(new_size-old_size), new_buf+new_size); _aux_limit = _gptr; } } _gptr--; if (c != EOF && *_gptr != c) *_gptr = c; return (unsigned char)*_gptr; } unsigned __adjust_column(unsigned start, const char *line, int count) { register const char *ptr = line + count; while (ptr > line) if (*--ptr == '\n') return line + count - ptr - 1; return start + count; } int ios::readable() { return !(rdbuf()->_flags & _S_NO_READS); } int ios::writable() { return !(rdbuf()->_flags & _S_NO_WRITES); } int ios::is_open() { return rdbuf() && (rdbuf()->_flags & _S_NO_READS+_S_NO_WRITES) != _S_NO_READS+_S_NO_WRITES; } #if defined(linux) #define IO_CLEANUP ; #endif #ifdef IO_CLEANUP IO_CLEANUP #else struct __io_defs { __io_defs() { } ~__io_defs() { streambuf::flush_all(); } }; __io_defs io_defs__;
int streambuf::sync() { if (gptr() == egptr() && pptr() == pbase()) return 0; return EOF; }
/** * Removes @c n characters from the beginning of the input sequence. * * @throws std::length_error If <tt>n > size()</tt>. */ void consume(std::size_t n) { if (gptr() + n > pptr()) n = pptr() - gptr(); gbump(static_cast<int>(n)); }
int stdiobuf::underflow() { /*************************/ // Handle allocating a buffer, if required. // Handle filling the get area of the streambuf. // Read more stuff from the input device. // Return the first character read. char *ptr; int len; __lock_it( __b_lock ); // Flush any output waiting in the buffer: if( out_waiting() > 0 ) { if( sync() == EOF ) { return( EOF ); } } // discard put area setp( NULL, NULL ); // Try to allocate a buffer: if( base() == NULL ) { if( allocate() == EOF ) { return( EOF ); } if( base() == NULL ) { // unbuffered special case ptr = __unbuffered_get_area + DEFAULT_PUTBACK_SIZE; setg( __unbuffered_get_area, ptr, ptr ); int ch; ch = fgetc( __file_pointer ); if( ch == EOF ) { return( EOF ); } else { *egptr() = (char)ch; } setg( eback(), gptr(), egptr() + 1 ); return( *gptr() ); } else { ptr = base() + DEFAULT_PUTBACK_SIZE; setg( base(), ptr, ptr ); } } else if( gptr() >= egptr() ) { ptr = base() + DEFAULT_PUTBACK_SIZE; setg( base(), ptr, ptr ); } len = (__huge_ptr_int)(ebuf() - egptr()); if( len > 0 ) { len = 1; int ch; ch = fgetc( __file_pointer ); if( ch == EOF ) { return( EOF ); } else { *egptr() = (char)ch; } } else { len = 0; } setg( eback(), gptr(), egptr() + len ); return( gptr() < egptr() ? *gptr() : EOF ); }
int strstreambuf::doallocate() { char *oldbuf; int oldbufsize; char *newbuf; int newbufsize; size_t base_offset, ptr_offset, end_offset; __lock_it( __b_lock ); if( !__dynamic || __frozen ) { return( EOF ); } oldbuf = base(); oldbufsize = blen(); if( __allocation_size <= oldbufsize ) { newbufsize = oldbufsize + DEFAULT_MAINBUF_SIZE; } else { newbufsize = __allocation_size; } if( __alloc_fn == NULL ) { newbuf = new char [newbufsize]; } else { newbuf = (char *) __alloc_fn( newbufsize ); } if( newbuf == NULL ) { return( EOF ); } setb( newbuf, newbuf + newbufsize, false ); // Copy the get area. This can be done directly by copying bytes and // setting new pointers. The size of the get area does not change. if( eback() != NULL ) { base_offset = (__huge_ptr_int)(eback() - oldbuf); ptr_offset = (__huge_ptr_int)(gptr() - oldbuf); end_offset = (__huge_ptr_int)(egptr() - oldbuf); ::memcpy( newbuf+base_offset, eback(), end_offset-base_offset ); setg( newbuf+base_offset, newbuf+ptr_offset, newbuf+end_offset ); } // Copy the put area. This can be done directly by copying bytes and // setting new pointers. Add the extra bytes allocated above to the // end of the put area. if( pbase() == NULL ) { setp( newbuf, newbuf + newbufsize ); } else { base_offset = (__huge_ptr_int)(pbase() - oldbuf); ptr_offset = (__huge_ptr_int)(pptr() - oldbuf); end_offset = (__huge_ptr_int)(epptr() - oldbuf); ::memcpy( newbuf+base_offset, pbase(), end_offset-base_offset ); end_offset += newbufsize - oldbufsize; // grow the put area setp( newbuf+base_offset, newbuf+end_offset ); pbump( ptr_offset - base_offset ); } // Free the old buffer. if( oldbuf != NULL ) { if( __free_fn == NULL ) { delete [] oldbuf; } else { __free_fn( oldbuf ); } } return( __NOT_EOF ); }
memrdbuf::pos_type memrdbuf::ff_to(pos_type target) { while (pos_ + egptr() - eback() < target) if (underflow() == traits_type::eof()) return pos_ + egptr() - gptr(); setg(eback(), eback() + target - pos_, egptr()); return target; }
streamsize CConn_Streambuf::xsgetn(CT_CHAR_TYPE* buf, streamsize m) { if (!m_Conn) return 0; // flush output buffer, if tied up to it if (m_Tie && x_sync() != 0) return 0; if (m < 0) return 0; _ASSERT((Uint8) m < numeric_limits<size_t>::max()); size_t n = (size_t) m; size_t n_read; if (n) { // first, read from the memory buffer n_read = (size_t)(egptr() - gptr()); if (n_read > n) n_read = n; memcpy(buf, gptr(), n_read); gbump(int(n_read)); n -= n_read; if (!n) return (streamsize) n_read; buf += n_read; } else n_read = 0; do { // next, read from the connection size_t x_toread = n && n < m_BufSize ? m_BufSize : n; CT_CHAR_TYPE* x_buf = n < m_BufSize ? m_ReadBuf : buf; size_t x_read; m_Status = CONN_Read(m_Conn, x_buf, x_toread, &x_read, eIO_ReadPlain); _ASSERT(x_read <= x_toread); if (!x_read) { _ASSERT(!x_toread || m_Status != eIO_Success); if (m_Status != eIO_Success && m_Status != eIO_Closed) ERR_POST_X(10, x_Message("xsgetn(): CONN_Read() failed")); break; } x_GPos += (CT_OFF_TYPE) x_read; // satisfy "usual backup condition", see standard: 27.5.2.4.3.13 if (x_buf == m_ReadBuf) { size_t xx_read = x_read; if (x_read > n) x_read = n; memcpy(buf, m_ReadBuf, x_read); setg(m_ReadBuf, m_ReadBuf + x_read, m_ReadBuf + xx_read); } else { _ASSERT(x_read <= n); size_t xx_read = x_read > m_BufSize ? m_BufSize : x_read; memcpy(m_ReadBuf, buf + x_read - xx_read, xx_read); setg(m_ReadBuf, m_ReadBuf + xx_read, m_ReadBuf + xx_read); } n_read += x_read; if (m_Status != eIO_Success) break; buf += x_read; n -= x_read; } while (n); return (streamsize) n_read; }
uint64_t tellg() const { return streamreadpos - (egptr()-gptr()); }
int DataIStreamBuf::underflow() { return (gptr() < egptr()) ? static_cast<unsigned char>(*gptr()) : EOF; // need a static_cast so a -1 doesn't turn into an EOF }
uint64_t tellg() const { // std::cerr << "here." << std::endl; return streamreadpos - (egptr()-gptr()); }
streampos filebuf::seekoff(streamoff offset, _seek_dir dir, int mode) { streampos result, new_offset, delta; _G_ssize_t count; if (mode == 0) // Don't move any pointers. dir = ios::cur, offset = 0; // Flush unwritten characters. // (This may do an unneeded write if we seek within the buffer. // But to be able to switch to reading, we would need to set // egptr to ptr. That can't be done in the current design, // which assumes file_ptr() is eGptr. Anyway, since we probably // end up flushing when we close(), it doesn't make much difference.) if (pptr() > pbase() || put_mode()) if (switch_to_get_mode()) return EOF; if (base() == NULL) { doallocbuf(); setp(base(), base()); setg(base(), base(), base()); } switch (dir) { case ios::cur: if (_fb._offset < 0) { _fb._offset = sys_seek(0, ios::cur); if (_fb._offset < 0) return EOF; } // Make offset absolute, assuming current pointer is file_ptr(). offset += _fb._offset; offset -= _egptr - _gptr; if (in_backup()) offset -= _other_egptr - _other_gbase; dir = ios::beg; break; case ios::beg: break; case ios::end: struct stat st; if (sys_stat(&st) == 0 && S_ISREG(st.st_mode)) { offset += st.st_size; dir = ios::beg; } else goto dumb; } // At this point, dir==ios::beg. // If destination is within current buffer, optimize: if (_fb._offset >= 0 && _eback != NULL) { // Offset relative to start of main get area. fpos_t rel_offset = offset - _fb._offset + (eGptr()-Gbase()); if (rel_offset >= 0) { if (in_backup()) switch_to_main_get_area(); if (rel_offset <= _egptr - _eback) { setg(base(), base() + rel_offset, egptr()); setp(base(), base()); return offset; } // If we have streammarkers, seek forward by reading ahead. if (have_markers()) { int to_skip = rel_offset - (_gptr - _eback); if (ignore(to_skip) != to_skip) goto dumb; return offset; } } if (rel_offset < 0 && rel_offset >= Bbase() - Bptr()) { if (!in_backup()) switch_to_backup_area(); gbump(_egptr + rel_offset - gptr()); return offset; } } unsave_markers(); // Try to seek to a block boundary, to improve kernel page management. new_offset = offset & ~(ebuf() - base() - 1); delta = offset - new_offset; if (delta > ebuf() - base()) { new_offset = offset; delta = 0; } result = sys_seek(new_offset, ios::beg); if (result < 0) return EOF; if (delta == 0) count = 0; else { count = sys_read(base(), ebuf()-base()); if (count < delta) { // We weren't allowed to read, but try to seek the remainder. offset = count == EOF ? delta : delta-count; dir = ios::cur; goto dumb; } } setg(base(), base()+delta, base()+count); setp(base(), base()); _fb._offset = result + count; xflags(xflags() & ~ _S_EOF_SEEN); return offset; dumb: unsave_markers(); result = sys_seek(offset, dir); if (result != EOF) { xflags(xflags() & ~_S_EOF_SEEN); } _fb._offset = result; setg(base(), base(), base()); setp(base(), base()); return result; }
streampos rpcbuf::seekoff(streamoff offset, ios::seek_dir dir, int mode) { #else streampos rpcbuf::seekoff(streamoff offset, seek_dir dir, int mode) { #endif if (!_opened || !gptr()) { return EOF; } if (offset != 0 || dir != ios::cur || mode != ios::in) { return EOF; } return (streampos)gptr(); } // Refuse any attempt to set the buffers for storing incoming and // outgoing RPC requests because we need the ability to dynamically // expand the buffers' sizes. streambuf* rpcbuf::setbuf(char*, int) { return nil; } // Dynamically allocate two separate buffers for storing incoming and // outgoing RPC requests. Allocating separate buffers for the get and // put areas makes it easier to expand either area later if necessary. int rpcbuf::doallocate() { const int RPCBUFSIZE = 2032; char* get = new char[RPCBUFSIZE]; if (!get) { error("rpcbuf::doallocate: out of memory"); return EOF; } setb(get, get + RPCBUFSIZE, true); setg(get, get, get); char* put = new char[RPCBUFSIZE]; if (!put) { error("rpcbuf::doallocate: out of memory"); return EOF; } setp(put, put + RPCBUFSIZE); setr(nil); return 0; } // Expand the get area to make room for a large incoming request. boolean rpcbuf::expand_g(int newsize) { char* get = new char[newsize]; if (!get) { return false; } int navail = in_avail(); Memory::copy(gptr(), get, navail); delete eback(); setb(get, get + newsize, true); setg(get, get, get + navail); return true; }
toktype yylex() { register ptrall bufptr; register toktype val; register struct exp *locxp; bufptr = tokptr; /*copy in the global value*/ top: if (bufptr < tokub){ gtoken(val, bufptr); switch(yylval = val){ case PARSEEOF : yylval = val = PARSEEOF; break; case INT: locxp = xp++; glong(locxp->xvalue, bufptr); makevalue: locxp->xtype = XABS; locxp->xloc = 0; locxp->xname = NULL; yylval = (int)locxp; break; case FLTNUM: /*case patched on 3-Jan-80*/ locxp = xp++; gdouble(locxp->doubval.dvalue, bufptr); /* * We make sure that locxp->xvalue * is not in the range suitable for * a short literal. The field * xvalue is only used for * integers, not doubles, but when * we test for short literals * in ascode.c, we look * at the field xvalue when * it encounters an in line * floating number. Ergo, * give it a bad value. */ locxp->xvalue = -1; goto makevalue; case NAME: gptr(yylval, bufptr); lastnam = (struct symtab *)yylval; break; case SIZESPEC: case REG: case INSTn: case INST0: gchar(yylval, bufptr); break; case IJXXX: gchar(yylval, bufptr); gptr(lastjxxx, bufptr); break; case ILINESKIP: gint(yylval, bufptr); lineno += yylval; goto top; case SKIP: eatskiplg(bufptr); goto top; case VOID: goto top; case STRING: strptr = &strbuf[strno ^= 1]; strptr->str_lg = *((lgtype *)bufptr); movestr(&strptr->str[0], (char *)bufptr + sizeof(lgtype), strptr->str_lg); eatstrlg(bufptr); yylval = (int)strptr; break; case ISTAB: case ISTABSTR: case ISTABNONE: case ISTABDOT: case IALIGN: gptr(yylval, bufptr); break; } /*end of the switch*/ #ifdef DEBUG if (toktrace) switch(val){ case INT: printf("Class integer val %d\n", ((struct exp *)yylval)->xvalue); break; case FLTNUM: printf("Class floating point num value %4.3f\n", ((struct exp *)yylval) -> doubval.dvalue); break; case NAME: printf("Class name, \"%.8s\"\n", ((struct symtab *)yylval)->name); break; case REG: printf("Class register, number %d\n", yylval); break; case INSTn: printf("Class INSTn, %.8s\n", itab[0xFF &yylval]->name); break; case IJXXX: printf("Class IJXXX, %.8s\n", itab[0xFF &yylval]->name); break; case INST0: printf("Class INST0, %.8s\n", itab[0xFF &yylval]->name); break; case STRING: printf("Class string, length %d\n", ((struct strdesc *)yylval)->str_lg); break; default: printf("Pass: %d Tok: %d Other class: %d, 0%o, '%c'\n", passno, bufptr - firsttoken, val,val, val); break; } /*end of the debug switch*/ #endif } /*end of this buffer*/ else { if (useVM){ bufno += 1; emptybuf = emptybuf->tok_next; if (emptybuf == 0){ struct tokbufdesc *newdallop; int i; if (passno == 2) goto badread; emptybuf = newdallop = (struct tokbufdesc *)sbrk( TOKDALLOP*sizeof (struct tokbufdesc)); if (emptybuf == (struct tokbufdesc *)-1) goto badwrite; for (i=0; i < TOKDALLOP; i++){ buftail->tok_next = newdallop; buftail = newdallop; newdallop += 1; } buftail->tok_next = 0; } /*end of need to get more buffers*/ (toktype *)bufptr = &(emptybuf->toks[0]); if (passno == 1) scan_dot_s(emptybuf); } else { /*don't use VM*/ bufno ^= 1; emptybuf = &tokbuf[bufno]; ((toktype *)bufptr) = &(emptybuf->toks[0]); if (passno == 1){ /* * First check if there are things to write * out at all */ if (emptybuf->tok_count >= 0){ if (fwrite(emptybuf, sizeof *emptybuf, 1, tmpfil) != 1){ badwrite: yyerror("Unexpected end of file writing the interpass tmp file"); exit(2); } } scan_dot_s(emptybuf); } else { /*pass 2*/ if (fread(emptybuf, sizeof *emptybuf, 1, tmpfil) != 1){ badread: yyerror("Unexpected end of file while reading the interpass tmp file"); exit(1); } } /*end of pass2*/ } /*end of using a real live file*/ (char *)tokub = (char *)bufptr + emptybuf->tok_count; #ifdef DEBUG firsttoken = bufptr; if (debug) printf("created buffernumber %d with %d tokens\n", bufno, emptybuf->tok_count); #endif goto top; } /*end of reading/creating a new buffer*/ tokptr = bufptr; /*copy back the global value*/ return(val); } /*end of yylex*/
void ParameterInfoPrivateHoard:: fill_hoard(GLuint program, GLenum count_enum, GLenum length_enum, F fptr, G gptr) { GLint count, largest_length; std::vector<char> pname; glGetProgramiv(program, count_enum, &count); if(count > 0) { m_values.resize(count); glGetProgramiv(program, length_enum, &largest_length); ++largest_length; pname.resize(largest_length, '\0'); for(int i = 0; i != count; ++i) { GLsizei name_length, psize; GLenum ptype; int array_index; std::memset(&pname[0], 0, largest_length); fptr(program, i, largest_length, &name_length, &psize, &ptype, &pname[0]); m_values[i].m_type = ptype; m_values[i].m_count = psize; m_values[i].m_name = filter_name(pname.begin(), pname.begin() + name_length, array_index); if(array_index != 0) { /* crazy GL... it lists an element from an array as a unique location, chicken out and add it with the array index: */ m_values[i].m_name = std::string(pname.begin(), pname.begin() + name_length); } m_values[i].m_index = i; m_values[i].m_location = gptr(program, &pname[0]); } /* sort m_values by name and then make our map */ std::sort(m_values.begin(), m_values.end()); for(unsigned int i = 0, endi = m_values.size(); i < endi; ++i) { m_map[m_values[i].m_name] = i; } } }