← Back to branch summary

~ubuntu-branches/ubuntu/hardy/mysql-dfsg-5.0/hardy-updates

« back to all changes in this revision

Viewing changes to ndb/src/common/util/BaseString.cpp

  • Committer: Bazaar Package Importer
  • Author(s): sean finney
  • Date: 2007-05-13 12:32:45 UTC
  • mfrom: (1.1.11 upstream)
  • Revision ID: james.westby@ubuntu.com-20070513123245-8c3l187dk34cz2ar
Tags: 5.0.41-2
the previous "translation changes" inadvertently introduced unrelated
changes in the package control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ndb/src/common/util/BaseString.cpp
16
16
/* -*- c-basic-offset: 4; -*- */
17
17
#include <ndb_global.h>
18
18
#include <BaseString.hpp>
19
 
#include <basestring_vsnprintf.h>
 
19
#include "basestring_vsnprintf.h"
20
20
 
21
21
BaseString::BaseString()
22
22
{
23
23
    m_chr = new char[1];
 
24
    if (m_chr == NULL)
 
25
    {
 
26
      errno = ENOMEM;
 
27
      m_len = 0;
 
28
      return;
 
29
    }
24
30
    m_chr[0] = 0;
25
31
    m_len = 0;
26
32
}
27
33
 
