1 /* ------------------------------------------------------------------
2 * Copyright (C) 1998-2009 PacketVideo
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
13 * express or implied.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 * -------------------------------------------------------------------
17 */
18 #ifndef OSCL_STRING_UTILS_H_INCLUDED
19 #include "oscl_string_utils.h"
20 #endif
21
22 #include "oscl_stdstring.h"
23
24 /* ======================================================================== */
25 /* Function : PV_atoi(char *buf,char new_format) */
26 /* Date : 02/22/2001 */
27 /* Purpose : Extracts an integer from the input string. */
28 /* In/out : */
29 /* Return : */
30 /* Modified : */
31 /* ======================================================================== */
PV_atoi(const char * buf,const char new_format,uint32 & value)32 OSCL_EXPORT_REF bool PV_atoi(const char *buf, const char new_format, uint32& value)
33 {
34 return PV_atoi(buf, new_format, oscl_strlen(buf), value);
35 }
36
37
PV_atoi(const char * buf,const char new_format,int length,uint32 & value)38 OSCL_EXPORT_REF bool PV_atoi(const char *buf, const char new_format, int length, uint32& value)
39 {
40 uint32 old, temp;
41 const char *ptr = buf;
42 value = 0;
43
44 if (buf == NULL) return false;
45
46 switch (new_format)
47 {
48 case 'x':
49 {
50 while (ptr - buf < length)
51 {
52 if ((*ptr == 'a') || (*ptr == 'A'))
53 temp = 10;
54 else if ((*ptr == 'b') || (*ptr == 'B'))
55 temp = 11;
56 else if ((*ptr == 'c') || (*ptr == 'C'))
57 temp = 12;
58 else if ((*ptr == 'd') || (*ptr == 'D'))
59 temp = 13;
60 else if ((*ptr == 'e') || (*ptr == 'E'))
61 temp = 14;
62 else if ((*ptr == 'f') || (*ptr == 'F'))
63 temp = 15;
64 else if ((*ptr >= 48) && (*ptr <= 57))
65 temp = (int)(*ptr - 48);
66 else return false;
67 ++ptr;
68 old = value;
69 value = value * 16 + temp;
70 if (old > value)
71 {
72 // overflow
73 return false;
74 }
75 }
76 }
77 break;
78 case 'd':
79 {
80 while (ptr - buf < length)
81 {
82 if ((*ptr >= 48) && (*ptr <= 57))
83 {
84 temp = (int)(*ptr - 48);
85 ++ptr;
86 old = value;
87 value = value * 10 + temp;
88 if (old > value)
89 {
90 // overflow
91 return false;
92 }
93 }
94 else
95 {
96 return false;
97 }
98
99 }
100 }
101 break;
102 default :
103 {
104 while (ptr - buf < length)
105 {
106 if ((*ptr >= 48) && (*ptr <= 57))
107 {
108 temp = (int)(*ptr - 48);
109 ++ptr;
110 old = value;
111 value = value * 10 + temp;
112 if (old > value)
113 {
114 // overflow
115 return false;
116 }
117 }
118 else
119 {
120 return false;
121 }
122 }
123 }
124 break;
125 }
126
127 return true;
128 }
129
PV_atoi(const char * buf,const char new_format,int length,uint64 & value)130 OSCL_EXPORT_REF bool PV_atoi(const char *buf, const char new_format, int length, uint64& value)
131 {
132 uint64 old, temp;
133 const char *ptr = buf;
134 value = 0;
135
136 if (buf == NULL) return false;
137
138 switch (new_format)
139 {
140 case 'x':
141 {
142 while (ptr - buf < length)
143 {
144 if ((*ptr == 'a') || (*ptr == 'A'))
145 temp = 10;
146 else if ((*ptr == 'b') || (*ptr == 'B'))
147 temp = 11;
148 else if ((*ptr == 'c') || (*ptr == 'C'))
149 temp = 12;
150 else if ((*ptr == 'd') || (*ptr == 'D'))
151 temp = 13;
152 else if ((*ptr == 'e') || (*ptr == 'E'))
153 temp = 14;
154 else if ((*ptr == 'f') || (*ptr == 'F'))
155 temp = 15;
156 else if ((*ptr >= 48) && (*ptr <= 57))
157 temp = (int)(*ptr - 48);
158 else return false;
159 ++ptr;
160 old = value;
161 value = value * (uint64)16 + temp;
162 if (old > value)
163 {
164 // overflow
165 return false;
166 }
167 }
168 }
169 break;
170 case 'd':
171 {
172 while (ptr - buf < length)
173 {
174 if ((*ptr >= 48) && (*ptr <= 57))
175 {
176 temp = (int)(*ptr - 48);
177 ++ptr;
178 old = value;
179 value = value * (uint64)10 + temp;
180 if (old > value)
181 {
182 // overflow
183 return false;
184 }
185 }
186 else
187 {
188 return false;
189 }
190
191 }
192 }
193 break;
194 default :
195 {
196 while (ptr - buf < length)
197 {
198 if ((*ptr >= 48) && (*ptr <= 57))
199 {
200 temp = (int)(*ptr - 48);
201 ++ptr;
202 old = value;
203 value = value * (uint64)10 + temp;
204 if (old > value)
205 {
206 // overflow
207 return false;
208 }
209 }
210 else
211 {
212 return false;
213 }
214 }
215 }
216 break;
217 }
218
219 return true;
220 }
221
222
223
224
225 /* ======================================================================== */
226 /* Function : skip_whitespace */
227 /* Date : 1/1/2000 */
228 /* Purpose : Skips over any leading whitespace (i.e., a space or */
229 /* horizontal tab character) in the input string and */
230 /* returns the pointer to the first non-whitespace */
231 /* character. */
232 /* In/out : */
233 /* Return : pointer to first non-whitespace character */
234 /* Modified : */
235 /* ======================================================================== */
236
skip_whitespace(const char * ptr)237 OSCL_EXPORT_REF const char* skip_whitespace(const char *ptr)
238 {
239 while (ptr && *ptr)
240 {
241 if (*ptr != ' ' && *ptr != '\t')
242 {
243 break;
244 }
245
246 ++ptr;
247 }
248
249 return ptr;
250 }
251
skip_whitespace(char * ptr)252 OSCL_EXPORT_REF char * skip_whitespace(char * ptr)
253 {
254 while (ptr && *ptr)
255 {
256 if (*ptr != ' ' && *ptr != '\t')
257 {
258 break;
259 }
260
261 ++ptr;
262 }
263
264 return ptr;
265 }
266
267
268
269 /* ======================================================================== */
270 /* Function : skip_whitespace */
271 /* Date : 1/1/2000 */
272 /* Purpose : Skips over any leading whitespace (i.e., a space or */
273 /* horizontal tab character) in the input string and */
274 /* returns the pointer to the first non-whitespace */
275 /* character. The input string is represented by */
276 /* starting and ending pointers and does not need to be */
277 /* NULL terminated. */
278 /* In/out : */
279 /* Return : pointer to first non-whitespace character */
280 /* Modified : */
281 /* ======================================================================== */
282
skip_whitespace(const char * start,const char * end)283 OSCL_EXPORT_REF const char* skip_whitespace(const char *start, const char *end)
284 {
285 while (start && (start < end))
286 {
287 if (*start != ' ' && *start != '\t')
288 {
289 break;
290 }
291
292 ++start;
293 }
294
295 return start;
296 }
297
298
299 /* ======================================================================== */
300 /* Function : skip_to_whitespace */
301 /* Date : 1/1/2001 */
302 /* Purpose : Skips to the first whitespace character (i.e., a space */
303 /* or horizontal tab character or line terminator) in the */
304 /* input string and returns the pointer to the first */
305 /* non-whitespace character. */
306 /* The input string is represented by */
307 /* starting and ending pointers and does not need to be */
308 /* NULL terminated. */
309 /* In/out : */
310 /* Return : pointer to first non-whitespace character */
311 /* Modified : */
312 /* ======================================================================== */
313
skip_to_whitespace(const char * start,const char * end)314 OSCL_EXPORT_REF const char* skip_to_whitespace(const char *start, const char *end)
315 {
316 while (start && (start < end))
317 {
318 if (*start == ' ' || *start == '\t' ||
319 *start == '\r' || *start == '\n')
320 {
321 break;
322 }
323
324 ++start;
325 }
326
327 return start;
328 }
329
330 /* ======================================================================== */
331 /* Function : skip_to_line_term */
332 /* Date : 9/15/2001 */
333 /* Purpose : Skips over any characters to the next line terminator */
334 /* (i.e., \r and \n) and */
335 /* returns the pointer to the line term character. */
336 /* The input string is represented by */
337 /* starting and ending pointers and does not need to be */
338 /* NULL terminated. */
339 /* In/out : */
340 /* Return : pointer to line terminator character */
341 /* Modified : */
342 /* ======================================================================== */
343
skip_to_line_term(const char * start,const char * end)344 OSCL_EXPORT_REF const char * skip_to_line_term(const char *start, const char *end)
345 {
346 while (start && (start < end))
347 {
348 if (*start == '\r' || *start == '\n')
349 {
350 return start;
351 }
352 ++start;
353 }
354
355 return start;
356 }
357
358
359 /* ======================================================================== */
360 /* Function : skip_whitespace_and_line_term */
361 /* Date : 9/15/2001 */
362 /* Purpose : Skips over any leading whitespace (i.e., a space or */
363 /* horizontal tab character) or line terminator (i.e., \r */
364 /* and \n) and */
365 /* returns the pointer to the first non-whitespace */
366 /* character. The input string is represented by */
367 /* starting and ending pointers and does not need to be */
368 /* NULL terminated. */
369 /* In/out : */
370 /* Return : pointer to first non-whitespace character */
371 /* Modified : */
372 /* ======================================================================== */
373
skip_whitespace_and_line_term(const char * start,const char * end)374 OSCL_EXPORT_REF const char* skip_whitespace_and_line_term(const char *start, const char *end)
375 {
376 while (start && (start < end))
377 {
378 if (*start != ' ' && *start != '\t' &&
379 *start != '\r' && *start != '\n')
380 {
381 break;
382 }
383
384 ++start;
385 }
386
387 return start;
388 }
389
390
391
392
393 /* ======================================================================== */
394 /* Function : extract_string */
395 /* Date : 1/1/2000 */
396 /* Purpose : Extracts string of a maximum size after skipping any */
397 /* leading whitespace. The input string is represented by */
398 /* starting and ending pointers and does not need to be */
399 /* NULL terminated. */
400 /* In/out : */
401 /* Return : length of the extracted string */
402 /* Modified : */
403 /* ======================================================================== */
404
405
extract_string(const char * start,const char * end,char * outstring,int maxsize)406 OSCL_EXPORT_REF int extract_string(const char * start, const char *end, char *outstring, int maxsize)
407 {
408 int len = 0;
409
410 if (! outstring)
411 {
412 return 0;
413 }
414
415 start = skip_whitespace(start, end);
416
417 for (; start && (start < end) ; ++start)
418 {
419
420 if (*start == ' ' || *start == '\t' || *start == '\n' || *start == '\r')
421 {
422 // whitespace so stop copying
423 break;
424 }
425
426 if (len < maxsize)
427 {
428 *outstring++ = *start;
429 }
430 else if (len == maxsize)
431 {
432 // too long so just terminate the string
433 *(outstring - 1) = '\0';
434 }
435 ++len;
436
437 }
438
439 if (len < maxsize)
440 {
441 // terminate the string
442 *outstring = '\0';
443 }
444
445 return len;
446 }
447
448 /* ======================================================================== */
449 /* Function : extract_string */
450 /* Date : 1/1/2000 */
451 /* Purpose : Extracts string of a maximum size after skipping any */
452 /* leading whitespace. */
453 /* In/out : */
454 /* Return : length of the extracted string */
455 /* Modified : */
456 /* ======================================================================== */
457
extract_string(const char * in_ptr,char * outstring,int maxsize)458 OSCL_EXPORT_REF int extract_string(const char * in_ptr, char *outstring, int maxsize)
459 {
460 int len = 0;
461
462 if (! outstring)
463 {
464 return 0;
465 }
466
467 in_ptr = skip_whitespace(in_ptr, in_ptr + oscl_strlen(in_ptr));
468
469 for (; in_ptr && *in_ptr ; ++in_ptr)
470 {
471
472 if (*in_ptr == ' ' || *in_ptr == '\t' || *in_ptr == '\n' || *in_ptr == '\r')
473 {
474 // whitespace so stop copying
475 break;
476 }
477
478 if (len < maxsize)
479 {
480 *outstring++ = *in_ptr;
481 }
482 else if (len == maxsize)
483 {
484 // too long so just terminate the string
485 *(outstring - 1) = '\0';
486 }
487 ++len;
488
489 }
490
491 if (len < maxsize)
492 {
493 // terminate the string
494 *outstring = '\0';
495 }
496
497 return len;
498 }
499
500 /* ======================================================================== */
501 /* Function : PV_atof(char *buf, OsclFloat& value) */
502 /* Purpose : Converts a character string to a float. The string */
503 /* argument has the following form: */
504 /* [whitespace] [sign] [digits] [.digits] */
505 /* In/out : */
506 /* Return : */
507 /* Modified : */
508 /* ======================================================================== */
PV_atof(const char * buf,OsclFloat & value)509 OSCL_EXPORT_REF bool PV_atof(const char *buf, OsclFloat& value)
510 {
511 return PV_atof(buf, oscl_strlen(buf), value);
512 }
513
PV_atof(const char * buf,int length,OsclFloat & value)514 OSCL_EXPORT_REF bool PV_atof(const char *buf, int length, OsclFloat& value)
515 {
516 int i, decimal_point_index = -1;
517 OsclFloat old;
518 bool minus_sign = false;
519 bool digit_found = false;
520 value = 0.0;
521
522 for (i = 0; i < length; i++)
523 {
524 if (buf[i] == ' ' || buf[i] == '\t')
525 {
526 if (digit_found)
527 break; // stop the conversion if the numeric value is ended with whitespace or tab (ie, "1.23 ")
528 else
529 continue; // skip leading whitespace or tab
530 }
531 else if (buf[i] == '-')
532 {
533 if (digit_found)
534 break; // stop the conversion if the numeric value is ended with a minus sign (ie, "1.23-")
535 else
536 {
537 minus_sign = true;
538 continue;
539 }
540 }
541 else if (buf[i] < '0' || buf[i] > '9')
542 {
543 if (buf[i] == '.')
544 {
545 if (decimal_point_index > -1)
546 break; // found another decimal point so stopping
547 else // continue the conversion if this is the first decimal point
548 {
549 decimal_point_index = i;
550 continue;
551 }
552 }
553 else
554 return false; // Non-numeric char so stopping
555 }
556 else
557 {
558 old = value;
559 value = value * 10 + buf[i] - '0';
560 if (old > value)
561 {
562 // overflow
563 return false;
564 }
565 if (!digit_found)
566 digit_found = true;
567 }
568 }
569
570 if (value > 0.0)
571 {
572 if (decimal_point_index != -1)
573 {
574 i = i - 1 - decimal_point_index;
575 if (i > 0)
576 {
577 while (i--)
578 value /= 10;
579 }
580 }
581 if (minus_sign)
582 value = (OsclFloat)(0.0 - value);
583 }
584 return true;
585 }
586
oscl_abs(int aVal)587 OSCL_EXPORT_REF int oscl_abs(int aVal)
588 {
589 return(aVal < 0 ? -aVal : aVal);
590 }
591
592