void unget_string(char *str) { if (*str != '\0') { unget_string(str+1); ungetch(*str); } }
static int post_preproc( char * out ) /* * Convert digraphs and double '\\' of the second byte of SJIS (BIGFIVE or * ISO2022_JP). * Note: Output of -K option embeds macro informations into comments. * scan_token() does not recognize comment and parses it as '/', '*', etc. */ { #if ! HAVE_DIGRAPHS int di_count = 0; #endif int token_type; int c; char * str; char * cp = out; unget_string( out, NULL); while ((c = get_ch()) != '\n') { /* Not to read over to next line */ if (char_type[ c] & HSP) { *cp++ = c; continue; } str = cp; token_type = scan_token( c, &cp, out_wend); switch (token_type) { #if ! MBCHAR_IS_ESCAPE_FREE case WSTR : case WCHR : str++; /* Skip prefix 'L' */ /* Fall through */ case STR : case CHR : if (bsl_need_escape) cp = esc_mbchar( str, cp); break; #endif /* ! MBCHAR_IS_ESCAPE_FREE */ #if ! HAVE_DIGRAPHS case OPE : if (mcpp_mode == STD && (openum & OP_DIGRAPH)) { cp = conv_a_digraph( cp); /* Convert a digraph */ di_count++; } break; #endif } } *cp++ = '\n'; *cp = EOS; #if ! HAVE_DIGRAPHS if (mcpp_mode == STD && di_count && (warn_level & 16)) cwarn( "%.0s%ld digraph(s) converted" /* _W16_ */ , NULL, (long) di_count, NULL); #endif return 0; }
static void devide_line( char * out /* 'out' is 'output' in actual */ ) /* * Devide a too long line into output lines shorter than NWORK. * This routine is called from putout(). */ { FILEINFO * file; char * save; char * wp; int c; file = unget_string( out, NULL); /* To re-read the line */ wp = out_ptr = out; while ((c = get_ch()), file == infile) { if (char_type[ c] & HSP) { if (keep_spaces || out == out_ptr || (char_type[ *(out_ptr - 1) & UCHARMAX] & HSP)) { *out_ptr++ = c; wp++; } continue; } scan_token( c, &wp, out_wend); /* Read a token */ if (NWORK-2 < wp - out_ptr) { /* Too long a token */ cfatal( "Too long token %s", out_ptr, 0L, NULL); /* _F_ */ } else if (out_end <= wp) { /* Too long line */ if (mcpp_debug & MACRO_CALL) { /* -K option */ /* Other than GCC or Visual C */ /* scan_token() scans a comment as sequence of some */ /* tokens such as '/', '*', ..., '*', '/', since it */ /* does not expect comment. */ save = out_ptr; while ((save = strrchr( save, '/')) != NULL) { if (*(save - 1) == '*') { /* '*' '/' sequence */ out_ptr = save + 1; /* Devide at the end*/ break; /* of a comment*/ } } } save = save_string( out_ptr); /* Save the token */ *out_ptr++ = '\n'; /* Append newline */ *out_ptr = EOS; put_a_line( out); /* Putout the former tokens */ wp = out_ptr = stpcpy( out, save); /* Restore the token */ free( save); } else { /* Still in size */ out_ptr = wp; /* Advance the pointer */ } } unget_ch(); /* Push back the source character */ put_a_line( out); /* Putout the last tokens */ sharp( NULL, 0); /* Correct line number */ }
int my_scan(streambuf* sb) { char buffer[20]; // Try reading "hounddog": int count; count = sb->sgetn(buffer, 8); if (count == 8 && strncmp(buffer, "hounddog", 8) == 0) return 3; // No, no "hounddog": Backup to 'fence' ... unget_string(sb, buffer, count); // ... and try reading "dog": count = sb->sgetn(buffer, 3); if (count == 3 && strncmp(buffer, "dog", 3) == 0) return 1; // No, no "dog" either: Backup to 'fence' ... unget_string(sb, buffer, count); // ... and try reading "hound": count = sb->sgetn(buffer, 5); if (count == 5 && strncmp(buffer, "hound", 5) == 0) return 2; // No, no "hound" either: Backup to 'fence' and signal failure. unget_string(sb, buffer, count); return -1; }
int main(int argc, char **argv) { char **zeroth = argv; ungetch('\n'); argv += argc - 1; while (argv != zeroth) { ungetch(' '); unget_string(*argv); argv--; } execute_line(); return 0; }
VIOAPI Status mni_input_int( FILE *file, int *i ) { Status status; STRING str; status = mni_input_string( file, &str, (char) ' ', (char) ';' ); if( status == OK && sscanf( str, "%d", i ) != 1 ) { unget_string( file, str ); status = ERROR; } delete_string( str ); return( status ); }
VIOAPI Status mni_input_real( FILE *file, Real *d ) { Status status; STRING str; status = mni_input_string( file, &str, (char) ' ', (char) ';' ); if( status == OK && sscanf( str, "%lf", d ) != 1 ) { unget_string( file, str ); status = ERROR; } delete_string( str ); return( status ); }
static void do_pragma_op( void) /* * Execute the _Pragma() operator contained in an expanded macro. * Note: _Pragma() operator is also implemented as a special macro. Therefore * it is always searched as a macro. * There might be more than one _Pragma() in a expanded macro and those may be * surrounded by other token sequences. * Since all the macros have been expanded completely, any name identical to * macro should not be re-expanded. * However, a macro in the string argument of _Pragma() may be expanded by * do_pragma() after de_stringize(), if EXPAND_PRAGMA == TRUE. */ { FILEINFO * file; DEFBUF * defp; int prev = output < out_ptr; /* There is a previous sequence */ int token_type; char * cp1, * cp2; int c; file = unget_string( out_ptr, NULL); while (c = get_ch(), file == infile) { if (char_type[ c] & HSP) { *out_ptr++ = c; continue; } if (scan_token( c, (cp1 = out_ptr, &cp1), out_wend) == NAM && (defp = is_macro( &cp1)) != NULL && defp->nargs == DEF_PRAGMA) { /* _Pragma() operator */ if (prev) { putout( output); /* Putout the previous sequence */ cp1 = stpcpy( output, "pragma "); /* From top of buffer */ } /* is_macro() already read over possible spaces after _Pragma */ *cp1++ = get_ch(); /* '(' */ while (char_type[ c = get_ch()] & HSP) *cp1++ = c; if (((token_type = scan_token( c, (cp2 = cp1, &cp1), out_wend)) != STR && token_type != WSTR)) { /* Not a string literal */ put_seq( output, cp1); return; } workp = de_stringize( cp2, work_buf); while (char_type[ c = get_ch()] & HSP) *cp1++ = c; if (c != ')') { /* More than a string literal */ unget_ch(); put_seq( output, cp1); return; } strcpy( workp, "\n"); /* Terminate with <newline> */ unget_string( work_buf, NULL); do_pragma(); /* Do the #pragma "line" */ infile->bptr += strlen( infile->bptr); /* Clear sequence */ cp1 = out_ptr = output; /* From the top of buffer */ prev = FALSE; } else { /* Not pragma sequence */ out_ptr = cp1; prev = TRUE; } } unget_ch(); if (prev) putout( output); }