/[meta-cvs]/meta-cvs/F-83F0E6A90D5BBCDFB58440970E850925.c
ViewVC logotype

Contents of /meta-cvs/F-83F0E6A90D5BBCDFB58440970E850925.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.4.2.1 - (hide annotations)
Tue Dec 3 07:21:05 2002 UTC (11 years, 4 months ago) by kaz
Branch: mcvs-1-0-branch
Changes since 1.4: +30 -0 lines
File MIME type: text/plain
Discontinuing use of CLISP's ext:run-program function in favor
of a new workalike which doesn't rely on the shell interpreter.

* code/unix-bindings/unix.lisp (unix-funcs:spawn): New C call out
function (unix-funcs:run-program): New function, implemented using
spawn.

* code/unix-bindings/impl.c (impl_spawn): New function; wraps
up fork, execvp and waitpid.

* code/clisp-unix.lisp: Switch from ext:run-program to
unix-funcs:run-program.
1 kaz 1.1 #include <stdio.h>
2 kaz 1.3 #include <stdlib.h>
3 kaz 1.1 #include <string.h>
4     #include <errno.h>
5     #include <dirent.h>
6 kaz 1.3 #include <unistd.h>
7 kaz 1.1 #include <sys/types.h>
8     #include <sys/stat.h>
9 kaz 1.4.2.1 #include <sys/wait.h>
10 kaz 1.1
11     /*
12 kaz 1.2 * Null pointer test
13     */
14    
15     int impl_null_pointer_p(void *ptr)
16     {
17     return ptr == 0;
18     }
19    
20     /*
21 kaz 1.1 * <errno.h> stuff
22     */
23    
24     int impl_get_errno(void)
25     {
26     return errno;
27     }
28    
29     int impl_set_errno(int value)
30     {
31     return errno = value;
32     }
33    
34     /*
35     * <dirent.h> stuff
36     */
37    
38     typedef struct {
39     unsigned long d_ino;
40     char d_name[1024];
41     } impl_dirent;
42    
43     impl_dirent *impl_readdir(DIR *dir)
44     {
45     static impl_dirent dw;
46     struct dirent *de = readdir(dir);
47     if (de != 0) {
48     strncpy(dw.d_name, de->d_name, sizeof dw.d_name - 1);
49     dw.d_ino = de->d_ino;
50     return &dw;
51     }
52     return 0;
53     }
54    
55     /*
56 kaz 1.4 * <unistd.h> stuff
57     */
58    
59     char *impl_readlink(const char *path)
60     {
61     size_t size = 256;
62     char *str = malloc(size);
63     char *temp;
64    
65     if (str == 0)
66     goto bail;
67    
68     for (;;) {
69     int result = readlink(path, str, size);
70     if (result == -1)
71     goto bail;
72     if (result < size) {
73     str[result] = 0;
74     break;
75     }
76     if (size * 2 < size)
77     goto bail;
78     size *= 2;
79     if ((temp = realloc(str, size)) == 0)
80     goto bail;
81     str = temp;
82     }
83    
84     /* No need to realloc to actual size, since CLISP will free this anyway */
85     return str;
86    
87     bail:
88     free(str);
89     return 0;
90     }
91    
92     /*
93 kaz 1.1 * <sys/stat.h> stuff
94     */
95    
96     struct impl_stat {
97     unsigned long dev;
98     unsigned long ino;
99     unsigned long mode;
100     unsigned int nlink;
101     unsigned int uid;
102     unsigned int gid;
103     unsigned long rdev;
104     unsigned long blksize;
105     unsigned long blocks;
106     unsigned long atime;
107     unsigned long mtime;
108     unsigned long ctime;
109     };
110    
111     static void stat_to_impl(struct impl_stat *out, const struct stat *in)
112     {
113     out->dev = in->st_dev;
114     out->ino = in->st_ino;
115     out->mode = in->st_mode;
116     out->nlink = in->st_nlink;
117     out->uid = in->st_uid;
118     out->gid = in->st_gid;
119     out->rdev = in->st_rdev;
120     out->blksize = in->st_blksize;
121     out->blocks = in->st_blocks;
122     out->atime = in->st_atime;
123     out->mtime = in->st_mtime;
124     out->ctime = in->st_ctime;
125     }
126    
127     #define IMPL_STAT(FUNC, ARGTYPE) \
128     int impl_ ## FUNC(ARGTYPE arg, struct impl_stat *buf) \
129     { \
130     struct stat sbuf; \
131     int retval = FUNC(arg, &sbuf); \
132     if (retval == 0) \
133     stat_to_impl(buf, &sbuf); \
134     return retval; \
135     }
136    
137     IMPL_STAT(stat, const char *)
138     IMPL_STAT(lstat, const char *)
139     IMPL_STAT(fstat, int)
140 kaz 1.3
141     /*
142     * <unistd.h> -- getcwd
143     */
144    
145     const char *impl_getcwd(void)
146     {
147     size_t size = 256;
148     char *str = malloc(size);
149     char *temp;
150    
151     if (str == 0)
152     goto bail;
153    
154     while (getcwd(str, size) == 0) {
155     if (size * 2 < size)
156     goto bail;
157     size *= 2;
158     if ((temp = realloc(str, size)) == 0)
159     goto bail;
160     str = temp;
161     }
162    
163     /* No need to realloc to actual size, since CLISP will free this anyway */
164     return str;
165    
166     bail:
167     free(str);
168     return 0;
169 kaz 1.4.2.1 }
170    
171     /*
172     * <unistd.h> -- fork, wait*, exec*
173     */
174    
175     int impl_spawn(const char *name, char *const *argv)
176     {
177     pid_t child = fork();
178     int result = -1;
179     int status;
180    
181     if (child == -1)
182     goto out;
183    
184     if (child == 0) {
185     execvp(name, argv);
186     _exit(EXIT_FAILURE);
187     }
188    
189     if (waitpid(child, &status, 0) == -1)
190     goto out;
191    
192     if (WIFEXITED(status))
193     result = WEXITSTATUS(status);
194    
195     out:
196     free(argv);
197     return result;
198 kaz 1.3 }

  ViewVC Help
Powered by ViewVC 1.1.5