« back to all changes in this revision
Viewing changes to client/linebuffer.cc
- browse files at revision 1095.2.1
- compare with another revision
- compare with revision 1130.3.1
- download diff
- download tarball
- view history from revision 1095.2.1
- Committer: Robert Klahn
- Date: 2009-07-17 03:11:10 UTC
- mto: (1093.1.23 captain)
- mto: This revision was merged to the branch mainline in revision 1099.
- Revision ID: rklahn@quad-20090717031110-0sn0vgfk1dzdbwg1
Replace typedef struct LINE_BUFFER with class LineBuffer, encapsulating current logic
- files renamed:
- client/readline.cc => client/linebuffer.cc
- client/my_readline.h => client/linebuffer.h
- files modified:
- Makefile.am
added
removed
client/linebuffer.cc
18
18
#include <drizzled/global.h>
19
19
#include <mysys/my_sys.h>
20
20
#include <mystrings/m_string.h>
21
#include "client/my_readline.h"
21
#include "client/linebuffer.h"
22
23
#include <stdexcept>
22
24
23
25
using namespace std;
24
26
25
static bool init_line_buffer(LINE_BUFFER *buffer,File file,uint32_t size,
26
uint32_t max_size);
27
static bool init_line_buffer_from_string(LINE_BUFFER *buffer,char * str);
28
static size_t fill_buffer(LINE_BUFFER *buffer);
29
static char *intern_read_line(LINE_BUFFER *buffer,uint32_t *out_length);
30
31
32
LINE_BUFFER *batch_readline_init(uint32_t max_size,FILE *file)
33
{
34
LINE_BUFFER *line_buff;
35
if (!(line_buff=(LINE_BUFFER*) malloc(sizeof(*line_buff))))
36
return 0;
37
memset(line_buff, 0, sizeof(*line_buff));
38
if (init_line_buffer(line_buff,fileno(file),IO_SIZE,max_size))
39
{
40
free(line_buff);
41
return 0;
42
}
43
return line_buff;
44
}
45
46
47
char *batch_readline(LINE_BUFFER *line_buff)
27
LineBuffer::LineBuffer(uint32_t my_max_size,FILE *my_file)
28
{
29
if (file)
30
file= fileno(my_file);
31
else
32
file= NULL;
33
bufread= IO_SIZE;
34
max_size= my_max_size;
35
buffer= (char *) malloc(bufread+1);
36
if (buffer == NULL)
37
throw runtime_error("malloc failed");
38
start_of_line= end_of_line= end= buffer;
39
buffer[0]= 0;
40
41
eof= read_length= 0;
42
}
43
44
LineBuffer::~LineBuffer()
45
{
46
free(buffer);
47
}
48
49
void LineBuffer::add_string(const char *str)
50
{
51
uint32_t old_length= (uint32_t) (end - buffer);
52
uint32_t length= (uint32_t) strlen(str);
53
char *tmpptr= (char *) realloc(buffer,old_length+length+2);
54
if (tmpptr == NULL)
55
throw runtime_error("malloc failed");
56
57
buffer= start_of_line= end_of_line= tmpptr;
58
end= buffer + old_length;
59
if (old_length)
60
end[-1]= ' ';
61
memcpy(end, str, length);
62
end[length]= '\n';
63
end[length+1]= 0;
64
end+= length+1;
65
eof= 1;
66
max_size= 1;
67
}
68
69
char *LineBuffer::readline()
48
70
{
49
71
char *pos;
50
72
uint32_t out_length;
51
73
52
if (!(pos=intern_read_line(line_buff,&out_length)))
74
if (!(pos=internal_readline(&out_length)))
53
75
return 0;
54
76
if (out_length && pos[out_length-1] == '\n')
55
77
if (--out_length && pos[out_length-1] == '\r') /* Remove '\n' */
56
78
out_length--; /* Remove '\r' */
57
line_buff->read_length=out_length;
79
read_length=out_length;
58
80
pos[out_length]=0;
59
81
return pos;
60
82
}
61
83
62
63
void batch_readline_end(LINE_BUFFER *line_buff)
64
{
65
if (line_buff)
66
{
67
free(line_buff->buffer);
68
free(line_buff);
69
}
70
}
71
72
73
LINE_BUFFER *batch_readline_command(LINE_BUFFER *line_buff, char * str)
74
{
75
if (!line_buff)
76
{
77
if (!(line_buff=(LINE_BUFFER*) malloc(sizeof(*line_buff))))
78
return 0;
79
memset(line_buff, 0, sizeof(*line_buff));
80
}
81
if (init_line_buffer_from_string(line_buff,str))
82
{
83
free(line_buff);
84
return 0;
85
}
86
return line_buff;
87
}
88
89
90
/*****************************************************************************
91
Functions to handle buffered readings of lines from a stream
92
******************************************************************************/
93
94
static bool
95
init_line_buffer(LINE_BUFFER *buffer,File file,uint32_t size,uint32_t max_buffer)
96
{
97
buffer->file=file;
98
buffer->bufread=size;
99
buffer->max_size=max_buffer;
100
if (!(buffer->buffer = (char*) malloc(buffer->bufread+1)))
101
return 1;
102
buffer->end_of_line=buffer->end=buffer->buffer;
103
buffer->buffer[0]=0; /* For easy start test */
104
return 0;
105
}
106
107
/*
108
init_line_buffer_from_string can be called on the same buffer
109
several times. the resulting buffer will contain a
110
concatenation of all strings separated by spaces
111
*/
112
static bool init_line_buffer_from_string(LINE_BUFFER *buffer,char * str)
113
{
114
uint32_t old_length=(uint32_t)(buffer->end - buffer->buffer);
115
uint32_t length= (uint32_t) strlen(str);
116
char * tmpptr= (char*)realloc(buffer->buffer, old_length+length+2);
117
if (tmpptr == NULL)
118
return 1;
119
120
buffer->buffer= buffer->start_of_line= buffer->end_of_line= tmpptr;
121
buffer->end= buffer->buffer + old_length;
122
if (old_length)
123
buffer->end[-1]=' ';
124
memcpy(buffer->end, str, length);
125
buffer->end[length]= '\n';
126
buffer->end[length+1]= 0;
127
buffer->end+= length+1;
128
buffer->eof=1;
129
buffer->max_size=1;
130
return 0;
131
}
132
133
134
/*
135
Fill the buffer retaining the last n bytes at the beginning of the
136
newly filled buffer (for backward context). Returns the number of new
137
bytes read from disk.
138
*/
139
140
static size_t fill_buffer(LINE_BUFFER *buffer)
84
char *LineBuffer::internal_readline(uint32_t *out_length)
85
{
86
char *pos;
87
size_t length;
88
89
start_of_line=end_of_line;
90
for (;;)
91
{
92
pos=end_of_line;
93
while (*pos != '\n' && *pos)
94
pos++;
95
if (pos == end)
96
{
97
if ((uint32_t) (pos - start_of_line) < max_size)
98
{
99
if (!(length=fill_buffer()) || length == (size_t) -1)
100
return(0);
101
continue;
102
}
103
pos--; /* break line here */
104
}
105
end_of_line= pos+1;
106
*out_length= (uint32_t) (pos + 1 - eof - start_of_line);
107
return(start_of_line);
108
}
109
}
110
111
size_t LineBuffer::fill_buffer()
141
112
{
142
113
size_t read_count;
143
uint32_t bufbytes= (uint32_t) (buffer->end - buffer->start_of_line);
114
uint32_t bufbytes= (uint32_t) (end - start_of_line);
144
115
145
if (buffer->eof)
116
if (eof)
146
117
return 0; /* Everything read */
147
118
148
119
/* See if we need to grow the buffer. */
149
120
150
121
for (;;)
151
122
{
152
uint32_t start_offset=(uint32_t) (buffer->start_of_line - buffer->buffer);
153
read_count=(buffer->bufread - bufbytes)/IO_SIZE;
123
uint32_t start_offset=(uint32_t) (start_of_line - buffer);
124
read_count=(bufread - bufbytes)/IO_SIZE;
154
125
if ((read_count*=IO_SIZE))
155
126
break;
156
buffer->bufread *= 2;
157
if (!(buffer->buffer = (char*) realloc(buffer->buffer,
158
buffer->bufread+1)))
127
bufread *= 2;
128
if (!(buffer = (char*) realloc(buffer, bufread+1)))
159
129
return (uint32_t) -1;
160
buffer->start_of_line=buffer->buffer+start_offset;
161
buffer->end=buffer->buffer+bufbytes;
130
start_of_line= buffer+start_offset;
131
end= buffer+bufbytes;
162
132
}
163
133
164
134
/* Shift stuff down. */
165
if (buffer->start_of_line != buffer->buffer)
135
if (start_of_line != buffer)
166
136
{
167
memmove(buffer->buffer, buffer->start_of_line, (uint32_t) bufbytes);
168
buffer->end=buffer->buffer+bufbytes;
137
memmove(buffer, start_of_line, (uint32_t) bufbytes);
138
end= buffer+bufbytes;
169
139
}
170
140
171
141
/* Read in new stuff. */
172
if ((read_count= my_read(buffer->file, (unsigned char*) buffer->end, read_count,
142
if ((read_count= my_read(file, (unsigned char*) end, read_count,
173
143
MYF(MY_WME))) == MY_FILE_ERROR)
174
144
return (size_t) -1;
175
145
176
146
/* Kludge to pretend every nonempty file ends with a newline. */
177
if (!read_count && bufbytes && buffer->end[-1] != '\n')
147
if (!read_count && bufbytes && end[-1] != '\n')
178
148
{
179
buffer->eof = read_count = 1;
180
*buffer->end = '\n';
149
eof= read_count = 1;
150
*end= '\n';
181
151
}
182
buffer->end_of_line=(buffer->start_of_line=buffer->buffer)+bufbytes;
183
buffer->end+=read_count;
184
*buffer->end=0; /* Sentinel */
152
end_of_line= (start_of_line=buffer)+bufbytes;
153
end+= read_count;
154
*end= 0; /* Sentinel */
185
155
return read_count;
186
156
}
187
157
188
189
190
char *intern_read_line(LINE_BUFFER *buffer,uint32_t *out_length)
191
{
192
char *pos;
193
size_t length;
194
195
196
buffer->start_of_line=buffer->end_of_line;
197
for (;;)
198
{
199
pos=buffer->end_of_line;
200
while (*pos != '\n' && *pos)
201
pos++;
202
if (pos == buffer->end)
203
{
204
if ((uint32_t) (pos - buffer->start_of_line) < buffer->max_size)
205
{
206
if (!(length=fill_buffer(buffer)) || length == (size_t) -1)
207
return(0);
208
continue;
209
}
210
pos--; /* break line here */
211
}
212
buffer->end_of_line=pos+1;
213
*out_length=(uint32_t) (pos + 1 - buffer->eof - buffer->start_of_line);
214
return(buffer->start_of_line);
215
}
216
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1