util.c

   1 #include <stdarg.h>
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include <string.h>
   5 #include <ctype.h>
   6
   7 #include "util.h"
   8
   9 struct list *list_cons(void *el, struct list *tail)
  10 {
  11         struct list *res = safe_malloc(sizeof(struct list));
  12         res->el = el;
  13         res->tail = tail;
  14         return res;
  15 }
  16
  17 void list_free(struct list *head, void (*freefun)(void *))
  18 {
  19         while (head != NULL) {
  20                 freefun(head->el);
  21                 head = head->tail;
  22         }
  23 }
  24
  25 void **list_to_array(struct list *list, int *num, bool reverse)
  26 {
  27         int i = list_length(list);
  28         *num = i;
  29         void **ptr = safe_malloc(i*sizeof(void *));
  30
  31         struct list *r = list;
  32         while(i > 0) {
  33                 if (reverse)
  34                         ptr[--i] = r->el;
  35                 else
  36                         ptr[*num-(--i)] = r->el;
  37                 struct list *t = r;
  38                 r = r->tail;
  39                 free(t);
  40         }
  41         return ptr;
  42 }
  43
  44 int list_length(struct list *r)
  45 {
  46         int i = 0;
  47         while(r != NULL) {
  48                 i++;
  49                 r = r->tail;
  50         }
  51         return i;
  52 }
  53
  54 int fromHex(char c)
  55 {
  56         if (c >= '0' && c <= '9')
  57                 return c-'0';
  58         if (c >= 'a' && c <= 'f')
  59                 return c-'a'+10;
  60         if (c >= 'A' && c <= 'F')
  61                 return c-'A'+10;
  62         return -1;
  63 }
  64
  65 char *escape_char(char c, char *buf, bool str)
  66 {
  67         buf = buf == NULL ? safe_malloc(10) : buf;
  68         switch (c) {
  69         case '\0': strcpy(buf, "\\0"); break;
  70         case '\a': strcpy(buf, "\\a"); break;
  71         case '\b': strcpy(buf, "\\b"); break;
  72         case '\t': strcpy(buf, "\\t"); break;
  73         case '\n': strcpy(buf, "\\n"); break;
  74         case '\v': strcpy(buf, "\\v"); break;
  75         case '\f': strcpy(buf, "\\f"); break;
  76         case '\r': strcpy(buf, "\\r"); break;
  77         case '\'': strcpy(buf, str ? "'" : "\\'"); break;
  78         case '"': strcpy(buf, str ? "\\\"" : "\""); break;
  79         default:
  80                 if (c >= ' ' && c < 127)
  81                         sprintf(buf, "%c", c);
  82                 else
  83                         sprintf(buf, "\\x%02x", (unsigned char)c);
  84                 break;
  85         }
  86         return buf;
  87 }
  88
  89 bool isodigit(char c)
  90 {
  91         return c >= '0' && c <= '7';
  92 }
  93
  94 int fromOctal(char c)
  95 {
  96         if (isodigit(c))
  97                 return c-'0';
  98         return -1;
  99 }
 100
 101 char *unescape_char(char *c)
 102 {
 103         if (c[0] == '\\') {
 104                 if (c[1] == 'x' && isxdigit(c[2])) {
 105                         //two hex
 106                         if (isxdigit(c[3])) {
 107                                 c[3] = (fromHex(c[2])*16)+fromHex(c[3]);
 108                                 c+=2;
 109                         //one hex
 110                         } else {
 111                                 c[2] = fromHex(c[2]);
 112                                 c++;
 113                         }
 114                 } else if (c[1] == '0' && isodigit(c[2])) {
 115                         if (isodigit(c[3])) {
 116                                 //three octal
 117                                 if (isodigit(c[4])) {
 118                                         c[4] = fromOctal(c[2])*64
 119                                                 +fromOctal(c[3])*8
 120                                                 +fromOctal(c[4]);
 121                                         c+=2;
 122                                 //two octal
 123                                 } else {
 124                                         c[3] = fromOctal(c[2])*8
 125                                                 +fromOctal(c[3]);
 126                                         c+=2;
 127                                 }
 128                         // one octal
 129                         } else {
 130                                 c[2] = fromOctal(c[2]);
 131                                 c++;
 132                         }
 133                 } else {
 134                         switch (c[1]) {
 135                         case '0': c[1] = '\0'; break;
 136                         case '\'': c[1] = '\''; break;
 137                         case '\\': c[1] = '\\'; break;
 138                         case '"': c[1] = '"'; break;
 139                         case 'a': c[1] = '\a'; break;
 140                         case 'b': c[1] = '\b'; break;
 141                         case 't': c[1] = '\t'; break;
 142                         case 'v': c[1] = '\v'; break;
 143                         case 'f': c[1] = '\f'; break;
 144                         case 'r': c[1] = '\r'; break;
 145                         }
 146                 }
 147                 c++;
 148         }
 149         return c;
 150 }
 151
 152 char *trimquotes(char *c)
 153 {
 154         char *r = c+1;
 155         r[strlen(r)-1] = '\0';
 156         return r;
 157 }
 158
 159 void pdie(const char *msg)
 160 {
 161         perror(msg);
 162         exit(1);
 163 }
 164
 165 void die(const char *msg, ...)
 166 {
 167         va_list ap;
 168         va_start(ap, msg);
 169         vfprintf(stderr, msg, ap);
 170         va_end(ap);
 171         exit(1);
 172 }
 173
 174 void pindent(int indent, FILE *out)
 175 {
 176         for (int i = 0; i<indent; i++)
 177                 if (fputc('\t', out) == EOF)
 178                         pdie("fputc");
 179 }
 180
 181 void safe_fprintf(FILE *out, const char *msg, ...)
 182 {
 183         va_list ap;
 184         va_start(ap, msg);
 185         int r = vfprintf(out, msg, ap);
 186         va_end(ap);
 187         if (r < 0)
 188                 pdie("fprintf");
 189 }
 190
 191 void *safe_malloc(size_t size)
 192 {
 193         void *res = malloc(size);
 194         if (res == NULL)
 195                 pdie("malloc");
 196         return res;
 197 }
 198
 199 void *safe_strdup(const char *c)
 200 {
 201         char *res = strdup(c);
 202         if (res == NULL)
 203                 pdie("strdup");
 204         return res;
 205 }