/simpletypesystem/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/simpletypesystem/trunk

« back to all changes in this revision

Viewing changes to libssts/utils.c

  • Committer: Gustav Hartvigsson
  • Date: 2016-08-07 21:08:54 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20160807210854-esvxch63s29kr2kw
* Fixed s_base_16_enc
* started work on s_base_16_dec (have not figured out how why id is not working)
* fixed reverse table size issue (127 -> 128 elements)
* Added tests for Base 16 stuffs
* added s_string_len
* fixed? s_ustring_to_string
* added (do not know if it is working?) s_string_to_ustring
* commented out strdup
* removed mainloop tests from the standard test suite, sholud be run seperatly anyway.
* use libc for memory managment in the tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
libssts/utils.c
82
82
}
83
83
 
84
84
size_t
 
85
s_string_len (const schar * str) {
 
86
  return strlen (str);
 
87
}
 
88
 
 
89
size_t
85
90
s_ustring_len (const suchar * us) {
86
91
  if (!us) {
87
92
    return 0;
88
93
  }
89
94
  size_t ret_val = 0;
90
 
  suchar * tmp = us;
 
95
  suchar * tmp = (suchar *)us;
91
96
  while (*tmp) {
92
97
    ret_val++;
93
98
    us++;
95
100
  return ret_val;
96
101
}
97
102
 
 
103
/******************************************************************************/
98
104
schar *
99
105
s_ustring_to_string (const suchar * us) {
100
 
  size_t buflen;
101
106
  schar * buffer;
102
107
  schar * resized;
103
108
  size_t bufpos;
109
114
   *
110
115
   * This is an adaptation of the original code to work with our suchar stuffs.
111
116
   */
112
 
 
 
117
  
113
118
  /* Save locale */
114
119
  schar * saved_locale;
115
120
  {
123
128
    setlocale (LC_ALL, "C.utf8");
124
129
  }
125
130
  
 
131
  buffer = malloc (sizeof (char32_t) * 4);
126
132
  
127
133
  schar out[MB_CUR_MAX];
128
134
  for(size_t n = 0, buflen = 4, bufpos = 0;
129
135
        n < s_ustring_len (us);
130
 
        n++, buflen *= 2) {
 
136
        n++, buflen += MB_CUR_MAX) { /* could be: buflen *= 2 ?*/
131
137
    sint rc = c32rtomb(out, us[n], &mbstate);
132
 
    if(! (resized = s_realloc (buffer, buflen)))
 
138
    if(! (resized = s_realloc (buffer, buflen))) {
133
139
      goto err;
 
140
    }
 
141
    buffer = resized;
134
142
    for (sint i = 0; i < rc; ++i) {
135
 
      buffer[bufpos];
 
143
      buffer[bufpos] = out[i];
136
144
      bufpos++;
137
145
    }
138
146
  }
139
147
  
 
148
    /* reset locale */
 
149
  setlocale (LC_ALL, saved_locale);
 
150
  
140
151
  /* shrink buffer to actually required size */
141
152
  if (! (resized = s_realloc (buffer, bufpos + 1)))
142
153
    goto err;
143
154
  
144
 
  /* reset locale */
145
 
  setlocale (LC_ALL, saved_locale);
146
 
 
147
 
  return resized;
148
 
err:
149
 
  /* reset locale */
150
 
  setlocale (LC_ALL, saved_locale);
151
 
 
152
 
  s_free(buffer);
153
 
  return NULL;
154
 
}
155
 
 
156
 
 
 
155
  
 
156
  return resized;
 
157
err:
 
158
  
 
159
  s_free(buffer);
 
160
  return NULL;
 
161
}
 
162
 
 
163
/******************************************************************************/
 
164
suchar *
 
