Return to readfilemap.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / expat / xmlwf

Annotation of embedaddon/expat/xmlwf/readfilemap.c, revision 1.1.1.1

1.1       misho       1: /* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
                      2:    See the file COPYING for copying permission.
                      3: */
                      4: 
                      5: #include <sys/types.h>
                      6: #include <sys/stat.h>
                      7: #include <fcntl.h>
                      8: #include <stdlib.h>
                      9: #include <stdio.h>
                     10: 
                     11: #ifdef __WATCOMC__
                     12: #ifndef __LINUX__
                     13: #include <io.h>
                     14: #else
                     15: #include <unistd.h>
                     16: #endif
                     17: #endif
                     18: 
                     19: #ifdef __BEOS__
                     20: #include <unistd.h>
                     21: #endif
                     22: 
                     23: #ifndef S_ISREG
                     24: #ifndef S_IFREG
                     25: #define S_IFREG _S_IFREG
                     26: #endif
                     27: #ifndef S_IFMT
                     28: #define S_IFMT _S_IFMT
                     29: #endif
                     30: #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
                     31: #endif /* not S_ISREG */
                     32: 
                     33: #ifndef O_BINARY
                     34: #ifdef _O_BINARY
                     35: #define O_BINARY _O_BINARY
                     36: #else
                     37: #define O_BINARY 0
                     38: #endif
                     39: #endif
                     40: 
                     41: #include "filemap.h"
                     42: 
                     43: int
                     44: filemap(const char *name,
                     45:         void (*processor)(const void *, size_t, const char *, void *arg),
                     46:         void *arg)
                     47: {
                     48:   size_t nbytes;
                     49:   int fd;
                     50:   int n;
                     51:   struct stat sb;
                     52:   void *p;
                     53: 
                     54:   fd = open(name, O_RDONLY|O_BINARY);
                     55:   if (fd < 0) {
                     56:     perror(name);
                     57:     return 0;
                     58:   }
                     59:   if (fstat(fd, &sb) < 0) {
                     60:     perror(name);
                     61:     return 0;
                     62:   }
                     63:   if (!S_ISREG(sb.st_mode)) {
                     64:     fprintf(stderr, "%s: not a regular file\n", name);
                     65:     return 0;
                     66:   }
                     67:   nbytes = sb.st_size;
                     68:   /* malloc will return NULL with nbytes == 0, handle files with size 0 */
                     69:   if (nbytes == 0) {
                     70:     static const char c = '\0';
                     71:     processor(&c, 0, name, arg);
                     72:     close(fd);
                     73:     return 1;
                     74:   }
                     75:   p = malloc(nbytes);
                     76:   if (!p) {
                     77:     fprintf(stderr, "%s: out of memory\n", name);
                     78:     close(fd);
                     79:     return 0;
                     80:   }
                     81:   n = read(fd, p, nbytes);
                     82:   if (n < 0) {
                     83:     perror(name);
                     84:     free(p);
                     85:     close(fd);
                     86:     return 0;
                     87:   }
                     88:   if (n != nbytes) {
                     89:     fprintf(stderr, "%s: read unexpected number of bytes\n", name);
                     90:     free(p);
                     91:     close(fd);
                     92:     return 0;
                     93:   }
                     94:   processor(p, nbytes, name, arg);
                     95:   free(p);
                     96:   close(fd);
                     97:   return 1;
                     98: }