AVR-LibC
2.2.0
Standard C library for AVR-GCC
|
AVR-LibC Documentation |
AVR-LibC Development Pages |
||||
Main Page |
User Manual |
Library Reference |
FAQ |
Example Projects |
File List |
Macros | |
#define | PROGMEM_FAR __attribute__((__section__(".progmemx.data"))) |
#define | PROGMEM __attribute__((__progmem__)) |
#define | PSTR(str) ({ static const PROGMEM char c[] = (str); &c[0]; }) |
#define | PSTR_FAR(str) ({ static const PROGMEM_FAR char c[] = (str); pgm_get_far_address(c[0]); }) |
#define | pgm_read_byte_near(__addr) __LPM ((uint16_t)(__addr)) |
#define | pgm_read_word_near(__addr) __LPM_word ((uint16_t)(__addr)) |
#define | pgm_read_dword_near(__addr) __LPM_dword ((uint16_t)(__addr)) |
#define | pgm_read_qword_near(__addr) __LPM_qword ((uint16_t)(__addr)) |
#define | pgm_read_float_near(addr) pgm_read_float (addr) |
#define | pgm_read_ptr_near(__addr) ((void*) __LPM_word ((uint16_t)(__addr))) |
#define | pgm_read_byte_far(__addr) __ELPM (__addr) |
#define | pgm_read_word_far(__addr) __ELPM_word (__addr) |
#define | pgm_read_dword_far(__addr) __ELPM_dword (__addr) |
#define | pgm_read_qword_far(__addr) __ELPM_qword (__addr) |
#define | pgm_read_ptr_far(__addr) ((void*) __ELPM_word (__addr)) |
#define | pgm_read_byte(__addr) pgm_read_byte_near(__addr) |
#define | pgm_read_word(__addr) pgm_read_word_near(__addr) |
#define | pgm_read_dword(__addr) pgm_read_dword_near(__addr) |
#define | pgm_read_qword(__addr) pgm_read_qword_near(__addr) |
#define | pgm_read_ptr(__addr) pgm_read_ptr_near(__addr) |
#define | pgm_get_far_address(var) |
Functions | |
static char | pgm_read_char (const char *__addr) |
static unsigned char | pgm_read_unsigned_char (const unsigned char *__addr) |
static signed char | pgm_read_signed_char (const signed char *__addr) |
static uint8_t | pgm_read_u8 (const uint8_t *__addr) |
static int8_t | pgm_read_i8 (const int8_t *__addr) |
static short | pgm_read_short (const short *__addr) |
static unsigned short | pgm_read_unsigned_short (const unsigned short *__addr) |
static uint16_t | pgm_read_u16 (const uint16_t *__addr) |
static int16_t | pgm_read_i16 (const int16_t *__addr) |
static int | pgm_read_int (const int *__addr) |
static signed | pgm_read_signed (const signed *__addr) |
static unsigned | pgm_read_unsigned (const unsigned *__addr) |
static signed int | pgm_read_signed_int (const signed int *__addr) |
static unsigned int | pgm_read_unsigned_int (const unsigned int *__addr) |
static __int24 | pgm_read_i24 (const __int24 *__addr) |
static __uint24 | pgm_read_u24 (const __uint24 *__addr) |
static uint32_t | pgm_read_u32 (const uint32_t *__addr) |
static int32_t | pgm_read_i32 (const int32_t *__addr) |
static long | pgm_read_long (const long *__addr) |
static unsigned long | pgm_read_unsigned_long (const unsigned long *__addr) |
static long long | pgm_read_long_long (const long long *__addr) |
static unsigned long long | pgm_read_unsigned_long_long (const unsigned long long *__addr) |
static uint64_t | pgm_read_u64 (const uint64_t *__addr) |
static int64_t | pgm_read_i64 (const int64_t *__addr) |
static float | pgm_read_float (const float *__addr) |
static double | pgm_read_double (const double *__addr) |
static long double | pgm_read_long_double (const long double *__addr) |
static char | pgm_read_char_far (uint_farptr_t __addr) |
static unsigned char | pgm_read_unsigned_char_far (uint_farptr_t __addr) |
static signed char | pgm_read_signed_char_far (uint_farptr_t __addr) |
static uint8_t | pgm_read_u8_far (uint_farptr_t __addr) |
static int8_t | pgm_read_i8_far (uint_farptr_t __addr) |
static short | pgm_read_short_far (uint_farptr_t __addr) |
static unsigned short | pgm_read_unsigned_short_far (uint_farptr_t __addr) |
static uint16_t | pgm_read_u16_far (uint_farptr_t __addr) |
static int16_t | pgm_read_i16_far (uint_farptr_t __addr) |
static int | pgm_read_int_far (uint_farptr_t __addr) |
static unsigned | pgm_read_unsigned_far (uint_farptr_t __addr) |
static unsigned int | pgm_read_unsigned_int_far (uint_farptr_t __addr) |
static signed | pgm_read_signed_far (uint_farptr_t __addr) |
static signed int | pgm_read_signed_int_far (uint_farptr_t __addr) |
static long | pgm_read_long_far (uint_farptr_t __addr) |
static unsigned long | pgm_read_unsigned_long_far (uint_farptr_t __addr) |
static __int24 | pgm_read_i24_far (uint_farptr_t __addr) |
static __uint24 | pgm_read_u24_far (uint_farptr_t __addr) |
static uint32_t | pgm_read_u32_far (uint_farptr_t __addr) |
static int32_t | pgm_read_i32_far (uint_farptr_t __addr) |
static long long | pgm_read_long_long_far (uint_farptr_t __addr) |
static unsigned long long | pgm_read_unsigned_long_long_far (uint_farptr_t __addr) |
static uint64_t | pgm_read_u64_far (uint_farptr_t __addr) |
static int64_t | pgm_read_i64_far (uint_farptr_t __addr) |
static float | pgm_read_float_far (uint_farptr_t __addr) |
static double | pgm_read_double_far (uint_farptr_t __addr) |
static long double | pgm_read_long_double_far (uint_farptr_t __addr) |
const void * | memchr_P (const void *, int __val, size_t __len) |
int | memcmp_P (const void *, const void *, size_t) |
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) |
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 *) |
char * | strcpy_P (char *, const char *) |
int | strcasecmp_P (const char *, const char *) |
char * | strcasestr_P (const char *, const char *) |
size_t | strcspn_P (const char *__s, const char *__reject) |
size_t | strlcat_P (char *, const char *, size_t) |
size_t | strlcpy_P (char *, const char *, size_t) |
size_t | strnlen_P (const char *, size_t) |
int | strncmp_P (const char *, const char *, size_t) |
int | strncasecmp_P (const char *, const char *, size_t) |
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) |
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) |
char * | strstr_P (const char *, const char *) |
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) |
int | strncmp_PF (const char *s1, uint_farptr_t s2, size_t n) |
int | strcasecmp_PF (const char *s1, uint_farptr_t s2) |
int | strncasecmp_PF (const char *s1, uint_farptr_t s2, size_t n) |
uint_farptr_t | strchr_PF (uint_farptr_t, int __val) |
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) |
static size_t | strlen_P (const char *s) |
template<typename T > | |
T | pgm_read< T > (const T *addr) |
template<typename T > | |
T | pgm_read_far< T > (uint_farptr_t addr) |
The functions in this module provide interfaces for a program to access data stored in program space (flash memory) of the device.
_P
require their arguments to be in the lower 64 KB of the flash ROM, as they do not use ELPM instructions. This is normally not a big concern as the linker setup arranges any program space constants declared using the macros from this header file so they are placed right after the interrupt vectors, and in front of any executable code. However, it can become a problem if there are too many of these constants, or for bootloaders on devices with more than 64 KB of ROM. All these functions will not work in that situation.NVM.CMD
or NVM_CMD
) is set to 0x00 (NOP) before using any of these functions. #define pgm_get_far_address | ( | var | ) |
This macro evaluates to a uint_farptr_t 32-bit "far" pointer (only 24 bits used) to data even beyond the 64 KiB limit for the 16-bit ordinary pointer. It is similar to the '&' operator, with some limitations. Example:
Comments:
var
has to be resolved at link-time as an existing symbol, i.e. a simple variable name, an array name, or an array or structure element provided the offset is known at compile-time, and var
is located in static storage, etc.0x0
, 0x800xx0
, and 0x810000
respectively, derived from the linker script used and linker options. #define pgm_read_byte | ( | __addr | ) | pgm_read_byte_near(__addr) |
Read a byte from the program space with a 16-bit (near) nyte-address.
#define pgm_read_byte_far | ( | __addr | ) | __ELPM (__addr) |
Read a byte from the program space with a 32-bit (far) byte-address.
#define pgm_read_byte_near | ( | __addr | ) | __LPM ((uint16_t)(__addr)) |
Read a byte from the program space with a 16-bit (near) byte-address.
#define pgm_read_dword | ( | __addr | ) | pgm_read_dword_near(__addr) |
Read a double word from the program space with a 16-bit (near) byte-address.
#define pgm_read_dword_far | ( | __addr | ) | __ELPM_dword (__addr) |
Read a double word from the program space with a 32-bit (far) byte-address.
#define pgm_read_dword_near | ( | __addr | ) | __LPM_dword ((uint16_t)(__addr)) |
Read a double word from the program space with a 16-bit (near) byte-address.
#define pgm_read_float_near | ( | addr | ) | pgm_read_float (addr) |
Read a float
from the program space with a 16-bit (near) byte-address.
#define pgm_read_ptr | ( | __addr | ) | pgm_read_ptr_near(__addr) |
Read a pointer from the program space with a 16-bit (near) byte-address.
#define pgm_read_ptr_far | ( | __addr | ) | ((void*) __ELPM_word (__addr)) |
Read a pointer from the program space with a 32-bit (far) byte-address.
#define pgm_read_ptr_near | ( | __addr | ) | ((void*) __LPM_word ((uint16_t)(__addr))) |
Read a pointer from the program space with a 16-bit (near) byte-address.
#define pgm_read_qword | ( | __addr | ) | pgm_read_qword_near(__addr) |
Read a quad-word from the program space with a 16-bit (near) byte-address.
#define pgm_read_qword_far | ( | __addr | ) | __ELPM_qword (__addr) |
Read a quad-word from the program space with a 32-bit (far) byte-address.
#define pgm_read_qword_near | ( | __addr | ) | __LPM_qword ((uint16_t)(__addr)) |
Read a quad-word from the program space with a 16-bit (near) byte-address.
#define pgm_read_word | ( | __addr | ) | pgm_read_word_near(__addr) |
Read a word from the program space with a 16-bit (near) byte-address.
#define pgm_read_word_far | ( | __addr | ) | __ELPM_word (__addr) |
Read a word from the program space with a 32-bit (far) byte-address.
#define pgm_read_word_near | ( | __addr | ) | __LPM_word ((uint16_t)(__addr)) |
Read a word from the program space with a 16-bit (near) byte-address.
#define PROGMEM __attribute__((__progmem__)) |
Attribute to use in order to declare an object being located in flash ROM.
#define PROGMEM_FAR __attribute__((__section__(".progmemx.data"))) |
Attribute to use in order to declare an object being located in far flash ROM. This is similar to PROGMEM, except that it puts the static storage object in section .progmemx.data
. In order to access the object, the pgm_read_*_far
and _PF
functions declare in this header can be used. In order to get its address, see pgm_get_far_address().
It only makes sense to put read-only objects in this section, though the compiler does not diagnose when this is not the case.
#define PSTR | ( | str | ) | ({ static const PROGMEM char c[] = (str); &c[0]; }) |
Used to declare a static pointer to a string in program space.
#define PSTR_FAR | ( | str | ) | ({ static const PROGMEM_FAR char c[] = (str); pgm_get_far_address(c[0]); }) |
Used to define a string literal in far program space, and to return its address of type uint_farptr_t.
void * memccpy_P | ( | void * | dest, |
const void * | src, | ||
int | val, | ||
size_t | len | ||
) |
This function is similar to memccpy() except that src
is pointer to a string in program space.
const void * memchr_P | ( | const void * | s, |
int | val, | ||
size_t | len | ||
) |
Scan flash memory for a character.
The memchr_P() function scans the first len
bytes of the flash memory area pointed to by s
for the character val
. The first byte to match val
(interpreted as an unsigned character) stops the operation.
NULL
if the character does not occur in the given memory area. int memcmp_P | ( | const void * | s1, |
const void * | s2, | ||
size_t | len | ||
) |
Compare memory areas.
The memcmp_P() function compares the first len
bytes of the memory areas s1
and flash s2
. The comparision is performed using unsigned char operations.
len
bytes of s1
is found, respectively, to be less than, to match, or be greater than the first len
bytes of s2
. int memcmp_PF | ( | const void * | s1, |
uint_farptr_t | s2, | ||
size_t | len | ||
) |
Compare memory areas.
The memcmp_PF() function compares the first len
bytes of the memory areas s1
and flash s2
. The comparision is performed using unsigned char operations. It is an equivalent of memcmp_P() function, except that it is capable working on all FLASH including the exteded area above 64kB.
len
bytes of s1
is found, respectively, to be less than, to match, or be greater than the first len
bytes of s2
. void * memcpy_P | ( | void * | dest, |
const void * | src, | ||
size_t | n | ||
) |
The memcpy_P() function is similar to memcpy(), except the src string resides in program space.
void * memcpy_PF | ( | void * | dest, |
uint_farptr_t | src, | ||
size_t | n | ||
) |
Copy a memory block from flash to SRAM.
The memcpy_PF() function is similar to memcpy(), except the data is copied from the program space and is addressed using a far pointer.
dest | A pointer to the destination buffer |
src | A far pointer to the origin of data in flash memory |
n | The number of bytes to be copied |
void * memmem_P | ( | const void * | s1, |
size_t | len1, | ||
const void * | s2, | ||
size_t | len2 | ||
) |
The memmem_P() function is similar to memmem() except that s2
is pointer to a string in program space.
const void memrchr_P | ( | const void * | src, |
int | val, | ||
size_t | len | ||
) |
The memrchr_P() function is like the memchr_P() function, except that it searches backwards from the end of the len
bytes pointed to by src
instead of forwards from the front. (Glibc, GNU extension.)
NULL
if the character does not occur in the given memory area. T pgm_read< T > | ( | const T * | addr | ) |
Read an object of type T
from program memory address addr
and return it. This template is only available when macro __pgm_read_template__
is defined.
|
inlinestatic |
Read a char
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read a char
from far byte-address __addr
. The address is in the program memory.
|
inlinestatic |
Read a double
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read a double
from far byte-address __addr
. The address is in the program memory.
T pgm_read_far< T > | ( | uint_farptr_t | addr | ) |
Read an object of type T
from program memory address addr
and return it. This template is only available when macro __pgm_read_template__
is defined.
|
inlinestatic |
Read a float
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read a float
from far byte-address __addr
. The address is in the program memory.
Read an int16_t
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read an int16_t
from far byte-address __addr
. The address is in the program memory.
|
inlinestatic |
Read an __int24
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read an __int24
from far byte-address __addr
. The address is in the program memory.
Read an int32_t
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read an int32_t
from far byte-address __addr
. The address is in the program memory.
Read an int64_t
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read an int64_t
from far byte-address __addr
. The address is in the program memory.
Read an int8_t
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read an int8_t
from far byte-address __addr
. The address is in the program memory.
|
inlinestatic |
Read an int
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read an int
from far byte-address __addr
. The address is in the program memory.
|
inlinestatic |
Read a long
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read a long double
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read a long double
from far byte-address __addr
. The address is in the program memory.
|
inlinestatic |
Read a long
from far byte-address __addr
. The address is in the program memory.
|
inlinestatic |
Read a long long
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read a long long
from far byte-address __addr
. The address is in the program memory.
|
inlinestatic |
Read a short
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read a short
from far byte-address __addr
. The address is in the program memory.
|
inlinestatic |
Read a signed
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read a signed char
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read a signed char
from far byte-address __addr
. The address is in the program memory.
|
inlinestatic |
Read a signed
from far byte-address __addr
. The address is in the program memory.
|
inlinestatic |
Read a signed int
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read a signed int
from far byte-address __addr
. The address is in the program memory.
Read an uint16_t
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read an uint16_t
from far byte-address __addr
. The address is in the program memory.
|
inlinestatic |
Read an __uint24
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read an __uint24
from far byte-address __addr
. The address is in the program memory.
Read an uint32_t
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read an uint32_t
from far byte-address __addr
. The address is in the program memory.
Read an uint64_t
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read an uint64_t
from far byte-address __addr
. The address is in the program memory.
Read an uint8_t
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read an uint8_t
from far byte-address __addr
. The address is in the program memory.
|
inlinestatic |
Read an unsigned
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read an unsigned char
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read an unsigned char
from far byte-address __addr
. The address is in the program memory.
|
inlinestatic |
Read an unsigned
from far byte-address __addr
. The address is in the program memory.
|
inlinestatic |
Read an unsigned int
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read an unsigned int
from far byte-address __addr
. The address is in the program memory.
|
inlinestatic |
Read an unsigned long
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read an unsigned long
from far byte-address __addr
. The address is in the program memory.
|
inlinestatic |
Read an unsigned long long
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read an unsigned long long
from far byte-address __addr
. The address is in the program memory.
|
inlinestatic |
Read an unsigned short
from 16-bit (near) byte-address __addr
. The address is in the lower 64 KiB of program memory.
|
inlinestatic |
Read an unsigned short
from far byte-address __addr
. The address is in the program memory.
int strcasecmp_P | ( | const char * | s1, |
const char * | s2 | ||
) |
Compare two strings ignoring case.
The strcasecmp_P() function compares the two strings s1
and s2
, ignoring the case of the characters.
s1 | A pointer to a string in the devices SRAM. |
s2 | A pointer to a string in the devices Flash. |
s1
is found, respectively, to be less than, to match, or be greater than s2
. A consequence of the ordering used by strcasecmp_P() is that if s1
is an initial substring of s2
, then s1
is considered to be "less than" s2
. int strcasecmp_PF | ( | const char * | s1, |
uint_farptr_t | s2 | ||
) |
Compare two strings ignoring case.
The strcasecmp_PF() function compares the two strings s1 and s2, ignoring the case of the characters.
s1 | A pointer to the first string in SRAM |
s2 | A far pointer to the second string in Flash |
char * strcasestr_P | ( | const char * | s1, |
const char * | s2 | ||
) |
This funtion is similar to strcasestr() except that s2
is pointer to a string in program space.
char * strcat_P | ( | char * | dest, |
const char * | src | ||
) |
The strcat_P() function is similar to strcat() except that the src string must be located in program space (flash).
char * strcat_PF | ( | char * | dst, |
uint_farptr_t | src | ||
) |
Concatenates two strings.
The strcat_PF() function is similar to strcat() except that the src string must be located in program space (flash) and is addressed using a far pointer
dst | A pointer to the destination string in SRAM |
src | A far pointer to the string to be appended in Flash |
const char * strchr_P | ( | const char * | s, |
int | val | ||
) |
Locate character in program space string.
The strchr_P() function locates the first occurrence of val
(converted to a char) in the string pointed to by s
in program space. The terminating null character is considered to be part of the string.
The strchr_P() function is similar to strchr() except that s
is pointer to a string in program space.
NULL
if the character is not found. uint_farptr_t strchr_PF | ( | uint_farptr_t | s, |
int | val | ||
) |
Locate character in far program space string.
The strchr_PF() function locates the first occurrence of val
(converted to a char) in the string pointed to by s
in far program space. The terminating null character is considered to be part of the string.
The strchr_PF() function is similar to strchr() except that s
is a far pointer to a string in program space that's not required to be located in the lower 64 KiB block like it is the case for strchr_P().
0
if the character is not found. const char * strchrnul_P | ( | const char * | s, |
int | c | ||
) |
The strchrnul_P() function is like strchr_P() except that if c
is not found in s
, then it returns a pointer to the null byte at the end of s
, rather than NULL
. (Glibc, GNU extension.)
s
(i.e., s+strlen
(s)) if the character is not found. int strcmp_P | ( | const char * | s1, |
const char * | s2 | ||
) |
The strcmp_P() function is similar to strcmp() except that s2
is pointer to a string in program space.
s1
is found, respectively, to be less than, to match, or be greater than s2
. A consequence of the ordering used by strcmp_P() is that if s1
is an initial substring of s2
, then s1
is considered to be "less than" s2
. int strcmp_PF | ( | const char * | s1, |
uint_farptr_t | s2 | ||
) |
Compares two strings.
The strcmp_PF() function is similar to strcmp() except that s2 is a far pointer to a string in program space.
s1 | A pointer to the first string in SRAM |
s2 | A far pointer to the second string in Flash |
char * strcpy_P | ( | char * | dest, |
const char * | src | ||
) |
The strcpy_P() function is similar to strcpy() except that src is a pointer to a string in program space.
char * strcpy_PF | ( | char * | dst, |
uint_farptr_t | src | ||
) |
Duplicate a string.
The strcpy_PF() function is similar to strcpy() except that src is a far pointer to a string in program space.
dst | A pointer to the destination string in SRAM |
src | A far pointer to the source string in Flash |
size_t strcspn_P | ( | const char * | s, |
const char * | reject | ||
) |
The strcspn_P() function calculates the length of the initial segment of s
which consists entirely of characters not in reject
. This function is similar to strcspn() except that reject
is a pointer to a string in program space.
s
which are not in the string reject
. The terminating zero is not considered as a part of string. size_t strlcat_P | ( | char * | dst, |
const char * | src, | ||
size_t | siz | ||
) |
Concatenate two strings.
The strlcat_P() function is similar to strlcat(), except that the src
string must be located in program space (flash).
Appends src
to string dst
of size siz
(unlike strncat(), siz
is the full size of dst
, not space left). At most siz-1
characters will be copied. Always NULL terminates (unless siz
<= strlen(dst)
).
size_t strlcat_PF | ( | char * | dst, |
uint_farptr_t | src, | ||
size_t | n | ||
) |
Concatenate two strings.
The strlcat_PF() function is similar to strlcat(), except that the src string must be located in program space (flash) and is addressed using a far pointer.
Appends src to string dst of size n (unlike strncat(), n is the full size of dst, not space left). At most n-1 characters will be copied. Always NULL terminates (unless n <= strlen(dst)).
dst | A pointer to the destination string in SRAM |
src | A far pointer to the source string in Flash |
n | The total number of bytes allocated to the destination string |
size_t strlcpy_P | ( | char * | dst, |
const char * | src, | ||
size_t | siz | ||
) |
Copy a string from progmem to RAM.
Copy src
to string dst
of size siz
. At most siz-1
characters will be copied. Always NULL terminates (unless siz
== 0). The strlcpy_P() function is similar to strlcpy() except that the src
is pointer to a string in memory space.
size_t strlcpy_PF | ( | char * | dst, |
uint_farptr_t | src, | ||
size_t | siz | ||
) |
Copy a string from progmem to RAM.
Copy src to string dst of size siz. At most siz-1 characters will be copied. Always NULL terminates (unless siz == 0).
|
inlinestatic |
The strlen_P() function is similar to strlen(), except that src is a pointer to a string in program space.
size_t strlen_PF | ( | uint_farptr_t | s | ) |
Obtain the length of a string.
The strlen_PF() function is similar to strlen(), except that s is a far pointer to a string in program space.
s | A far pointer to the string in flash |
int strncasecmp_P | ( | const char * | s1, |
const char * | s2, | ||
size_t | n | ||
) |
Compare two strings ignoring case.
The strncasecmp_P() function is similar to strcasecmp_P(), except it only compares the first n
characters of s1
.
s1 | A pointer to a string in the devices SRAM. |
s2 | A pointer to a string in the devices Flash. |
n | The maximum number of bytes to compare. |
s1
(or the first n
bytes thereof) is found, respectively, to be less than, to match, or be greater than s2
. A consequence of the ordering used by strncasecmp_P() is that if s1
is an initial substring of s2
, then s1
is considered to be "less than" s2
. int strncasecmp_PF | ( | const char * | s1, |
uint_farptr_t | s2, | ||
size_t | n | ||
) |
Compare two strings ignoring case.
The strncasecmp_PF() function is similar to strcasecmp_PF(), except it only compares the first n characters of s1 and the string in flash is addressed using a far pointer.
s1 | A pointer to a string in SRAM |
s2 | A far pointer to a string in Flash |
n | The maximum number of bytes to compare |
char * strncat_P | ( | char * | dest, |
const char * | src, | ||
size_t | len | ||
) |
Concatenate two strings.
The strncat_P() function is similar to strncat(), except that the src string must be located in program space (flash).
char * strncat_PF | ( | char * | dst, |
uint_farptr_t | src, | ||
size_t | n | ||
) |
Concatenate two strings.
The strncat_PF() function is similar to strncat(), except that the src string must be located in program space (flash) and is addressed using a far pointer.
dst | A pointer to the destination string in SRAM |
src | A far pointer to the source string in Flash |
n | The maximum number of bytes to append |
int strncmp_P | ( | const char * | s1, |
const char * | s2, | ||
size_t | n | ||
) |
The strncmp_P() function is similar to strcmp_P() except it only compares the first (at most) n characters of s1 and s2.
int strncmp_PF | ( | const char * | s1, |
uint_farptr_t | s2, | ||
size_t | n | ||
) |
Compare two strings with limited length.
The strncmp_PF() function is similar to strcmp_PF() except it only compares the first (at most) n characters of s1 and s2.
s1 | A pointer to the first string in SRAM |
s2 | A far pointer to the second string in Flash |
n | The maximum number of bytes to compare |
char * strncpy_P | ( | char * | dest, |
const char * | src, | ||
size_t | n | ||
) |
The strncpy_P() function is similar to strcpy_P() except that not more than n bytes of src are copied. Thus, if there is no null byte among the first n bytes of src, the result will not be null-terminated.
In the case where the length of src is less than that of n, the remainder of dest will be padded with nulls.
char * strncpy_PF | ( | char * | dst, |
uint_farptr_t | src, | ||
size_t | n | ||
) |
Duplicate a string until a limited length.
The strncpy_PF() function is similar to strcpy_PF() except that not more than n bytes of src are copied. Thus, if there is no null byte among the first n bytes of src, the result will not be null-terminated.
In the case where the length of src is less than that of n, the remainder of dst will be padded with nulls.
dst | A pointer to the destination string in SRAM |
src | A far pointer to the source string in Flash |
n | The maximum number of bytes to copy |
size_t strnlen_P | ( | const char * | src, |
size_t | len | ||
) |
Determine the length of a fixed-size string.
The strnlen_P() function is similar to strnlen(), except that src
is a pointer to a string in program space.
len
, or len
if there is no '\0' character among the first len
characters pointed to by src
. size_t strnlen_PF | ( | uint_farptr_t | s, |
size_t | len | ||
) |
Determine the length of a fixed-size string.
The strnlen_PF() function is similar to strnlen(), except that s is a far pointer to a string in program space.
s | A far pointer to the string in Flash |
len | The maximum number of length to return |
char * strpbrk_P | ( | const char * | s, |
const char * | accept | ||
) |
The strpbrk_P() function locates the first occurrence in the string s
of any of the characters in the flash string accept
. This function is similar to strpbrk() except that accept
is a pointer to a string in program space.
s
that matches one of the characters in accept
, or NULL
if no such character is found. The terminating zero is not considered as a part of string: if one or both args are empty, the result will NULL
. const char * strrchr_P | ( | const char * | s, |
int | val | ||
) |
Locate character in string.
The strrchr_P() function returns a pointer to the last occurrence of the character val
in the flash string s
.
NULL
if the character is not found. char * strsep_P | ( | char ** | sp, |
const char * | delim | ||
) |
Parse a string into tokens.
The strsep_P() function locates, in the string referenced by *sp
, the first occurrence of any character in the string delim
(or the terminating '\0' character) and replaces it with a '\0'. The location of the next character after the delimiter character (or NULL
, if the end of the string was reached) is stored in *sp
. An ``empty'' field, i.e. one caused by two adjacent delimiter characters, can be detected by comparing the location referenced by the pointer returned in *sp
to '\0'. This function is similar to strsep() except that delim
is a pointer to a string in program space.
*sp
. If *sp
is initially NULL
, strsep_P() returns NULL
. size_t strspn_P | ( | const char * | s, |
const char * | accept | ||
) |
The strspn_P() function calculates the length of the initial segment of s
which consists entirely of characters in accept
. This function is similar to strspn() except that accept
is a pointer to a string in program space.
s
which consist only of characters from accept
. The terminating zero is not considered as a part of string. char * strstr_P | ( | const char * | s1, |
const char * | s2 | ||
) |
Locate a substring.
The strstr_P() function finds the first occurrence of the substring s2
in the string s1
. The terminating '\0' characters are not compared. The strstr_P() function is similar to strstr() except that s2
is pointer to a string in program space.
s2
points to a string of zero length, the function returns s1
. char * strstr_PF | ( | const char * | s1, |
uint_farptr_t | s2 | ||
) |
Locate a substring.
The strstr_PF() function finds the first occurrence of the substring s2
in the string s1
. The terminating '\0' characters are not compared. The strstr_PF() function is similar to strstr() except that s2
is a far pointer to a string in program space.
s2
points to a string of zero length, the function returns s1
. The contents of RAMPZ SFR are undefined when the function returns. char * strtok_P | ( | char * | s, |
const char * | delim | ||
) |
Parses the string into tokens.
strtok_P() parses the string s
into tokens. The first call to strtok_P() should have s
as its first argument. Subsequent calls should have the first argument set to NULL. If a token ends with a delimiter, this delimiting character is overwritten with a '\0' and a pointer to the next character is saved for the next call to strtok_P(). The delimiter string delim
may be different for each call.
The strtok_P() function is similar to strtok() except that delim
is pointer to a string in program space.
char * strtok_rP | ( | char * | string, |
const char * | delim, | ||
char ** | last | ||
) |
Parses string into tokens.
The strtok_rP() function parses string
into tokens. The first call to strtok_rP() should have string as its first argument. Subsequent calls should have the first argument set to NULL. If a token ends with a delimiter, this delimiting character is overwritten with a '\0' and a pointer to the next character is saved for the next call to strtok_rP(). The delimiter string delim
may be different for each call. last
is a user allocated char* pointer. It must be the same while parsing the same string. strtok_rP() is a reentrant version of strtok_P().
The strtok_rP() function is similar to strtok_r() except that delim
is pointer to a string in program space.