165
s_string_to_ustring (const schar * str) {
 
166
  suchar * buffer;
 
167
  suchar * resized;
 
168
  size_t bufpos;
 
169
  mbstate_t mbstate;
 
170
  memset (&mbstate, 0, sizeof (mbstate));
 
171
  
 
172
  suint slen = s_string_len (str);
 
173
  
 
174
  
 
175
  /* Addaptation of the code in s_wstring_to_string to make it convert
 
176
   * mb strings to char32_t strings.
 
177
   */
 
178
  
 
179
  /* Save locale */
 
180
  schar * saved_locale;
 
181
  {
 
182
    schar * old_locale;
 
183
    size_t old_locale_len;
 
184
    old_locale = setlocale (LC_ALL, NULL);
 
185
    old_locale_len = strlen (old_locale) + 1;
 
186
    saved_locale = s_malloc (sizeof (char *) * old_locale_len);
 
187
    memcpy (saved_locale, old_locale, old_locale_len);
 
188
    /* set locale */
 
189
    setlocale (LC_ALL, "C.utf8");
 
190
  }
 
191
  
 
192
  buffer = malloc (sizeof (char32_t) * 4);
 
193
  
 
194
  suchar * out = s_malloc (sizeof (suchar));
 
195
  for(size_t n = 0, buflen = 4, bufpos = 0;
 
196
        n < slen;
 
197
        buflen += 2) {
 
198
    sint rc = mbrtoc32(out, &str[n], slen ,&mbstate);
 
199
    n += rc; // Get next mb in string...?
 
200
    if(! (resized = s_realloc (buffer, buflen * sizeof (suchar)))){
 
201
      goto err;
 
202
    }
 
203
    buffer = resized;
 
204
    buffer[bufpos] = *out;
 
205
    bufpos++;
 
206
  }
 
207
  
 
208
  s_free (out);
 
209
  
 
210
  /* reset locale */
 
211
  setlocale (LC_ALL, saved_locale);
 
212
  
 
213
  /* shrink buffer to actually required size */
 
214
  if (! (resized = s_realloc (buffer, (bufpos + 1) * sizeof (suchar)))) {
 
215
    goto err;
 
216
  }
 
217
  
 
218
  
 
219
  return resized;
 
220
err:
 
221
  
 
222
  s_free(buffer);
 
223
  return NULL;
 
224
  
 
225
}
 
226
 
 
227
/******************************************************************************/
157
228
/*
158
229
 * This should not be used. If you need to use this, uncomment it.
159
230
 * I am conveting to something more sane than wchar_t.
165
236
               "specific and may, or may not couse troubble.\n"
166
237
               "Use uchar strings instead of wchar_t strings, and "
167
238
               "use s_ustring_to_string instead of this.\n");
168
 
 
 
239
  
169
240
  size_t buflen;
170
241
  schar * buffer;
171
242
  schar * resized;
172
243
  size_t bufpos;
173
244
  mbstate_t mbstate;
174
245
  memset (&mbstate, 0, sizeof (mbstate));
175
 
 
176
 
 
 
246
  
 
247
  
177
248
  /* Save locale */
178
249
  schar * saved_locale;
179
250
  {
186
257
    /* set locale */
187
258
    setlocale (LC_ALL, "C.utf8");
188
259
  }
189
 
 
 
260
  
190
261
  /* Thanks to Florian Philipp.
191
262
   * Thread: https://plus.google.com/u/0/+GustavHartvigsson/posts/4Wk7La1kWPP
192
263
   *
210
281
      goto err;
211
282
    bufpos += converted;
212
283
  }
213
 
 
 
284
  
 
285
  /* reset locale */
 
286
  setlocale (LC_ALL, saved_locale);
 
287
  
214
288
  /* shrink buffer to actually required size */
215
 
  if (! (resized = s_realloc (buffer, bufpos + 1)))
 
289
  if (! (resized = s_realloc (buffer, bufpos + 1))) {
216
290
    goto err;
217
 
 
218
 
  /* reset locale */
219
 
  setlocale (LC_ALL, saved_locale);
220
 
 
 
291
  }
 
292
  
221
293
  return resized;
222
294
err:
223
 
  /* reset locale */
224
 
  setlocale (LC_ALL, saved_locale);
225
 
 
 
295
  
226
296
  s_free(buffer);
227
297
  return NULL;
228
298
}