| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/Makefile |
|---|
| 0,0 → 1,6 |
| THIS_SRCS = memchr.c memcmp.c memcpy.c memmove.s memset.s strcat.c \ |
| strchr.c strcmp.c strcoll.c strcpy.c strcspn.c strerror.c \ |
| strlen.c strncat.c strncmp.c strncpy.c strpbrk.c strrchr.c \ |
| strspn.c strstr.c strtok.c strxfrm.c syserr1.c syserr2.c syserr3.c |
| include $(MENUET_LIBC_TOPDIR)/Make.rules |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/memchr.c |
|---|
| 0,0 → 1,18 |
| #include<string.h> |
| #include<libc/unconst.h> |
| #include<assert.h> |
| void * memchr(const void *s, int c, size_t n) |
| { |
| int d0; |
| register void * __res; |
| if (!n) return NULL; |
| __asm__ __volatile__( |
| "repne\n\t" |
| "scasb\n\t" |
| "je 1f\n\t" |
| "movl $1,%0\n" |
| "1:\tdecl %0" |
| :"=D" (__res), "=&c" (d0) : "a" (c),"0" (s),"1" (n)); |
| return __res; |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/memcmp.c |
|---|
| 0,0 → 1,18 |
| /* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */ |
| #include <string.h> |
| #include <assert.h> |
| int |
| memcmp(const void *s1, const void *s2, size_t n) |
| { |
| if (n != 0) |
| { |
| const unsigned char *p1 = s1, *p2 = s2; |
| do { |
| if (*p1++ != *p2++) |
| return (*--p1 - *--p2); |
| } while (--n != 0); |
| } |
| return 0; |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/memcpy.c |
|---|
| 0,0 → 1,23 |
| #include<stdio.h> |
| #include<stdlib.h> |
| #include<string.h> |
| void * memcpy(void * _dest, const void *_src, size_t _n) |
| { |
| int d0, d1, d2; |
| __asm__ __volatile__( |
| "jcxz 1f\n\t" |
| "rep ; movsl\n\t" |
| "1:\t" |
| "testb $2,%b4\n\t" |
| "je 1f\n\t" |
| "movsw\n" |
| "1:\ttestb $1,%b4\n\t" |
| "je 2f\n\t" |
| "movsb\n" |
| "2:" |
| : "=&c" (d0), "=&D" (d1), "=&S" (d2) |
| :"0" (_n/4), "q" (_n),"1" ((long)_dest),"2" ((long)_src) |
| : "memory"); |
| return (_dest); |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/memmove.s |
|---|
| 0,0 → 1,33 |
| /* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */ |
| .file "memmove.s" |
| #include<libc/asm.h> |
| MK_C_SYM(memmove) |
| pushl %ebp |
| movl %esp,%ebp |
| pushl %esi |
| pushl %edi |
| movl 8(%ebp),%edi |
| movl 12(%ebp),%esi |
| movl 16(%ebp),%ecx |
| jecxz L2 |
| cld |
| cmpl %esi,%edi |
| jb L3 |
| std |
| addl %ecx,%esi |
| addl %ecx,%edi |
| decl %esi |
| decl %edi |
| L3: |
| rep |
| movsb |
| L2: |
| cld |
| popl %edi |
| popl %esi |
| movl 8(%ebp),%eax |
| leave |
| ret |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/memset.s |
|---|
| 0,0 → 1,51 |
| /* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */ |
| #include<libc/asm.h> |
| .file "memset.s" |
| .text |
| .align 4 |
| MK_C_SYM(memset) |
| pushl %ebp |
| movl %esp,%ebp |
| pushl %edi |
| movl 8(%ebp),%edi |
| movl 12(%ebp),%eax |
| movl 16(%ebp),%ecx |
| cld |
| # We will handle memsets of <= 15 bytes one byte at a time. |
| # This avoids some extra overhead for small memsets, and |
| # knowing we are setting > 15 bytes eliminates some annoying |
| # checks in the "long move" case. |
| cmpl $15,%ecx |
| jle L3 |
| # Otherwise, tile the byte value out into %eax. |
| # 0x41 -> 0x41414141, etc. |
| movb %al,%ah |
| movl %eax,%edx |
| sall $16,%eax |
| movw %dx,%ax |
| jmp L2 |
| # Handle any cruft necessary to get %edi long-aligned. |
| L1: stosb |
| decl %ecx |
| L2: testl $3,%edi |
| jnz L1 |
| # Now slam out all of the longs. |
| movl %ecx,%edx |
| shrl $2,%ecx |
| rep |
| stosl |
| # Finally, handle any trailing cruft. We know the high three bytes |
| # of %ecx must be zero, so just put the "slop count" in the low byte. |
| movb %dl,%cl |
| andb $3,%cl |
| L3: rep |
| stosb |
| popl %edi |
| movl 8(%ebp),%eax |
| leave |
| ret |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/strcat.c |
|---|
| 0,0 → 1,17 |
| #include <string.h> |
| char * strcat(char *s, const char *append) |
| { |
| int d0, d1, d2, d3; |
| __asm__ __volatile__( |
| "repne\n\t" |
| "scasb\n\t" |
| "decl %1\n" |
| "1:\tlodsb\n\t" |
| "stosb\n\t" |
| "testb %%al,%%al\n\t" |
| "jne 1b" |
| : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3) |
| : "0" (append),"1"(s),"2"(0),"3" (0xffffffff):"memory"); |
| return s; |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/strchr.c |
|---|
| 0,0 → 1,20 |
| #include <string.h> |
| #include <libc/unconst.h> |
| char * strchr(const char *s, int c) |
| { |
| int d0; |
| register char * __res; |
| __asm__ __volatile__( |
| "movb %%al,%%ah\n" |
| "1:\tlodsb\n\t" |
| "cmpb %%ah,%%al\n\t" |
| "je 2f\n\t" |
| "testb %%al,%%al\n\t" |
| "jne 1b\n\t" |
| "movl $1,%1\n" |
| "2:\tmovl %1,%0\n\t" |
| "decl %0" |
| :"=a" (__res), "=&S" (d0) : "1" (s),"0" (c)); |
| return __res; |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/strcmp.c |
|---|
| 0,0 → 1,21 |
| #include <string.h> |
| int strcmp(const char *s1, const char *s2) |
| { |
| int d0, d1; |
| register int __res; |
| __asm__ __volatile__( |
| "1:\tlodsb\n\t" |
| "scasb\n\t" |
| "jne 2f\n\t" |
| "testb %%al,%%al\n\t" |
| "jne 1b\n\t" |
| "xorl %%eax,%%eax\n\t" |
| "jmp 3f\n" |
| "2:\tsbbl %%eax,%%eax\n\t" |
| "orb $1,%%al\n" |
| "3:" |
| :"=a" (__res), "=&S" (d0), "=&D" (d1) |
| :"1" (s1),"2" (s2)); |
| return __res; |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/strcoll.c |
|---|
| 0,0 → 1,8 |
| /* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */ |
| #include <string.h> |
| int |
| strcoll(const char *s1, const char *s2) |
| { |
| return strcmp(s1, s2); |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/strcpy.c |
|---|
| 0,0 → 1,15 |
| /* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */ |
| #include <string.h> |
| char * strcpy(char *to, const char *from) |
| { |
| int d0, d1, d2; |
| __asm__ __volatile__( |
| "1:\tlodsb\n\t" |
| "stosb\n\t" |
| "testb %%al,%%al\n\t" |
| "jne 1b" |
| : "=&S" (d0), "=&D" (d1), "=&a" (d2) |
| :"0" (from),"1" (to) : "memory"); |
| return to; |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/strcspn.c |
|---|
| 0,0 → 1,20 |
| /* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */ |
| #include <string.h> |
| size_t |
| strcspn(const char *s1, const char *s2) |
| { |
| const char *p, *spanp; |
| char c, sc; |
| for (p = s1;;) |
| { |
| c = *p++; |
| spanp = s2; |
| do { |
| if ((sc = *spanp++) == c) |
| return p - 1 - s1; |
| } while (sc != 0); |
| } |
| /* NOTREACHED */ |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/strerror.c |
|---|
| 0,0 → 1,37 |
| /* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */ |
| #include <stdio.h> |
| #include <string.h> |
| #include <errno.h> |
| #include <libc/unconst.h> |
| char * |
| strerror(int errnum) |
| { |
| static char ebuf[40]; /* 64-bit number + slop */ |
| char *cp; |
| int v=1000000, lz=0; |
| if (errnum >= 0 && errnum < __sys_nerr) |
| return(unconst(__sys_errlist[errnum], char *)); |
| strcpy(ebuf, "Unknown error: "); |
| cp = ebuf + 15; |
| if (errnum < 0) |
| { |
| *cp++ = '-'; |
| errnum = -errnum; |
| } |
| while (v) |
| { |
| int d = errnum / v; |
| if (d || lz || (v == 1)) |
| { |
| *cp++ = d+'0'; |
| lz = 1; |
| } |
| errnum %= v; |
| v /= 10; |
| } |
| return ebuf; |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/strlen.c |
|---|
| 0,0 → 1,15 |
| /* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */ |
| #include <string.h> |
| size_t strlen(const char *str) |
| { |
| int d0; |
| register int __res; |
| __asm__ __volatile__( |
| "repne\n\t" |
| "scasb\n\t" |
| "notl %0\n\t" |
| "decl %0" |
| :"=c" (__res), "=&D" (d0) :"1" (str),"a" (0), "0" (0xffffffff)); |
| return __res; |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/strncat.c |
|---|
| 0,0 → 1,24 |
| #include <string.h> |
| char * |
| strncat(char *dst, const char *src, size_t n) |
| { |
| int d0, d1, d2, d3; |
| __asm__ __volatile__( |
| "repne\n\t" |
| "scasb\n\t" |
| "decl %1\n\t" |
| "movl %8,%3\n" |
| "1:\tdecl %3\n\t" |
| "js 2f\n\t" |
| "lodsb\n\t" |
| "stosb\n\t" |
| "testb %%al,%%al\n\t" |
| "jne 1b\n" |
| "2:\txorl %2,%2\n\t" |
| "stosb" |
| : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3) |
| : "0" (src),"1" (dst),"2" (0),"3" (0xffffffff), "g" (n) |
| : "memory"); |
| return dst; |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/strncmp.c |
|---|
| 0,0 → 1,24 |
| /* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */ |
| #include <string.h> |
| int strncmp(const char *s1, const char *s2, size_t n) |
| { |
| register int __res; |
| int d0, d1, d2; |
| __asm__ __volatile__( |
| "1:\tdecl %3\n\t" |
| "js 2f\n\t" |
| "lodsb\n\t" |
| "scasb\n\t" |
| "jne 3f\n\t" |
| "testb %%al,%%al\n\t" |
| "jne 1b\n" |
| "2:\txorl %%eax,%%eax\n\t" |
| "jmp 4f\n" |
| "3:\tsbbl %%eax,%%eax\n\t" |
| "orb $1,%%al\n" |
| "4:" |
| :"=a" (__res), "=&S" (d0), "=&D" (d1), "=&c" (d2) |
| :"1" (s1),"2" (s2),"3" (n)); |
| return __res; |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/strncpy.c |
|---|
| 0,0 → 1,20 |
| /* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */ |
| #include <string.h> |
| char * strncpy(char *dst, const char *src, size_t n) |
| { |
| int d0, d1, d2, d3; |
| __asm__ __volatile__( |
| "1:\tdecl %2\n\t" |
| "js 2f\n\t" |
| "lodsb\n\t" |
| "stosb\n\t" |
| "testb %%al,%%al\n\t" |
| "jne 1b\n\t" |
| "rep\n\t" |
| "stosb\n" |
| "2:" |
| : "=&S" (d0), "=&D" (d1), "=&c" (d2), "=&a" (d3) |
| :"0" (src),"1" (dst),"2" (n) : "memory"); |
| return dst; |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/strpbrk.c |
|---|
| 0,0 → 1,18 |
| /* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */ |
| #include <string.h> |
| #include <libc/unconst.h> |
| char * |
| strpbrk(const char *s1, const char *s2) |
| { |
| const char *scanp; |
| int c, sc; |
| while ((c = *s1++) != 0) |
| { |
| for (scanp = s2; (sc = *scanp++) != 0;) |
| if (sc == c) |
| return unconst(s1 - 1, char *); |
| } |
| return 0; |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/strrchr.c |
|---|
| 0,0 → 1,21 |
| /* Copyright (C) 1996 DJ Delorie, see COPYING.DJ for details */ |
| /* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */ |
| #include <string.h> |
| #include <libc/unconst.h> |
| char * |
| strrchr(const char *s, int c) |
| { |
| char cc = c; |
| const char *sp=(char *)0; |
| while (*s) |
| { |
| if (*s == cc) |
| sp = s; |
| s++; |
| } |
| if (cc == 0) |
| sp = s; |
| return unconst(sp, char *); |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/strspn.c |
|---|
| 0,0 → 1,16 |
| /* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */ |
| #include <string.h> |
| size_t |
| strspn(const char *s1, const char *s2) |
| { |
| const char *p = s1, *spanp; |
| char c, sc; |
| cont: |
| c = *p++; |
| for (spanp = s2; (sc = *spanp++) != 0;) |
| if (sc == c) |
| goto cont; |
| return (p - 1 - s1); |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/strstr.c |
|---|
| 0,0 → 1,23 |
| /* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */ |
| #include <string.h> |
| #include <libc/unconst.h> |
| char * |
| strstr(const char *s, const char *find) |
| { |
| char c, sc; |
| size_t len; |
| if ((c = *find++) != 0) |
| { |
| len = strlen(find); |
| do { |
| do { |
| if ((sc = *s++) == 0) |
| return 0; |
| } while (sc != c); |
| } while (strncmp(s, find, len) != 0); |
| s--; |
| } |
| return unconst(s, char *); |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/strtok.c |
|---|
| 0,0 → 1,51 |
| /* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */ |
| #include <string.h> |
| char * |
| strtok(char *s, const char *delim) |
| { |
| const char *spanp; |
| int c, sc; |
| char *tok; |
| static char *last; |
| if (s == NULL && (s = last) == NULL) |
| return (NULL); |
| /* |
| * Skip (span) leading delimiters (s += strspn(s, delim), sort of). |
| */ |
| cont: |
| c = *s++; |
| for (spanp = delim; (sc = *spanp++) != 0;) { |
| if (c == sc) |
| goto cont; |
| } |
| if (c == 0) { /* no non-delimiter characters */ |
| last = NULL; |
| return (NULL); |
| } |
| tok = s - 1; |
| /* |
| * Scan token (scan for delimiters: s += strcspn(s, delim), sort of). |
| * Note that delim must have one NUL; we stop if we see that, too. |
| */ |
| for (;;) { |
| c = *s++; |
| spanp = delim; |
| do { |
| if ((sc = *spanp++) == c) { |
| if (c == 0) |
| s = NULL; |
| else |
| s[-1] = 0; |
| last = s; |
| return (tok); |
| } |
| } while (sc != 0); |
| } |
| /* NOTREACHED */ |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/strxfrm.c |
|---|
| 0,0 → 1,28 |
| /* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */ |
| #include <string.h> |
| size_t |
| strxfrm(dst, src, n) |
| char *dst; |
| const char *src; |
| size_t n; |
| { |
| size_t r = 0; |
| int c; |
| if (n != 0) { |
| while ((c = *src++) != 0) |
| { |
| r++; |
| if (--n == 0) |
| { |
| while (*src++ != 0) |
| r++; |
| break; |
| } |
| *dst++ = c; |
| } |
| *dst = 0; |
| } |
| return r; |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/syserr1.c |
|---|
| 0,0 → 1,42 |
| /* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */ |
| #include "syserr1.h" |
| char __syserr00[] = "No Error"; |
| char __syserr01[] = "Input to function out of range (EDOM)"; |
| char __syserr02[] = "Output of function out of range (ERANGE)"; |
| char __syserr03[] = "Argument list too long (E2BIG)"; |
| char __syserr04[] = "Permission denied (EACCES)"; |
| char __syserr05[] = "Resource temporarily unavailable (EAGAIN)"; |
| char __syserr06[] = "Bad file descriptor (EBADF)"; |
| char __syserr07[] = "Resource busy (EBUSY)"; |
| char __syserr08[] = "No child processes (ECHILD)"; |
| char __syserr09[] = "Resource deadlock avoided (EDEADLK)"; |
| char __syserr10[] = "File exists (EEXIST)"; |
| char __syserr11[] = "Bad address (EFAULT)"; |
| char __syserr12[] = "File too large (EFBIG)"; |
| char __syserr13[] = "Interrupted system call (EINTR)"; |
| char __syserr14[] = "Invalid argument (EINVAL)"; |
| char __syserr15[] = "Input or output error (EIO)"; |
| char __syserr16[] = "Is a directory (EISDIR)"; |
| char __syserr17[] = "Too many open files (EMFILE)"; |
| char __syserr18[] = "Too many links (EMLINK)"; |
| char __syserr19[] = "File name too long (ENAMETOOLONG)"; |
| char __syserr20[] = "Too many open files in system (ENFILE)"; |
| char __syserr21[] = "No such device (ENODEV)"; |
| char __syserr22[] = "No such file or directory (ENOENT)"; |
| char __syserr23[] = "Unable to execute file (ENOEXEC)"; |
| char __syserr24[] = "No locks available (ENOLCK)"; |
| char __syserr25[] = "Not enough memory (ENOMEM)"; |
| char __syserr26[] = "No space left on drive (ENOSPC)"; |
| char __syserr27[] = "Function not implemented (ENOSYS)"; |
| char __syserr28[] = "Not a directory (ENOTDIR)"; |
| char __syserr29[] = "Directory not empty (ENOTEMPTY)"; |
| char __syserr30[] = "Inappropriate I/O control operation (ENOTTY)"; |
| char __syserr31[] = "No such device or address (ENXIO)"; |
| char __syserr32[] = "Operation not permitted (EPERM)"; |
| char __syserr33[] = "Broken pipe (EPIPE)"; |
| char __syserr34[] = "Read-only file system (EROFS)"; |
| char __syserr35[] = "Invalid seek (ESPIPE)"; |
| char __syserr36[] = "No such process (ESRCH)"; |
| char __syserr37[] = "Improper link (EXDEV)"; |
| char __syserr38[] = "No more files (ENMFILE)"; |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/syserr1.h |
|---|
| 0,0 → 1,40 |
| /* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */ |
| extern char __syserr00[]; |
| extern char __syserr01[]; |
| extern char __syserr02[]; |
| extern char __syserr03[]; |
| extern char __syserr04[]; |
| extern char __syserr05[]; |
| extern char __syserr06[]; |
| extern char __syserr07[]; |
| extern char __syserr08[]; |
| extern char __syserr09[]; |
| extern char __syserr10[]; |
| extern char __syserr11[]; |
| extern char __syserr12[]; |
| extern char __syserr13[]; |
| extern char __syserr14[]; |
| extern char __syserr15[]; |
| extern char __syserr16[]; |
| extern char __syserr17[]; |
| extern char __syserr18[]; |
| extern char __syserr19[]; |
| extern char __syserr20[]; |
| extern char __syserr21[]; |
| extern char __syserr22[]; |
| extern char __syserr23[]; |
| extern char __syserr24[]; |
| extern char __syserr25[]; |
| extern char __syserr26[]; |
| extern char __syserr27[]; |
| extern char __syserr28[]; |
| extern char __syserr29[]; |
| extern char __syserr30[]; |
| extern char __syserr31[]; |
| extern char __syserr32[]; |
| extern char __syserr33[]; |
| extern char __syserr34[]; |
| extern char __syserr35[]; |
| extern char __syserr36[]; |
| extern char __syserr37[]; |
| extern char __syserr38[]; |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/syserr2.c |
|---|
| 0,0 → 1,16 |
| /* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */ |
| #include <errno.h> |
| #include "syserr1.h" |
| const char *__sys_errlist[] = { |
| __syserr00, __syserr01, __syserr02, __syserr03, __syserr04, |
| __syserr05, __syserr06, __syserr07, __syserr08, __syserr09, |
| __syserr10, __syserr11, __syserr12, __syserr13, __syserr14, |
| __syserr15, __syserr16, __syserr17, __syserr18, __syserr19, |
| __syserr20, __syserr21, __syserr22, __syserr23, __syserr24, |
| __syserr25, __syserr26, __syserr27, __syserr28, __syserr29, |
| __syserr30, __syserr31, __syserr32, __syserr33, __syserr34, |
| __syserr35, __syserr36, __syserr37, __syserr38 |
| }; |
| int __sys_nerr = sizeof(__sys_errlist) / sizeof(__sys_errlist[0]); |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /programs/develop/libraries/menuetlibc/src/libc/ansi/string/syserr3.c |
|---|
| 0,0 → 1,16 |
| /* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */ |
| #include <errno.h> |
| #include "syserr1.h" |
| char *sys_errlist[] = { |
| __syserr00, __syserr01, __syserr02, __syserr03, __syserr04, |
| __syserr05, __syserr06, __syserr07, __syserr08, __syserr09, |
| __syserr10, __syserr11, __syserr12, __syserr13, __syserr14, |
| __syserr15, __syserr16, __syserr17, __syserr18, __syserr19, |
| __syserr20, __syserr21, __syserr22, __syserr23, __syserr24, |
| __syserr25, __syserr26, __syserr27, __syserr28, __syserr29, |
| __syserr30, __syserr31, __syserr32, __syserr33, __syserr34, |
| __syserr35, __syserr36, __syserr37, __syserr38 |
| }; |
| int sys_nerr = sizeof(sys_errlist) / sizeof(sys_errlist[0]); |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |