1/* This is part of libio/iostream, providing -*- C++ -*- input/output.
2Copyright (C) 1993 Free Software Foundation
3
4This file is part of the GNU IO Library.  This library is free
5software; you can redistribute it and/or modify it under the
6terms of the GNU General Public License as published by the
7Free Software Foundation; either version 2, or (at your option)
8any later version.
9
10This library is distributed in the hope that it will be useful,
11but WITHOUT ANY WARRANTY; without even the implied warranty of
12MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13GNU General Public License for more details.
14
15You should have received a copy of the GNU General Public License
16along with this library; see the file COPYING.  If not, write to the Free
17Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19As a special exception, if you link this library with files
20compiled with a GNU compiler to produce an executable, this does not cause
21the resulting executable to be covered by the GNU General Public License.
22This exception does not however invalidate any other reasons why
23the executable file might be covered by the GNU General Public License.
24
25Written by Per Bothner (bothner@cygnus.com). */
26
27#ifndef PARSESTREAM_H
28#define PARSESTREAM_H
29#ifdef __GNUG__
30#pragma interface
31#endif
32#include "streambuf.h"
33
34extern "C++" {
35// A parsebuf is a streambuf optimized for scanning text files.
36// It keeps track of line and column numbers.
37// It is guaranteed to remember the entire current line,
38// as well the '\n'-s on either side of it (if they exist).
39// You can arbitrarily seek (or unget) within this extended line.
40// Other backward seeks are not supported.
41// Normal read semantics are supported (and hence istream operators like >>).
42
43class parsebuf : public streambuf {
44  protected:
45    _IO_off_t pos_at_line_start;
46    long _line_length;
47    unsigned long __line_number;
48    char *buf_start;
49    char *buf_end;
50
51  public:
52    parsebuf *chain;
53
54    // Return column number (raw - don't handle tabs etc).
55    // Retult can be -1, meaning: at '\n' before current line.
56    virtual int tell_in_line();
57
58    // seek to (raw) column I in current line.
59    // Result is new (raw) column position - differs from I if unable to seek.
60    // Seek to -1 tries to seek to before previous LF.
61    virtual int seek_in_line(int i);
62
63    // Note: there is no "current line" initially, until something is read.
64
65    // Current line number, starting with 0.
66    // If tell_in_line()==-1, then line number of next line.
67    int line_number() { return __line_number; }
68
69    // Length of current line, not counting either '\n'.
70    int line_length() { return _line_length; }
71    // Current line - not a copy, so file ops may trash it.
72    virtual char* current_line();
73    virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
74    virtual streambuf* setbuf(char* p, int len);
75  protected:
76    parsebuf() { chain= NULL;
77	__line_number = 0; pos_at_line_start = 0; _line_length = -1; }
78    virtual int pbackfail(int c);
79};
80
81// A string_parsebuf is a parsebuf whose source is a fixed string.
82
83class string_parsebuf : public parsebuf {
84  public:
85    int do_delete;
86    string_parsebuf(char *str, int len, int delete_at_close=0);
87    virtual int underflow();
88    virtual char* current_line();
89    virtual int seek_in_line(int i);
90    virtual int tell_in_line();
91    char *left() const { return base(); }
92    char *right() const { return ebuf(); }
93//    streampos seekoff(streamoff, _seek_dir, int);
94};
95
96// A func_parsebuf calls a given function to get new input.
97// Each call returns an entire NUL-terminated line (without the '\n').
98// That line has been allocated with malloc(), not new.
99// The interface is tailored to the GNU readline library.
100// Example:
101// char* DoReadLine(void* arg)
102// {
103//   char *line = readline((char*)arg); /* 'arg' is used as prompt. */
104//   if line == NULL) { putc('\n', stderr); return NULL; }
105//   if (line[0] != '\0') add_history(line);
106//    return line;
107// }
108// char PromptBuffer[100] = "> ";
109// func_parsebuf my_stream(DoReadLine, PromptBuffer);
110
111typedef char *(*CharReader)(void *arg);
112class istream;
113
114class func_parsebuf : public parsebuf {
115  public:
116    void *arg;
117    CharReader read_func;
118    int backed_up_to_newline;
119    func_parsebuf(CharReader func, void *argm = NULL);
120    int underflow();
121    virtual int tell_in_line();
122    virtual int seek_in_line(int i);
123    virtual char* current_line();
124};
125
126// A general_parsebuf is a parsebuf which gets its input from some
127// other streambuf. It explicitly buffers up an entire line.
128
129class general_parsebuf : public parsebuf {
130  public:
131    streambuf *sbuf;
132    int delete_buf; // Delete sbuf when destroying this.
133    general_parsebuf(streambuf *buf, int delete_arg_buf = 0);
134    int underflow();
135    virtual int tell_in_line();
136    virtual int seek_in_line(int i);
137    ~general_parsebuf();
138    virtual char* current_line();
139};
140
141#if 0
142class parsestream : public istream {
143    streammarker marks[2];
144    short _first; // of the two marks; either 0 or 1
145    int _lineno;
146    int first() { return _first; }
147    int second() { return 1-_first; }
148    int line_length() { marks[second].delta(marks[first]); }
149    int line_length() { marks[second].delta(marks[first]); }
150    int seek_in_line(int i);
151    int tell_in_line();
152    int line_number();
153};
154#endif
155} // extern "C++"
156#endif /*!defined(PARSESTREAM_H)*/
157