OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [newlib-1.18.0/] [newlib/] [libc/] [stdio/] [sprintf.c] - Blame information for rev 207

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 207 jeremybenn
/*
2
 * Copyright (c) 1990 The Regents of the University of California.
3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms are permitted
6
 * provided that the above copyright notice and this paragraph are
7
 * duplicated in all such forms and that any documentation,
8
 * advertising materials, and other materials related to such
9
 * distribution and use acknowledge that the software was developed
10
 * by the University of California, Berkeley.  The name of the
11
 * University may not be used to endorse or promote products derived
12
 * from this software without specific prior written permission.
13
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
14
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
15
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
16
 */
17
 
18
/*
19
FUNCTION
20
<<sprintf>>, <<fprintf>>, <<printf>>, <<snprintf>>, <<asprintf>>, <<asnprintf>>---format output
21
 
22
INDEX
23
        fprintf
24
INDEX
25
        _fprintf_r
26
INDEX
27
        printf
28
INDEX
29
        _printf_r
30
INDEX
31
        asprintf
32
INDEX
33
        _asprintf_r
34
INDEX
35
        sprintf
36
INDEX
37
        _sprintf_r
38
INDEX
39
        snprintf
40
INDEX
41
        _snprintf_r
42
INDEX
43
        asnprintf
44
INDEX
45
        _asnprintf_r
46
 
47
ANSI_SYNOPSIS
48
        #include <stdio.h>
49
 
50
        int printf(const char *<[format]>, ...);
51
        int fprintf(FILE *<[fd]>, const char *<[format]>, ...);
52
        int sprintf(char *<[str]>, const char *<[format]>, ...);
53
        int snprintf(char *<[str]>, size_t <[size]>, const char *<[format]>,
54
                     ...);
55
        int asprintf(char **<[strp]>, const char *<[format]>, ...);
56
        char *asnprintf(char *<[str]>, size_t *<[size]>, const char *<[format]>,
57
                        ...);
58
 
59
        int _printf_r(struct _reent *<[ptr]>, const char *<[format]>, ...);
60
        int _fprintf_r(struct _reent *<[ptr]>, FILE *<[fd]>,
61
                       const char *<[format]>, ...);
62
        int _sprintf_r(struct _reent *<[ptr]>, char *<[str]>,
63
                       const char *<[format]>, ...);
64
        int _snprintf_r(struct _reent *<[ptr]>, char *<[str]>, size_t <[size]>,
65
                        const char *<[format]>, ...);
66
        int _asprintf_r(struct _reent *<[ptr]>, char **<[strp]>,
67
                        const char *<[format]>, ...);
68
        char *_asnprintf_r(struct _reent *<[ptr]>, char *<[str]>,
69
                           size_t *<[size]>, const char *<[format]>, ...);
70
 
71
DESCRIPTION
72
        <<printf>> accepts a series of arguments, applies to each a
73
        format specifier from <<*<[format]>>>, and writes the
74
        formatted data to <<stdout>>, without a terminating NUL
75
        character.  The behavior of <<printf>> is undefined if there
76
        are not enough arguments for the format.  <<printf>> returns
77
        when it reaches the end of the format string.  If there are
78
        more arguments than the format requires, excess arguments are
79
        ignored.
80
 
81
        <<fprintf>> is like <<printf>>, except that output is directed
82
        to the stream <[fd]> rather than <<stdout>>.
83
 
84
        <<sprintf>> is like <<printf>>, except that output is directed
85
        to the buffer <[str]>, and a terminating NUL is output.
86
        Behavior is undefined if more output is generated than the
87
        buffer can hold.
88
 
89
        <<snprintf>> is like <<sprintf>>, except that output is
90
        limited to at most <[size]> bytes, including the terminating
91
        <<NUL>>.  As a special case, if <[size]> is 0, <[str]> can be
92
        NULL, and <<snprintf>> merely calculates how many bytes would
93
        be printed.
94
 
95
        <<asprintf>> is like <<sprintf>>, except that the output is
96
        stored in a dynamically allocated buffer, <[pstr]>, which
97
        should be freed later with <<free>>.
98
 
99
        <<asnprintf>> is like <<sprintf>>, except that the return type
100
        is either the original <[str]> if it was large enough, or a
101
        dynamically allocated string if the output exceeds *<[size]>;
102
        the length of the result is returned in *<[size]>.  When
103
        dynamic allocation occurs, the contents of the original
104
        <[str]> may have been modified.
105
 
106
        For <<sprintf>>, <<snprintf>>, and <<asnprintf>>, the behavior
107
        is undefined if the output <<*<[str]>>> overlaps with one of
108
        the arguments.  Behavior is also undefined if the argument for
109
        <<%n>> within <<*<[format]>>> overlaps another argument.
110
 
111
        <[format]> is a pointer to a character string containing two
112
        types of objects: ordinary characters (other than <<%>>),
113
        which are copied unchanged to the output, and conversion
114
        specifications, each of which is introduced by <<%>>. (To
115
        include <<%>> in the output, use <<%%>> in the format string.)
116
        A conversion specification has the following form:
117
 
118
.       %[<[pos]>][<[flags]>][<[width]>][.<[prec]>][<[size]>]<[type]>
119
 
120
        The fields of the conversion specification have the following
121
        meanings:
122
 
123
        O+
124
        o <[pos]>
125
 
126
        Conversions normally consume arguments in the order that they
127
        are presented.  However, it is possible to consume arguments
128
        out of order, and reuse an argument for more than one
129
        conversion specification (although the behavior is undefined
130
        if the same argument is requested with different types), by
131
        specifying <[pos]>, which is a decimal integer followed by
132
        '$'.  The integer must be between 1 and <NL_ARGMAX> from
133
        limits.h, and if argument <<%n$>> is requested, all earlier
134
        arguments must be requested somewhere within <[format]>.  If
135
        positional parameters are used, then all conversion
136
        specifications except for <<%%>> must specify a position.
137
        This positional parameters method is a POSIX extension to the C
138
        standard definition for the functions.
139
 
140
        o <[flags]>
141
 
142
        <[flags]> is an optional sequence of characters which control
143
        output justification, numeric signs, decimal points, trailing
144
        zeros, and octal and hex prefixes.  The flag characters are
145
        minus (<<->>), plus (<<+>>), space ( ), zero (<<0>>), sharp
146
        (<<#>>), and quote (<<'>>).  They can appear in any
147
        combination, although not all flags can be used for all
148
        conversion specification types.
149
 
150
                o+
151
                o '
152
                        A POSIX extension to the C standard.  However, this
153
                        implementation presently treats it as a no-op, which
154
                        is the default behavior for the C locale, anyway.  (If
155
                        it did what it is supposed to, when <[type]> were <<i>>,
156
                        <<d>>, <<u>>, <<f>>, <<F>>, <<g>>, or <<G>>, the
157
                        integer portion of the conversion would be formatted
158
                        with thousands' grouping wide characters.)
159
 
160
                o -
161
                        The result of the conversion is left
162
                        justified, and the right is padded with
163
                        blanks.  If you do not use this flag, the
164
                        result is right justified, and padded on the
165
                        left.
166
 
167
                o +
168
                        The result of a signed conversion (as
169
                        determined by <[type]> of <<d>>, <<i>>, <<a>>,
170
                        <<A>>, <<e>>, <<E>>, <<f>>, <<F>>, <<g>>, or
171
                        <<G>>) will always begin with a plus or minus
172
                        sign.  (If you do not use this flag, positive
173
                        values do not begin with a plus sign.)
174
 
175
                o " " (space)
176
                        If the first character of a signed conversion
177
                        specification is not a sign, or if a signed
178
                        conversion results in no characters, the
179
                        result will begin with a space.  If the space
180
                        ( ) flag and the plus (<<+>>) flag both
181
                        appear, the space flag is ignored.
182
 
183
                o 0
184
                        If the <[type]> character is <<d>>, <<i>>,
185
                        <<o>>, <<u>>, <<x>>, <<X>>, <<a>>, <<A>>,
186
                        <<e>>, <<E>>, <<f>>, <<F>>, <<g>>, or <<G>>:  leading
187
                        zeros are used to pad the field width
188
                        (following any indication of sign or base); no
189
                        spaces are used for padding.  If the zero
190
                        (<<0>>) and minus (<<->>) flags both appear,
191
                        the zero (<<0>>) flag will be ignored.  For
192
                        <<d>>, <<i>>, <<o>>, <<u>>, <<x>>, and <<X>>
193
                        conversions, if a precision <[prec]> is
194
                        specified, the zero (<<0>>) flag is ignored.
195
 
196
                        Note that <<0>> is interpreted as a flag, not
197
                        as the beginning of a field width.
198
 
199
                o #
200
                        The result is to be converted to an
201
                        alternative form, according to the <[type]>
202
                        character:
203
 
204
                        o+
205
                        o o
206
                                Increases precision to force the first
207
                                digit of the result to be a zero.
208
 
209
                        o x
210
                                A non-zero result will have a <<0x>>
211
                                prefix.
212
 
213
                        o X
214
                                A non-zero result will have a <<0X>>
215
                                prefix.
216
 
217
                        o a, A, e, E, f, or F
218
                                The result will always contain a
219
                                decimal point even if no digits follow
220
                                the point.  (Normally, a decimal point
221
                                appears only if a digit follows it.)
222
                                Trailing zeros are removed.
223
 
224
                        o g or G
225
                                The result will always contain a
226
                                decimal point even if no digits follow
227
                                the point.  Trailing zeros are not
228
                                removed.
229
 
230
                        o all others
231
                                Undefined.
232
 
233
                        o-
234
                o-
235
 
236
        o <[width]>
237
 
238
                <[width]> is an optional minimum field width.  You can
239
                either specify it directly as a decimal integer, or
240
                indirectly by using instead an asterisk (<<*>>), in
241
                which case an <<int>> argument is used as the field
242
                width.  If positional arguments are used, then the
243
                width must also be specified positionally as <<*m$>>,
244
                with m as a decimal integer.  Negative field widths
245
                are treated as specifying the minus (<<->>) flag for
246
                left justfication, along with a positive field width.
247
                The resulting format may be wider than the specified
248
                width.
249
 
250
        o <[prec]>
251
 
252
                <[prec]> is an optional field; if present, it is
253
                introduced with `<<.>>' (a period). You can specify
254
                the precision either directly as a decimal integer or
255
                indirectly by using an asterisk (<<*>>), in which case
256
                an <<int>> argument is used as the precision.  If
257
                positional arguments are used, then the precision must
258
                also be specified positionally as <<*m$>>, with m as a
259
                decimal integer.  Supplying a negative precision is
260
                equivalent to omitting the precision.  If only a
261
                period is specified the precision is zero. The effect
262
                depends on the conversion <[type]>.
263
 
264
                o+
265
                o d, i, o, u, x, or X
266
                        Minimum number of digits to appear.  If no
267
                        precision is given, defaults to 1.
268
 
269
                o a or A
270
                        Number of digits to appear after the decimal
271
                        point.  If no precision is given, the
272
                        precision defaults to the minimum needed for
273
                        an exact representation.
274
 
275
                o e, E, f or F
276
                        Number of digits to appear after the decimal
277
                        point.  If no precision is given, the
278
                        precision defaults to 6.
279
 
280
                o g or G
281
                        Maximum number of significant digits.  A
282
                        precision of 0 is treated the same as a
283
                        precision of 1.  If no precision is given, the
284
                        precision defaults to 6.
285
 
286
                o s or S
287
                        Maximum number of characters to print from the
288
                        string.  If no precision is given, the entire
289
                        string is printed.
290
 
291
                o all others
292
                        undefined.
293
 
294
                o-
295
 
296
        o <[size]>
297
 
298
                <[size]> is an optional modifier that changes the data
299
                type that the corresponding argument has.  Behavior is
300
                unspecified if a size is given that does not match the
301
                <[type]>.
302
 
303
                o+
304
                o hh
305
                        With <<d>>, <<i>>, <<o>>, <<u>>, <<x>>, or
306
                        <<X>>, specifies that the argument should be
307
                        converted to a <<signed char>> or <<unsigned
308
                        char>> before printing.
309
 
310
                        With <<n>>, specifies that the argument is a
311
                        pointer to a <<signed char>>.
312
 
313
                o h
314
                        With <<d>>, <<i>>, <<o>>, <<u>>, <<x>>, or
315
                        <<X>>, specifies that the argument should be
316
                        converted to a <<short>> or <<unsigned short>>
317
                        before printing.
318
 
319
                        With <<n>>, specifies that the argument is a
320
                        pointer to a <<short>>.
321
 
322
                o l
323
                        With <<d>>, <<i>>, <<o>>, <<u>>, <<x>>, or
324
                        <<X>>, specifies that the argument is a
325
                        <<long>> or <<unsigned long>>.
326
 
327
                        With <<c>>, specifies that the argument has
328
                        type <<wint_t>>.
329
 
330
                        With <<s>>, specifies that the argument is a
331
                        pointer to <<wchar_t>>.
332
 
333
                        With <<n>>, specifies that the argument is a
334
                        pointer to a <<long>>.
335
 
336
                        With <<a>>, <<A>>, <<e>>, <<E>>, <<f>>, <<F>>,
337
                        <<g>>, or <<G>>, has no effect (because of
338
                        vararg promotion rules, there is no need to
339
                        distinguish between <<float>> and <<double>>).
340
 
341
                o ll
342
                        With <<d>>, <<i>>, <<o>>, <<u>>, <<x>>, or
343
                        <<X>>, specifies that the argument is a
344
                        <<long long>> or <<unsigned long long>>.
345
 
346
                        With <<n>>, specifies that the argument is a
347
                        pointer to a <<long long>>.
348
 
349
                o j
350
                        With <<d>>, <<i>>, <<o>>, <<u>>, <<x>>, or
351
                        <<X>>, specifies that the argument is an
352
                        <<intmax_t>> or <<uintmax_t>>.
353
 
354
                        With <<n>>, specifies that the argument is a
355
                        pointer to an <<intmax_t>>.
356
 
357
                o z
358
                        With <<d>>, <<i>>, <<o>>, <<u>>, <<x>>, or
359
                        <<X>>, specifies that the argument is a <<size_t>>.
360
 
361
                        With <<n>>, specifies that the argument is a
362
                        pointer to a <<size_t>>.
363
 
364
                o t
365
                        With <<d>>, <<i>>, <<o>>, <<u>>, <<x>>, or
366
                        <<X>>, specifies that the argument is a
367
                        <<ptrdiff_t>>.
368
 
369
                        With <<n>>, specifies that the argument is a
370
                        pointer to a <<ptrdiff_t>>.
371
 
372
                o L
373
                        With <<a>>, <<A>>, <<e>>, <<E>>, <<f>>, <<F>>,
374
                        <<g>>, or <<G>>, specifies that the argument
375
                        is a <<long double>>.
376
 
377
                o-
378
 
379
        o   <[type]>
380
 
381
                <[type]> specifies what kind of conversion <<printf>>
382
                performs.  Here is a table of these:
383
 
384
                o+
385
                o %
386
                        Prints the percent character (<<%>>).
387
 
388
                o c
389
                        Prints <[arg]> as single character.  If the
390
                        <<l>> size specifier is in effect, a multibyte
391
                        character is printed.
392
 
393
                o C
394
                        Short for <<%lc>>.  A POSIX extension to the C standard.
395
 
396
                o s
397
                        Prints the elements of a pointer to <<char>>
398
                        until the precision or a null character is
399
                        reached.  If the <<l>> size specifier is in
400
                        effect, the pointer is to an array of
401
                        <<wchar_t>>, and the string is converted to
402
                        multibyte characters before printing.
403
 
404
                o S
405
                        Short for <<%ls>>.  A POSIX extension to the C standard.
406
 
407
                o d or i
408
                        Prints a signed decimal integer; takes an
409
                        <<int>>.  Leading zeros are inserted as
410
                        necessary to reach the precision.  A value of 0 with
411
                        a precision of 0 produces an empty string.
412
 
413
                o D
414
                        Newlib extension, short for <<%ld>>.
415
 
416
                o o
417
                        Prints an unsigned octal integer; takes an
418
                        <<unsigned>>.  Leading zeros are inserted as
419
                        necessary to reach the precision.  A value of 0 with
420
                        a precision of 0 produces an empty string.
421
 
422
                o O
423
                        Newlib extension, short for <<%lo>>.
424
 
425
                o u
426
                        Prints an unsigned decimal integer; takes an
427
                        <<unsigned>>.  Leading zeros are inserted as
428
                        necessary to reach the precision.  A value of 0 with
429
                        a precision of 0 produces an empty string.
430
 
431
                o U
432
                        Newlib extension, short for <<%lu>>.
433
 
434
                o x
435
                        Prints an unsigned hexadecimal integer (using
436
                        <<abcdef>> as digits beyond <<9>>); takes an
437
                        <<unsigned>>.  Leading zeros are inserted as
438
                        necessary to reach the precision.  A value of 0 with
439
                        a precision of 0 produces an empty string.
440
 
441
                o X
442
                        Like <<x>>, but uses <<ABCDEF>> as digits
443
                        beyond <<9>>.
444
 
445
                o f
446
                        Prints a signed value of the form
447
                        <<[-]9999.9999>>, with the precision
448
                        determining how many digits follow the decimal
449
                        point; takes a <<double>> (remember that
450
                        <<float>> promotes to <<double>> as a vararg).
451
                        The low order digit is rounded to even.  If
452
                        the precision results in at most DECIMAL_DIG
453
                        digits, the result is rounded correctly; if
454
                        more than DECIMAL_DIG digits are printed, the
455
                        result is only guaranteed to round back to the
456
                        original value.
457
 
458
                        If the value is infinite, the result is
459
                        <<inf>>, and no zero padding is performed.  If
460
                        the value is not a number, the result is
461
                        <<nan>>, and no zero padding is performed.
462
 
463
                o F
464
                        Like <<f>>, but uses <<INF>> and <<NAN>> for
465
                        non-finite numbers.
466
 
467
                o e
468
                        Prints a signed value of the form
469
                        <<[-]9.9999e[+|-]999>>; takes a <<double>>.
470
                        The digit before the decimal point is non-zero
471
                        if the value is non-zero.  The precision
472
                        determines how many digits appear between
473
                        <<.>> and <<e>>, and the exponent always
474
                        contains at least two digits.  The value zero
475
                        has an exponent of zero.  If the value is not
476
                        finite, it is printed like <<f>>.
477
 
478
                o E
479
                        Like <<e>>, but using <<E>> to introduce the
480
                        exponent, and like <<F>> for non-finite
481
                        values.
482
 
483
                o g
484
                        Prints a signed value in either <<f>> or <<e>>
485
                        form, based on the given value and
486
                        precision---an exponent less than -4 or
487
                        greater than the precision selects the <<e>>
488
                        form.  Trailing zeros and the decimal point
489
                        are printed only if necessary; takes a
490
                        <<double>>.
491
 
492
                o G
493
                        Like <<g>>, except use <<F>> or <<E>> form.
494
 
495
                o a
496
                        Prints a signed value of the form
497
                        <<[-]0x1.ffffp[+|-]9>>; takes a <<double>>.
498
                        The letters <<abcdef>> are used for digits
499
                        beyond <<9>>.  The precision determines how
500
                        many digits appear after the decimal point.
501
                        The exponent contains at least one digit, and
502
                        is a decimal value representing the power of
503
                        2; a value of 0 has an exponent of 0.
504
                        Non-finite values are printed like <<f>>.
505
 
506
                o A
507
                        Like <<a>>, except uses <<X>>, <<P>>, and
508
                        <<ABCDEF>> instead of lower case.
509
 
510
                o n
511
                        Takes a pointer to <<int>>, and stores a count
512
                        of the number of bytes written so far.  No
513
                        output is created.
514
 
515
                o p
516
                        Takes a pointer to <<void>>, and prints it in
517
                        an implementation-defined format.  This
518
                        implementation is similar to <<%#tx>>), except
519
                        that <<0x>> appears even for the NULL pointer.
520
 
521
                o-
522
        O-
523
 
524
        <<_printf_r>>, <<_fprintf_r>>, <<_asprintf_r>>,
525
        <<_sprintf_r>>, <<_snprintf_r>>, <<_asnprintf_r>> are simply
526
        reentrant versions of the functions above.
527
 
528
RETURNS
529
On success, <<sprintf>> and <<asprintf>> return the number of bytes in
530
the output string, except the concluding <<NUL>> is not counted.
531
<<snprintf>> returns the number of bytes that would be in the output
532
string, except the concluding <<NUL>> is not counted.  <<printf>> and
533
<<fprintf>> return the number of characters transmitted.
534
<<asnprintf>> returns the original <[str]> if there was enough room,
535
otherwise it returns an allocated string.
536
 
537
If an error occurs, the result of <<printf>>, <<fprintf>>,
538
<<snprintf>>, and <<asprintf>> is a negative value, and the result of
539
<<asnprintf>> is NULL.  No error returns occur for <<sprintf>>.  For
540
<<printf>> and <<fprintf>>, <<errno>> may be set according to
541
<<fputc>>.  For <<asprintf>> and <<asnprintf>>, <<errno>> may be set
542
to ENOMEM if allocation fails, and for <<snprintf>>, <<errno>> may be
543
set to EOVERFLOW if <[size]> or the output length exceeds INT_MAX.
544
 
545
BUGS
546
The ``''' (quote) flag does not work when locale's thousands_sep is not empty.
547
 
548
PORTABILITY
549
ANSI C requires <<printf>>, <<fprintf>>, <<sprintf>>, and
550
<<snprintf>>.  <<asprintf>> and <<asnprintf>> are newlib extensions.
551
 
552
The ANSI C standard specifies that implementations must support at
553
least formatted output of up to 509 characters.  This implementation
554
has no inherent limit.
555
 
556
Depending on how newlib was configured, not all format specifiers are
557
supported.
558
 
559
Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
560
<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
561
*/
562
 
