Provided by: avr-libc_1.8.0+Atmel3.5.0-1_all bug

NAME

       pgmspace.h -

SYNOPSIS

   Macros
       #define __need_size_t
       #define __ATTR_PROGMEM__   __attribute__((__progmem__))
       #define __ATTR_PURE__   __attribute__((__pure__))
       #define PROGMEM   __ATTR_PROGMEM__
       #define PGM_P   const char *
       #define PGM_VOID_P   const void *
       #define PSTR(s)   ((const PROGMEM char *)(s))
       #define __LPM_classic__(addr)
       #define __LPM_tiny__(addr)
       #define __LPM_enhanced__(addr)
       #define __LPM_word_classic__(addr)
       #define __LPM_word_tiny__(addr)
       #define __LPM_word_enhanced__(addr)
       #define __LPM_dword_classic__(addr)
       #define __LPM_dword_tiny__(addr)
       #define __LPM_dword_enhanced__(addr)
       #define __LPM_float_classic__(addr)
       #define __LPM_float_tiny__(addr)
       #define __LPM_float_enhanced__(addr)
       #define __LPM(addr)   __LPM_classic__(addr)
       #define __LPM_word(addr)   __LPM_word_classic__(addr)
       #define __LPM_dword(addr)   __LPM_dword_classic__(addr)
       #define __LPM_float(addr)   __LPM_float_classic__(addr)
       #define pgm_read_byte_near(address_short)   __LPM((uint16_t)(address_short))
       #define pgm_read_word_near(address_short)   __LPM_word((uint16_t)(address_short))
       #define pgm_read_dword_near(address_short)   __LPM_dword((uint16_t)(address_short))
       #define pgm_read_float_near(address_short)   __LPM_float((uint16_t)(address_short))
       #define pgm_read_ptr_near(address_short)   (void*)__LPM_word((uint16_t)(address_short))
       #define __ELPM_classic__(addr)
       #define __ELPM_enhanced__(addr)
       #define __ELPM_xmega__(addr)
       #define __ELPM_word_classic__(addr)
       #define __ELPM_word_enhanced__(addr)
       #define __ELPM_word_xmega__(addr)
       #define __ELPM_dword_classic__(addr)
       #define __ELPM_dword_enhanced__(addr)
       #define __ELPM_dword_xmega__(addr)
       #define __ELPM_float_classic__(addr)
       #define __ELPM_float_enhanced__(addr)
       #define __ELPM_float_xmega__(addr)
       #define __ELPM(addr)   __ELPM_classic__(addr)
       #define __ELPM_word(addr)   __ELPM_word_classic__(addr)
       #define __ELPM_dword(addr)   __ELPM_dword_classic__(addr)
       #define __ELPM_float(addr)   __ELPM_float_classic__(addr)
       #define pgm_read_byte_far(address_long)   __ELPM((uint32_t)(address_long))
       #define pgm_read_word_far(address_long)   __ELPM_word((uint32_t)(address_long))
       #define pgm_read_dword_far(address_long)   __ELPM_dword((uint32_t)(address_long))
       #define pgm_read_float_far(address_long)   __ELPM_float((uint32_t)(address_long))
       #define pgm_read_ptr_far(address_long)   (void*)__ELPM_word((uint32_t)(address_long))
       #define pgm_read_byte(address_short)   pgm_read_byte_near(address_short)
       #define pgm_read_word(address_short)   pgm_read_word_near(address_short)
       #define pgm_read_dword(address_short)   pgm_read_dword_near(address_short)
       #define pgm_read_float(address_short)   pgm_read_float_near(address_short)
       #define pgm_read_ptr(address_short)   pgm_read_ptr_near(address_short)
       #define pgm_get_far_address(var)

   Typedefs
       typedef void PROGMEM prog_void
       typedef char PROGMEM prog_char
       typedef unsigned char PROGMEM prog_uchar
       typedef int8_t PROGMEM prog_int8_t
       typedef uint8_t PROGMEM prog_uint8_t
       typedef int16_t PROGMEM prog_int16_t
       typedef uint16_t PROGMEM prog_uint16_t
       typedef int32_t PROGMEM prog_int32_t
       typedef uint32_t PROGMEM prog_uint32_t
       typedef int64_t PROGMEM prog_int64_t
       typedef uint64_t PROGMEM prog_uint64_t

   Functions
       const void * memchr_P (const void *, int __val, size_t __len)
       int memcmp_P (const void *, const void *, size_t) __ATTR_PURE__
       void * memccpy_P (void *, const void *, int __val, size_t)
       void * memcpy_P (void *, const void *, size_t)
       void * memmem_P (const void *, size_t, const void *, size_t) __ATTR_PURE__
       const void * memrchr_P (const void *, int __val, size_t __len)
       char * strcat_P (char *, const char *)
       const char * strchr_P (const char *, int __val)
       const char * strchrnul_P (const char *, int __val)
       int strcmp_P (const char *, const char *) __ATTR_PURE__
       char * strcpy_P (char *, const char *)
       int strcasecmp_P (const char *, const char *) __ATTR_PURE__
       char * strcasestr_P (const char *, const char *) __ATTR_PURE__
       size_t strcspn_P (const char *__s, const char *__reject) __ATTR_PURE__
       size_t strlcat_P (char *, const char *, size_t)
       size_t strlcpy_P (char *, const char *, size_t)
       size_t __strlen_P (const char *)
       size_t strnlen_P (const char *, size_t)
       int strncmp_P (const char *, const char *, size_t) __ATTR_PURE__
       int strncasecmp_P (const char *, const char *, size_t) __ATTR_PURE__
       char * strncat_P (char *, const char *, size_t)
       char * strncpy_P (char *, const char *, size_t)
       char * strpbrk_P (const char *__s, const char *__accept) __ATTR_PURE__
       const char * strrchr_P (const char *, int __val)
       char * strsep_P (char **__sp, const char *__delim)
       size_t strspn_P (const char *__s, const char *__accept) __ATTR_PURE__
       char * strstr_P (const char *, const char *) __ATTR_PURE__
       char * strtok_P (char *__s, const char *__delim)
       char * strtok_rP (char *__s, const char *__delim, char **__last)
       size_t strlen_PF (uint_farptr_t src)
       size_t strnlen_PF (uint_farptr_t src, size_t len)
       void * memcpy_PF (void *dest, uint_farptr_t src, size_t len)
       char * strcpy_PF (char *dest, uint_farptr_t src)
       char * strncpy_PF (char *dest, uint_farptr_t src, size_t len)
       char * strcat_PF (char *dest, uint_farptr_t src)
       size_t strlcat_PF (char *dst, uint_farptr_t src, size_t siz)
       char * strncat_PF (char *dest, uint_farptr_t src, size_t len)
       int strcmp_PF (const char *s1, uint_farptr_t s2) __ATTR_PURE__
       int strncmp_PF (const char *s1, uint_farptr_t s2, size_t n) __ATTR_PURE__
       int strcasecmp_PF (const char *s1, uint_farptr_t s2) __ATTR_PURE__
       int strncasecmp_PF (const char *s1, uint_farptr_t s2, size_t n) __ATTR_PURE__
       char * strstr_PF (const char *s1, uint_farptr_t s2)
       size_t strlcpy_PF (char *dst, uint_farptr_t src, size_t siz)
       int memcmp_PF (const void *, uint_farptr_t, size_t) __ATTR_PURE__
       __attribute__ ((__always_inline__)) static __inline__ size_t strlen_P(const char *s)
       static __inline__ size_t strlen_P (const char *s)

