isl_printer.c

   1 #include <string.h>
   2 #include <isl_printer_private.h>
   3
   4 static __isl_give isl_printer *file_start_line(__isl_take isl_printer *p)
   5 {
   6         fprintf(p->file, "%*s%s", p->indent, "", p->prefix ? p->prefix : "");
   7         return p;
   8 }
   9
  10 static __isl_give isl_printer *file_end_line(__isl_take isl_printer *p)
  11 {
  12         fprintf(p->file, "%s\n", p->suffix ? p->suffix : "");
  13         return p;
  14 }
  15
  16 static __isl_give isl_printer *file_flush(__isl_take isl_printer *p)
  17 {
  18         fflush(p->file);
  19         return p;
  20 }
  21
  22 static __isl_give isl_printer *file_print_str(__isl_take isl_printer *p,
  23         const char *s)
  24 {
  25         fprintf(p->file, "%s", s);
  26         return p;
  27 }
  28
  29 static __isl_give isl_printer *file_print_double(__isl_take isl_printer *p,
  30         double d)
  31 {
  32         fprintf(p->file, "%g", d);
  33         return p;
  34 }
  35
  36 static __isl_give isl_printer *file_print_int(__isl_take isl_printer *p, int i)
  37 {
  38         fprintf(p->file, "%d", i);
  39         return p;
  40 }
  41
  42 static __isl_give isl_printer *file_print_isl_int(__isl_take isl_printer *p, isl_int i)
  43 {
  44         isl_int_print(p->file, i, p->width);
  45         return p;
  46 }
  47
  48 static int grow_buf(__isl_keep isl_printer *p, int extra)
  49 {
  50         int new_size;
  51         char *new_buf;
  52
  53         if (p->buf_size == 0)
  54                 return -1;
  55
  56         new_size = ((p->buf_n + extra + 1) * 3) / 2;
  57         new_buf = isl_realloc_array(p->ctx, p->buf, char, new_size);
  58         if (!new_buf) {
  59                 p->buf_size = 0;
  60                 return -1;
  61         }
  62         p->buf = new_buf;
  63         p->buf_size = new_size;
  64
  65         return 0;
  66 }
  67
  68 static __isl_give isl_printer *str_print(__isl_take isl_printer *p,
  69         const char *s, int len)
  70 {
  71         if (p->buf_n + len + 1 >= p->buf_size && grow_buf(p, len))
  72                 goto error;
  73         memcpy(p->buf + p->buf_n, s, len);
  74         p->buf_n += len;
  75
  76         p->buf[p->buf_n] = '\0';
  77         return p;
  78 error:
  79         isl_printer_free(p);
  80         return NULL;
  81 }
  82
  83 static __isl_give isl_printer *str_print_indent(__isl_take isl_printer *p,
  84         int indent)
  85 {
  86         int i;
  87
  88         if (p->buf_n + indent + 1 >= p->buf_size && grow_buf(p, indent))
  89                 goto error;
  90         for (i = 0; i < indent; ++i)
  91                 p->buf[p->buf_n++] = ' ';
  92         return p;
  93 error:
  94         isl_printer_free(p);
  95         return NULL;
  96 }
  97
  98 static __isl_give isl_printer *str_start_line(__isl_take isl_printer *p)
  99 {
 100         p = str_print_indent(p, p->indent);
 101         if (p->prefix)
 102                 p = str_print(p, p->prefix, strlen(p->prefix));
 103         return p;
 104 }
 105
 106 static __isl_give isl_printer *str_end_line(__isl_take isl_printer *p)
 107 {
 108         if (p->suffix)
 109                 p = str_print(p, p->suffix, strlen(p->suffix));
 110         p = str_print(p, "\n", strlen("\n"));
 111         return p;
 112 }
 113
 114 static __isl_give isl_printer *str_flush(__isl_take isl_printer *p)
 115 {
 116         p->buf_n = 0;
 117         return p;
 118 }
 119
 120 static __isl_give isl_printer *str_print_str(__isl_take isl_printer *p,
 121         const char *s)
 122 {
 123         return str_print(p, s, strlen(s));
 124 }
 125
 126 static __isl_give isl_printer *str_print_double(__isl_take isl_printer *p,
 127         double d)
 128 {
 129         int left = p->buf_size - p->buf_n;
 130         int need = snprintf(p->buf + p->buf_n, left, "%g", d);
 131         if (need >= left) {
 132                 if (grow_buf(p, need))
 133                         goto error;
 134                 left = p->buf_size - p->buf_n;
 135                 need = snprintf(p->buf + p->buf_n, left, "%g", d);
 136         }
 137         p->buf_n += need;
 138         return p;
 139 error:
 140         isl_printer_free(p);
 141         return NULL;
 142 }
 143
 144 static __isl_give isl_printer *str_print_int(__isl_take isl_printer *p, int i)
 145 {
 146         int left = p->buf_size - p->buf_n;
 147         int need = snprintf(p->buf + p->buf_n, left, "%d", i);
 148         if (need >= left) {
 149                 if (grow_buf(p, need))
 150                         goto error;
 151                 left = p->buf_size - p->buf_n;
 152                 need = snprintf(p->buf + p->buf_n, left, "%d", i);
 153         }
 154         p->buf_n += need;
 155         return p;
 156 error:
 157         isl_printer_free(p);
 158         return NULL;
 159 }
 160
 161 static __isl_give isl_printer *str_print_isl_int(__isl_take isl_printer *p,
 162         isl_int i)
 163 {
 164         char *s;
 165         int len;
 166         isl_int_print_gmp_free_t gmp_free;
 167
 168         s = isl_int_get_str(i);
 169         len = strlen(s);
 170         if (len < p->width)
 171                 p = str_print_indent(p, p->width - len);
 172         p = str_print(p, s, len);
 173         mp_get_memory_functions(NULL, NULL, &gmp_free);
 174         (*gmp_free)(s, len + 1);
 175         return p;
 176 }
 177
 178 struct isl_printer_ops {
 179         __isl_give isl_printer *(*start_line)(__isl_take isl_printer *p);
 180         __isl_give isl_printer *(*end_line)(__isl_take isl_printer *p);
 181         __isl_give isl_printer *(*print_double)(__isl_take isl_printer *p,
 182                 double d);
 183         __isl_give isl_printer *(*print_int)(__isl_take isl_printer *p, int i);
 184         __isl_give isl_printer *(*print_isl_int)(__isl_take isl_printer *p,
 185                                                 isl_int i);
 186         __isl_give isl_printer *(*print_str)(__isl_take isl_printer *p,
 187                                                 const char *s);
 188         __isl_give isl_printer *(*flush)(__isl_take isl_printer *p);
 189 };
 190
 191 static struct isl_printer_ops file_ops = {
 192         file_start_line,
 193         file_end_line,
 194         file_print_double,
 195         file_print_int,
 196         file_print_isl_int,
 197         file_print_str,
 198         file_flush
 199 };
 200
 201 static struct isl_printer_ops str_ops = {
 202         str_start_line,
 203         str_end_line,
 204         str_print_double,
 205         str_print_int,
 206         str_print_isl_int,
 207         str_print_str,
 208         str_flush
 209 };
 210
 211 __isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx, FILE *file)
 212 {
 213         struct isl_printer *p = isl_alloc_type(ctx, struct isl_printer);
 214         if (!p)
 215                 return NULL;
 216         p->ctx = ctx;
 217         isl_ctx_ref(p->ctx);
 218         p->ops = &file_ops;
 219         p->file = file;
 220         p->buf = NULL;
 221         p->buf_n = 0;
 222         p->buf_size = 0;
 223         p->indent = 0;
 224         p->output_format = ISL_FORMAT_ISL;
 225         p->prefix = NULL;
 226         p->suffix = NULL;
 227         p->width = 0;
 228
 229         return p;
 230 }
 231
 232 __isl_give isl_printer *isl_printer_to_str(isl_ctx *ctx)
 233 {
 234         struct isl_printer *p = isl_alloc_type(ctx, struct isl_printer);
 235         if (!p)
 236                 return NULL;
 237         p->ctx = ctx;
 238         isl_ctx_ref(p->ctx);
 239         p->ops = &str_ops;
 240         p->file = NULL;
 241         p->buf = isl_alloc_array(ctx, char, 256);
 242         if (!p->buf)
 243                 goto error;
 244         p->buf_n = 0;
 245         p->buf[0] = '\0';
 246         p->buf_size = 256;
 247         p->indent = 0;
 248         p->output_format = ISL_FORMAT_ISL;
 249         p->prefix = NULL;
 250         p->suffix = NULL;
 251         p->width = 0;
 252
 253         return p;
 254 error:
 255         isl_printer_free(p);
 256         return NULL;
 257 }
 258
 259 void *isl_printer_free(__isl_take isl_printer *p)
 260 {
 261         if (!p)
 262                 return NULL;
 263         free(p->buf);
 264         isl_ctx_deref(p->ctx);
 265         free(p);
 266
 267         return NULL;
 268 }
 269
 270 isl_ctx *isl_printer_get_ctx(__isl_keep isl_printer *printer)
 271 {
 272         return printer ? printer->ctx : NULL;
 273 }
 274
 275 FILE *isl_printer_get_file(__isl_keep isl_printer *printer)
 276 {
 277         if (!printer)
 278                 return NULL;
 279         if (!printer->file)
 280                 isl_die(isl_printer_get_ctx(printer), isl_error_invalid,
 281                         "not a file printer", return NULL);
 282         return printer->file;
 283 }
 284
 285 __isl_give isl_printer *isl_printer_set_isl_int_width(__isl_take isl_printer *p,
 286         int width)
 287 {
 288         if (!p)
 289                 return NULL;
 290
 291         p->width = width;
 292
 293         return p;
 294 }
 295
 296 __isl_give isl_printer *isl_printer_set_indent(__isl_take isl_printer *p,
 297         int indent)
 298 {
 299         if (!p)
 300                 return NULL;
 301
 302         p->indent = indent;
 303
 304         return p;
 305 }
 306
 307 __isl_give isl_printer *isl_printer_indent(__isl_take isl_printer *p,
 308         int indent)
 309 {
 310         if (!p)
 311                 return NULL;
 312
 313         p->indent += indent;
 314         if (p->indent < 0)
 315                 p->indent = 0;
 316
 317         return p;
 318 }
 319
 320 __isl_give isl_printer *isl_printer_set_prefix(__isl_take isl_printer *p,
 321         const char *prefix)
 322 {
 323         if (!p)
 324                 return NULL;
 325
 326         p->prefix = prefix;
 327
 328         return p;
 329 }
 330
 331 __isl_give isl_printer *isl_printer_set_suffix(__isl_take isl_printer *p,
 332         const char *suffix)
 333 {
 334         if (!p)
 335                 return NULL;
 336
 337         p->suffix = suffix;
 338
 339         return p;
 340 }
 341
 342 __isl_give isl_printer *isl_printer_set_output_format(__isl_take isl_printer *p,
 343         int output_format)
 344 {
 345         if (!p)
 346                 return NULL;
 347
 348         p->output_format = output_format;
 349
 350         return p;
 351 }
 352
 353 int isl_printer_get_output_format(__isl_keep isl_printer *p)
 354 {
 355         if (!p)
 356                 return -1;
 357         return p->output_format;
 358 }
 359
 360 __isl_give isl_printer *isl_printer_print_str(__isl_take isl_printer *p,
 361         const char *s)
 362 {
 363         if (!p)
 364                 return NULL;
 365         if (!s)
 366                 return isl_printer_free(p);
 367
 368         return p->ops->print_str(p, s);
 369 }
 370
 371 __isl_give isl_printer *isl_printer_print_double(__isl_take isl_printer *p,
 372         double d)
 373 {
 374         if (!p)
 375                 return NULL;
 376
 377         return p->ops->print_double(p, d);
 378 }
 379
 380 __isl_give isl_printer *isl_printer_print_int(__isl_take isl_printer *p, int i)
 381 {
 382         if (!p)
 383                 return NULL;
 384
 385         return p->ops->print_int(p, i);
 386 }
 387
 388 __isl_give isl_printer *isl_printer_print_isl_int(__isl_take isl_printer *p,
 389         isl_int i)
 390 {
 391         if (!p)
 392                 return NULL;
 393
 394         return p->ops->print_isl_int(p, i);
 395 }
 396
 397 __isl_give isl_printer *isl_printer_start_line(__isl_take isl_printer *p)
 398 {
 399         if (!p)
 400                 return NULL;
 401
 402         return p->ops->start_line(p);
 403 }
 404
 405 __isl_give isl_printer *isl_printer_end_line(__isl_take isl_printer *p)
 406 {
 407         if (!p)
 408                 return NULL;
 409
 410         return p->ops->end_line(p);
 411 }
 412
 413 char *isl_printer_get_str(__isl_keep isl_printer *printer)
 414 {
 415         if (!printer || !printer->buf)
 416                 return NULL;
 417         return strdup(printer->buf);
 418 }
 419
 420 __isl_give isl_printer *isl_printer_flush(__isl_take isl_printer *p)
 421 {
 422         if (!p)
 423                 return NULL;
 424
 425         return p->ops->flush(p);
 426 }