| 1,7 → 1,6 |
|---|
| /* |
| * Copyright (c) 2005 Martin Decky |
| * Copyright (C) 1998 by Wes Peters <wes@softweyr.com> |
| * Copyright (c) 1988, 1993 The Regents of the University of California. |
| * Copyright (c) 2008 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| 35,96 → 34,11 |
|---|
| */ |
| |
| #include <string.h> |
| #include <unistd.h> |
| #include <stdlib.h> |
| #include <limits.h> |
| #include <ctype.h> |
| #include <limits.h> |
| #include <align.h> |
| #include <sys/types.h> |
| #include <malloc.h> |
| |
| /* Dummy implementation of mem/ functions */ |
| |
| void *memset(void *s, int c, size_t n) |
| { |
| char *os = s; |
| |
| while (n--) |
| *(os++) = c; |
| |
| return s; |
| } |
| |
| struct along { |
| unsigned long n; |
| } __attribute__ ((packed)); |
| |
| static void *unaligned_memcpy(void *dst, const void *src, size_t n) |
| { |
| int i, j; |
| struct along *adst = dst; |
| const struct along *asrc = src; |
| |
| for (i = 0; i < n / sizeof(unsigned long); i++) |
| adst[i].n = asrc[i].n; |
| |
| for (j = 0; j < n % sizeof(unsigned long); j++) |
| ((unsigned char *) (((unsigned long *) dst) + i))[j] = |
| ((unsigned char *) (((unsigned long *) src) + i))[j]; |
| |
| return (char *) dst; |
| } |
| |
| void *memcpy(void *dst, const void *src, size_t n) |
| { |
| int i, j; |
| |
| if (((long) dst & (sizeof(long) - 1)) || |
| ((long) src & (sizeof(long) - 1))) |
| return unaligned_memcpy(dst, src, n); |
| |
| for (i = 0; i < n / sizeof(unsigned long); i++) |
| ((unsigned long *) dst)[i] = ((unsigned long *) src)[i]; |
| |
| for (j = 0; j < n % sizeof(unsigned long); j++) |
| ((unsigned char *) (((unsigned long *) dst) + i))[j] = |
| ((unsigned char *) (((unsigned long *) src) + i))[j]; |
| |
| return (char *) dst; |
| } |
| |
| void *memmove(void *dst, const void *src, size_t n) |
| { |
| int i, j; |
| |
| if (src > dst) |
| return memcpy(dst, src, n); |
| |
| for (j = (n % sizeof(unsigned long)) - 1; j >= 0; j--) |
| ((unsigned char *) ((unsigned long *) dst))[j] = |
| ((unsigned char *) ((unsigned long *) src))[j]; |
| |
| for (i = n / sizeof(unsigned long) - 1; i >=0 ; i--) |
| ((unsigned long *) dst)[i] = ((unsigned long *) src)[i]; |
| |
| return (char *) dst; |
| } |
| |
| /** Compare two memory areas. |
| * |
| * @param s1 Pointer to the first area to compare. |
| * @param s2 Pointer to the second area to compare. |
| * @param len Size of the first area in bytes. Both areas must have |
| * the same length. |
| * @return If len is 0, return zero. If the areas match, return |
| * zero. Otherwise return non-zero. |
| */ |
| int bcmp(const char *s1, const char *s2, size_t len) |
| { |
| for (; len && *s1++ == *s2++; len--) |
| ; |
| return len; |
| } |
| |
| /** Count the number of characters in the string, not including terminating 0. |
| * |
| * @param str String. |
| 398,51 → 312,36 |
|---|
| return (char *) memcpy(ret, s1, len); |
| } |
| |
| /* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */ |
| char * strtok_r(char *s, const char *delim, char **last) |
| char *strtok(char *s, const char *delim) |
| { |
| char *spanp, *tok; |
| int c, sc; |
| static char *next; |
| |
| if (s == NULL && (s = *last) == NULL) |
| return (NULL); |
| return strtok_r(s, delim, &next); |
| } |
| |
| cont: |
| c = *s++; |
| for (spanp = (char *)delim; (sc = *spanp++) != 0;) { |
| if (c == sc) |
| goto cont; |
| } |
| char *strtok_r(char *s, const char *delim, char **next) |
| { |
| char *start, *end; |
| |
| if (c == 0) { /* no non-delimiter characters */ |
| *last = NULL; |
| return (NULL); |
| } |
| if (s == NULL) |
| s = *next; |
| |
| tok = s - 1; |
| /* Skip over leading delimiters. */ |
| while (*s && (strchr(delim, *s) != NULL)) ++s; |
| start = s; |
| |
| for (;;) { |
| c = *s++; |
| spanp = (char *)delim; |
| do { |
| if ((sc = *spanp++) == c) { |
| if (c == 0) |
| s = NULL; |
| else |
| s[-1] = '\0'; |
| *last = s; |
| return (tok); |
| } |
| } while (sc != 0); |
| /* Skip over token characters. */ |
| while (*s && (strchr(delim, *s) == NULL)) ++s; |
| end = s; |
| *next = (*s ? s + 1 : s); |
| |
| if (start == end) { |
| return NULL; /* No more tokens. */ |
| } |
| } |
| |
| /* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */ |
| char * strtok(char *s, const char *delim) |
| { |
| static char *last; |
| |
| return (strtok_r(s, delim, &last)); |
| /* Overwrite delimiter with NULL terminator. */ |
| *end = '\0'; |
| return start; |
| } |
| |
| /** @} |