« back to all changes in this revision
Viewing changes to client/linebuffer.cc
- browse files at revision 1099
- compare with another revision
- compare with revision 1757.1.2
- download diff
- download tarball
- view history from revision 1099
- Committer: Brian Aker
- Date: 2009-07-23 00:02:03 UTC
- mfrom: (1093.1.25 captain)
- Revision ID: brian@gaz-20090723000203-kkrx4udjiiwy869o
Mege Jay
- files renamed:
- client/readline.cc => client/linebuffer.cc
- client/my_readline.h => client/linebuffer.h
- files modified:
- Makefile.am
added
removed
client/linebuffer.cc
17
17
18
18
#include <drizzled/global.h>
19
19
#include <mysys/my_sys.h>
20
#include <mystrings/m_string.h>
21
#include "client/my_readline.h"
20
#include "client/linebuffer.h"
21
22
#include <vector>
22
23
23
24
using namespace std;
24
25
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)
48
{
49
char *pos;
50
uint32_t out_length;
51
52
if (!(pos=intern_read_line(line_buff,&out_length)))
53
return 0;
54
if (out_length && pos[out_length-1] == '\n')
55
if (--out_length && pos[out_length-1] == '\r') /* Remove '\n' */
56
out_length--; /* Remove '\r' */
57
line_buff->read_length=out_length;
58
pos[out_length]=0;
59
return pos;
60
}
61
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)
141
{
142
size_t read_count;
143
uint32_t bufbytes= (uint32_t) (buffer->end - buffer->start_of_line);
144
145
if (buffer->eof)
146
return 0; /* Everything read */
147
148
/* See if we need to grow the buffer. */
149
150
for (;;)
151
{
152
uint32_t start_offset=(uint32_t) (buffer->start_of_line - buffer->buffer);
153
read_count=(buffer->bufread - bufbytes)/IO_SIZE;
154
if ((read_count*=IO_SIZE))
155
break;
156
buffer->bufread *= 2;
157
if (!(buffer->buffer = (char*) realloc(buffer->buffer,
158
buffer->bufread+1)))
159
return (uint32_t) -1;
160
buffer->start_of_line=buffer->buffer+start_offset;
161
buffer->end=buffer->buffer+bufbytes;
162
}
163
164
/* Shift stuff down. */
165
if (buffer->start_of_line != buffer->buffer)
166
{
167
memmove(buffer->buffer, buffer->start_of_line, (uint32_t) bufbytes);
168
buffer->end=buffer->buffer+bufbytes;
169
}
170
171
/* Read in new stuff. */
172
if ((read_count= my_read(buffer->file, (unsigned char*) buffer->end, read_count,
173
MYF(MY_WME))) == MY_FILE_ERROR)
174
return (size_t) -1;
175
176
/* Kludge to pretend every nonempty file ends with a newline. */
177
if (!read_count && bufbytes && buffer->end[-1] != '\n')
178
{
179
buffer->eof = read_count = 1;
180
*buffer->end = '\n';
181
}
182
buffer->end_of_line=(buffer->start_of_line=buffer->buffer)+bufbytes;
183
buffer->end+=read_count;
184
*buffer->end=0; /* Sentinel */
185
return read_count;
186
}
187
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)
26
LineBuffer::LineBuffer(uint32_t my_max_size,FILE *my_file)
27
:
28
file(my_file),
29
line(),
30
max_size(my_max_size),
31
eof(false)
32
{
33
line.reserve(max_size);
34
}
35
36
void LineBuffer::addString(const string &str)
37
{
38
buffer << str << endl;
39
}
40
41
char *LineBuffer::readline()
42
{
43
uint32_t read_count;
44
45
if (file && !eof)
46
{
47
if ((read_count= my_read(fileno(file),
48
(unsigned char *) (&line[0]),
49
max_size-1,MYF(MY_WME))))
203
50
{
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 */
51
line[read_count+1]= '\0';
52
buffer << &line[0];
211
53
}
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);
54
else
55
eof= true;
215
56
}
57
58
buffer.getline(&line[0],max_size);
59
60
if (buffer.eof())
61
return 0;
62
else
63
return &line[0];
216
64
}
65
Loggerhead is a web-based interface for Breezy
Version: 2.0.1