Macro Definition Documentation

   #define __ELPM_classic__(addr)
       Value:

       (__extension__({                    \
           uint32_t __addr32 = (uint32_t)(addr); \
           uint8_t __result;                   __asm__ __volatile__                (                                       "out %2, %C1" ""                "mov r31, %B1" ""               "mov r30, %A1" ""               "elpm" ""                       "mov %0, r0" ""                 : "=r" (__result)                   : "r" (__addr32),                     "I" (_SFR_IO_ADDR(RAMPZ))         : "r0", "r30", "r31"            );                                  __result;                       }))

   #define __ELPM_dword_enhanced__(addr)
       Value:

       (__extension__({                          \
           uint32_t __addr32 = (uint32_t)(addr); \
           uint32_t __result;                        __asm__ __volatile__                      (                                             "out %2, %C1"   ""                    "movw r30, %1"  ""                    "elpm %A0, Z+"  ""                    "elpm %B0, Z+"  ""                    "elpm %C0, Z+"  ""                    "elpm %D0, Z"   ""                    : "=r" (__result)                         : "r" (__addr32),                           "I" (_SFR_IO_ADDR(RAMPZ))               : "r30", "r31"                        );                                        __result;                             }))

   #define __ELPM_dword_xmega__(addr)
       Value:

       (__extension__({                          \
           uint32_t __addr32 = (uint32_t)(addr); \
           uint32_t __result;                        __asm__ __volatile__                      (                                             "in __tmp_reg__, %2" ""               "out %2, %C1"   ""                    "movw r30, %1"  ""                    "elpm %A0, Z+"  ""                    "elpm %B0, Z+"  ""                    "elpm %C0, Z+"  ""                    "elpm %D0, Z"   ""                    "out %2, __tmp_reg__"                     : "=r" (__result)                         : "r" (__addr32),                           "I" (_SFR_IO_ADDR(RAMPZ))               : "r30", "r31"                        );                                        __result;                             }))

   #define __ELPM_enhanced__(addr)
       Value:

       (__extension__({                    \
           uint32_t __addr32 = (uint32_t)(addr); \
           uint8_t __result;                   __asm__ __volatile__                (                                       "out %2, %C1" ""                "movw r30, %1" ""               "elpm %0, Z+" ""                : "=r" (__result)                   : "r" (__addr32),                     "I" (_SFR_IO_ADDR(RAMPZ))         : "r30", "r31"                  );                                  __result;                       }))

   #define __ELPM_float_enhanced__(addr)
       Value:

       (__extension__({                          \
           uint32_t __addr32 = (uint32_t)(addr);     float __result;                           __asm__ __volatile__                      (                                             "out %2, %C1"   ""                    "movw r30, %1"  ""                    "elpm %A0, Z+"  ""                    "elpm %B0, Z+"  ""                    "elpm %C0, Z+"  ""                    "elpm %D0, Z"   ""                    : "=r" (__result)                         : "r" (__addr32),                           "I" (_SFR_IO_ADDR(RAMPZ))               : "r30", "r31"                        );                                        __result;                             }))

   #define __ELPM_float_xmega__(addr)
       Value:

       (__extension__({                          \
           uint32_t __addr32 = (uint32_t)(addr);     float __result;                           __asm__ __volatile__                      (                                             "in __tmp_reg__, %2" ""               "out %2, %C1"   ""                    "movw r30, %1"  ""                    "elpm %A0, Z+"  ""                    "elpm %B0, Z+"  ""                    "elpm %C0, Z+"  ""                    "elpm %D0, Z"   ""                    "out %2, __tmp_reg__"                     : "=r" (__result)                         : "r" (__addr32),                           "I" (_SFR_IO_ADDR(RAMPZ))               : "r30", "r31"                        );                                        __result;                             }))

   #define __ELPM_word_classic__(addr)
       Value:

       (__extension__({                        \
           uint32_t __addr32 = (uint32_t)(addr); \
           uint16_t __result;                      __asm__ __volatile__                    (                                           "out %2, %C1"   ""                  "mov r31, %B1"  ""                  "mov r30, %A1"  ""                  "elpm"          ""                  "mov %A0, r0"   ""                  "in r0, %2"     ""                  "adiw r30, 1"   ""                  "adc r0, __zero_reg__" ""           "out %2, r0"    ""                  "elpm"          ""                  "mov %B0, r0"   ""                  : "=r" (__result)                       : "r" (__addr32),                         "I" (_SFR_IO_ADDR(RAMPZ))             : "r0", "r30", "r31"                );                                      __result;                           }))

   #define __ELPM_word_enhanced__(addr)
       Value:

       (__extension__({                        \
           uint32_t __addr32 = (uint32_t)(addr); \
           uint16_t __result;                      __asm__ __volatile__                    (                                           "out %2, %C1"   ""                  "movw r30, %1"  ""                  "elpm %A0, Z+"  ""                  "elpm %B0, Z"   ""                  : "=r" (__result)                       : "r" (__addr32),                         "I" (_SFR_IO_ADDR(RAMPZ))             : "r30", "r31"                      );                                      __result;                           }))

   #define __ELPM_word_xmega__(addr)
       Value:

       (__extension__({                        \
           uint32_t __addr32 = (uint32_t)(addr); \
           uint16_t __result;                      __asm__ __volatile__                    (                                           "in __tmp_reg__, %2" ""             "out %2, %C1"   ""                  "movw r30, %1"  ""                  "elpm %A0, Z+"  ""                  "elpm %B0, Z"   ""                  "out %2, __tmp_reg__"                   : "=r" (__result)                       : "r" (__addr32),                         "I" (_SFR_IO_ADDR(RAMPZ))             : "r30", "r31"                      );                                      __result;                           }))

   #define __ELPM_xmega__(addr)
       Value:

       (__extension__({                    \
           uint32_t __addr32 = (uint32_t)(addr); \
           uint8_t __result;                   __asm__ __volatile__                (                                       "in __tmp_reg__, %2" ""         "out %2, %C1" ""                "movw r30, %1" ""               "elpm %0, Z+" ""                "out %2, __tmp_reg__"               : "=r" (__result)                   : "r" (__addr32),                     "I" (_SFR_IO_ADDR(RAMPZ))         : "r30", "r31"                  );                                  __result;                       }))

   #define __LPM_classic__(addr)
       Value:

       (__extension__({                \
           uint16_t __addr16 = (uint16_t)(addr); \
           uint8_t __result;               __asm__ __volatile__            (                                   "lpm" ""                    "mov %0, r0" ""             : "=r" (__result)               : "z" (__addr16)                : "r0"                      );                              __result;                   }))

   #define __LPM_dword_classic__(addr)
       Value:

       (__extension__({                            \
           uint16_t __addr16 = (uint16_t)(addr);   \
           uint32_t __result;                          __asm__ __volatile__                        (                                               "lpm"           ""                      "mov %A0, r0"   ""                      "adiw r30, 1"   ""                      "lpm"           ""                      "mov %B0, r0"   ""                      "adiw r30, 1"   ""                      "lpm"           ""                      "mov %C0, r0"   ""                      "adiw r30, 1"   ""                      "lpm"           ""                      "mov %D0, r0"   ""                      : "=r" (__result), "=z" (__addr16)          : "1" (__addr16)                            : "r0"                                  );                                          __result;                               }))

   #define __LPM_dword_enhanced__(addr)
       Value:

       (__extension__({                            \
           uint16_t __addr16 = (uint16_t)(addr);   \
           uint32_t __result;                          __asm__ __volatile__                        (                                               "lpm %A0, Z+"   ""                      "lpm %B0, Z+"   ""                      "lpm %C0, Z+"   ""                      "lpm %D0, Z"    ""                      : "=r" (__result), "=z" (__addr16)          : "1" (__addr16)                        );                                          __result;                               }))

   #define __LPM_dword_tiny__(addr)
       Value:

       (__extension__({                            \
           uint16_t __addr16 = (uint16_t)(addr) + __AVR_TINY_PM_BASE_ADDRESS__; \
           uint32_t __result;                          __asm__                                     (                                               "ld %A0, z+"    ""                      "ld %B0, z+"    ""                      "ld %C0, z+"    ""                      "ld %D0, z"     ""                      : "=r" (__result), "=z" (__addr16)          : "1" (__addr16)                        );                                          __result;                               }))

   #define __LPM_enhanced__(addr)
       Value:

       (__extension__({                \
           uint16_t __addr16 = (uint16_t)(addr); \
           uint8_t __result;               __asm__ __volatile__            (                                   "lpm %0, Z" ""              : "=r" (__result)               : "z" (__addr16)            );                              __result;                   }))

   #define __LPM_float_classic__(addr)
       Value:

       (__extension__({                            \
           uint16_t __addr16 = (uint16_t)(addr);       float __result;                             __asm__ __volatile__                        (                                               "lpm"           ""                      "mov %A0, r0"   ""                      "adiw r30, 1"   ""                      "lpm"           ""                      "mov %B0, r0"   ""                      "adiw r30, 1"   ""                      "lpm"           ""                      "mov %C0, r0"   ""                      "adiw r30, 1"   ""                      "lpm"           ""                      "mov %D0, r0"   ""                      : "=r" (__result), "=z" (__addr16)          : "1" (__addr16)                            : "r0"                                  );                                          __result;                               }))

   #define __LPM_float_enhanced__(addr)
       Value:

       (__extension__({                            \
           uint16_t __addr16 = (uint16_t)(addr);       float __result;                             __asm__ __volatile__                        (                                               "lpm %A0, Z+"   ""                      "lpm %B0, Z+"   ""                      "lpm %C0, Z+"   ""                      "lpm %D0, Z"    ""                      : "=r" (__result), "=z" (__addr16)          : "1" (__addr16)                        );                                          __result;                               }))

   #define __LPM_float_tiny__(addr)
       Value:

       (__extension__({                            \
           uint16_t __addr16 = (uint16_t)(addr) + __AVR_TINY_PM_BASE_ADDRESS__;     float __result;                             __asm__                                     (                                               "ld %A0, z+"   ""                       "ld %B0, z+"   ""                       "ld %C0, z+"   ""                       "ld %D0, z"    ""                       : "=r" (__result), "=z" (__addr16)          : "1" (__addr16)                        );                                          __result;                               }))

   #define __LPM_tiny__(addr)
       Value:

       (__extension__({                \
           uint16_t __addr16 = (uint16_t)(addr) + __AVR_TINY_PM_BASE_ADDRESS__; \
           uint8_t __result;               __asm__                         (                                   "ld %0, z" ""               : "=r" (__result)               : "z" (__addr16)            );                              __result;                   }))

   #define __LPM_word_classic__(addr)
       Value:

       (__extension__({                            \
           uint16_t __addr16 = (uint16_t)(addr);   \
           uint16_t __result;                          __asm__ __volatile__                        (                                               "lpm"           ""                      "mov %A0, r0"   ""                      "adiw r30, 1"   ""                      "lpm"           ""                      "mov %B0, r0"   ""                      : "=r" (__result), "=z" (__addr16)          : "1" (__addr16)                            : "r0"                                  );                                          __result;                               }))

   #define __LPM_word_enhanced__(addr)
       Value:

       (__extension__({                            \
           uint16_t __addr16 = (uint16_t)(addr);   \
           uint16_t __result;                          __asm__ __volatile__                        (                                               "lpm %A0, Z+"   ""                      "lpm %B0, Z"    ""                      : "=r" (__result), "=z" (__addr16)          : "1" (__addr16)                        );                                          __result;                               }))

   #define __LPM_word_tiny__(addr)
       Value:

       (__extension__({                            \
           uint16_t __addr16 = (uint16_t)(addr) + __AVR_TINY_PM_BASE_ADDRESS__; \
           uint16_t __result;                          __asm__                                     (                                               "ld %A0, z+"     ""                     "ld %B0, z"      ""                     : "=r" (__result), "=z" (__addr16)          : "1" (__addr16)                        );                                          __result;                               }))

   #define pgm_get_far_address(var)
       Value:

       ({                                                    \
            uint_farptr_t tmp;                                                                                              __asm__ __volatile__(                                                                                                           "ldi    %A0, lo8(%1)"           ""                            "ldi    %B0, hi8(%1)"           ""                            "ldi    %C0, hh8(%1)"           ""                            "clr    %D0"                    ""                    :                                                                     "=d" (tmp)                                                :                                                                     "p"  (&(var))                                     );                                                        tmp;                                              })

Author

       Generated automatically by Doxygen for avr-libc from the source code.