source: arduino-1-6-7/trunk/fuentes/arduino-ide-amd64/hardware/tools/avr/avr/include/stdlib.h @ 4837

Last change on this file since 4837 was 4837, checked in by daduve, 3 years ago

Adding new version

File size: 24.6 KB
Line 
1/* Copyright (c) 2002, Marek Michalkiewicz
2   Copyright (c) 2004,2007 Joerg Wunsch
3
4   Portions of documentation Copyright (c) 1990, 1991, 1993, 1994
5   The Regents of the University of California.
6
7   All rights reserved.
8
9   Redistribution and use in source and binary forms, with or without
10   modification, are permitted provided that the following conditions are met:
11
12   * Redistributions of source code must retain the above copyright
13     notice, this list of conditions and the following disclaimer.
14
15   * Redistributions in binary form must reproduce the above copyright
16     notice, this list of conditions and the following disclaimer in
17     the documentation and/or other materials provided with the
18     distribution.
19
20   * Neither the name of the copyright holders nor the names of
21     contributors may be used to endorse or promote products derived
22     from this software without specific prior written permission.
23
24  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34  POSSIBILITY OF SUCH DAMAGE.
35
36  $Id$
37*/
38
39#ifndef _STDLIB_H_
40#define _STDLIB_H_ 1
41
42#ifndef __ASSEMBLER__
43
44#ifndef __DOXYGEN__
45#define __need_NULL
46#define __need_size_t
47#define __need_wchar_t
48#include <stddef.h>
49
50#ifndef __ptr_t
51#define __ptr_t void *
52#endif
53#endif  /* !__DOXYGEN__ */
54
55#ifdef __cplusplus
56extern "C" {
57#endif
58
59/** \file */
60
61/** \defgroup avr_stdlib <stdlib.h>: General utilities
62    \code #include <stdlib.h> \endcode
63
64    This file declares some basic C macros and functions as
65    defined by the ISO standard, plus some AVR-specific extensions.
66*/
67
68/*@{*/
69/** Result type for function div(). */
70typedef struct {
71        int quot;                   /**< The Quotient. */
72        int rem;                    /**< The Remainder. */
73} div_t;
74
75/** Result type for function ldiv(). */
76typedef struct {
77        long quot;                  /**< The Quotient. */
78        long rem;                   /**< The Remainder. */
79} ldiv_t;
80
81/** Comparision function type for qsort(), just for convenience. */
82typedef int (*__compar_fn_t)(const void *, const void *);
83
84#ifndef __DOXYGEN__
85
86#ifndef __ATTR_CONST__
87# define __ATTR_CONST__ __attribute__((__const__))
88#endif
89
90#ifndef __ATTR_MALLOC__
91# define __ATTR_MALLOC__ __attribute__((__malloc__))
92#endif
93
94#ifndef __ATTR_NORETURN__
95# define __ATTR_NORETURN__ __attribute__((__noreturn__))
96#endif
97
98#ifndef __ATTR_PURE__
99# define __ATTR_PURE__ __attribute__((__pure__))
100#endif
101
102#ifndef __ATTR_GNU_INLINE__
103# ifdef  __GNUC_STDC_INLINE__
104#  define __ATTR_GNU_INLINE__   __attribute__((__gnu_inline__))
105# else
106#  define __ATTR_GNU_INLINE__
107# endif
108#endif
109
110#endif
111
112/** The abort() function causes abnormal program termination to occur.
113    This realization disables interrupts and jumps to _exit() function
114    with argument equal to 1. In the limited AVR environment, execution is
115    effectively halted by entering an infinite loop. */
116extern void abort(void) __ATTR_NORETURN__;
117
118/** The abs() function computes the absolute value of the integer \c i.
119   \note The abs() and labs() functions are builtins of gcc.
120*/
121extern int abs(int __i) __ATTR_CONST__;
122#ifndef __DOXYGEN__
123#define abs(__i) __builtin_abs(__i)
124#endif
125
126/** The labs() function computes the absolute value of the long integer
127    \c i.
128   \note The abs() and labs() functions are builtins of gcc.
129*/
130extern long labs(long __i) __ATTR_CONST__;
131#ifndef __DOXYGEN__
132#define labs(__i) __builtin_labs(__i)
133#endif
134
135/**
136     The bsearch() function searches an array of \c nmemb objects, the
137     initial member of which is pointed to by \c base, for a member
138     that matches the object pointed to by \c key.  The size of each
139     member of the array is specified by \c size.
140
141     The contents of the array should be in ascending sorted order
142     according to the comparison function referenced by \c compar.
143     The \c compar routine is expected to have two arguments which
144     point to the key object and to an array member, in that order,
145     and should return an integer less than, equal to, or greater than
146     zero if the key object is found, respectively, to be less than,
147     to match, or be greater than the array member.
148
149     The bsearch() function returns a pointer to a matching member of
150     the array, or a null pointer if no match is found.  If two
151     members compare as equal, which member is matched is unspecified.
152*/
153extern void *bsearch(const void *__key, const void *__base, size_t __nmemb,
154                     size_t __size, int (*__compar)(const void *, const void *));
155
156/* __divmodhi4 and __divmodsi4 from libgcc.a */
157/**
158     The div() function computes the value \c num/denom and returns
159     the quotient and remainder in a structure named \c div_t that
160     contains two int members named \c quot and \c rem.
161*/
162extern div_t div(int __num, int __denom) __asm__("__divmodhi4") __ATTR_CONST__;
163/**
164     The ldiv() function computes the value \c num/denom and returns
165     the quotient and remainder in a structure named \c ldiv_t that
166     contains two long integer members named \c quot and \c rem.
167*/
168extern ldiv_t ldiv(long __num, long __denom) __asm__("__divmodsi4") __ATTR_CONST__;
169
170/**
171     The qsort() function is a modified partition-exchange sort, or
172     quicksort.
173
174     The qsort() function sorts an array of \c nmemb objects, the
175     initial member of which is pointed to by \c base.  The size of
176     each object is specified by \c size.  The contents of the array
177     base are sorted in ascending order according to a comparison
178     function pointed to by \c compar, which requires two arguments
179     pointing to the objects being compared.
180
181     The comparison function must return an integer less than, equal
182     to, or greater than zero if the first argument is considered to
183     be respectively less than, equal to, or greater than the second.
184*/
185extern void qsort(void *__base, size_t __nmemb, size_t __size,
186                  __compar_fn_t __compar);
187
188/**
189    The strtol() function converts the string in \c nptr to a long
190    value.  The conversion is done according to the given base, which
191    must be between 2 and 36 inclusive, or be the special value 0.
192
193    The string may begin with an arbitrary amount of white space (as
194    determined by isspace()) followed by a single optional \c '+' or \c '-'
195    sign.  If \c base is zero or 16, the string may then include a
196    \c "0x" prefix, and the number will be read in base 16; otherwise,
197    a zero base is taken as 10 (decimal) unless the next character is
198    \c '0', in which case it is taken as 8 (octal).
199
200    The remainder of the string is converted to a long value in the
201    obvious manner, stopping at the first character which is not a
202    valid digit in the given base.  (In bases above 10, the letter \c 'A'
203    in either upper or lower case represents 10, \c 'B' represents 11,
204    and so forth, with \c 'Z' representing 35.)
205
206    If \c endptr is not NULL, strtol() stores the address of the first
207    invalid character in \c *endptr.  If there were no digits at all,
208    however, strtol() stores the original value of \c nptr in \c
209    *endptr.  (Thus, if \c *nptr is not \c '\\0' but \c **endptr is \c '\\0'
210    on return, the entire string was valid.)
211
212    The strtol() function returns the result of the conversion, unless
213    the value would underflow or overflow.  If no conversion could be
214    performed, 0 is returned.  If an overflow or underflow occurs, \c
215    errno is set to \ref avr_errno "ERANGE" and the function return value
216    is clamped to \c LONG_MIN or \c LONG_MAX, respectively.
217*/
218extern long strtol(const char *__nptr, char **__endptr, int __base);
219
220/**
221    The strtoul() function converts the string in \c nptr to an
222    unsigned long value.  The conversion is done according to the
223    given base, which must be between 2 and 36 inclusive, or be the
224    special value 0.
225
226    The string may begin with an arbitrary amount of white space (as
227    determined by isspace()) followed by a single optional \c '+' or \c '-'
228    sign.  If \c base is zero or 16, the string may then include a
229    \c "0x" prefix, and the number will be read in base 16; otherwise,
230    a zero base is taken as 10 (decimal) unless the next character is
231    \c '0', in which case it is taken as 8 (octal).
232
233    The remainder of the string is converted to an unsigned long value
234    in the obvious manner, stopping at the first character which is
235    not a valid digit in the given base.  (In bases above 10, the
236    letter \c 'A' in either upper or lower case represents 10, \c 'B'
237    represents 11, and so forth, with \c 'Z' representing 35.)
238
239    If \c endptr is not NULL, strtoul() stores the address of the first
240    invalid character in \c *endptr.  If there were no digits at all,
241    however, strtoul() stores the original value of \c nptr in \c
242    *endptr.  (Thus, if \c *nptr is not \c '\\0' but \c **endptr is \c '\\0'
243    on return, the entire string was valid.)
244
245    The strtoul() function return either the result of the conversion
246    or, if there was a leading minus sign, the negation of the result
247    of the conversion, unless the original (non-negated) value would
248    overflow; in the latter case, strtoul() returns ULONG_MAX, and \c
249    errno is set to \ref avr_errno "ERANGE".  If no conversion could
250    be performed, 0 is returned.
251*/
252extern unsigned long strtoul(const char *__nptr, char **__endptr, int __base);
253
254/**
255    The atol() function converts the initial portion of the string
256    pointed to by \p s to long integer representation. In contrast to
257
258        \code strtol(s, (char **)NULL, 10); \endcode
259
260    this function does not detect overflow (\c errno is not changed and
261    the result value is not predictable), uses smaller memory (flash and
262    stack) and works more quickly.
263*/
264extern long atol(const char *__s) __ATTR_PURE__;
265
266/**
267    The atoi() function converts the initial portion of the string
268    pointed to by \p s to integer representation. In contrast to
269
270        \code (int)strtol(s, (char **)NULL, 10); \endcode
271
272    this function does not detect overflow (\c errno is not changed and
273    the result value is not predictable), uses smaller memory (flash and
274    stack) and works more quickly.
275*/
276extern int atoi(const char *__s) __ATTR_PURE__;
277
278/**
279   The exit() function terminates the application.  Since there is no
280   environment to return to, \c status is ignored, and code execution
281   will eventually reach an infinite loop, thereby effectively halting
282   all code processing.  Before entering the infinite loop, interrupts
283   are globally disabled.
284
285   In a C++ context, global destructors will be called before halting
286   execution.
287*/
288extern void exit(int __status) __ATTR_NORETURN__;
289
290/**
291   The malloc() function allocates \c size bytes of memory.
292   If malloc() fails, a NULL pointer is returned.
293
294   Note that malloc() does \e not initialize the returned memory to
295   zero bytes.
296
297   See the chapter about \ref malloc "malloc() usage" for implementation
298   details.
299*/
300extern void *malloc(size_t __size) __ATTR_MALLOC__;
301
302/**
303   The free() function causes the allocated memory referenced by \c
304   ptr to be made available for future allocations.  If \c ptr is
305   NULL, no action occurs.
306*/
307extern void free(void *__ptr);
308
309/**
310   \c malloc() \ref malloc_tunables "tunable".
311*/
312extern size_t __malloc_margin;
313
314/**
315   \c malloc() \ref malloc_tunables "tunable".
316*/
317extern char *__malloc_heap_start;
318
319/**
320   \c malloc() \ref malloc_tunables "tunable".
321*/
322extern char *__malloc_heap_end;
323
324/**
325   Allocate \c nele elements of \c size each.  Identical to calling
326   \c malloc() using <tt>nele * size</tt> as argument, except the
327   allocated memory will be cleared to zero.
328*/
329extern void *calloc(size_t __nele, size_t __size) __ATTR_MALLOC__;
330
331/**
332   The realloc() function tries to change the size of the region
333   allocated at \c ptr to the new \c size value.  It returns a
334   pointer to the new region.  The returned pointer might be the
335   same as the old pointer, or a pointer to a completely different
336   region.
337
338   The contents of the returned region up to either the old or the new
339   size value (whatever is less) will be identical to the contents of
340   the old region, even in case a new region had to be allocated.
341
342   It is acceptable to pass \c ptr as NULL, in which case realloc()
343   will behave identical to malloc().
344
345   If the new memory cannot be allocated, realloc() returns NULL, and
346   the region at \c ptr will not be changed.
347*/
348extern void *realloc(void *__ptr, size_t __size) __ATTR_MALLOC__;
349
350extern double strtod(const char *__nptr, char **__endptr);
351
352/** \ingroup avr_stdlib
353    \fn  double atof (const char *nptr)
354
355    The atof() function converts the initial portion of the string pointed
356    to by \a nptr to double representation.
357
358    It is equivalent to calling
359        \code strtod(nptr, (char **)0); \endcode
360 */
361extern double atof(const char *__nptr);
362
363/** Highest number that can be generated by rand(). */
364#define RAND_MAX 0x7FFF
365
366/**
367     The rand() function computes a sequence of pseudo-random integers in the
368     range of 0 to \c RAND_MAX (as defined by the header file <stdlib.h>).
369
370     The srand() function sets its argument \c seed as the seed for a new
371     sequence of pseudo-random numbers to be returned by rand().  These
372     sequences are repeatable by calling srand() with the same seed value.
373
374     If no seed value is provided, the functions are automatically seeded with
375     a value of 1.
376
377     In compliance with the C standard, these functions operate on
378     \c int arguments.  Since the underlying algorithm already uses
379     32-bit calculations, this causes a loss of precision.  See
380     \c random() for an alternate set of functions that retains full
381     32-bit precision.
382*/
383extern int rand(void);
384/**
385   Pseudo-random number generator seeding; see rand().
386*/
387extern void srand(unsigned int __seed);
388
389/**
390   Variant of rand() that stores the context in the user-supplied
391   variable located at \c ctx instead of a static library variable
392   so the function becomes re-entrant.
393*/
394extern int rand_r(unsigned long *__ctx);
395/*@}*/
396
397/*@{*/
398/** \name Non-standard (i.e. non-ISO C) functions.
399 \ingroup avr_stdlib
400*/
401/**
402   \brief Convert an integer to a string.
403
404   The function itoa() converts the integer value from \c val into an
405   ASCII representation that will be stored under \c s.  The caller
406   is responsible for providing sufficient storage in \c s.
407
408   \note The minimal size of the buffer \c s depends on the choice of
409   radix. For example, if the radix is 2 (binary), you need to supply a buffer
410   with a minimal length of 8 * sizeof (int) + 1 characters, i.e. one
411   character for each bit plus one for the string terminator. Using a larger
412   radix will require a smaller minimal buffer size.
413
414   \warning If the buffer is too small, you risk a buffer overflow.
415
416   Conversion is done using the \c radix as base, which may be a
417   number between 2 (binary conversion) and up to 36.  If \c radix
418   is greater than 10, the next digit after \c '9' will be the letter
419   \c 'a'.
420   
421    If radix is 10 and val is negative, a minus sign will be prepended.
422
423   The itoa() function returns the pointer passed as \c s.
424*/
425#ifdef  __DOXYGEN__
426extern char *itoa(int val, char *s, int radix);
427#else
428extern __inline__ __ATTR_GNU_INLINE__
429char *itoa (int __val, char *__s, int __radix)
430{
431    if (!__builtin_constant_p (__radix)) {
432        extern char *__itoa (int, char *, int);
433        return __itoa (__val, __s, __radix);
434    } else if (__radix < 2 || __radix > 36) {
435        *__s = 0;
436        return __s;
437    } else {
438        extern char *__itoa_ncheck (int, char *, unsigned char);
439        return __itoa_ncheck (__val, __s, __radix);
440    }
441}
442#endif
443
444/**
445 \ingroup avr_stdlib
446 
447   \brief Convert a long integer to a string.
448
449   The function ltoa() converts the long integer value from \c val into an
450   ASCII representation that will be stored under \c s.  The caller
451   is responsible for providing sufficient storage in \c s.
452
453   \note The minimal size of the buffer \c s depends on the choice of
454   radix. For example, if the radix is 2 (binary), you need to supply a buffer
455   with a minimal length of 8 * sizeof (long int) + 1 characters, i.e. one
456   character for each bit plus one for the string terminator. Using a larger
457   radix will require a smaller minimal buffer size.
458
459   \warning If the buffer is too small, you risk a buffer overflow.
460
461   Conversion is done using the \c radix as base, which may be a
462   number between 2 (binary conversion) and up to 36.  If \c radix
463   is greater than 10, the next digit after \c '9' will be the letter
464   \c 'a'.
465
466   If radix is 10 and val is negative, a minus sign will be prepended.
467
468   The ltoa() function returns the pointer passed as \c s.
469*/
470#ifdef  __DOXYGEN__
471extern char *ltoa(long val, char *s, int radix);
472#else
473extern __inline__ __ATTR_GNU_INLINE__
474char *ltoa (long __val, char *__s, int __radix)
475{
476    if (!__builtin_constant_p (__radix)) {
477        extern char *__ltoa (long, char *, int);
478        return __ltoa (__val, __s, __radix);
479    } else if (__radix < 2 || __radix > 36) {
480        *__s = 0;
481        return __s;
482    } else {
483        extern char *__ltoa_ncheck (long, char *, unsigned char);
484        return __ltoa_ncheck (__val, __s, __radix);
485    }
486}
487#endif
488
489/**
490 \ingroup avr_stdlib
491
492   \brief Convert an unsigned integer to a string.
493
494   The function utoa() converts the unsigned integer value from \c val into an
495   ASCII representation that will be stored under \c s.  The caller
496   is responsible for providing sufficient storage in \c s.
497
498   \note The minimal size of the buffer \c s depends on the choice of
499   radix. For example, if the radix is 2 (binary), you need to supply a buffer
500   with a minimal length of 8 * sizeof (unsigned int) + 1 characters, i.e. one
501   character for each bit plus one for the string terminator. Using a larger
502   radix will require a smaller minimal buffer size.
503
504   \warning If the buffer is too small, you risk a buffer overflow.
505
506   Conversion is done using the \c radix as base, which may be a
507   number between 2 (binary conversion) and up to 36.  If \c radix
508   is greater than 10, the next digit after \c '9' will be the letter
509   \c 'a'.
510
511   The utoa() function returns the pointer passed as \c s.
512*/
513#ifdef  __DOXYGEN__
514extern char *utoa(unsigned int val, char *s, int radix);
515#else
516extern __inline__ __ATTR_GNU_INLINE__
517char *utoa (unsigned int __val, char *__s, int __radix)
518{
519    if (!__builtin_constant_p (__radix)) {
520        extern char *__utoa (unsigned int, char *, int);
521        return __utoa (__val, __s, __radix);
522    } else if (__radix < 2 || __radix > 36) {
523        *__s = 0;
524        return __s;
525    } else {
526        extern char *__utoa_ncheck (unsigned int, char *, unsigned char);
527        return __utoa_ncheck (__val, __s, __radix);
528    }
529}
530#endif
531
532/**
533 \ingroup avr_stdlib
534   \brief Convert an unsigned long integer to a string.
535
536   The function ultoa() converts the unsigned long integer value from
537   \c val into an ASCII representation that will be stored under \c s.
538   The caller is responsible for providing sufficient storage in \c s.
539
540   \note The minimal size of the buffer \c s depends on the choice of
541   radix. For example, if the radix is 2 (binary), you need to supply a buffer
542   with a minimal length of 8 * sizeof (unsigned long int) + 1 characters,
543   i.e. one character for each bit plus one for the string terminator. Using a
544   larger radix will require a smaller minimal buffer size.
545
546   \warning If the buffer is too small, you risk a buffer overflow.
547
548   Conversion is done using the \c radix as base, which may be a
549   number between 2 (binary conversion) and up to 36.  If \c radix
550   is greater than 10, the next digit after \c '9' will be the letter
551   \c 'a'.
552
553   The ultoa() function returns the pointer passed as \c s.
554*/
555#ifdef  __DOXYGEN__
556extern char *ultoa(unsigned long val, char *s, int radix);
557#else
558extern __inline__ __ATTR_GNU_INLINE__
559char *ultoa (unsigned long __val, char *__s, int __radix)
560{
561    if (!__builtin_constant_p (__radix)) {
562        extern char *__ultoa (unsigned long, char *, int);
563        return __ultoa (__val, __s, __radix);
564    } else if (__radix < 2 || __radix > 36) {
565        *__s = 0;
566        return __s;
567    } else {
568        extern char *__ultoa_ncheck (unsigned long, char *, unsigned char);
569        return __ultoa_ncheck (__val, __s, __radix);
570    }
571}
572#endif
573
574/**  \ingroup avr_stdlib
575Highest number that can be generated by random(). */
576#define RANDOM_MAX 0x7FFFFFFF
577
578/**
579 \ingroup avr_stdlib
580     The random() function computes a sequence of pseudo-random integers in the
581     range of 0 to \c RANDOM_MAX (as defined by the header file <stdlib.h>).
582
583     The srandom() function sets its argument \c seed as the seed for a new
584     sequence of pseudo-random numbers to be returned by rand().  These
585     sequences are repeatable by calling srandom() with the same seed value.
586
587     If no seed value is provided, the functions are automatically seeded with
588     a value of 1.
589*/
590extern long random(void);
591/**
592 \ingroup avr_stdlib
593   Pseudo-random number generator seeding; see random().
594*/
595extern void srandom(unsigned long __seed);
596
597/**
598 \ingroup avr_stdlib
599   Variant of random() that stores the context in the user-supplied
600   variable located at \c ctx instead of a static library variable
601   so the function becomes re-entrant.
602*/
603extern long random_r(unsigned long *__ctx);
604#endif /* __ASSEMBLER */
605/*@}*/
606
607/*@{*/
608/** \name Conversion functions for double arguments.
609 \ingroup avr_stdlib
610 Note that these functions are not located in the default library,
611 <tt>libc.a</tt>, but in the mathematical library, <tt>libm.a</tt>.
612 So when linking the application, the \c -lm option needs to be
613 specified.
614*/
615/** \ingroup avr_stdlib
616    Bit value that can be passed in \c flags to dtostre(). */
617#define DTOSTR_ALWAYS_SIGN 0x01        /* put '+' or ' ' for positives */
618/** \ingroup avr_stdlib
619    Bit value that can be passed in \c flags to dtostre(). */
620#define DTOSTR_PLUS_SIGN   0x02        /* put '+' rather than ' ' */
621/** \ingroup avr_stdlib
622    Bit value that can be passed in \c flags to dtostre(). */
623#define DTOSTR_UPPERCASE   0x04        /* put 'E' rather 'e' */
624
625#ifndef __ASSEMBLER__
626
627/**
628   \ingroup avr_stdlib
629   The dtostre() function converts the double value passed in \c val into
630   an ASCII representation that will be stored under \c s.  The caller
631   is responsible for providing sufficient storage in \c s.
632
633   Conversion is done in the format \c "[-]d.ddde±dd" where there is
634   one digit before the decimal-point character and the number of
635   digits after it is equal to the precision \c prec; if the precision
636   is zero, no decimal-point character appears.  If \c flags has the
637   DTOSTRE_UPPERCASE bit set, the letter \c 'E' (rather than \c 'e' ) will be
638   used to introduce the exponent.  The exponent always contains two
639   digits; if the value is zero, the exponent is \c "00".
640
641   If \c flags has the DTOSTRE_ALWAYS_SIGN bit set, a space character
642   will be placed into the leading position for positive numbers.
643
644   If \c flags has the DTOSTRE_PLUS_SIGN bit set, a plus sign will be
645   used instead of a space character in this case.
646
647   The dtostre() function returns the pointer to the converted string \c s.
648*/
649extern char *dtostre(double __val, char *__s, unsigned char __prec,
650                     unsigned char __flags);
651
652/**
653   \ingroup avr_stdlib
654   The dtostrf() function converts the double value passed in \c val into
655   an ASCII representationthat will be stored under \c s.  The caller
656   is responsible for providing sufficient storage in \c s.
657
658   Conversion is done in the format \c "[-]d.ddd".  The minimum field
659   width of the output string (including the possible \c '.' and the possible
660   sign for negative values) is given in \c width, and \c prec determines
661   the number of digits after the decimal sign. \c width is signed value,
662   negative for left adjustment.
663
664   The dtostrf() function returns the pointer to the converted string \c s.
665*/
666extern char *dtostrf(double __val, signed char __width,
667                     unsigned char __prec, char *__s);
668
669/**
670   \ingroup avr_stdlib
671    Successful termination for exit(); evaluates to 0.
672*/
673#define EXIT_SUCCESS 0
674
675/**
676   \ingroup avr_stdlib
677    Unsuccessful termination for exit(); evaluates to a non-zero value.
678*/
679#define EXIT_FAILURE 1
680
681/*@}*/
682
683#ifndef __DOXYGEN__
684/* dummy declarations for libstdc++ compatibility */
685extern int atexit(void (*)(void));
686extern int system (const char *);
687extern char *getenv (const char *);
688#endif  /* __DOXYGEN__ */
689
690#ifdef __cplusplus
691}
692#endif
693
694#endif /* __ASSEMBLER */
695
696#endif /* _STDLIB_H_ */
Note: See TracBrowser for help on using the repository browser.