emit.c

   1 /*
   2  * Copyright 2011 Leiden University. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  *    1. Redistributions of source code must retain the above copyright
   9  *       notice, this list of conditions and the following disclaimer.
  10  *
  11  *    2. Redistributions in binary form must reproduce the above
  12  *       copyright notice, this list of conditions and the following
  13  *       disclaimer in the documentation and/or other materials provided
  14  *       with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY LEIDEN UNIVERSITY ''AS IS'' AND ANY
  17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL LEIDEN UNIVERSITY OR
  20  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  21  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  23  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * The views and conclusions contained in the software and documentation
  29  * are those of the authors and should not be interpreted as
  30  * representing official policies, either expressed or implied, of
  31  * Leiden University.
  32  */
  33
  34 #include <yaml.h>
  35
  36 #include "scop.h"
  37 #include "scop_yaml.h"
  38
  39 static int emit_string(yaml_emitter_t *emitter, const char *str)
  40 {
  41         yaml_event_t event;
  42
  43         if (!yaml_scalar_event_initialize(&event, NULL, NULL,
  44                                     (yaml_char_t *) str, strlen(str),
  45                                     1, 1, YAML_PLAIN_SCALAR_STYLE))
  46                 return -1;
  47         if (!yaml_emitter_emit(emitter, &event))
  48                 return -1;
  49
  50         return 0;
  51 }
  52
  53 static int emit_int(yaml_emitter_t *emitter, int i)
  54 {
  55         char buffer[40];
  56
  57         snprintf(buffer, sizeof(buffer), "%d", i);
  58         return emit_string(emitter, buffer);
  59 }
  60
  61 static int emit_named_int(yaml_emitter_t *emitter, const char *name, int i)
  62 {
  63         if (emit_string(emitter, name) < 0)
  64                 return -1;
  65         if (emit_int(emitter, i) < 0)
  66                 return -1;
  67         return 0;
  68 }
  69
  70 static int emit_double(yaml_emitter_t *emitter, double d)
  71 {
  72         char buffer[40];
  73
  74         snprintf(buffer, sizeof(buffer), "%g", d);
  75         return emit_string(emitter, buffer);
  76 }
  77
  78 static int emit_map(yaml_emitter_t *emitter, __isl_keep isl_map *map)
  79 {
  80         isl_ctx *ctx = isl_map_get_ctx(map);
  81         isl_printer *p;
  82         char *str;
  83         int r;
  84
  85         p = isl_printer_to_str(ctx);
  86         p = isl_printer_print_map(p, map);
  87         str = isl_printer_get_str(p);
  88         isl_printer_free(p);
  89         r = emit_string(emitter, str);
  90         free(str);
  91         return r;
  92 }
  93
  94 static int emit_set(yaml_emitter_t *emitter, __isl_keep isl_set *set)
  95 {
  96         isl_ctx *ctx = isl_set_get_ctx(set);
  97         isl_printer *p;
  98         char *str;
  99         int r;
 100
 101         p = isl_printer_to_str(ctx);
 102         p = isl_printer_print_set(p, set);
 103         str = isl_printer_get_str(p);
 104         isl_printer_free(p);
 105         r = emit_string(emitter, str);
 106         free(str);
 107         return r;
 108 }
 109
 110 static int emit_named_set(yaml_emitter_t *emitter, const char *name,
 111         __isl_keep isl_set *set)
 112 {
 113         if (emit_string(emitter, name) < 0)
 114                 return -1;
 115         if (emit_set(emitter, set) < 0)
 116                 return -1;
 117         return 0;
 118 }
 119
 120 static int emit_array(yaml_emitter_t *emitter, struct pet_array *array)
 121 {
 122         yaml_event_t event;
 123
 124         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 125                                                 YAML_BLOCK_MAPPING_STYLE))
 126                 return -1;
 127         if (!yaml_emitter_emit(emitter, &event))
 128                 return -1;
 129
 130         if (emit_string(emitter, "context") < 0)
 131                 return -1;
 132         if (emit_set(emitter, array->context) < 0)
 133                 return -1;
 134
 135         if (emit_string(emitter, "extent") < 0)
 136                 return -1;
 137         if (emit_set(emitter, array->extent) < 0)
 138                 return -1;
 139
 140         if (array->value_bounds) {
 141                 if (emit_string(emitter, "value_bounds") < 0)
 142                         return -1;
 143                 if (emit_set(emitter, array->value_bounds) < 0)
 144                         return -1;
 145         }
 146
 147         if (emit_string(emitter, "element_type") < 0)
 148                 return -1;
 149         if (emit_string(emitter, array->element_type) < 0)
 150                 return -1;
 151         if (emit_named_int(emitter, "element_size", array->element_size) < 0)
 152                 return -1;
 153
 154         if (array->live_out) {
 155                 if (emit_string(emitter, "live_out") < 0)
 156                         return -1;
 157                 if (emit_string(emitter, "1") < 0)
 158                         return -1;
 159         }
 160
 161         if (array->uniquely_defined) {
 162                 if (emit_string(emitter, "uniquely_defined") < 0)
 163                         return -1;
 164                 if (emit_string(emitter, "1") < 0)
 165                         return -1;
 166         }
 167
 168         if (array->declared && emit_named_int(emitter, "declared", 1) < 0)
 169                 return -1;
 170         if (array->exposed && emit_named_int(emitter, "exposed", 1) < 0)
 171                 return -1;
 172
 173         if (!yaml_mapping_end_event_initialize(&event))
 174                 return -1;
 175         if (!yaml_emitter_emit(emitter, &event))
 176                 return -1;
 177
 178         return 0;
 179 }
 180
 181 static int emit_arrays(yaml_emitter_t *emitter, int n_array,
 182         struct pet_array **arrays)
 183 {
 184         int i;
 185         yaml_event_t event;
 186
 187         if (emit_string(emitter, "arrays") < 0)
 188                 return -1;
 189         if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 190                                                 YAML_BLOCK_SEQUENCE_STYLE))
 191                 return -1;
 192         if (!yaml_emitter_emit(emitter, &event))
 193                 return -1;
 194
 195         for (i = 0; i < n_array; ++i)
 196                 if (emit_array(emitter, arrays[i]) < 0)
 197                         return -1;
 198
 199         if (!yaml_sequence_end_event_initialize(&event))
 200                 return -1;
 201         if (!yaml_emitter_emit(emitter, &event))
 202                 return -1;
 203
 204         return 0;
 205 }
 206
 207 static int emit_type(yaml_emitter_t *emitter, enum pet_expr_type type)
 208 {
 209         if (emit_string(emitter, pet_type_str(type)) < 0)
 210                 return -1;
 211         return 0;
 212 }
 213
 214 static int emit_expr(yaml_emitter_t *emitter, struct pet_expr *expr)
 215 {
 216         yaml_event_t event;
 217
 218         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 219                                                 YAML_BLOCK_MAPPING_STYLE))
 220                 return -1;
 221         if (!yaml_emitter_emit(emitter, &event))
 222                 return -1;
 223
 224         if (emit_string(emitter, "type") < 0)
 225                 return -1;
 226         if (emit_type(emitter, expr->type) < 0)
 227                 return -1;
 228
 229         switch (expr->type) {
 230         case pet_expr_double:
 231                 if (emit_string(emitter, "value") < 0)
 232                         return -1;
 233                 if (emit_double(emitter, expr->d.val) < 0)
 234                         return -1;
 235                 if (emit_string(emitter, "string") < 0)
 236                         return -1;
 237                 if (emit_string(emitter, expr->d.s) < 0)
 238                         return -1;
 239                 break;
 240         case pet_expr_access:
 241                 if (emit_string(emitter, "relation") < 0)
 242                         return -1;
 243                 if (emit_map(emitter, expr->acc.access) < 0)
 244                         return -1;
 245                 if (emit_string(emitter, "read") < 0)
 246                         return -1;
 247                 if (emit_int(emitter, expr->acc.read) < 0)
 248                         return -1;
 249                 if (emit_string(emitter, "write") < 0)
 250                         return -1;
 251                 if (emit_int(emitter, expr->acc.write) < 0)
 252                         return -1;
 253                 break;
 254         case pet_expr_unary:
 255         case pet_expr_binary:
 256                 if (emit_string(emitter, "operation") < 0)
 257                         return -1;
 258                 if (emit_string(emitter, pet_op_str(expr->op)) < 0)
 259                         return -1;
 260                 break;
 261         case pet_expr_ternary:
 262                 break;
 263         case pet_expr_call:
 264                 if (emit_string(emitter, "name") < 0)
 265                         return -1;
 266                 if (emit_string(emitter, expr->name) < 0)
 267                         return -1;
 268                 break;
 269         }
 270
 271         if (expr->n_arg > 0) {
 272                 int i;
 273
 274                 if (emit_string(emitter, "arguments") < 0)
 275                         return -1;
 276                 if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 277                                                     YAML_BLOCK_SEQUENCE_STYLE))
 278                         return -1;
 279                 if (!yaml_emitter_emit(emitter, &event))
 280                         return -1;
 281
 282                 for (i = 0; i < expr->n_arg; ++i)
 283                         if (emit_expr(emitter, expr->args[i]) < 0)
 284                                 return -1;
 285
 286                 if (!yaml_sequence_end_event_initialize(&event))
 287                         return -1;
 288                 if (!yaml_emitter_emit(emitter, &event))
 289                         return -1;
 290         }
 291
 292         if (!yaml_mapping_end_event_initialize(&event))
 293                 return -1;
 294         if (!yaml_emitter_emit(emitter, &event))
 295                 return -1;
 296
 297         return 0;
 298 }
 299
 300 static int emit_stmt(yaml_emitter_t *emitter, struct pet_stmt *stmt)
 301 {
 302         yaml_event_t event;
 303
 304         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 305                                                 YAML_BLOCK_MAPPING_STYLE))
 306                 return -1;
 307         if (!yaml_emitter_emit(emitter, &event))
 308                 return -1;
 309
 310         if (emit_string(emitter, "line") < 0)
 311                 return -1;
 312         if (emit_int(emitter, stmt->line) < 0)
 313                 return -1;
 314
 315         if (emit_string(emitter, "domain") < 0)
 316                 return -1;
 317         if (emit_set(emitter, stmt->domain) < 0)
 318                 return -1;
 319
 320         if (emit_string(emitter, "schedule") < 0)
 321                 return -1;
 322         if (emit_map(emitter, stmt->schedule) < 0)
 323                 return -1;
 324
 325         if (emit_string(emitter, "body") < 0)
 326                 return -1;
 327         if (emit_expr(emitter, stmt->body) < 0)
 328                 return -1;
 329
 330         if (stmt->n_arg > 0) {
 331                 int i;
 332
 333                 if (emit_string(emitter, "arguments") < 0)
 334                         return -1;
 335                 if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 336                                                     YAML_BLOCK_SEQUENCE_STYLE))
 337                         return -1;
 338                 if (!yaml_emitter_emit(emitter, &event))
 339                         return -1;
 340
 341                 for (i = 0; i < stmt->n_arg; ++i)
 342                         if (emit_expr(emitter, stmt->args[i]) < 0)
 343                                 return -1;
 344
 345                 if (!yaml_sequence_end_event_initialize(&event))
 346                         return -1;
 347                 if (!yaml_emitter_emit(emitter, &event))
 348                         return -1;
 349         }
 350
 351         if (!yaml_mapping_end_event_initialize(&event))
 352                 return -1;
 353         if (!yaml_emitter_emit(emitter, &event))
 354                 return -1;
 355
 356         return 0;
 357 }
 358
 359 static int emit_statements(yaml_emitter_t *emitter, int n_stmt,
 360         struct pet_stmt **stmts)
 361 {
 362         int i;
 363         yaml_event_t event;
 364
 365         if (emit_string(emitter, "statements") < 0)
 366                 return -1;
 367         if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 368                                                 YAML_BLOCK_SEQUENCE_STYLE))
 369                 return -1;
 370         if (!yaml_emitter_emit(emitter, &event))
 371                 return -1;
 372
 373         for (i = 0; i < n_stmt; ++i)
 374                 if (emit_stmt(emitter, stmts[i]) < 0)
 375                         return -1;
 376
 377         if (!yaml_sequence_end_event_initialize(&event))
 378                 return -1;
 379         if (!yaml_emitter_emit(emitter, &event))
 380                 return -1;
 381
 382         return 0;
 383 }
 384
 385 static int emit_scop(yaml_emitter_t *emitter, struct pet_scop *scop)
 386 {
 387         yaml_event_t event;
 388
 389         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 390                                                 YAML_BLOCK_MAPPING_STYLE))
 391                 return -1;
 392         if (!yaml_emitter_emit(emitter, &event))
 393                 return -1;
 394
 395         if (emit_string(emitter, "context") < 0)
 396                 return -1;
 397         if (emit_set(emitter, scop->context) < 0)
 398                 return -1;
 399         if (!isl_set_plain_is_universe(scop->context_value) &&
 400             emit_named_set(emitter, "context_value", scop->context_value) < 0)
 401                 return -1;
 402
 403         if (emit_arrays(emitter, scop->n_array, scop->arrays) < 0)
 404                 return -1;
 405
 406         if (emit_statements(emitter, scop->n_stmt, scop->stmts) < 0)
 407                 return -1;
 408
 409         if (!yaml_mapping_end_event_initialize(&event))
 410                 return -1;
 411         if (!yaml_emitter_emit(emitter, &event))
 412                 return -1;
 413
 414         return 0;
 415 }
 416
 417 /* Print a YAML serialization of "scop" to "out".
 418  */
 419 int pet_scop_emit(FILE *out, struct pet_scop *scop)
 420 {
 421         yaml_emitter_t emitter;
 422         yaml_event_t event;
 423
 424         yaml_emitter_initialize(&emitter);
 425
 426         yaml_emitter_set_output_file(&emitter, out);
 427
 428         yaml_stream_start_event_initialize(&event, YAML_UTF8_ENCODING);
 429         if (!yaml_emitter_emit(&emitter, &event))
 430                 goto error;
 431
 432         if (!yaml_document_start_event_initialize(&event, NULL, NULL, NULL, 1))
 433                 goto error;
 434         if (!yaml_emitter_emit(&emitter, &event))
 435                 goto error;
 436
 437         if (emit_scop(&emitter, scop) < 0)
 438                 goto error;
 439
 440         if (!yaml_document_end_event_initialize(&event, 1))
 441                 goto error;
 442         if (!yaml_emitter_emit(&emitter, &event))
 443                 goto error;
 444
 445         yaml_stream_end_event_initialize(&event);
 446         if (!yaml_emitter_emit(&emitter, &event))
 447                 goto error;
 448
 449         yaml_emitter_delete(&emitter);
 450         return 0;
 451 error:
 452         yaml_emitter_delete(&emitter);
 453         return -1;
 454 }