← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/readline.cc

  • Committer: Brian Aker
  • Date: 2009-02-10 00:14:40 UTC
  • Revision ID: brian@tangent.org-20090210001440-qjg8eofh3h93064b
Adding Multi-threaded Scheduler into the system.

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/readline.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/* readline for batch mode */
17
17
 
18
 
#include "config.h"
19
 
#include "drizzled/internal/my_sys.h"
20
 
#include "client/linebuffer.h"
21
 
#include <boost/version.hpp>
22
 
 
23
 
#include <vector>
 
18
#include <drizzled/global.h>
 
19
#include <mysys/my_sys.h>
 
20
#include <mystrings/m_string.h>
 
21
#include "my_readline.h"
24
22
 
25
23
using namespace std;
26
 
using namespace drizzled;
27
 
 
28
 
LineBuffer::LineBuffer(uint32_t my_max_size,FILE *my_file)
29
 
  :
30
 
    file(my_file),
31
 
    max_size(my_max_size)
32
 
{
33
 
  if (my_file)
34
 
 
35
 
  /*
36
 
    if here beacuse the old way of using file_descriptor is deprecated in boost
37
 
    1.44.  There is a #define to re-enable the function but this is broken in
38
 
    Fedora 14. See https://bugzilla.redhat.com/show_bug.cgi?id=654480
39
 
  */
40
 
#if BOOST_VERSION < 104400
41
 
    file_stream = new boost::iostreams::stream<boost::iostreams::file_descriptor>(fileno(my_file), true);
42
 
#else
43
 
    file_stream = new boost::iostreams::stream<boost::iostreams::file_descriptor>(fileno(my_file), boost::iostreams::never_close_handle);
44
 
#endif
45
 
  else
46
 
    file_stream = new std::stringstream;
47
 
  line.reserve(max_size);
48
 
}
49
 
 
50
 
void LineBuffer::addString(const string &str)
51
 
{
52
 
  (*file_stream) << str << endl;
53
 
}
54
 
 
55
 
char *LineBuffer::readline()
56
 
{
57
 
  file_stream->getline(&line[0], max_size);
58
 
 
59
 
  if (file_stream->fail())
60
 
    return 0;
61
 
  else
62
 
    return &line[0];
63
 
}
64
 
 
 
24
 
 
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
  uint old_length=(uint)(buffer->end - buffer->buffer);
 
115
  uint length= (uint) 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
  uint bufbytes= (uint) (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
    uint start_offset=(uint) (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 (uint) -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, (uint) 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)
 
203
    {
 
204
      if ((uint) (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
}