inline byte FileInputStream::read_bit_as_byte( )
{
if ( !eof && buffered_count == next_unread && buffered_bits_count == 0 )
{
load_bytes( );
}
if ( end_of_stream( ) )
{
return false;
}
if ( buffered_bits_count == 0 )
{
buffered_bits = buffered_bytes[next_unread++];
buffered_bits_count = 8;
}
byte result = buffered_bits >> 7;
buffered_bits <<= 1;
--buffered_bits_count;
++position;
return result;
}
// Try to advance iterator 'distance' incremenets forwards.
// Throw if we prematurely reach the end.
static void check_distance(
Iterator it, const Iterator end, size_t distance)
{
for (size_t i = 0; i < distance; ++i)
{
// Is this a valid byte?
if (it == end)
throw end_of_stream();
// If so move to next value.
++it;
}
}
unsigned int FileInputStream::read_bytes( byte * bytes, unsigned int count )
{
unsigned int read = 0;
while ( !end_of_stream( ) && read < count )
{
byte curr = 0;
for ( int i = 0; i < BITS_COUNT; ++i )
{
curr <<= 1;
byte bit = read_bit_as_byte( );
curr = ( curr + bit );
}
if ( !end_of_stream( ) )
{
bytes[read++] = curr;
}
}
return read;
}
T Stream<T>::nextValue()
{
if (end_of_stream()) return T();
int first, second;
string temp;
char c;
while (__file.read(&c, sizeof(char))) {
if (c == ')') {
temp += c;
if (!__file.eof()) {
__file.read(&c, sizeof(char));
}
break;
}
temp += c;
}
sscanf(temp.c_str(), "(%d %d)", &first, &second);
return T(first, second);
}
gboolean child_out_handler(
GIOChannel *source,
GIOCondition condition,
gpointer data )
{
data_bucket b = (data_bucket)data;
gboolean rv = TRUE;
switch( condition )
{
case G_IO_IN:
case G_IO_PRI:
{
gchar *line;
gsize len, term_pos;
GError *err = NULL;
GIOStatus stat = g_io_channel_read_line(
source, &line, &len, &term_pos, &err );
switch( stat )
{
case G_IO_STATUS_NORMAL:
{
if( source == b->out_source )
{
read_line_result_ rval;
read_line( b, line, &err, &rval );
/* do something with rval */
// g_free( rval.name );
// g_free( rval.original_string );
}
else if( source == b->err_source )
{
printf( "child stderr: >%s", line );
}
break;
}
case G_IO_STATUS_EOF:
end_of_stream( source, b );
rv = FALSE;
break;
case G_IO_STATUS_ERROR:
case G_IO_STATUS_AGAIN:
printf( "G_IO error of some sort. Must improve error handling\n" );
abort();
break;
default: abort(); /* There is a case for every legal value */
}
if( line != NULL )
{
g_free( line );
}
break;
}
case G_IO_HUP:
end_of_stream( source, b );
rv = FALSE;
break;
case G_IO_OUT: printf( "Shouldn't be getting G_IO_OUT events on an input stream!\n" ); break;
case G_IO_ERR: printf( "err!\n" ); break;
case G_IO_NVAL: printf( "nval!\n" ); break;
default: abort(); /* There is a case for every legal value */
}
return rv;
}
_nc_get_token(bool silent)
{
static const char terminfo_punct[] = "@%&*!#";
long number;
int type;
int ch;
char *numchk;
char numbuf[80];
unsigned found;
static char buffer[MAX_ENTRY_SIZE];
char *ptr;
int dot_flag = FALSE;
long token_start;
if (pushtype != NO_PUSHBACK) {
int retval = pushtype;
_nc_set_type(pushname);
DEBUG(3, ("pushed-back token: `%s', class %d",
_nc_curr_token.tk_name, pushtype));
pushtype = NO_PUSHBACK;
pushname[0] = '\0';
/* currtok wasn't altered by _nc_push_token() */
return (retval);
}
if (end_of_stream())
return (EOF);
start_token:
token_start = stream_pos();
while ((ch = next_char()) == '\n' || iswhite(ch))
continue;
ch = eat_escaped_newline(ch);
if (ch == EOF)
type = EOF;
else {
/* if this is a termcap entry, skip a leading separator */
if (separator == ':' && ch == ':')
ch = next_char();
if (ch == '.'
#if NCURSES_EXT_FUNCS
&& !_nc_disable_period
#endif
) {
dot_flag = TRUE;
DEBUG(8, ("dot-flag set"));
while ((ch = next_char()) == '.' || iswhite(ch))
continue;
}
if (ch == EOF) {
type = EOF;
goto end_of_token;
}
/* have to make some punctuation chars legal for terminfo */
if (!isalnum(ch)
#if NCURSES_EXT_FUNCS
&& !(ch == '.' && _nc_disable_period)
#endif
&& !strchr(terminfo_punct, (char) ch)) {
if (!silent)
_nc_warning("Illegal character (expected alphanumeric or %s) - %s",
terminfo_punct, unctrl((chtype) ch));
_nc_panic_mode(separator);
goto start_token;
}
ptr = buffer;
*(ptr++) = ch;
if (first_column) {
char *desc;
_nc_comment_start = token_start;
_nc_comment_end = _nc_curr_file_pos;
_nc_start_line = _nc_curr_line;
_nc_syntax = ERR;
while ((ch = next_char()) != '\n') {
if (ch == EOF)
_nc_err_abort("premature EOF");
else if (ch == ':' && last_char() != ',') {
_nc_syntax = SYN_TERMCAP;
separator = ':';
break;
} else if (ch == ',') {
_nc_syntax = SYN_TERMINFO;
separator = ',';
/*
* Fall-through here is not an accident. The idea is that
* if we see a comma, we figure this is terminfo unless we
* subsequently run into a colon -- but we don't stop
* looking for that colon until hitting a newline. This
* allows commas to be embedded in description fields of
* either syntax.
*/
/* FALLTHRU */
} else
ch = eat_escaped_newline(ch);
*ptr++ = ch;
}
ptr[0] = '\0';
if (_nc_syntax == ERR) {
/*
* Grrr...what we ought to do here is barf, complaining that
* the entry is malformed. But because a couple of name fields
* in the 8.2 termcap file end with |\, we just have to assume
* it's termcap syntax.
*/
_nc_syntax = SYN_TERMCAP;
separator = ':';
} else if (_nc_syntax == SYN_TERMINFO) {
/* throw away trailing /, *$/ */
for (--ptr; iswhite(*ptr) || *ptr == ','; ptr--)
continue;
ptr[1] = '\0';
}
/*
* This is the soonest we have the terminal name fetched. Set up
* for following warning messages.
*/
ptr = strchr(buffer, '|');
if (ptr == (char *) NULL)
ptr = buffer + strlen(buffer);
ch = *ptr;
*ptr = '\0';
_nc_set_type(buffer);
*ptr = ch;
/*
* Compute the boundary between the aliases and the description
* field for syntax-checking purposes.
*/
desc = strrchr(buffer, '|');
if (!silent && desc) {
if (*desc == '\0')
_nc_warning("empty longname field");
else if (strchr(desc, ' ') == (char *) NULL)
_nc_warning("older tic versions may treat the description field as an alias");
}
if (!desc)
desc = buffer + strlen(buffer);
/*
* Whitespace in a name field other than the long name can confuse
* rdist and some termcap tools. Slashes are a no-no. Other
* special characters can be dangerous due to shell expansion.
*/
for (ptr = buffer; ptr < desc; ptr++) {
if (isspace(CharOf(*ptr))) {
if (!silent)
_nc_warning("whitespace in name or alias field");
break;
} else if (*ptr == '/') {
if (!silent)
_nc_warning("slashes aren't allowed in names or aliases");
break;
} else if (strchr("$[]!*?", *ptr)) {
if (!silent)
_nc_warning("dubious character `%c' in name or alias field", *ptr);
break;
}
}
ptr = buffer;
_nc_curr_token.tk_name = buffer;
type = NAMES;
} else {
while ((ch = next_char()) != EOF) {
if (!isalnum(ch)) {
if (_nc_syntax == SYN_TERMINFO) {
if (ch != '_')
break;
} else { /* allow ';' for "k;" */
if (ch != ';')
break;
}
}
*(ptr++) = ch;
}
*ptr++ = '\0';
switch (ch) {
case ',':
case ':':
if (ch != separator)
_nc_err_abort("Separator inconsistent with syntax");
_nc_curr_token.tk_name = buffer;
type = BOOLEAN;
break;
case '@':
if ((ch = next_char()) != separator && !silent)
_nc_warning("Missing separator after `%s', have %s",
buffer, unctrl((chtype) ch));
_nc_curr_token.tk_name = buffer;
type = CANCEL;
break;
case '#':
found = 0;
while (isalnum(ch = next_char())) {
numbuf[found++] = ch;
if (found >= sizeof(numbuf) - 1)
break;
}
numbuf[found] = '\0';
number = strtol(numbuf, &numchk, 0);
if (!silent) {
if (numchk == numbuf)
_nc_warning("no value given for `%s'", buffer);
if ((*numchk != '\0') || (ch != separator))
_nc_warning("Missing separator");
}
_nc_curr_token.tk_name = buffer;
_nc_curr_token.tk_valnumber = number;
type = NUMBER;
break;
case '=':
ch = _nc_trans_string(ptr, buffer + sizeof(buffer));
if (!silent && ch != separator)
_nc_warning("Missing separator");
_nc_curr_token.tk_name = buffer;
_nc_curr_token.tk_valstring = ptr;
type = STRING;
break;
case EOF:
type = EOF;
break;
default:
/* just to get rid of the compiler warning */
type = UNDEF;
if (!silent)
_nc_warning("Illegal character - %s", unctrl((chtype) ch));
}
} /* end else (first_column == FALSE) */
} /* end else (ch != EOF) */
end_of_token:
#ifdef TRACE
if (dot_flag == TRUE)
DEBUG(8, ("Commented out "));
if (_nc_tracing >= DEBUG_LEVEL(7)) {
switch (type) {
case BOOLEAN:
_tracef("Token: Boolean; name='%s'",
_nc_curr_token.tk_name);
break;
case NUMBER:
_tracef("Token: Number; name='%s', value=%d",
_nc_curr_token.tk_name,
_nc_curr_token.tk_valnumber);
break;
case STRING:
_tracef("Token: String; name='%s', value=%s",
_nc_curr_token.tk_name,
_nc_visbuf(_nc_curr_token.tk_valstring));
break;
case CANCEL:
_tracef("Token: Cancel; name='%s'",
_nc_curr_token.tk_name);
break;
case NAMES:
_tracef("Token: Names; value='%s'",
_nc_curr_token.tk_name);
break;
case EOF:
_tracef("Token: End of file");
break;
default:
_nc_warning("Bad token type");
}
}
#endif
if (dot_flag == TRUE) /* if commented out, use the next one */
type = _nc_get_token(silent);
DEBUG(3, ("token: `%s', class %d",
_nc_curr_token.tk_name != 0 ? _nc_curr_token.tk_name :
"<null>",
type));
return (type);
}
