chiark / gitweb /
Bring CGI docs pretty much up to date
[disorder] / lib / macros-builtin.c
1 /*
2  * This file is part of DisOrder
3  * Copyright (C) 2008 Richard Kettlewell
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
18  * USA
19  */
20
21 /** @file lib/macros-builtin.c
22  * @brief Built-in expansions
23  *
24  * This is a grab-bag of non-domain-specific expansions.  Documentation will be
25  * generated from the comments at the head of each function.
26  */
27
28 #include <config.h>
29 #include "types.h"
30
31 #include <stdio.h>
32 #include <string.h>
33 #include <errno.h>
34 #include <assert.h>
35 #include <unistd.h>
36 #include <fcntl.h>
37 #include <sys/stat.h>
38 #include <sys/wait.h>
39
40 #include "hash.h"
41 #include "mem.h"
42 #include "macros.h"
43 #include "sink.h"
44 #include "syscalls.h"
45 #include "log.h"
46 #include "wstat.h"
47 #include "kvp.h"
48 #include "split.h"
49 #include "printf.h"
50 #include "vector.h"
51 #include "filepart.h"
52
53 static struct vector include_path;
54
55 /** @brief Return 1 if @p s is 'true' else 0 */
56 int mx_str2bool(const char *s) {
57   return !strcmp(s, "true");
58 }
59
60 /** @brief Return "true" if @p n is nonzero else "false" */
61 const char *mx_bool2str(int n) {
62   return n ? "true" : "false";
63 }
64
65 /** @brief Write a boolean result */
66 int mx_bool_result(struct sink *output, int result) {
67   if(sink_writes(output, mx_bool2str(result)) < 0)
68     return -1;
69   else
70     return 0;
71 }
72
73 /** @brief Search the include path */
74 char *mx_find(const char *name) {
75   char *path;
76   int n;
77   
78   if(name[0] == '/') {
79     if(access(name, O_RDONLY) < 0) {
80       error(errno, "cannot read %s", name);
81       return 0;
82     }
83     path = xstrdup(name);
84   } else {
85     /* Search the include path */
86     for(n = 0; n < include_path.nvec; ++n) {
87       byte_xasprintf(&path, "%s/%s", include_path.vec[n], name);
88       if(access(path, O_RDONLY) == 0)
89         break;
90     }
91     if(n >= include_path.nvec) {
92       error(0, "cannot find '%s' in search path", name);
93       return 0;
94     }
95   }
96   return path;
97 }
98
99 /*! @include{TEMPLATE}@
100  *
101  * Includes TEMPLATE.
102  *
103  * TEMPLATE can be an absolute filename starting with a '/'; only the file with
104  * exactly this name will be included.
105  *
106  * Alternatively it can be a relative filename, not starting with a '/'.  In
107  * this case the file will be searched for in the include path.  When searching
108  * paths, unreadable files are treated as if they do not exist (rather than
109  * matching then producing an error).
110  *
111  * If the name chosen ends ".tmpl" then the file will be expanded as a
112  * template.  Anything else is included byte-for-byte without further
113  * modification.
114  *
115  * Only regular files are allowed (no devices, sockets or name pipes).
116  */
117 static int exp_include(int attribute((unused)) nargs,
118                        char **args,
119                        struct sink *output,
120                        void *u) {
121   const char *path;
122   int fd, n;
123   char buffer[4096];
124   struct stat sb;
125
126   if(!(path = mx_find(args[0]))) {
127     if(sink_printf(output, "[[cannot find '%s']]", args[0]) < 0)
128       return 0;
129     return 0;
130   }
131   /* If it's a template expand it */
132   if(strlen(path) >= 5 && !strncmp(path + strlen(path) - 5, ".tmpl", 5))
133     return mx_expand_file(path, output, u);
134   /* Read the raw file.  As with mx_expand_file() we insist that the file is a
135    * regular file. */
136   if((fd = open(path, O_RDONLY)) < 0)
137     fatal(errno, "error opening %s", path);
138   if(fstat(fd, &sb) < 0)
139     fatal(errno, "error statting %s", path);
140   if(!S_ISREG(sb.st_mode))
141     fatal(0, "%s: not a regular file", path);
142   while((n = read(fd, buffer, sizeof buffer)) > 0) {
143     if(sink_write(output, buffer, n) < 0) {
144       xclose(fd);
145       return -1;
146     }
147   }
148   if(n < 0)
149     fatal(errno, "error reading %s", path);
150   xclose(fd);
151   return 0;
152 }
153
154 /*! @include{COMMAND}@
155  *
156  * Executes COMMAND via the shell (using "sh -c") and copies its
157  * standard output to the template output.  The shell command output
158  * is not expanded or modified in any other way.
159  *
160  * The shell command's standard error is copied to the error log.
161  *
162  * If the shell exits nonzero then this is reported to the error log
163  * but otherwise no special action is taken.
164  */
165 static int exp_shell(int attribute((unused)) nargs,
166                      char **args,
167                      struct sink *output,
168                      void attribute((unused)) *u) {
169   int w, p[2], n;
170   char buffer[4096];
171   pid_t pid;
172   
173   xpipe(p);
174   if(!(pid = xfork())) {
175     exitfn = _exit;
176     xclose(p[0]);
177     xdup2(p[1], 1);
178     xclose(p[1]);
179     execlp("sh", "sh", "-c", args[0], (char *)0);
180     fatal(errno, "error executing sh");
181   }
182   xclose(p[1]);
183   while((n = read(p[0], buffer, sizeof buffer))) {
184     if(n < 0) {
185       if(errno == EINTR)
186         continue;
187       else
188         fatal(errno, "error reading from pipe");
189     }
190     if(output->write(output, buffer, n) < 0)
191       return -1;
192   }
193   xclose(p[0]);
194   while((n = waitpid(pid, &w, 0)) < 0 && errno == EINTR)
195     ;
196   if(n < 0)
197     fatal(errno, "error calling waitpid");
198   if(w)
199     error(0, "shell command '%s' %s", args[0], wstat(w));
200   return 0;
201 }
202
203 /*! @if{CONDITION}{IF-TRUE}{IF-FALSE}@
204  *
205  * If CONDITION is "true" then evaluates to IF-TRUE.  Otherwise
206  * evaluates to IF-FALSE.  The IF-FALSE part is optional.
207  */
208 static int exp_if(int nargs,
209                   const struct mx_node **args,
210                   struct sink *output,
211                   void *u) {
212   char *s;
213   int rc;
214
215   if((rc = mx_expandstr(args[0], &s, u, "argument #0 (CONDITION)")))
216     return rc;
217   if(mx_str2bool(s))
218     return mx_expand(args[1], output, u);
219   else if(nargs > 2)
220     return mx_expand(args[2], output, u);
221   else
222     return 0;
223 }
224
225 /*! @and{BRANCH}{BRANCH}...@
226  *
227  * Expands to "true" if all the branches are "true" otherwise to "false".  If
228  * there are no brances then the result is "true".  Only as many branches as
229  * necessary to compute the answer are evaluated (starting from the first one),
230  * so if later branches have side effects they may not take place.
231  */
232 static int exp_and(int nargs,
233                    const struct mx_node **args,
234                    struct sink *output,
235                    void *u) {
236   int n, result = 1, rc;
237   char *s, *argname;
238
239   for(n = 0; n < nargs; ++n) {
240     byte_xasprintf(&argname, "argument #%d", n);
241     if((rc = mx_expandstr(args[n], &s, u, argname)))
242       return rc;
243     if(!mx_str2bool(s)) {
244       result = 0;
245       break;
246     }
247   }
248   return mx_bool_result(output, result);
249 }
250
251 /*! @or{BRANCH}{BRANCH}...@
252  *
253  * Expands to "true" if any of the branches are "true" otherwise to "false".
254  * If there are no brances then the result is "false".  Only as many branches
255  * as necessary to compute the answer are evaluated (starting from the first
256  * one), so if later branches have side effects they may not take place.
257  */
258 static int exp_or(int nargs,
259                   const struct mx_node **args,
260                   struct sink *output,
261                   void *u) {
262   int n, result = 0, rc;
263   char *s, *argname;
264
265   for(n = 0; n < nargs; ++n) {
266     byte_xasprintf(&argname, "argument #%d", n);
267     if((rc = mx_expandstr(args[n], &s, u, argname)))
268       return rc;
269     if(mx_str2bool(s)) {
270       result = 1;
271       break;
272     }
273   }
274   return mx_bool_result(output, result);
275 }
276
277 /*! @not{CONDITION}@
278  *
279  * Expands to "true" unless CONDITION is "true" in which case "false".
280  */
281 static int exp_not(int attribute((unused)) nargs,
282                    char **args,
283                    struct sink *output,
284                    void attribute((unused)) *u) {
285   return mx_bool_result(output, !mx_str2bool(args[0]));
286 }
287
288 /*! @#{...}@
289  *
290  * Expands to nothing.  The argument(s) are not fully evaluated, and no side
291  * effects occur.
292  */
293 static int exp_comment(int attribute((unused)) nargs,
294                        const struct mx_node attribute((unused)) **args,
295                        struct sink attribute((unused)) *output,
296                        void attribute((unused)) *u) {
297   return 0;
298 }
299
300 /*! @urlquote{STRING}@
301  *
302  * URL-quotes a string, i.e. replaces any characters not safe to use unquoted
303  * in a URL with %-encoded form.
304  */
305 static int exp_urlquote(int attribute((unused)) nargs,
306                         char **args,
307                         struct sink *output,
308                         void attribute((unused)) *u) {
309   if(sink_writes(output, urlencodestring(args[0])) < 0)
310     return -1;
311   else
312     return 0;
313 }
314
315 /*! @eq{S1}{S2}...@
316  *
317  * Expands to "true" if all the arguments are identical, otherwise to "false"
318  * (i.e. if any pair of arguments differs).
319  *
320  * If there are no arguments then expands to "true".  Evaluates all arguments
321  * (with their side effects) even if that's not strictly necessary to discover
322  * the result.
323  */
324 static int exp_eq(int nargs,
325                   char **args,
326                   struct sink *output,
327                   void attribute((unused)) *u) {
328   int n, result = 1;
329   
330   for(n = 1; n < nargs; ++n) {
331     if(strcmp(args[n], args[0])) {
332       result = 0;
333       break;
334     }
335   }
336   return mx_bool_result(output, result);
337 }
338
339 /*! @ne{S1}{S2}...@
340  *
341  * Expands to "true" if all of the arguments differ from one another, otherwise
342  * to "false" (i.e. if any value appears more than once).
343  *
344  * If there are no arguments then expands to "true".  Evaluates all arguments
345  * (with their side effects) even if that's not strictly necessary to discover
346  * the result.
347  */
348 static int exp_ne(int nargs,
349                   char **args,
350                   struct sink *output,
351                   void  attribute((unused))*u) {
352   hash *h = hash_new(sizeof (char *));
353   int n, result = 1;
354
355   for(n = 0; n < nargs; ++n)
356     if(hash_add(h, args[n], "", HASH_INSERT)) {
357       result = 0;
358       break;
359     }
360   return mx_bool_result(output, result);
361 }
362
363 /*! @discard{...}@
364  *
365  * Expands to nothing.  Unlike the comment expansion @#{...}, side effects of
366  * arguments are not suppressed.  So this can be used to surround a collection
367  * of macro definitions with whitespace, free text commentary, etc.
368  */
369 static int exp_discard(int attribute((unused)) nargs,
370                        char attribute((unused)) **args,
371                        struct sink attribute((unused)) *output,
372                        void attribute((unused)) *u) {
373   return 0;
374 }
375
376 /*! @define{NAME}{ARG1 ARG2...}{DEFINITION}@
377  *
378  * Define a macro.  The macro will be called NAME and will act like an
379  * expansion.  When it is expanded, the expansion is replaced by DEFINITION,
380  * with each occurence of @ARG1@ etc replaced by the parameters to the
381  * expansion.
382  */
383 static int exp_define(int attribute((unused)) nargs,
384                       const struct mx_node **args,
385                       struct sink attribute((unused)) *output,
386                       void attribute((unused)) *u) {
387   char **as, *name, *argnames;
388   int rc, nas;
389   
390   if((rc = mx_expandstr(args[0], &name, u, "argument #0 (NAME)")))
391     return rc;
392   if((rc = mx_expandstr(args[1], &argnames, u, "argument #1 (ARGS)")))
393     return rc;
394   as = split(argnames, &nas, 0, 0, 0);
395   mx_register_macro(name, nas, as, args[2]);
396   return 0;
397 }
398
399 /*! @basename{PATH}
400  *
401  * Expands to the UNQUOTED basename of PATH.
402  */
403 static int exp_basename(int attribute((unused)) nargs,
404                         char **args,
405                         struct sink attribute((unused)) *output,
406                         void attribute((unused)) *u) {
407   return sink_writes(output, d_basename(args[0])) < 0 ? -1 : 0;
408 }
409
410 /*! @dirname{PATH}
411  *
412  * Expands to the UNQUOTED directory name of PATH.
413  */
414 static int exp_dirname(int attribute((unused)) nargs,
415                        char **args,
416                        struct sink attribute((unused)) *output,
417                        void attribute((unused)) *u) {
418   return sink_writes(output, d_dirname(args[0])) < 0 ? -1 : 0;
419 }
420
421 /*! @q{STRING}
422  *
423  * Expands to STRING.
424  */
425 static int exp_q(int attribute((unused)) nargs,
426                  char **args,
427                  struct sink attribute((unused)) *output,
428                  void attribute((unused)) *u) {
429   return sink_writes(output, args[0]) < 0 ? -1 : 0;
430 }
431
432 /** @brief Register built-in expansions */
433 void mx_register_builtin(void) {
434   mx_register("basename", 1, 1, exp_basename);
435   mx_register("dirname", 1, 1, exp_dirname);
436   mx_register("discard", 0, INT_MAX, exp_discard);
437   mx_register("eq", 0, INT_MAX, exp_eq);
438   mx_register("include", 1, 1, exp_include);
439   mx_register("ne", 0, INT_MAX, exp_ne);
440   mx_register("not", 1, 1, exp_not);
441   mx_register("shell", 1, 1, exp_shell);
442   mx_register("urlquote", 1, 1, exp_urlquote);
443   mx_register("q", 1, 1, exp_q);
444   mx_register_magic("#", 0, INT_MAX, exp_comment);
445   mx_register_magic("and", 0, INT_MAX, exp_and);
446   mx_register_magic("define", 3, 3, exp_define);
447   mx_register_magic("if", 2, 3, exp_if);
448   mx_register_magic("or", 0, INT_MAX, exp_or);
449 }
450
451 /** @brief Add a directory to the search path
452  * @param s Directory to add
453  */
454 void mx_search_path(const char *s) {
455   vector_append(&include_path, xstrdup(s));
456 }
457
458 /*
459 Local Variables:
460 c-basic-offset:2
461 comment-column:40
462 fill-column:79
463 indent-tabs-mode:nil
464 End:
465 */