563
#include <_ansi.h>
564
#include <reent.h>
565
#include <stdio.h>
566
#ifdef _HAVE_STDC
567
#include <stdarg.h>
568
#else
569
#include <varargs.h>
570
#endif
571
#include <limits.h>
572
#include "local.h"
573
 
574
int
575
#ifdef _HAVE_STDC
576
_DEFUN(_sprintf_r, (ptr, str, fmt),
577
       struct _reent *ptr _AND
578
       char *str          _AND
579
       _CONST char *fmt _DOTS)
580
#else
581
_sprintf_r(ptr, str, fmt, va_alist)
582
           struct _reent *ptr;
583
           char *str;
584
           _CONST char *fmt;
585
           va_dcl
586
#endif
587
{
588
  int ret;
589
  va_list ap;
590
  FILE f;
591
 
592
  f._flags = __SWR | __SSTR;
593
  f._bf._base = f._p = (unsigned char *) str;
594
  f._bf._size = f._w = INT_MAX;
595
  f._file = -1;  /* No file. */
596
#ifdef _HAVE_STDC
597
  va_start (ap, fmt);
598
#else
599
  va_start (ap);
600
#endif
601
  ret = _svfprintf_r (ptr, &f, fmt, ap);
602
  va_end (ap);
603
  *f._p = '\0'; /* terminate the string */
604
  return (ret);
605
}
606
 
607
#ifndef _REENT_ONLY
608
 
609
int
610
#ifdef _HAVE_STDC
611
_DEFUN(sprintf, (str, fmt),
612
       char *str _AND
613
       _CONST char *fmt _DOTS)
614
#else
615
sprintf(str, fmt, va_alist)
616
        char *str;
617
        _CONST char *fmt;
618
        va_dcl
619
#endif
620
{
621
  int ret;
622
  va_list ap;
623
  FILE f;
624
 
625
  f._flags = __SWR | __SSTR;
626
  f._bf._base = f._p = (unsigned char *) str;
627
  f._bf._size = f._w = INT_MAX;
628
  f._file = -1;  /* No file. */
629
#ifdef _HAVE_STDC
630
  va_start (ap, fmt);
631
#else
632
  va_start (ap);
633
#endif
634
  ret = _svfprintf_r (_REENT, &f, fmt, ap);
635
  va_end (ap);
636
  *f._p = '\0'; /* terminate the string */
637
  return (ret);
638
}
639
 
640
#endif

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.