28
34
BaseString::BaseString(const char* s)
29
35
{
 
36
    if (s == NULL)
 
37
    {
 
38
      m_chr = NULL;
 
39
      m_len = 0;
 
40
    }
30
41
    const size_t n = strlen(s);
31
42
    m_chr = new char[n + 1];
 
43
    if (m_chr == NULL)
 
44
    {
 
45
      errno = ENOMEM;
 
46
      m_len = 0;
 
47
      return;
 
48
    }
32
49
    memcpy(m_chr, s, n + 1);
33
50
    m_len = n;
34
51
}
37
54
{
38
55
    const char* const s = str.m_chr;
39
56
    const size_t n = str.m_len;
 
57
    if (s == NULL)
 
58
    {
 
59
      m_chr = NULL;
 
60
      m_len = 0;
 
61
      return;
 
62
    }
40
63
    char* t = new char[n + 1];
 
64
    if (t == NULL)
 
65
    {
 
66
      errno = ENOMEM;
 
67
      m_chr = NULL;
 
68
      m_len = 0;
 
69
      return;
 
70
    }
41
71
    memcpy(t, s, n + 1);
42
72
    m_chr = t;
43
73
    m_len = n;
51
81
BaseString&
52
82
BaseString::assign(const char* s)
53
83
{
54
 
    const size_t n = strlen(s);
 
84
    if (s == NULL)
 
85
    {
 
86
      m_chr = NULL;
 
87
      m_len = 0;
 
88
      return *this;
 
89
    }
 
90
    size_t n = strlen(s);
55
91
    char* t = new char[n + 1];
56
 
    memcpy(t, s, n + 1);
 
92
    if (t)
 
93
    {
 
94
      memcpy(t, s, n + 1);
 
95
    }
 
96
    else
 
97
    {
 
98
      errno = ENOMEM;
 
99
      n = 0;
 
100
    }
57
101
    delete[] m_chr;
58
102
    m_chr = t;
59
103
    m_len = n;
64
108
BaseString::assign(const char* s, size_t n)
65
109
{
66
110
    char* t = new char[n + 1];
67
 
    memcpy(t, s, n);
68
 
    t[n] = 0;
 
111
    if (t)
 
112
    {
 
113
      memcpy(t, s, n);
 
114
      t[n] = 0;
 
115
    }
 
116
    else
 
117
    {
 
118
      errno = ENOMEM;
 
119
      n = 0;
 
120
    }
69
121
    delete[] m_chr;
70
122
    m_chr = t;
71
123
    m_len = n;
83
135
BaseString&
84
136
BaseString::append(const char* s)
85
137
{
86
 
    const size_t n = strlen(s);
 
138
    size_t n = strlen(s);
87
139
    char* t = new char[m_len + n + 1];
88
 
    memcpy(t, m_chr, m_len);
89
 
    memcpy(t + m_len, s, n + 1);
 
140
    if (t)
 
141
    {
 
142
      memcpy(t, m_chr, m_len);
 
143
      memcpy(t + m_len, s, n + 1);
 
144
    }
 
145
    else
 
146
    {
 
147
      errno = ENOMEM;
 
148
      m_len = 0;
 
149
      n = 0;
 
150
    }
90
151
    delete[] m_chr;
91
152
    m_chr = t;
92
153
    m_len += n;
130
191
    l = basestring_vsnprintf(buf, sizeof(buf), fmt, ap) + 1;
131
192
    va_end(ap);
132
193
    if(l > (int)m_len) {
 
194
        char *t = new char[l];
 
195
        if (t == NULL)
 
196
        {
 
197
          errno = ENOMEM;
 
198
          return *this;
 
199
        }
133
200
        delete[] m_chr;
134
 
        m_chr = new char[l];
 
201
        m_chr = t;
135
202
    }
136
203
    va_start(ap, fmt);
137
204
    basestring_vsnprintf(m_chr, l, fmt, ap);
155
222
    l = basestring_vsnprintf(buf, sizeof(buf), fmt, ap) + 1;
156
223
    va_end(ap);
157
224
    char *tmp = new char[l];
 
225
    if (tmp == NULL)
 
226
    {
 
227
      errno = ENOMEM;
 
228
      return *this;
 
229
    }
158
230
    va_start(ap, fmt);
159
231
    basestring_vsnprintf(tmp, l, fmt, ap);
160
232
    va_end(ap);
242
314
    Vector<char *> vargv;
243
315
    
244
316
    if(argv0 != NULL)
245
 
        vargv.push_back(strdup(argv0));
 
317
    {
 
318
      char *t = strdup(argv0);
 
319
      if (t == NULL)
 
320
      {
 
321
        errno = ENOMEM;
 
322
        return NULL;
 
323
      }
 
324
      if (vargv.push_back(t))
 
325
      {
 
326
        free(t);
 
327
        return NULL;
 
328
      }
 
329
    }
246
330
    
247
331
    char *tmp = new char[strlen(src)+1];
 
332
    if (tmp == NULL)
 
333
    {
 
334
      for(size_t i = 0; i < vargv.size(); i++)
 
335
        free(vargv[i]);
 
336
      errno = ENOMEM;
 
337
      return NULL;
 
338
    }
248
339
    char *dst = tmp;
249
340
    const char *end = src + strlen(src);
250
341
    /* Copy characters from src to destination, while compacting them
287
378
        /* Make sure the string is properly terminated */
288
379
        *dst++ = '\0';
289
380
        src++;
290
 
        
291
 
        vargv.push_back(strdup(begin));
 
381
 
 
382
        {
 
383
          char *t = strdup(begin);
 
384
          if (t == NULL)
 
385
          {
 
386
            delete[] tmp;
 
387
            for(size_t i = 0; i < vargv.size(); i++)
 
388
              free(vargv[i]);
 
389
            errno = ENOMEM;
 
390
            return NULL;
 
391
          }
 
392
          if (vargv.push_back(t))
 
393
          {
 
394
            free(t);
 
395
            delete[] tmp;
 
396
            for(size_t i = 0; i < vargv.size(); i++)
 
397
              free(vargv[i]);
 
398
            return NULL;
 
399
          }
 
400
        }
292
401
    }
293
402
 end:
294
403
    
295
404
    delete[] tmp;
296
 
    vargv.push_back(NULL);
 
405
    if (vargv.push_back(NULL))
 
406
    {
 
407
      for(size_t i = 0; i < vargv.size(); i++)
 
408
        free(vargv[i]);
 
409
      return NULL;
 
410
    }
297
411
    
298
412
    /* Convert the C++ Vector into a C-vector of strings, suitable for
299
413
     * calling execv().
300
414
     */
301
415
    char **argv = (char **)malloc(sizeof(*argv) * (vargv.size()));
302
416
    if(argv == NULL)
 
417
    {
 
418
        for(size_t i = 0; i < vargv.size(); i++)
 
419
          free(vargv[i]);
 
420
        errno = ENOMEM;
303
421
        return NULL;
 
422
    }
304
423
    
305
424
    for(size_t i = 0; i < vargv.size(); i++){
306
425
        argv[i] = vargv[i];