← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/readline.c

  • Committer: Monty Taylor
  • Date: 2008-08-02 01:03:15 UTC
  • mto: (236.1.42 codestyle)
  • mto: This revision was merged to the branch mainline in revision 261.
  • Revision ID: monty@inaugust.com-20080802010315-65h5938pymg9d99z
Moved m4 macros to top-level m4 dir, per GNU standards (and where gettext wanted it :)

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/readline.c
15
15
 
16
16
/* readline for batch mode */
17
17
 
18
 
#include <drizzled/global.h>
 
18
#include "client_priv.h"
19
19
#include <mysys/my_sys.h>
20
20
#include <mystrings/m_string.h>
21
21
#include "my_readline.h"
22
22
 
23
 
using namespace std;
24
 
 
25
 
static bool init_line_buffer(LINE_BUFFER *buffer,File file,uint32_t size,
26
 
                            uint32_t max_size);
 
23
static bool init_line_buffer(LINE_BUFFER *buffer,File file,ulong size,
 
24
                            ulong max_size);
27
25
static bool init_line_buffer_from_string(LINE_BUFFER *buffer,char * str);
28
26
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)
 
27
static char *intern_read_line(LINE_BUFFER *buffer,ulong *out_length);
 
28
 
 
29
 
 
30
LINE_BUFFER *batch_readline_init(ulong max_size,FILE *file)
33
31
{
34
32
  LINE_BUFFER *line_buff;
35
 
  if (!(line_buff=(LINE_BUFFER*) malloc(sizeof(*line_buff))))
 
33
  if (!(line_buff=(LINE_BUFFER*)
 
34
        my_malloc(sizeof(*line_buff),MYF(MY_WME | MY_ZEROFILL))))
36
35
    return 0;
37
 
  memset(line_buff, 0, sizeof(*line_buff));
38
36
  if (init_line_buffer(line_buff,fileno(file),IO_SIZE,max_size))
39
37
  {
40
 
    free(line_buff);
 
38
    my_free(line_buff,MYF(0));
41
39
    return 0;
42
40
  }
43
41
  return line_buff;
47
45
char *batch_readline(LINE_BUFFER *line_buff)
48
46
{
49
47
  char *pos;
50
 
  uint32_t out_length;
 
48
  ulong out_length;
51
49
 
52
50
  if (!(pos=intern_read_line(line_buff,&out_length)))
53
51
    return 0;
64
62
{
65
63
  if (line_buff)
66
64
  {
67
 
    free(line_buff->buffer);
68
 
    free(line_buff);
 
65
    my_free(line_buff->buffer,MYF(MY_ALLOW_ZERO_PTR));
 
66
    my_free(line_buff,MYF(0));
69
67
  }
70
68
}
71
69
 
73
71
LINE_BUFFER *batch_readline_command(LINE_BUFFER *line_buff, char * str)
74
72
{
75
73
  if (!line_buff)
76
 
  {
77
 
    if (!(line_buff=(LINE_BUFFER*) malloc(sizeof(*line_buff))))
 
74
    if (!(line_buff=(LINE_BUFFER*)
 
75
          my_malloc(sizeof(*line_buff),MYF(MY_WME | MY_ZEROFILL))))
78
76
      return 0;
79
 
    memset(line_buff, 0, sizeof(*line_buff));
80
 
  }
81
77
  if (init_line_buffer_from_string(line_buff,str))
82
78
  {
83
 
    free(line_buff);
 
79
    my_free(line_buff,MYF(0));
84
80
    return 0;
85
81
  }
86
82
  return line_buff;
92
88
******************************************************************************/
93
89
 
94
90
static bool
95
 
init_line_buffer(LINE_BUFFER *buffer,File file,uint32_t size,uint32_t max_buffer)
 
91
init_line_buffer(LINE_BUFFER *buffer,File file,ulong size,ulong max_buffer)
96
92
{
97
93
  buffer->file=file;
98
94
  buffer->bufread=size;
99
95
  buffer->max_size=max_buffer;
100
 
  if (!(buffer->buffer = (char*) malloc(buffer->bufread+1)))
 
96
  if (!(buffer->buffer = (char*) my_malloc(buffer->bufread+1,
 
97
                                           MYF(MY_WME | MY_FAE))))
101
98
    return 1;
102
99
  buffer->end_of_line=buffer->end=buffer->buffer;
103
100
  buffer->buffer[0]=0;                          /* For easy start test */
113
110
{
114
111
  uint old_length=(uint)(buffer->end - buffer->buffer);
115
112
  uint length= (uint) strlen(str);
116
 
  char * tmpptr= (char*)realloc(buffer->buffer, old_length+length+2);
117
 
  if (tmpptr == NULL)
 
113
  if (!(buffer->buffer= buffer->start_of_line= buffer->end_of_line=
 
114
        (char*) my_realloc((uchar*) buffer->buffer, old_length+length+2,
 
115
                           MYF(MY_FAE|MY_ALLOW_ZERO_PTR))))
118
116
    return 1;
119
 
  
120
 
  buffer->buffer= buffer->start_of_line= buffer->end_of_line= tmpptr;
121
117
  buffer->end= buffer->buffer + old_length;
122
118
  if (old_length)
123
119
    buffer->end[-1]=' ';
154
150
    if ((read_count*=IO_SIZE))
155
151
      break;
156
152
    buffer->bufread *= 2;
157
 
    if (!(buffer->buffer = (char*) realloc(buffer->buffer,
158
 
                                           buffer->bufread+1)))
 
153
    if (!(buffer->buffer = (char*) my_realloc(buffer->buffer,
 
154
                                              buffer->bufread+1,
 
155
                                              MYF(MY_WME | MY_FAE))))
159
156
      return (uint) -1;
160
157
    buffer->start_of_line=buffer->buffer+start_offset;
161
158
    buffer->end=buffer->buffer+bufbytes;
164
161
  /* Shift stuff down. */
165
162
  if (buffer->start_of_line != buffer->buffer)
166
163
  {
167
 
    memmove(buffer->buffer, buffer->start_of_line, (uint) bufbytes);
 
164
    memcpy(buffer->buffer, buffer->start_of_line, (uint) bufbytes);
168
165
    buffer->end=buffer->buffer+bufbytes;
169
166
  }
170
167
 
171
168
  /* Read in new stuff. */
172
 
  if ((read_count= my_read(buffer->file, (unsigned char*) buffer->end, read_count,
 
169
  if ((read_count= my_read(buffer->file, (uchar*) buffer->end, read_count,
173
170
                           MYF(MY_WME))) == MY_FILE_ERROR)
174
171
    return (size_t) -1;
175
172
 
187
184
 
188
185
 
189
186
 
190
 
char *intern_read_line(LINE_BUFFER *buffer,uint32_t *out_length)
 
187
char *intern_read_line(LINE_BUFFER *buffer,ulong *out_length)
191
188
{
192
189
  char *pos;
193
190
  size_t length;
210
207
      pos--;                                    /* break line here */
211
208
    }
212
209
    buffer->end_of_line=pos+1;
213
 
    *out_length=(uint32_t) (pos + 1 - buffer->eof - buffer->start_of_line);
 
210
    *out_length=(ulong) (pos + 1 - buffer->eof - buffer->start_of_line);
214
211
    return(buffer->start_of_line);
215
212
  }
216
213
}