AVR Libc Home Page AVRs AVR Libc Development Pages
Main Page User Manual Library Reference FAQ Alphabetical Index Example Projects

pgmspace.h File Reference

Go to the source code of this file.

Defines

#define __PGMSPACE_H_   1
#define __need_size_t
#define __ATTR_PROGMEM__   __attribute__((__progmem__))
#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 size_t strlen_P (const char *s)

Detailed Description


Define Documentation

#define __ELPM_classic__ ( addr   ) 
Value:
(__extension__({                    \
    uint32_t __addr32 = (uint32_t)(addr); \
    uint8_t __result;               \
    __asm__ __volatile__            \
    (                               \
        "out %2, %C1" "\n\t"        \
        "mov r31, %B1" "\n\t"       \
        "mov r30, %A1" "\n\t"       \
        "elpm" "\n\t"               \
        "mov %0, r0" "\n\t"         \
        : "=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"   "\n\t"            \
        "movw r30, %1"  "\n\t"            \
        "elpm %A0, Z+"  "\n\t"            \
        "elpm %B0, Z+"  "\n\t"            \
        "elpm %C0, Z+"  "\n\t"            \
        "elpm %D0, Z"   "\n\t"            \
        : "=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" "\n\t"       \
        "out %2, %C1"   "\n\t"            \
        "movw r30, %1"  "\n\t"            \
        "elpm %A0, Z+"  "\n\t"            \
        "elpm %B0, Z+"  "\n\t"            \
        "elpm %C0, Z+"  "\n\t"            \
        "elpm %D0, Z"   "\n\t"            \
        "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" "\n\t"        \
        "movw r30, %1" "\n\t"       \
        "elpm %0, Z+" "\n\t"        \
        : "=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"   "\n\t"            \
        "movw r30, %1"  "\n\t"            \
        "elpm %A0, Z+"  "\n\t"            \
        "elpm %B0, Z+"  "\n\t"            \
        "elpm %C0, Z+"  "\n\t"            \
        "elpm %D0, Z"   "\n\t"            \
        : "=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" "\n\t"       \
        "out %2, %C1"   "\n\t"            \
        "movw r30, %1"  "\n\t"            \
        "elpm %A0, Z+"  "\n\t"            \
        "elpm %B0, Z+"  "\n\t"            \
        "elpm %C0, Z+"  "\n\t"            \
        "elpm %D0, Z"   "\n\t"            \
        "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"   "\n\t"          \
        "mov r31, %B1"  "\n\t"          \
        "mov r30, %A1"  "\n\t"          \
        "elpm"          "\n\t"          \
        "mov %A0, r0"   "\n\t"          \
        "in r0, %2"     "\n\t"          \
        "adiw r30, 1"   "\n\t"          \
        "adc r0, __zero_reg__" "\n\t"   \
        "out %2, r0"    "\n\t"          \
        "elpm"          "\n\t"          \
        "mov %B0, r0"   "\n\t"          \
        : "=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"   "\n\t"          \
        "movw r30, %1"  "\n\t"          \
        "elpm %A0, Z+"  "\n\t"          \
        "elpm %B0, Z"   "\n\t"          \
        : "=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" "\n\t"     \
        "out %2, %C1"   "\n\t"          \
        "movw r30, %1"  "\n\t"          \
        "elpm %A0, Z+"  "\n\t"          \
        "elpm %B0, Z"   "\n\t"          \
        "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" "\n\t" \
        "out %2, %C1" "\n\t"        \
        "movw r30, %1" "\n\t"       \
        "elpm %0, Z+" "\n\t"        \
        "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" "\n\t"            \
        "mov %0, r0" "\n\t"     \
        : "=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"           "\n\t"              \
        "mov %A0, r0"   "\n\t"              \
        "adiw r30, 1"   "\n\t"              \
        "lpm"           "\n\t"              \
        "mov %B0, r0"   "\n\t"              \
        "adiw r30, 1"   "\n\t"              \
        "lpm"           "\n\t"              \
        "mov %C0, r0"   "\n\t"              \
        "adiw r30, 1"   "\n\t"              \
        "lpm"           "\n\t"              \
        "mov %D0, r0"   "\n\t"              \
        : "=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+"   "\n\t"              \
        "lpm %B0, Z+"   "\n\t"              \
        "lpm %C0, Z+"   "\n\t"              \
        "lpm %D0, Z"    "\n\t"              \
        : "=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+"    "\n\t"              \
        "ld %B0, z+"    "\n\t"              \
        "ld %C0, z+"    "\n\t"              \
        "ld %D0, z"     "\n\t"              \
        : "=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" "\n\t"      \
        : "=r" (__result)       \
        : "z" (__addr16)        \
    );                          \
    __result;                   \
}))
#define __LPM_float_classic__ ( addr   ) 
Value:
(__extension__({                            \
    uint16_t __addr16 = (uint16_t)(addr);   \
    float __result;                         \
    __asm__ __volatile__                    \
    (                                       \
        "lpm"           "\n\t"              \
        "mov %A0, r0"   "\n\t"              \
        "adiw r30, 1"   "\n\t"              \
        "lpm"           "\n\t"              \
        "mov %B0, r0"   "\n\t"              \
        "adiw r30, 1"   "\n\t"              \
        "lpm"           "\n\t"              \
        "mov %C0, r0"   "\n\t"              \
        "adiw r30, 1"   "\n\t"              \
        "lpm"           "\n\t"              \
        "mov %D0, r0"   "\n\t"              \
        : "=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+"   "\n\t"              \
        "lpm %B0, Z+"   "\n\t"              \
        "lpm %C0, Z+"   "\n\t"              \
        "lpm %D0, Z"    "\n\t"              \
        : "=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+"   "\n\t"               \
        "ld %B0, z+"   "\n\t"               \
        "ld %C0, z+"   "\n\t"               \
        "ld %D0, z"    "\n\t"               \
        : "=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" "\n\t"       \
        : "=r" (__result)       \
        : "z" (__addr16)        \
    );                          \
    __result;                   \
}))
#define __LPM_word_classic__ ( addr   ) 
Value:
(__extension__({                            \
    uint16_t __addr16 = (uint16_t)(addr);   \
    uint16_t __result;                      \
    __asm__ __volatile__                    \
    (                                       \
        "lpm"           "\n\t"              \
        "mov %A0, r0"   "\n\t"              \
        "adiw r30, 1"   "\n\t"              \
        "lpm"           "\n\t"              \
        "mov %B0, r0"   "\n\t"              \
        : "=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+"   "\n\t"              \
        "lpm %B0, Z"    "\n\t"              \
        : "=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+"     "\n\t"             \
        "ld %B0, z"      "\n\t"             \
        : "=r" (__result), "=z" (__addr16)  \
        : "1" (__addr16)                    \
    );                                      \
    __result;                               \
}))
#define pgm_get_far_address ( var   ) 
Value:
({                                                    \
        uint_farptr_t tmp;                                \
                                                      \
        __asm__ __volatile__(                             \
                                                      \
                        "ldi    %A0, lo8(%1)"           "\n\t"    \
                        "ldi    %B0, hi8(%1)"           "\n\t"    \
                        "ldi    %C0, hh8(%1)"           "\n\t"    \
                        "clr    %D0"                    "\n\t"    \
                :                                             \
                        "=d" (tmp)                                \
                :                                             \
                        "p"  (&(var))                             \
        );                                                \
        tmp;                                              \
})

Automatically generated by Doxygen 1.6.1 on 25 Apr 2014.