t/src/compiler.t

   1 #! perl
   2 # Copyright (C) 2001-2008, The Perl Foundation.
   3 # $Id$
   4
   5 use strict;
   6 use warnings;
   7 use lib qw( . lib ../lib ../../lib );
   8 use Test::More;
   9 use Parrot::Test;
  10
  11 plan tests => 6;
  12
  13 =head1 NAME
  14
  15 t/src/compiler.t - Compile and run a PIR program from C.
  16
  17 =head1 SYNOPSIS
  18
  19     % prove t/src/compiler.t
  20
  21 =head1 DESCRIPTION
  22
  23 Show steps to run a program from C. Functionality should be
  24 gathered in some API calls..
  25
  26 =cut
  27
  28 SKIP: {
  29     skip( 'compreg disabled/imcc_compile_pir() not exported', 1 );
  30     c_output_is( <<'CODE', <<'OUTPUT', "compreg/compile" );
  31
  32 #include <stdio.h>
  33 #include "parrot/parrot.h"
  34 #include "parrot/embed.h"
  35
  36 static opcode_t *
  37 run(Parrot_Interp interp, int argc, char *argv[])
  38 {
  39     const char *c_src = ".sub main :main\n" "    print \"ok\\n\"\n" ".end\n";
  40
  41     STRING *src, *smain;
  42     PMC *prog, *entry;
  43     opcode_t *dest;
  44
  45     /* get PIR compiler  - TODO API */
  46     PMC    *compreg = Parrot_PMC_get_pmc_keyed_int(interp,
  47                                        interp->iglobals,
  48                                        IGLOBALS_COMPREG_HASH);
  49     STRING *pir     = const_string(interp, "PIR");
  50     PMC    *comp    = Parrot_PMC_get_pmc_keyed_str(interp, compreg, pir);
  51
  52     if (PMC_IS_NULL(comp) || !Parrot_PMC_defined(interp, comp)) {
  53         PIO_eprintf(interp, "Pir compiler not loaded");
  54         exit(EXIT_FAILURE);
  55     }
  56
  57     /* compile source */
  58     prog = imcc_compile_pir(interp, c_src);
  59
  60     if (PMC_IS_NULL(prog) || !Parrot_PMC_defined(interp, prog)) {
  61         PIO_eprintf(interp, "Pir compiler returned no prog");
  62         exit(EXIT_FAILURE);
  63     }
  64
  65     /* keep eval PMC alive */
  66     dod_register_pmc(interp, prog);
  67
  68     /* locate function to run */
  69     smain = const_string(interp, "main");
  70     entry = Parrot_find_global_cur(interp, smain);
  71
  72     /* location of the entry */
  73     interp->current_cont = new_ret_continuation_pmc(interp, NULL);
  74     dest                 = Parrot_PMC_invoke(interp, entry, NULL);
  75
  76     /* where to start */
  77     interp->resume_offset = dest -interp->code->base.data;
  78
  79     /* and go */
  80     Parrot_runcode(interp, argc, argv);
  81     return NULL;
  82 }
  83
  84 int
  85 main(int margc, char *margv[])
  86 {
  87     Parrot_Interp interp;
  88     PackFile *pf;
  89     int argc = 1;
  90     char *argv[] = { "test", NULL };
  91
  92     PackFile_Segment *seg;
  93
  94     /* Interpreter set-up */
  95     interp = Parrot_new(NULL);
  96     if (interp == NULL)
  97         return 1;
  98
  99     /* dummy pf and segment to get things started */
 100     pf = PackFile_new_dummy(interp, "test_code");
 101
 102     /* Parrot_set_flag(interp, PARROT_TRACE_FLAG); */
 103     run(interp, argc, argv);
 104     Parrot_exit(interp, 0);
 105     return 0;
 106 }
 107 CODE
 108 ok
 109 OUTPUT
 110 }
 111
 112 c_output_is( <<'CODE', <<'OUTPUT', "Parrot Compile API Single call" );
 113
 114 #include <stdio.h>
 115 #include "parrot/parrot.h"
 116 #include "parrot/embed.h"
 117 #include "parrot/extend.h"
 118
 119 static opcode_t *
 120 run(Parrot_Interp interp, int argc, char *argv[])
 121 {
 122     const char *c_src = ".sub main :main\n" "    print \"ok\\n\"\n" ".end\n";
 123
 124     STRING *src, *smain;
 125     PMC *prog, *entry;
 126     opcode_t *dest;
 127     STRING *error;
 128
 129     /* get PIR compiler  - TODO API */
 130     PMC   *compreg = Parrot_PMC_get_pmc_keyed_int(interp,
 131                                        interp->iglobals,
 132                                        IGLOBALS_COMPREG_HASH);
 133     STRING *pir    = const_string(interp, "PIR");
 134     PMC    *comp   = Parrot_PMC_get_pmc_keyed_str(interp, compreg, pir);
 135
 136     if (PMC_IS_NULL(comp) || !Parrot_PMC_defined(interp, comp)) {
 137         PIO_eprintf(interp, "Pir compiler not loaded");
 138         exit(EXIT_FAILURE);
 139     }
 140
 141     /* compile source */
 142     prog = Parrot_compile_string(interp, pir, c_src, &error);
 143
 144     if (PMC_IS_NULL(prog) || !Parrot_PMC_defined(interp, prog)) {
 145         PIO_eprintf(interp, "Pir compiler returned no prog");
 146         exit(EXIT_FAILURE);
 147     }
 148
 149     /* keep eval PMC alive */
 150     dod_register_pmc(interp, prog);
 151
 152     /* locate function to run */
 153     smain = const_string(interp, "main");
 154     entry = Parrot_find_global_cur(interp, smain);
 155
 156     /* location of the entry */
 157     interp->current_cont = new_ret_continuation_pmc(interp, NULL);
 158     dest                 = Parrot_PMC_invoke(interp, entry, NULL);
 159
 160     /* where to start */
 161     interp->resume_offset = dest -interp->code->base.data;
 162
 163     /* and go */
 164     Parrot_runcode(interp, argc, (char **)argv);
 165     return NULL;
 166 }
 167
 168 int
 169 main(int margc, char *margv[])
 170 {
 171     Parrot_Interp interp;
 172     PackFile *pf;
 173     int argc = 1;
 174     const char *argv[] = { "test", NULL };
 175
 176     PackFile_Segment *seg;
 177
 178     /* Interpreter set-up */
 179     interp = Parrot_new(NULL);
 180     if (interp == NULL)
 181         return 1;
 182
 183     /* dummy pf and segment to get things started */
 184     pf = PackFile_new_dummy(interp, "test_code");
 185
 186     /* Parrot_set_flag(interp, PARROT_TRACE_FLAG); */
 187     run(interp, argc, (char **)argv);
 188     Parrot_exit(interp, 0);
 189     return 0;
 190 }
 191 CODE
 192 ok
 193 OUTPUT
 194 c_output_is( <<'CODE', <<'OUTPUT', "Parrot Compile API Multiple Calls" );
 195
 196 #include <stdio.h>
 197 #include "parrot/parrot.h"
 198 #include "parrot/embed.h"
 199 #include "parrot/extend.h"
 200
 201 static void
 202 compile_run(Parrot_Interp interp, const char *src, STRING *type, int argc,
 203             char *argv[])
 204 {
 205     STRING   *smain;
 206     PMC      *entry;
 207     STRING   *error;
 208     opcode_t *dest;
 209     PMC      *prog = Parrot_compile_string(interp, type, src, &error);
 210
 211     if (PMC_IS_NULL(prog) || !Parrot_PMC_defined(interp, prog)) {
 212         PIO_eprintf(interp, "Pir compiler returned no prog");
 213         exit(EXIT_FAILURE);
 214     }
 215
 216     /* keep eval PMC alive */
 217     dod_register_pmc(interp, prog);
 218
 219     /* locate function to run */
 220     smain = const_string(interp, "main");
 221     entry = Parrot_find_global_cur(interp, smain);
 222
 223     /* location of the entry */
 224     interp->current_cont = new_ret_continuation_pmc(interp, NULL);
 225     dest                 = Parrot_PMC_invoke(interp, entry, NULL);
 226
 227     /* where to start */
 228     interp->resume_offset = dest -interp->code->base.data;
 229
 230     /* and go */
 231     Parrot_runcode(interp, argc, (char **)argv);
 232 }
 233
 234 static opcode_t *
 235 run(Parrot_Interp interp, int argc, char *argv[])
 236 {
 237     const char *c_src  = ".sub main :main\n" "    print \"ok\\n\"\n" ".end\n";
 238
 239     const char *c2_src =
 240         ".sub main :main\n" "    print \"hola\\n\"\n" ".end\n";
 241
 242     STRING *src, *smain;
 243
 244     /* get PIR compiler  - TODO API */
 245     PMC    *compreg = Parrot_PMC_get_pmc_keyed_int(interp,
 246                                        interp->iglobals,
 247                                        IGLOBALS_COMPREG_HASH);
 248     STRING *pir     = const_string(interp, "PIR");
 249     PMC    *comp    = Parrot_PMC_get_pmc_keyed_str(interp, compreg, pir);
 250
 251     if (PMC_IS_NULL(comp) || !Parrot_PMC_defined(interp, comp)) {
 252         PIO_eprintf(interp, "Pir compiler not loaded");
 253         exit(EXIT_FAILURE);
 254     }
 255
 256     compile_run(interp, c_src, pir, argc, argv);
 257     compile_run(interp, c2_src, pir, argc, argv);
 258 }
 259
 260 int
 261 main(int margc, char *margv[])
 262 {
 263     Parrot_Interp interp;
 264     PackFile *pf;
 265     int argc = 1;
 266     const char *argv[] = { "test", NULL };
 267
 268     PackFile_Segment *seg;
 269
 270     /* Interpreter set-up */
 271     interp = Parrot_new(NULL);
 272     if (interp == NULL)
 273         return 1;
 274
 275     /* dummy pf and segment to get things started */
 276     pf = PackFile_new_dummy(interp, "test_code");
 277
 278     /* Parrot_set_flag(interp, PARROT_TRACE_FLAG); */
 279     run(interp, argc, (char **) argv);
 280     Parrot_exit(interp, 0);
 281     return 0;
 282 }
 283 CODE
 284 ok
 285 hola
 286 OUTPUT
 287 c_output_is( <<'CODE', <<'OUTPUT', "Parrot Compile API Multiple 1st bad PIR" );
 288
 289 #include <stdio.h>
 290 #include "parrot/parrot.h"
 291 #include "parrot/embed.h"
 292 #include "parrot/extend.h"
 293
 294 static void
 295 compile_run(Parrot_Interp interp, const char *src, STRING *type, int argc,
 296             char *argv[])
 297 {
 298     STRING   *smain;
 299     PMC      *entry;
 300     STRING   *error;
 301     opcode_t *dest;
 302     PMC      *prog = Parrot_compile_string(interp, type, src, &error);
 303
 304     if (PMC_IS_NULL(prog) || !Parrot_PMC_defined(interp, prog)) {
 305         PIO_eprintf(interp, "Pir compiler returned no prog\n");
 306         return;
 307     }
 308
 309     /* keep eval PMC alive */
 310     dod_register_pmc(interp, prog);
 311
 312     /* locate function to run */
 313     smain = const_string(interp, "main");
 314     entry = Parrot_find_global_cur(interp, smain);
 315
 316     /* location of the entry */
 317     interp->current_cont = new_ret_continuation_pmc(interp, NULL);
 318     dest                 = Parrot_PMC_invoke(interp, entry, NULL);
 319
 320     /* where to start */
 321     interp->resume_offset = dest -interp->code->base.data;
 322
 323     /* and go */
 324     Parrot_runcode(interp, argc, (char **) argv);
 325 }
 326
 327 static opcode_t *
 328 run(Parrot_Interp interp, int argc, char *argv[])
 329 {
 330     const char *c_src  = ".sub main :main\n" "    print ok\\n\"\n" ".end\n";
 331
 332     const char *c2_src =
 333         ".sub main :main\n" "    print \"hola\\n\"\n" ".end\n";
 334
 335     STRING *src, *smain;
 336
 337     /* get PIR compiler  - TODO API */
 338     PMC    *compreg = Parrot_PMC_get_pmc_keyed_int(interp,
 339                                        interp->iglobals,
 340                                        IGLOBALS_COMPREG_HASH);
 341     STRING *pir     = const_string(interp, "PIR");
 342     PMC    *comp    = Parrot_PMC_get_pmc_keyed_str(interp, compreg, pir);
 343
 344     if (PMC_IS_NULL(comp) || !Parrot_PMC_defined(interp, comp)) {
 345         PIO_eprintf(interp, "Pir compiler not loaded");
 346         return NULL;
 347     }
 348
 349     compile_run(interp, c_src, pir, argc, argv);
 350     compile_run(interp, c2_src, pir, argc, argv);
 351 }
 352
 353 int
 354 main(int margc, char *margv[])
 355 {
 356     Parrot_Interp interp;
 357     PackFile *pf;
 358     int argc = 1;
 359     char *argv[] = { "test", NULL };
 360
 361     PackFile_Segment *seg;
 362
 363     /* Interpreter set-up */
 364     interp = Parrot_new(NULL);
 365     if (interp == NULL)
 366         return 1;
 367
 368     /* dummy pf and segment to get things started */
 369     pf = PackFile_new_dummy(interp, "test_code");
 370
 371     /* Parrot_set_flag(interp, PARROT_TRACE_FLAG); */
 372     run(interp, argc, argv);
 373     Parrot_exit(interp, 0);
 374     return 0;
 375 }
 376 CODE
 377 Pir compiler returned no prog
 378 hola
 379 OUTPUT
 380 c_output_is( <<'CODE', <<'OUTPUT', "Parrot Compile API Multiple 2nd bad PIR" );
 381
 382 #include <stdio.h>
 383 #include "parrot/parrot.h"
 384 #include "parrot/embed.h"
 385 #include "parrot/extend.h"
 386
 387 static void
 388 compile_run(Parrot_Interp interp, const char *src, STRING *type, int argc,
 389             char *argv[])
 390 {
 391     STRING   *smain;
 392     PMC      *entry;
 393     STRING   *error;
 394     opcode_t *dest;
 395     PMC      *prog = Parrot_compile_string(interp, type, src, &error);
 396
 397     if (PMC_IS_NULL(prog) || !Parrot_PMC_defined(interp, prog)) {
 398         PIO_eprintf(interp, "Pir compiler returned no prog\n");
 399         return;
 400     }
 401
 402     /* keep eval PMC alive */
 403     dod_register_pmc(interp, prog);
 404
 405     /* locate function to run */
 406     smain = const_string(interp, "main");
 407     entry = Parrot_find_global_cur(interp, smain);
 408
 409     /* location of the entry */
 410     interp->current_cont = new_ret_continuation_pmc(interp, NULL);
 411     dest                 = Parrot_PMC_invoke(interp, entry, NULL);
 412
 413     /* where to start */
 414     interp->resume_offset = dest -interp->code->base.data;
 415
 416     /* and go */
 417     Parrot_runcode(interp, argc, (char **)argv);
 418 }
 419
 420 static opcode_t *
 421 run(Parrot_Interp interp, int argc, char *argv[])
 422 {
 423     const char *c_src  = ".sub main :main\n" "    print ok\\n\"\n" ".end\n";
 424
 425     const char *c2_src =
 426         ".sub main :main\n" "    print \"hola\\n\"\n" ".end\n";
 427
 428     STRING *src, *smain;
 429     /* get PIR compiler  - TODO API */
 430     PMC    *compreg = Parrot_PMC_get_pmc_keyed_int(interp,
 431                                        interp->iglobals,
 432                                        IGLOBALS_COMPREG_HASH);
 433     STRING *pir     = const_string(interp, "PIR");
 434     PMC    *comp    = Parrot_PMC_get_pmc_keyed_str(interp, compreg, pir);
 435
 436     if (PMC_IS_NULL(comp) || !Parrot_PMC_defined(interp, comp)) {
 437         PIO_eprintf(interp, "Pir compiler not loaded");
 438         return NULL;
 439     }
 440
 441     compile_run(interp, c2_src, pir, argc, argv);
 442     compile_run(interp, c_src, pir, argc, argv);
 443 }
 444
 445 int
 446 main(int margc, char *margv[])
 447 {
 448     Parrot_Interp interp;
 449     PackFile *pf;
 450     int argc = 1;
 451     char *argv[] = { "test", NULL };
 452
 453     PackFile_Segment *seg;
 454
 455     /* Interpreter set-up */
 456     interp = Parrot_new(NULL);
 457     if (interp == NULL)
 458         return 1;
 459
 460     /* dummy pf and segment to get things started */
 461     pf = PackFile_new_dummy(interp, "test_code");
 462
 463     /* Parrot_set_flag(interp, PARROT_TRACE_FLAG); */
 464     run(interp, argc, argv);
 465     Parrot_exit(interp, 0);
 466     return 0;
 467 }
 468 CODE
 469 hola
 470 Pir compiler returned no prog
 471 OUTPUT
 472 c_output_is( <<'CODE', <<'OUTPUT', "Parrot Compile API Multiple bad PIR" );
 473
 474 #include <stdio.h>
 475 #include "parrot/parrot.h"
 476 #include "parrot/embed.h"
 477 #include "parrot/extend.h"
 478
 479 static void
 480 compile_run(Parrot_Interp interp, const char *src, STRING *type, int argc,
 481             char *argv[])
 482 {
 483     STRING   *smain;
 484     PMC      *entry;
 485     STRING   *error;
 486     opcode_t *dest;
 487     PMC      *prog = Parrot_compile_string(interp, type, src, &error);
 488
 489     if (PMC_IS_NULL(prog) || !Parrot_PMC_defined(interp, prog)) {
 490         PIO_eprintf(interp, "Pir compiler returned no prog\n");
 491         return;
 492     }
 493
 494     /* keep eval PMC alive */
 495     dod_register_pmc(interp, prog);
 496
 497     /* locate function to run */
 498     smain = const_string(interp, "main");
 499     entry = Parrot_find_global_cur(interp, smain);
 500
 501     /* location of the entry */
 502     interp->current_cont = new_ret_continuation_pmc(interp, NULL);
 503     dest                 = Parrot_PMC_invoke(interp, entry, NULL);
 504
 505     /* where to start */
 506     interp->resume_offset = dest -interp->code->base.data;
 507
 508     /* and go */
 509     Parrot_runcode(interp, argc, (char **)argv);
 510 }
 511
 512 static opcode_t *
 513 run(Parrot_Interp interp, int argc, char *argv[])
 514 {
 515     const char *c_src  = ".sub main :main\n" "    print ok\\n\"\n" ".end\n";
 516
 517     const char *c2_src = ".sub main :main\n" "    print hola\\n\"\n" ".end\n";
 518
 519     STRING *src, *smain;
 520     /* get PIR compiler  - TODO API */
 521     PMC    *compreg = Parrot_PMC_get_pmc_keyed_int(interp,
 522                                        interp->iglobals,
 523                                        IGLOBALS_COMPREG_HASH);
 524     STRING *pir     = const_string(interp, "PIR");
 525     PMC    *comp    = Parrot_PMC_get_pmc_keyed_str(interp, compreg, pir);
 526
 527     if (PMC_IS_NULL(comp) || !Parrot_PMC_defined(interp, comp)) {
 528         PIO_eprintf(interp, "Pir compiler not loaded");
 529         return NULL;
 530     }
 531
 532     compile_run(interp, c_src, pir, argc, argv);
 533     compile_run(interp, c2_src, pir, argc, argv);
 534 }
 535
 536 int
 537 main(int margc, char *margv[])
 538 {
 539     Parrot_Interp interp;
 540     PackFile *pf;
 541     int argc = 1;
 542     char *argv[] = { "test", NULL };
 543
 544     PackFile_Segment *seg;
 545
 546     /* Interpreter set-up */
 547     interp = Parrot_new(NULL);
 548     if (interp == NULL)
 549         return 1;
 550
 551     /* dummy pf and segment to get things started */
 552     pf = PackFile_new_dummy(interp, "test_code");
 553
 554     /* Parrot_set_flag(interp, PARROT_TRACE_FLAG); */
 555     run(interp, argc, argv);
 556     Parrot_exit(interp, 0);
 557     return 0;
 558 }
 559 CODE
 560 Pir compiler returned no prog
 561 Pir compiler returned no prog
 562 OUTPUT
 563
 564 # Local Variables:
 565 #   mode: cperl
 566 #   cperl-indent-level: 4
 567 #   fill-column: 100
 568 # End:
 569 # vim: expandtab shiftwidth=4: