compilers/bcg/src/bcg.c

   1 /*
   2  * $Id$
   3  * Copyright (C) 2006-2007, The Perl Foundation.
   4  */
   5
   6 /*
   7
   8 =head1 NAME
   9
  10 bcg.c Byte Code Generator (BCG) Public API implementation.
  11
  12 =head1 DESCRIPTION
  13
  14 The functions in this file implement the API defined in bcg.h, the public API
  15 for BCG.
  16
  17 =head2 Methods
  18
  19 List of methods imlemented in this file.
  20
  21 =over 4
  22
  23 =cut
  24
  25 */
  26
  27 #include <string.h>
  28 #include "bcg.h"
  29 #include "bcg_private.h"
  30 #include "bcg_logger.h"
  31 #include "bcg_reg_alloc.h"
  32 #include "bcg_emitter.h"
  33
  34 /* Forward decleration */
  35
  36 /* BCG state management functions. */
  37 static void set_state(BCG_info * bcg_info, bcg_state state);
  38 static void unset_state(BCG_info * bcg_info, bcg_state state);
  39 static int in_state(BCG_info * bcg_info, bcg_state state);
  40
  41 /*
  42
  43 =item C<BCG_info *
  44 BCG_create(void)>
  45
  46 This function create an instance of Byte Code Generator.
  47
  48 =cut
  49
  50 */
  51 BCG_info *
  52 BCG_create(void)
  53 {
  54     BCG_info *bcg_info;
  55
  56     bcg_info = (BCG_info *) mem_sys_allocate_zeroed(sizeof (BCG_info));
  57     bcg_info->private_info = bcg_info_private_create(bcg_info);
  58     BCG_INFO_PRIV(bcg_info)->state = 0;
  59     set_state(bcg_info, BCG_STATE_INIT);
  60     return bcg_info;
  61 }
  62
  63 /*
  64
  65 =item C<void
  66 BCG_destroy(BCG_info *bcg_info)>
  67
  68 This methods destroys the specified instance of Byte Code Generator.
  69
  70 =cut
  71
  72 */
  73 void
  74 BCG_destroy(BCG_info *bcg_info)
  75 {
  76     bcg_info_private_destroy(bcg_info, BCG_INFO_PRIV(bcg_info));
  77     if (bcg_info->error_msg != NULL) {
  78         mem_sys_free(bcg_info->error_msg);
  79     }
  80     mem_sys_free(bcg_info);
  81 }
  82
  83 /*
  84
  85 =item C<void
  86 BCG_start_code_gen(BCG_info * bcg_info)>
  87
  88 RT#48260: Not yet documented!!!
  89
  90 =cut
  91
  92 */
  93
  94 void
  95 BCG_start_code_gen(BCG_info * bcg_info)
  96 {
  97     if (BCG_INFO_PRIV(bcg_info)->state != BCG_STATE_INIT) {
  98         bcg_throw_exception(bcg_info, BCG_EXCEPTION,
  99                             "Expected BCG to be in INIT state.");
 100     }
 101
 102     set_state(bcg_info, BCG_STATE_IN_CODEGEN);
 103
 104 }
 105
 106 /*
 107
 108 =item C<void
 109 BCG_end_code_gen(BCG_info * bcg_info)>
 110
 111 RT#48260: Not yet documented!!!
 112
 113 =cut
 114
 115 */
 116
 117 void
 118 BCG_end_code_gen(BCG_info * bcg_info)
 119 {
 120     if (BCG_INFO_PRIV(bcg_info)->state != BCG_STATE_IN_CODEGEN) {
 121         bcg_throw_exception(bcg_info, BCG_EXCEPTION,
 122                             "Expected BCG to be in IN_CODEGEN state.");
 123     }
 124
 125     unset_state(bcg_info, BCG_STATE_IN_CODEGEN);
 126 }
 127
 128 /*
 129
 130 =item C<void
 131 BCG_start_sub(BCG_info * bcg_info, char *sub_name, char *pragma)>
 132
 133 RT#48260: Not yet documented!!!
 134
 135 =cut
 136
 137 */
 138
 139 void
 140 BCG_start_sub(BCG_info * bcg_info, char *sub_name, char *pragma)
 141 {
 142
 143     bcg_unit *unit;
 144
 145     if (BCG_INFO_PRIV(bcg_info)->state != BCG_STATE_IN_CODEGEN) {
 146         bcg_throw_exception(bcg_info, BCG_EXCEPTION,
 147                             "Expected BCG to be in IN_CODEGEN state.");
 148     }
 149
 150     set_state(bcg_info, BCG_STATE_IN_SUB);
 151     unit = bcg_unit_create(bcg_info, sub_name, pragma);
 152     bcg_info_add_unit(bcg_info, unit);
 153     unit->symbol_table = bcg_hash_create(bcg_info);
 154 }
 155
 156 /*
 157
 158 =item C<void
 159 BCG_end_sub(BCG_info * bcg_info)>
 160
 161 RT#48260: Not yet documented!!!
 162
 163 =cut
 164
 165 */
 166
 167 void
 168 BCG_end_sub(BCG_info * bcg_info)
 169 {
 170     bcg_unit *curr_unit;
 171
 172     if (!in_state(bcg_info, BCG_STATE_IN_SUB)) {
 173         bcg_throw_exception(bcg_info, BCG_EXCEPTION,
 174                             "Expected BCG to be in IN_SUB state.");
 175     }
 176
 177     unset_state(bcg_info, BCG_STATE_IN_SUB);
 178     curr_unit = bcg_info_current_unit(bcg_info);
 179     reg_alloc_vanilla(bcg_info, curr_unit);
 180 }
 181
 182 /*
 183
 184 =item C<void
 185 BCG_start_call(BCG_info * bcg_info, char *sub_name)>
 186
 187 RT#48260: Not yet documented!!!
 188
 189 =cut
 190
 191 */
 192
 193 void
 194 BCG_start_call(BCG_info * bcg_info, char *sub_name)
 195 {
 196     if (!in_state(bcg_info, BCG_STATE_IN_SUB)) {
 197         bcg_throw_exception(bcg_info, BCG_EXCEPTION,
 198                             "Expected BCG to be in IN_SUB state.");
 199     }
 200
 201     set_state(bcg_info, BCG_STATE_IN_CALL);
 202 }
 203
 204 /*
 205
 206 =item C<void
 207 BCG_end_call(BCG_info * bcg_info)>
 208
 209 RT#48260: Not yet documented!!!
 210
 211 =cut
 212
 213 */
 214
 215 void
 216 BCG_end_call(BCG_info * bcg_info)
 217 {
 218     if (!in_state(bcg_info, BCG_STATE_IN_CALL)) {
 219         bcg_throw_exception(bcg_info, BCG_EXCEPTION,
 220                             "Expected BCG to be in IN_CALL state.");
 221     }
 222
 223     unset_state(bcg_info, BCG_STATE_IN_CALL);
 224 }
 225
 226 /*
 227
 228 =item C<void
 229 BCG_start_op(BCG_info * bcg_info, char *op_name)>
 230
 231 RT#48260: Not yet documented!!!
 232
 233 =cut
 234
 235 */
 236
 237 void
 238 BCG_start_op(BCG_info * bcg_info, char *op_name)
 239 {
 240     bcg_unit *curr_unit;
 241     bcg_op *op;
 242
 243     if (!in_state(bcg_info, BCG_STATE_IN_SUB)) {
 244         bcg_throw_exception(bcg_info, BCG_EXCEPTION,
 245                             "Expected BCG to be in IN_SUB state.");
 246     }
 247
 248     set_state(bcg_info, BCG_STATE_IN_OP);
 249     curr_unit = bcg_info_current_unit(bcg_info);
 250     op = bcg_op_create(bcg_info, op_name, BCG_OP);
 251     bcg_unit_add_op(bcg_info, curr_unit, op);
 252 }
 253
 254 /*
 255
 256 =item C<void
 257 BCG_end_op(BCG_info * bcg_info)>
 258
 259 RT#48260: Not yet documented!!!
 260
 261 =cut
 262
 263 */
 264
 265 void
 266 BCG_end_op(BCG_info * bcg_info)
 267 {
 268     bcg_op *curr_op;
 269
 270     if (!in_state(bcg_info, BCG_STATE_IN_OP)) {
 271         bcg_throw_exception(bcg_info, BCG_EXCEPTION,
 272                             "Expected BCG to be in IN_CALL state.");
 273     }
 274
 275     unset_state(bcg_info, BCG_STATE_IN_OP);
 276     curr_op = bcg_info_current_op(bcg_info);
 277     bcg_op_resolve_full_name(bcg_info, curr_op);
 278 }
 279
 280 /*
 281
 282 =item C<void
 283 BCG_var(BCG_info * bcg_info, char *var_name, char var_type)>
 284
 285 RT#48260: Not yet documented!!!
 286
 287 =cut
 288
 289 */
 290
 291 void
 292 BCG_var(BCG_info * bcg_info, char *var_name, char var_type)
 293 {
 294     bcg_unit *curr_unit;
 295     bcg_op *curr_op;
 296     bcg_op_arg *op_arg;
 297
 298     if (!in_state(bcg_info, BCG_STATE_IN_OP)) {
 299         bcg_throw_exception(bcg_info, BCG_EXCEPTION,
 300                             "Expected BCG to be in IN_OP state.");
 301     }
 302
 303     curr_unit = bcg_info_current_unit(bcg_info);
 304     curr_op = bcg_info_current_op(bcg_info);
 305     op_arg  = (bcg_op_arg *)bcg_hash_get(bcg_info, curr_unit->symbol_table, var_name);
 306
 307     if (!op_arg)
 308         op_arg = bcg_op_arg_create(bcg_info, var_name, BCG_OP_ARG_VARIABLE,
 309                               var_type);
 310
 311     bcg_op_add_arg(bcg_info, curr_op, op_arg);
 312     bcg_hash_put(bcg_info, curr_unit->symbol_table, var_name, op_arg);
 313 }
 314
 315 /*
 316
 317 =item C<void
 318 BCG_val(BCG_info * bcg_info, char *val, char val_type)>
 319
 320 RT#48260: Not yet documented!!!
 321
 322 =cut
 323
 324 */
 325
 326 void
 327 BCG_val(BCG_info * bcg_info, char *val, char val_type)
 328 {
 329     bcg_op *curr_op;
 330     bcg_op_arg *op_arg;
 331
 332     if (!in_state(bcg_info, BCG_STATE_IN_OP)) {
 333         bcg_throw_exception(bcg_info, BCG_EXCEPTION,
 334                             "Expected BCG to be in IN_OP state.");
 335     }
 336
 337     curr_op = bcg_info_current_op(bcg_info);
 338     op_arg = bcg_op_arg_create(bcg_info, val, BCG_OP_ARG_CONSTANT, val_type);
 339     bcg_op_add_arg(bcg_info, curr_op, op_arg);
 340 }
 341
 342 /*
 343
 344 =item C<void
 345 BCG_label(BCG_info * bcg_info, char *label)>
 346
 347 RT#48260: Not yet documented!!!
 348
 349 =cut
 350
 351 */
 352
 353 void
 354 BCG_label(BCG_info * bcg_info, char *label)
 355 {
 356     bcg_unit *curr_unit;
 357     bcg_op *op;
 358
 359     if (!in_state(bcg_info, BCG_STATE_IN_SUB)) {
 360         bcg_throw_exception(bcg_info, BCG_EXCEPTION,
 361                             "Expected BCG to be in IN_SUB state.");
 362     }
 363
 364     curr_unit = bcg_info_current_unit(bcg_info);
 365     op = bcg_op_create(bcg_info, label, BCG_OP_LABEL);
 366     bcg_unit_add_op(bcg_info, curr_unit, op);
 367 }
 368
 369 /*
 370
 371 =item C<void
 372 BCG_print_pasm(BCG_info * bcg_info)>
 373
 374 RT#48260: Not yet documented!!!
 375
 376 =cut
 377
 378 */
 379
 380 void
 381 BCG_print_pasm(BCG_info * bcg_info)
 382 {
 383     emit_pasm(bcg_info);
 384 }
 385
 386 /*
 387
 388 =item C<bcg_info_private *
 389 bcg_info_private_create(BCG_info * bcg_info)>
 390
 391 RT#48260: Not yet documented!!!
 392
 393 =cut
 394
 395 */
 396
 397 bcg_info_private *
 398 bcg_info_private_create(BCG_info * bcg_info)
 399 {
 400     bcg_info_private *bcg_info_priv;
 401
 402     UNUSED(bcg_info);
 403     bcg_info_priv = (bcg_info_private *)
 404         mem_sys_allocate_zeroed(sizeof (bcg_info_private));
 405     return bcg_info_priv;
 406 }
 407
 408 /*
 409
 410 =item C<void
 411 bcg_info_private_destroy(BCG_info * bcg_info, bcg_info_private * bcg_info_priv)>
 412
 413 RT#48260: Not yet documented!!!
 414
 415 =cut
 416
 417 */
 418
 419 void
 420 bcg_info_private_destroy(BCG_info * bcg_info, bcg_info_private * bcg_info_priv)
 421 {
 422     bcg_unit *unit, *cur_unit;
 423
 424     UNUSED(bcg_info);
 425
 426     unit = bcg_info_priv->first_unit;
 427     while (!unit) {
 428         cur_unit = unit;
 429         unit = unit->next;
 430         bcg_unit_destroy(bcg_info, cur_unit);
 431     }
 432
 433     mem_sys_free(bcg_info_priv);
 434 }
 435
 436 /*
 437
 438 =item C<void
 439 bcg_info_add_unit(BCG_info * bcg_info, bcg_unit * unit)>
 440
 441 RT#48260: Not yet documented!!!
 442
 443 =cut
 444
 445 */
 446
 447 void
 448 bcg_info_add_unit(BCG_info * bcg_info, bcg_unit * unit)
 449 {
 450     bcg_info_private *bcg_info_priv = BCG_INFO_PRIV(bcg_info);
 451     if (!bcg_info_priv->first_unit) {
 452         bcg_info_priv->first_unit = unit;
 453         unit->next = NULL;
 454         unit->prev = NULL;
 455     }
 456     else {
 457         bcg_info_priv->last_unit->next = unit;
 458         unit->prev = bcg_info_priv->last_unit;
 459     }
 460     bcg_info_priv->last_unit = unit;
 461
 462 }
 463
 464 /*
 465
 466 =item C<static void
 467 set_state(BCG_info * bcg_info, bcg_state state)>
 468
 469 RT#48260: Not yet documented!!!
 470
 471 =cut
 472
 473 */
 474
 475 static void
 476 set_state(BCG_info * bcg_info, bcg_state state)
 477 {
 478     BCG_INFO_PRIV(bcg_info)->state |= state;
 479 }
 480
 481 /*
 482
 483 =item C<static void
 484 unset_state(BCG_info * bcg_info, bcg_state state)>
 485
 486 RT#48260: Not yet documented!!!
 487
 488 =cut
 489
 490 */
 491
 492 static void
 493 unset_state(BCG_info * bcg_info, bcg_state state)
 494 {
 495     BCG_INFO_PRIV(bcg_info)->state &= (~state);
 496 }
 497
 498 /*
 499
 500 =item C<static int
 501 in_state(BCG_info * bcg_info, bcg_state state)>
 502
 503 RT#48260: Not yet documented!!!
 504
 505 =cut
 506
 507 */
 508
 509 static int
 510 in_state(BCG_info * bcg_info, bcg_state state)
 511 {
 512     return state == (state & BCG_INFO_PRIV(bcg_info)->state);
 513 }
 514
 515 /*
 516
 517 =back
 518
 519 =head1 LICENSE
 520
 521 Copyright (C) 2006, The Perl Foundation.
 522
 523 This is free software; you may redistribute it and/or modify
 524 it under the same terms as Parrot.
 525
 526 =head1 AUTHOR
 527
 528 Vishal Soni <vishalrsoni@gmail.com>
 529
 530 =cut
 531
 532 */
 533
 534 /*
 535  * Local variables:
 536  *   c-file-style: "parrot"
 537  * End:
 538  * vim: expandtab shiftwidth=4:
 539  */