git.sur5r.net Git - cc65/blob - src/cc65/codegen.c

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*                                 codegen.c                                 */
   4 /*                                                                           */
   5 /*                            6502 code generator                            */
   6 /*                                                                           */
   7 /*                                                                           */
   8 /*                                                                           */
   9 /* (C) 1998-2001 Ullrich von Bassewitz                                       */
  10 /*               Wacholderweg 14                                             */
  11 /*               D-70597 Stuttgart                                           */
  12 /* EMail:        uz@cc65.org                                                 */
  13 /*                                                                           */
  14 /*                                                                           */
  15 /* This software is provided 'as-is', without any expressed or implied       */
  16 /* warranty.  In no event will the authors be held liable for any damages    */
  17 /* arising from the use of this software.                                    */
  18 /*                                                                           */
  19 /* Permission is granted to anyone to use this software for any purpose,     */
  20 /* including commercial applications, and to alter it and redistribute it    */
  21 /* freely, subject to the following restrictions:                            */
  22 /*                                                                           */
  23 /* 1. The origin of this software must not be misrepresented; you must not   */
  24 /*    claim that you wrote the original software. If you use this software   */
  25 /*    in a product, an acknowledgment in the product documentation would be  */
  26 /*    appreciated but is not required.                                       */
  27 /* 2. Altered source versions must be plainly marked as such, and must not   */
  28 /*    be misrepresented as being the original software.                      */
  29 /* 3. This notice may not be removed or altered from any source              */
  30 /*    distribution.                                                          */
  31 /*                                                                           */
  32 /*****************************************************************************/
  33
  34
  35
  36 #include <stdio.h>
  37 #include <string.h>
  38 #include <stdarg.h>
  39
  40 /* common */
  41 #include "check.h"
  42 #include "strbuf.h"
  43 #include "version.h"
  44 #include "xmalloc.h"
  45 #include "xsprintf.h"
  46
  47 /* cc65 */
  48 #include "asmcode.h"
  49 #include "asmlabel.h"
  50 #include "casenode.h"
  51 #include "codeseg.h"
  52 #include "cpu.h"
  53 #include "dataseg.h"
  54 #include "error.h"
  55 #include "global.h"
  56 #include "segments.h"
  57 #include "textseg.h"
  58 #include "util.h"
  59 #include "codegen.h"
  60
  61
  62
  63 /*****************************************************************************/
  64 /*                                   Data                                    */
  65 /*****************************************************************************/
  66
  67
  68
  69 /* Compiler relative stack pointer */
  70 int oursp       = 0;
  71
  72
  73
  74 /*****************************************************************************/
  75 /*                                  Helpers                                  */
  76 /*****************************************************************************/
  77
  78
  79
  80 static void typeerror (unsigned type)
  81 /* Print an error message about an invalid operand type */
  82 {
  83     Internal ("Invalid type in CF flags: %04X, type = %u", type, type & CF_TYPE);
  84 }
  85
  86
  87
  88 static void CheckLocalOffs (unsigned Offs)
  89 /* Check the offset into the stack for 8bit range */
  90 {
  91     if (Offs >= 256) {
  92         /* Too many local vars */
  93         Error ("Too many local variables");
  94     }
  95 }
  96
  97
  98
  99 static char* GetLabelName (unsigned flags, unsigned long label, unsigned offs)
 100 {
 101     static char lbuf [128];             /* Label name */
 102
 103     /* Create the correct label name */
 104     switch (flags & CF_ADDRMASK) {
 105
 106         case CF_STATIC:
 107             /* Static memory cell */
 108             sprintf (lbuf, "%s+%u", LocalLabelName (label), offs);
 109             break;
 110
 111         case CF_EXTERNAL:
 112             /* External label */
 113             sprintf (lbuf, "_%s+%u", (char*) label, offs);
 114             break;
 115
 116         case CF_ABSOLUTE:
 117             /* Absolute address */
 118             sprintf (lbuf, "$%04X", (unsigned)((label+offs) & 0xFFFF));
 119             break;
 120
 121         case CF_REGVAR:
 122             /* Variable in register bank */
 123             sprintf (lbuf, "regbank+%u", (unsigned)((label+offs) & 0xFFFF));
 124             break;
 125
 126         default:
 127             Internal ("Invalid address flags");
 128     }
 129
 130     /* Return a pointer to the static buffer */
 131     return lbuf;
 132 }
 133
 134
 135
 136 /*****************************************************************************/
 137 /*                            Pre- and postamble                             */
 138 /*****************************************************************************/
 139
 140
 141
 142 void g_preamble (void)
 143 /* Generate the assembler code preamble */
 144 {
 145     /* Create a new (global) segment list and remember it */
 146     PushSegments (0);
 147     GS = CS;
 148
 149     /* Identify the compiler version */
 150     AddTextLine (";");
 151     AddTextLine ("; File generated by cc65 v %u.%u.%u",
 152                  VER_MAJOR, VER_MINOR, VER_PATCH);
 153     AddTextLine (";");
 154
 155     /* Insert some object file options */
 156     AddTextLine ("\t.fopt\t\tcompiler,\"cc65 v %u.%u.%u\"",
 157                     VER_MAJOR, VER_MINOR, VER_PATCH);
 158
 159     /* If we're producing code for some other CPU, switch the command set */
 160     if (CPU == CPU_65C02) {
 161         AddTextLine ("\t.pc02");
 162     }
 163
 164     /* Allow auto import for runtime library routines */
 165     AddTextLine ("\t.autoimport\ton");
 166
 167     /* Switch the assembler into case sensitive mode */
 168     AddTextLine ("\t.case\t\ton");
 169
 170     /* Tell the assembler if we want to generate debug info */
 171     AddTextLine ("\t.debuginfo\t%s", (DebugInfo != 0)? "on" : "off");
 172
 173     /* Import the stack pointer for direct auto variable access */
 174     AddTextLine ("\t.importzp\tsp, sreg, regsave, regbank, tmp1, ptr1, ptr2");
 175
 176     /* Define long branch macros */
 177     AddTextLine ("\t.macpack\tlongbranch");
 178 }
 179
 180
 181
 182 void g_fileinfo (const char* Name, unsigned long Size, unsigned long MTime)
 183 /* If debug info is enabled, place a file info into the source */
 184 {
 185     if (DebugInfo) {
 186         /* We have to place this into the global text segment, so it will
 187          * appear before all .dbg line statements.
 188          */
 189         TS_AddLine (GS->Text, "\t.dbg\t\tfile, \"%s\", %lu, %lu", Name, Size, MTime);
 190     }
 191 }
 192
 193
 194
 195 /*****************************************************************************/
 196 /*                              Segment support                              */
 197 /*****************************************************************************/
 198
 199
 200
 201 void g_userodata (void)
 202 /* Switch to the read only data segment */
 203 {
 204     UseDataSeg (SEG_RODATA);
 205 }
 206
 207
 208
 209 void g_usedata (void)
 210 /* Switch to the data segment */
 211 {
 212     UseDataSeg (SEG_DATA);
 213 }
 214
 215
 216
 217 void g_usebss (void)
 218 /* Switch to the bss segment */
 219 {
 220     UseDataSeg (SEG_BSS);
 221 }
 222
 223
 224
 225 void g_segname (segment_t Seg, const char* Name)
 226 /* Set the name of a segment */
 227 {
 228     DataSeg* S;
 229
 230     /* Remember the new name */
 231     NewSegName (Seg, Name);
 232
 233     /* Emit a segment directive for the data style segments */
 234     switch (Seg) {
 235         case SEG_RODATA: S = CS->ROData; break;
 236         case SEG_DATA:   S = CS->Data;   break;
 237         case SEG_BSS:    S = CS->BSS;    break;
 238         default:         S = 0;          break;
 239     }
 240     if (S) {
 241         DS_AddLine (S, ".segment\t\"%s\"", Name);
 242     }
 243 }
 244
 245
 246
 247 /*****************************************************************************/
 248 /*                                   Code                                    */
 249 /*****************************************************************************/
 250
 251
 252
 253 unsigned sizeofarg (unsigned flags)
 254 /* Return the size of a function argument type that is encoded in flags */
 255 {
 256     switch (flags & CF_TYPE) {
 257
 258         case CF_CHAR:
 259             return (flags & CF_FORCECHAR)? 1 : 2;
 260
 261         case CF_INT:
 262             return 2;
 263
 264         case CF_LONG:
 265             return 4;
 266
 267         default:
 268             typeerror (flags);
 269             /* NOTREACHED */
 270             return 2;
 271     }
 272 }
 273
 274
 275
 276 int pop (unsigned flags)
 277 /* Pop an argument of the given size */
 278 {
 279     return oursp += sizeofarg (flags);
 280 }
 281
 282
 283
 284 int push (unsigned flags)
 285 /* Push an argument of the given size */
 286 {
 287     return oursp -= sizeofarg (flags);
 288 }
 289
 290
 291
 292 static unsigned MakeByteOffs (unsigned Flags, unsigned Offs)
 293 /* The value in Offs is an offset to an address in a/x. Make sure, an object
 294  * of the type given in Flags can be loaded or stored into this address by
 295  * adding part of the offset to the address in ax, so that the remaining
 296  * offset fits into an index register. Return the remaining offset.
 297  */
 298 {
 299     /* If the offset is too large for a byte register, add the high byte
 300      * of the offset to the primary. Beware: We need a special correction
 301      * if the offset in the low byte will overflow in the operation.
 302      */
 303     unsigned O = Offs & ~0xFFU;
 304     if ((Offs & 0xFF) > 256 - sizeofarg (Flags)) {
 305         /* We need to add the low byte also */
 306         O += Offs & 0xFF;
 307     }
 308
 309     /* Do the correction if we need one */
 310     if (O != 0) {
 311         g_inc (CF_INT | CF_CONST, O);
 312         Offs -= O;
 313     }
 314
 315     /* Return the new offset */
 316     return Offs;
 317 }
 318
 319
 320
 321 /*****************************************************************************/
 322 /*                      Functions handling local labels                      */
 323 /*****************************************************************************/
 324
 325
 326
 327 void g_defcodelabel (unsigned label)
 328 /* Define a local code label */
 329 {
 330     CS_AddLabel (CS->Code, LocalLabelName (label));
 331 }
 332
 333
 334
 335 void g_defdatalabel (unsigned label)
 336 /* Define a local data label */
 337 {
 338     AddDataLine ("%s:", LocalLabelName (label));
 339 }
 340
 341
 342
 343 /*****************************************************************************/
 344 /*                     Functions handling global labels                      */
 345 /*****************************************************************************/
 346
 347
 348
 349 void g_defgloblabel (const char* Name)
 350 /* Define a global label with the given name */
 351 {
 352     /* Global labels are always data labels */
 353     AddDataLine ("_%s:", Name);
 354 }
 355
 356
 357
 358 void g_defexport (const char* Name, int ZP)
 359 /* Export the given label */
 360 {
 361     if (ZP) {
 362         AddTextLine ("\t.exportzp\t_%s", Name);
 363     } else {
 364         AddTextLine ("\t.export\t\t_%s", Name);
 365     }
 366 }
 367
 368
 369
 370 void g_defimport (const char* Name, int ZP)
 371 /* Import the given label */
 372 {
 373     if (ZP) {
 374         AddTextLine ("\t.importzp\t_%s", Name);
 375     } else {
 376         AddTextLine ("\t.import\t\t_%s", Name);
 377     }
 378 }
 379
 380
 381
 382 /*****************************************************************************/
 383 /*                   Load functions for various registers                    */
 384 /*****************************************************************************/
 385
 386
 387
 388 static void ldaconst (unsigned val)
 389 /* Load a with a constant */
 390 {
 391     AddCodeLine ("lda #$%02X", val & 0xFF);
 392 }
 393
 394
 395
 396 static void ldxconst (unsigned val)
 397 /* Load x with a constant */
 398 {
 399     AddCodeLine ("ldx #$%02X", val & 0xFF);
 400 }
 401
 402
 403
 404 static void ldyconst (unsigned val)
 405 /* Load y with a constant */
 406 {
 407     AddCodeLine ("ldy #$%02X", val & 0xFF);
 408 }
 409
 410
 411
 412 /*****************************************************************************/
 413 /*                          Function entry and exit                          */
 414 /*****************************************************************************/
 415
 416
 417
 418 /* Remember the argument size of a function. The variable is set by g_enter
 419  * and used by g_leave. If the functions gets its argument size by the caller
 420  * (variable param list or function without prototype), g_enter will set the
 421  * value to -1.
 422  */
 423 static int funcargs;
 424
 425
 426 void g_enter (unsigned flags, unsigned argsize)
 427 /* Function prologue */
 428 {
 429     if ((flags & CF_FIXARGC) != 0) {
 430         /* Just remember the argument size for the leave */
 431         funcargs = argsize;
 432     } else {
 433         funcargs = -1;
 434         AddCodeLine ("jsr enter");
 435     }
 436 }
 437
 438
 439
 440 void g_leave (void)
 441 /* Function epilogue */
 442 {
 443     /* How many bytes of locals do we have to drop? */
 444     int k = -oursp;
 445
 446     /* If we didn't have a variable argument list, don't call leave */
 447     if (funcargs >= 0) {
 448
 449         /* Drop stackframe if needed */
 450         k += funcargs;
 451         if (k > 0) {
 452             if (k <= 8) {
 453             AddCodeLine ("jsr incsp%d", k);
 454             } else {
 455                 CheckLocalOffs (k);
 456                 ldyconst (k);
 457                 AddCodeLine ("jsr addysp");
 458             }
 459         }
 460
 461     } else {
 462
 463         if (k == 0) {
 464             /* Nothing to drop */
 465             AddCodeLine ("jsr leave");
 466         } else {
 467             /* We've a stack frame to drop */
 468             ldyconst (k);
 469             AddCodeLine ("jsr leavey");
 470         }
 471     }
 472
 473     /* Add the final rts */
 474     AddCodeLine ("rts");
 475 }
 476
 477
 478
 479 /*****************************************************************************/
 480 /*                            Register variables                             */
 481 /*****************************************************************************/
 482
 483
 484
 485 void g_save_regvars (int RegOffs, unsigned Bytes)
 486 /* Save register variables */
 487 {
 488     /* Don't loop for up to two bytes */
 489     if (Bytes == 1) {
 490
 491         AddCodeLine ("lda regbank%+d", RegOffs);
 492         AddCodeLine ("jsr pusha");
 493
 494     } else if (Bytes == 2) {
 495
 496         AddCodeLine ("lda regbank%+d", RegOffs);
 497         AddCodeLine ("ldx regbank%+d", RegOffs+1);
 498         AddCodeLine ("jsr pushax");
 499
 500     } else {
 501
 502         /* More than two bytes - loop */
 503         unsigned Label = GetLocalLabel ();
 504         g_space (Bytes);
 505         ldyconst (Bytes - 1);
 506         ldxconst (Bytes);
 507         g_defcodelabel (Label);
 508         AddCodeLine ("lda regbank%+d,x", RegOffs-1);
 509         AddCodeLine ("sta (sp),y");
 510         AddCodeLine ("dey");
 511         AddCodeLine ("dex");
 512         AddCodeLine ("bne %s", LocalLabelName (Label));
 513
 514     }
 515
 516     /* We pushed stuff, correct the stack pointer */
 517     oursp -= Bytes;
 518 }
 519
 520
 521
 522 void g_restore_regvars (int StackOffs, int RegOffs, unsigned Bytes)
 523 /* Restore register variables */
 524 {
 525     /* Calculate the actual stack offset and check it */
 526     StackOffs -= oursp;
 527     CheckLocalOffs (StackOffs);
 528
 529     /* Don't loop for up to two bytes */
 530     if (Bytes == 1) {
 531
 532         ldyconst (StackOffs);
 533         AddCodeLine ("lda (sp),y");
 534         AddCodeLine ("sta regbank%+d", RegOffs);
 535
 536     } else if (Bytes == 2) {
 537
 538         ldyconst (StackOffs);
 539         AddCodeLine ("lda (sp),y");
 540         AddCodeLine ("sta regbank%+d", RegOffs);
 541         AddCodeLine ("iny");
 542         AddCodeLine ("lda (sp),y");
 543         AddCodeLine ("sta regbank%+d", RegOffs+1);
 544
 545     } else {
 546
 547         /* More than two bytes - loop */
 548         unsigned Label = GetLocalLabel ();
 549         ldyconst (StackOffs+Bytes-1);
 550         ldxconst (Bytes);
 551         g_defcodelabel (Label);
 552         AddCodeLine ("lda (sp),y");
 553         AddCodeLine ("sta regbank%+d,x", RegOffs-1);
 554         AddCodeLine ("dey");
 555         AddCodeLine ("dex");
 556         AddCodeLine ("bne %s", LocalLabelName (Label));
 557
 558     }
 559 }
 560
 561
 562
 563 /*****************************************************************************/
 564 /*                           Fetching memory cells                           */
 565 /*****************************************************************************/
 566
 567
 568
 569 void g_getimmed (unsigned Flags, unsigned long Val, unsigned Offs)
 570 /* Load a constant into the primary register */
 571 {
 572     unsigned char B1, B2, B3, B4;
 573     unsigned      Done;
 574
 575
 576     if ((Flags & CF_CONST) != 0) {
 577
 578         /* Numeric constant */
 579         switch (Flags & CF_TYPE) {
 580
 581             case CF_CHAR:
 582                 if ((Flags & CF_FORCECHAR) != 0) {
 583                     ldaconst (Val);
 584                     break;
 585                 }
 586                 /* FALL THROUGH */
 587             case CF_INT:
 588                 ldxconst ((Val >> 8) & 0xFF);
 589                 ldaconst (Val & 0xFF);
 590                 break;
 591
 592             case CF_LONG:
 593                 /* Split the value into 4 bytes */
 594                 B1 = (unsigned char) (Val >>  0);
 595                 B2 = (unsigned char) (Val >>  8);
 596                 B3 = (unsigned char) (Val >> 16);
 597                 B4 = (unsigned char) (Val >> 24);
 598
 599                 /* Remember which bytes are done */
 600                 Done = 0;
 601
 602                 /* Load the value */
 603                 AddCodeLine ("ldx #$%02X", B2);
 604                 Done |= 0x02;
 605                 if (B2 == B3) {
 606                     AddCodeLine ("stx sreg");
 607                     Done |= 0x04;
 608                 }
 609                 if (B2 == B4) {
 610                     AddCodeLine ("stx sreg+1");
 611                     Done |= 0x08;
 612                 }
 613                 if ((Done & 0x04) == 0 && B1 != B3) {
 614                     AddCodeLine ("lda #$%02X", B3);
 615                     AddCodeLine ("sta sreg");
 616                     Done |= 0x04;
 617                 }
 618                 if ((Done & 0x08) == 0 && B1 != B4) {
 619                     AddCodeLine ("lda #$%02X", B4);
 620                     AddCodeLine ("sta sreg+1");
 621                     Done |= 0x08;
 622                 }
 623                 AddCodeLine ("lda #$%02X", B1);
 624                 Done |= 0x01;
 625                 if ((Done & 0x04) == 0) {
 626                     CHECK (B1 == B3);
 627                     AddCodeLine ("sta sreg");
 628                 }
 629                 if ((Done & 0x08) == 0) {
 630                     CHECK (B1 == B4);
 631                     AddCodeLine ("sta sreg+1");
 632                 }
 633                 break;
 634
 635             default:
 636                 typeerror (Flags);
 637                 break;
 638
 639         }
 640
 641     } else {
 642
 643         /* Some sort of label */
 644         const char* Label = GetLabelName (Flags, Val, Offs);
 645
 646         /* Load the address into the primary */
 647         AddCodeLine ("lda #<(%s)", Label);
 648         AddCodeLine ("ldx #>(%s)", Label);
 649
 650     }
 651 }
 652
 653
 654
 655 void g_getstatic (unsigned flags, unsigned long label, unsigned offs)
 656 /* Fetch an static memory cell into the primary register */
 657 {
 658     /* Create the correct label name */
 659     char* lbuf = GetLabelName (flags, label, offs);
 660
 661     /* Check the size and generate the correct load operation */
 662     switch (flags & CF_TYPE) {
 663
 664         case CF_CHAR:
 665             if ((flags & CF_FORCECHAR) || (flags & CF_TEST)) {
 666                 AddCodeLine ("lda %s", lbuf);   /* load A from the label */
 667             } else {
 668                 ldxconst (0);
 669                 AddCodeLine ("lda %s", lbuf);   /* load A from the label */
 670                 if (!(flags & CF_UNSIGNED)) {
 671                     /* Must sign extend */
 672                     unsigned L = GetLocalLabel ();
 673                     AddCodeLine ("bpl %s", LocalLabelName (L));
 674                     AddCodeLine ("dex");
 675                     g_defcodelabel (L);
 676                 }
 677             }
 678             break;
 679
 680         case CF_INT:
 681             AddCodeLine ("lda %s", lbuf);
 682             if (flags & CF_TEST) {
 683                 AddCodeLine ("ora %s+1", lbuf);
 684             } else {
 685                 AddCodeLine ("ldx %s+1", lbuf);
 686             }
 687             break;
 688
 689         case CF_LONG:
 690             if (flags & CF_TEST) {
 691                 AddCodeLine ("lda %s+3", lbuf);
 692                 AddCodeLine ("ora %s+2", lbuf);
 693                 AddCodeLine ("ora %s+1", lbuf);
 694                 AddCodeLine ("ora %s+0", lbuf);
 695             } else {
 696                 AddCodeLine ("lda %s+3", lbuf);
 697                 AddCodeLine ("sta sreg+1");
 698                 AddCodeLine ("lda %s+2", lbuf);
 699                 AddCodeLine ("sta sreg");
 700                 AddCodeLine ("ldx %s+1", lbuf);
 701                 AddCodeLine ("lda %s", lbuf);
 702             }
 703             break;
 704
 705         default:
 706             typeerror (flags);
 707
 708     }
 709 }
 710
 711
 712
 713 void g_getlocal (unsigned flags, int offs)
 714 /* Fetch specified local object (local var). */
 715 {
 716     offs -= oursp;
 717     CheckLocalOffs (offs);
 718     switch (flags & CF_TYPE) {
 719
 720         case CF_CHAR:
 721             if ((flags & CF_FORCECHAR) || (flags & CF_TEST)) {
 722                 if (CPU == CPU_65C02 && offs == 0) {
 723                     AddCodeLine ("lda (sp)");
 724                 } else {
 725                     ldyconst (offs);
 726                     AddCodeLine ("lda (sp),y");
 727                 }
 728             } else {
 729                 ldyconst (offs);
 730                 AddCodeLine ("ldx #$00");
 731                 AddCodeLine ("lda (sp),y");
 732                 if ((flags & CF_UNSIGNED) == 0) {
 733                     unsigned L = GetLocalLabel();
 734                     AddCodeLine ("bpl %s", LocalLabelName (L));
 735                     AddCodeLine ("dex");
 736                     g_defcodelabel (L);
 737                 }
 738             }
 739             break;
 740
 741         case CF_INT:
 742             CheckLocalOffs (offs + 1);
 743             if (flags & CF_TEST) {
 744                 ldyconst (offs + 1);
 745                 AddCodeLine ("lda (sp),y");
 746                 AddCodeLine ("dey");
 747                 AddCodeLine ("ora (sp),y");
 748             } else {
 749                 if (CodeSizeFactor > 180) {
 750                     ldyconst (offs + 1);
 751                     AddCodeLine ("lda (sp),y");
 752                     AddCodeLine ("tax");
 753                     AddCodeLine ("dey");
 754                     AddCodeLine ("lda (sp),y");
 755                 } else {
 756                     ldyconst (offs+1);
 757                     AddCodeLine ("jsr ldaxysp");
 758                 }
 759             }
 760             break;
 761
 762         case CF_LONG:
 763             ldyconst (offs+3);
 764             AddCodeLine ("jsr ldeaxysp");
 765             break;
 766
 767         default:
 768             typeerror (flags);
 769     }
 770 }
 771
 772
 773
 774 void g_getind (unsigned flags, unsigned offs)
 775 /* Fetch the specified object type indirect through the primary register
 776  * into the primary register
 777  */
 778 {
 779     /* If the offset is greater than 255, add the part that is > 255 to
 780      * the primary. This way we get an easy addition and use the low byte
 781      * as the offset
 782      */
 783     offs = MakeByteOffs (flags, offs);
 784
 785     /* Handle the indirect fetch */
 786     switch (flags & CF_TYPE) {
 787
 788         case CF_CHAR:
 789             /* Character sized */
 790             if (flags & CF_UNSIGNED) {
 791                 ldyconst (offs);
 792                 AddCodeLine ("jsr ldauidx");
 793             } else {
 794                 ldyconst (offs);
 795                 AddCodeLine ("jsr ldaidx");
 796             }
 797             break;
 798
 799         case CF_INT:
 800             if (flags & CF_TEST) {
 801                 ldyconst (offs);
 802                 AddCodeLine ("sta ptr1");
 803                 AddCodeLine ("stx ptr1+1");
 804                 AddCodeLine ("lda (ptr1),y");
 805                 AddCodeLine ("iny");
 806                 AddCodeLine ("ora (ptr1),y");
 807             } else {
 808                 ldyconst (offs+1);
 809                 AddCodeLine ("jsr ldaxidx");
 810             }
 811             break;
 812
 813         case CF_LONG:
 814             ldyconst (offs+3);
 815             AddCodeLine ("jsr ldeaxidx");
 816             if (flags & CF_TEST) {
 817                 AddCodeLine ("jsr tsteax");
 818             }
 819             break;
 820
 821         default:
 822             typeerror (flags);
 823
 824     }
 825 }
 826
 827
 828
 829 void g_leasp (int offs)
 830 /* Fetch the address of the specified symbol into the primary register */
 831 {
 832     /* Calculate the offset relative to sp */
 833     offs -= oursp;
 834
 835     /* For value 0 we do direct code */
 836     if (offs == 0) {
 837         AddCodeLine ("lda sp");
 838         AddCodeLine ("ldx sp+1");
 839     } else {
 840         if (CodeSizeFactor < 300) {
 841             ldaconst (offs);                    /* Load A with offset value */
 842             AddCodeLine ("jsr leaasp"); /* Load effective address */
 843         } else {
 844             unsigned L = GetLocalLabel ();
 845             if (CPU == CPU_65C02 && offs == 1) {
 846                 AddCodeLine ("lda sp");
 847                 AddCodeLine ("ldx sp+1");
 848                 AddCodeLine ("ina");
 849                 AddCodeLine ("bne %s", LocalLabelName (L));
 850                 AddCodeLine ("inx");
 851             } else {
 852                 ldaconst (offs);
 853                 AddCodeLine ("clc");
 854                 AddCodeLine ("ldx sp+1");
 855                 AddCodeLine ("adc sp");
 856                 AddCodeLine ("bcc %s", LocalLabelName (L));
 857                 AddCodeLine ("inx");
 858             }
 859             g_defcodelabel (L);
 860         }
 861     }
 862 }
 863
 864
 865
 866 void g_leavariadic (int Offs)
 867 /* Fetch the address of a parameter in a variadic function into the primary
 868  * register
 869  */
 870 {
 871     unsigned ArgSizeOffs;
 872
 873     /* Calculate the offset relative to sp */
 874     Offs -= oursp;
 875
 876     /* Get the offset of the parameter which is stored at sp+0 on function
 877      * entry and check if this offset is reachable with a byte offset.
 878      */
 879     CHECK (oursp <= 0);
 880     ArgSizeOffs = -oursp;
 881     CheckLocalOffs (ArgSizeOffs);
 882
 883     /* Get the size of all parameters. */
 884     if (ArgSizeOffs == 0 && CPU == CPU_65C02) {
 885         AddCodeLine ("lda (sp)");
 886     } else {
 887         ldyconst (ArgSizeOffs);
 888         AddCodeLine ("lda (sp),y");
 889     }
 890
 891     /* Add the value of the stackpointer */
 892     if (CodeSizeFactor > 250) {
 893         unsigned L = GetLocalLabel();
 894         AddCodeLine ("ldx sp+1");
 895         AddCodeLine ("clc");
 896         AddCodeLine ("adc sp");
 897         AddCodeLine ("bcc %s", LocalLabelName (L));
 898         AddCodeLine ("inx");
 899         g_defcodelabel (L);
 900     } else {
 901         AddCodeLine ("jsr leaasp");
 902     }
 903
 904     /* Add the offset to the primary */
 905     if (Offs > 0) {
 906         g_inc (CF_INT | CF_CONST, Offs);
 907     } else if (Offs < 0) {
 908         g_dec (CF_INT | CF_CONST, -Offs);
 909     }
 910 }
 911
 912
 913
 914 /*****************************************************************************/
 915 /*                             Store into memory                             */
 916 /*****************************************************************************/
 917
 918
 919
 920 void g_putstatic (unsigned flags, unsigned long label, unsigned offs)
 921 /* Store the primary register into the specified static memory cell */
 922 {
 923     /* Create the correct label name */
 924     char* lbuf = GetLabelName (flags, label, offs);
 925
 926     /* Check the size and generate the correct store operation */
 927     switch (flags & CF_TYPE) {
 928
 929         case CF_CHAR:
 930             AddCodeLine ("sta %s", lbuf);
 931             break;
 932
 933         case CF_INT:
 934             AddCodeLine ("sta %s", lbuf);
 935             AddCodeLine ("stx %s+1", lbuf);
 936             break;
 937
 938         case CF_LONG:
 939             AddCodeLine ("sta %s", lbuf);
 940             AddCodeLine ("stx %s+1", lbuf);
 941             AddCodeLine ("ldy sreg");
 942             AddCodeLine ("sty %s+2", lbuf);
 943             AddCodeLine ("ldy sreg+1");
 944             AddCodeLine ("sty %s+3", lbuf);
 945             break;
 946
 947         default:
 948             typeerror (flags);
 949
 950     }
 951 }
 952
 953
 954
 955 void g_putlocal (unsigned Flags, int Offs, long Val)
 956 /* Put data into local object. */
 957 {
 958     Offs -= oursp;
 959     CheckLocalOffs (Offs);
 960     switch (Flags & CF_TYPE) {
 961
 962         case CF_CHAR:
 963             if (Flags & CF_CONST) {
 964                 AddCodeLine ("lda #$%02X", (unsigned char) Val);
 965             }
 966             if (CPU == CPU_65C02 && Offs == 0) {
 967                 AddCodeLine ("sta (sp)");
 968             } else {
 969                 ldyconst (Offs);
 970                 AddCodeLine ("sta (sp),y");
 971             }
 972             break;
 973
 974         case CF_INT:
 975             if (Flags & CF_CONST) {
 976                 ldyconst (Offs+1);
 977                 AddCodeLine ("lda #$%02X", (unsigned char) (Val >> 8));
 978                 AddCodeLine ("sta (sp),y");
 979                 if ((Flags & CF_NOKEEP) == 0) {
 980                     /* Place high byte into X */
 981                     AddCodeLine ("tax");
 982                 }
 983                 if (CPU == CPU_65C02 && Offs == 0) {
 984                     AddCodeLine ("lda #$%02X", (unsigned char) Val);
 985                     AddCodeLine ("sta (sp)");
 986                 } else {
 987                     if ((Val & 0xFF) == Offs+1) {
 988                         /* The value we need is already in Y */
 989                         AddCodeLine ("tya");
 990                         AddCodeLine ("dey");
 991                     } else {
 992                         AddCodeLine ("dey");
 993                         AddCodeLine ("lda #$%02X", (unsigned char) Val);
 994                     }
 995                     AddCodeLine ("sta (sp),y");
 996                 }
 997             } else {
 998                 if ((Flags & CF_NOKEEP) == 0 || CodeSizeFactor < 160) {
 999                     ldyconst (Offs);
1000                     AddCodeLine ("jsr staxysp");
1001                 } else {
1002                     if (CPU == CPU_65C02 && Offs == 0) {
1003                         AddCodeLine ("sta (sp)");
1004                         ldyconst (1);
1005                         AddCodeLine ("txa");
1006                         AddCodeLine ("sta (sp),y");
1007                     } else {
1008                         ldyconst (Offs);
1009                         AddCodeLine ("sta (sp),y");
1010                         AddCodeLine ("iny");
1011                         AddCodeLine ("txa");
1012                         AddCodeLine ("sta (sp),y");
1013                     }
1014                 }
1015             }
1016             break;
1017
1018         case CF_LONG:
1019             if (Flags & CF_CONST) {
1020                 g_getimmed (Flags, Val, 0);
1021             }
1022             ldyconst (Offs);
1023             AddCodeLine ("jsr steaxysp");
1024             break;
1025
1026         default:
1027             typeerror (Flags);
1028
1029     }
1030 }
1031
1032
1033
1034 void g_putind (unsigned Flags, unsigned Offs)
1035 /* Store the specified object type in the primary register at the address
1036  * on the top of the stack
1037  */
1038 {
1039     /* We can handle offsets below $100 directly, larger offsets must be added
1040      * to the address. Since a/x is in use, best code is achieved by adding
1041      * just the high byte. Be sure to check if the low byte will overflow while
1042      * while storing.
1043      */
1044     if ((Offs & 0xFF) > 256 - sizeofarg (Flags | CF_FORCECHAR)) {
1045
1046         /* Overflow - we need to add the low byte also */
1047         AddCodeLine ("ldy #$00");
1048         AddCodeLine ("clc");
1049         AddCodeLine ("pha");
1050         AddCodeLine ("lda #$%02X", Offs & 0xFF);
1051         AddCodeLine ("adc (sp),y");
1052         AddCodeLine ("sta (sp),y");
1053         AddCodeLine ("iny");
1054         AddCodeLine ("lda #$%02X", (Offs >> 8) & 0xFF);
1055         AddCodeLine ("adc (sp),y");
1056         AddCodeLine ("sta (sp),y");
1057         AddCodeLine ("pla");
1058
1059         /* Complete address is on stack, new offset is zero */
1060         Offs = 0;
1061
1062     } else if ((Offs & 0xFF00) != 0) {
1063
1064         /* We can just add the high byte */
1065         AddCodeLine ("ldy #$01");
1066         AddCodeLine ("clc");
1067         AddCodeLine ("pha");
1068         AddCodeLine ("lda #$%02X", (Offs >> 8) & 0xFF);
1069         AddCodeLine ("adc (sp),y");
1070         AddCodeLine ("sta (sp),y");
1071         AddCodeLine ("pla");
1072
1073         /* Offset is now just the low byte */
1074         Offs &= 0x00FF;
1075     }
1076
1077     /* Check the size and determine operation */
1078     switch (Flags & CF_TYPE) {
1079
1080         case CF_CHAR:
1081             ldyconst (Offs);
1082             AddCodeLine ("jsr staspidx");
1083             break;
1084
1085         case CF_INT:
1086             ldyconst (Offs);
1087             AddCodeLine ("jsr staxspidx");
1088             break;
1089
1090         case CF_LONG:
1091             ldyconst (Offs);
1092             AddCodeLine ("jsr steaxspidx");
1093             break;
1094
1095         default:
1096             typeerror (Flags);
1097
1098     }
1099
1100     /* Pop the argument which is always a pointer */
1101     pop (CF_PTR);
1102 }
1103
1104
1105
1106 /*****************************************************************************/
1107 /*                    type conversion and similiar stuff                     */
1108 /*****************************************************************************/
1109
1110
1111
1112 void g_toslong (unsigned flags)
1113 /* Make sure, the value on TOS is a long. Convert if necessary */
1114 {
1115     switch (flags & CF_TYPE) {
1116
1117         case CF_CHAR:
1118         case CF_INT:
1119             if (flags & CF_UNSIGNED) {
1120                 AddCodeLine ("jsr tosulong");
1121             } else {
1122                 AddCodeLine ("jsr toslong");
1123             }
1124             push (CF_INT);
1125             break;
1126
1127         case CF_LONG:
1128             break;
1129
1130         default:
1131             typeerror (flags);
1132     }
1133 }
1134
1135
1136
1137 void g_tosint (unsigned flags)
1138 /* Make sure, the value on TOS is an int. Convert if necessary */
1139 {
1140     switch (flags & CF_TYPE) {
1141
1142         case CF_CHAR:
1143         case CF_INT:
1144             break;
1145
1146         case CF_LONG:
1147             AddCodeLine ("jsr tosint");
1148             pop (CF_INT);
1149             break;
1150
1151         default:
1152             typeerror (flags);
1153     }
1154 }
1155
1156
1157
1158 void g_reglong (unsigned flags)
1159 /* Make sure, the value in the primary register a long. Convert if necessary */
1160 {
1161     switch (flags & CF_TYPE) {
1162
1163         case CF_CHAR:
1164         case CF_INT:
1165             if (flags & CF_UNSIGNED) {
1166                 if (CodeSizeFactor >= 200) {
1167                     ldyconst (0);
1168                     AddCodeLine ("sty sreg");
1169                     AddCodeLine ("sty sreg+1");
1170                 } else {
1171                     AddCodeLine ("jsr axulong");
1172                 }
1173             } else {
1174                 AddCodeLine ("jsr axlong");
1175             }
1176             break;
1177
1178         case CF_LONG:
1179             break;
1180
1181         default:
1182             typeerror (flags);
1183     }
1184 }
1185
1186
1187
1188 unsigned g_typeadjust (unsigned lhs, unsigned rhs)
1189 /* Adjust the integer operands before doing a binary operation. lhs is a flags
1190  * value, that corresponds to the value on TOS, rhs corresponds to the value
1191  * in (e)ax. The return value is the the flags value for the resulting type.
1192  */
1193 {
1194     unsigned ltype, rtype;
1195     unsigned result;
1196
1197     /* Get the type spec from the flags */
1198     ltype = lhs & CF_TYPE;
1199     rtype = rhs & CF_TYPE;
1200
1201     /* Check if a conversion is needed */
1202     if (ltype == CF_LONG && rtype != CF_LONG && (rhs & CF_CONST) == 0) {
1203         /* We must promote the primary register to long */
1204         g_reglong (rhs);
1205         /* Get the new rhs type */
1206         rhs = (rhs & ~CF_TYPE) | CF_LONG;
1207         rtype = CF_LONG;
1208     } else if (ltype != CF_LONG && (lhs & CF_CONST) == 0 && rtype == CF_LONG) {
1209         /* We must promote the lhs to long */
1210         if (lhs & CF_REG) {
1211             g_reglong (lhs);
1212         } else {
1213             g_toslong (lhs);
1214         }
1215         /* Get the new rhs type */
1216         lhs = (lhs & ~CF_TYPE) | CF_LONG;
1217         ltype = CF_LONG;
1218     }
1219
1220     /* Determine the result type for the operation:
1221      *  - The result is const if both operands are const.
1222      *  - The result is unsigned if one of the operands is unsigned.
1223      *  - The result is long if one of the operands is long.
1224      *  - Otherwise the result is int sized.
1225      */
1226     result = (lhs & CF_CONST) & (rhs & CF_CONST);
1227     result |= (lhs & CF_UNSIGNED) | (rhs & CF_UNSIGNED);
1228     if (rtype == CF_LONG || ltype == CF_LONG) {
1229         result |= CF_LONG;
1230     } else {
1231         result |= CF_INT;
1232     }
1233     return result;
1234 }
1235
1236
1237
1238 unsigned g_typecast (unsigned lhs, unsigned rhs)
1239 /* Cast the value in the primary register to the operand size that is flagged
1240  * by the lhs value. Return the result value.
1241  */
1242 {
1243     unsigned ltype, rtype;
1244
1245     /* Get the type spec from the flags */
1246     ltype = lhs & CF_TYPE;
1247     rtype = rhs & CF_TYPE;
1248
1249     /* Check if a conversion is needed */
1250     if (ltype == CF_LONG && rtype != CF_LONG && (rhs & CF_CONST) == 0) {
1251         /* We must promote the primary register to long */
1252         g_reglong (rhs);
1253     }
1254
1255     /* Do not need any other action. If the left type is int, and the primary
1256      * register is long, it will be automagically truncated. If the right hand
1257      * side is const, it is not located in the primary register and handled by
1258      * the expression parser code.
1259      */
1260
1261     /* Result is const if the right hand side was const */
1262     lhs |= (rhs & CF_CONST);
1263
1264     /* The resulting type is that of the left hand side (that's why you called
1265      * this function :-)
1266      */
1267     return lhs;
1268 }
1269
1270
1271
1272 void g_scale (unsigned flags, long val)
1273 /* Scale the value in the primary register by the given value. If val is positive,
1274  * scale up, is val is negative, scale down. This function is used to scale
1275  * the operands or results of pointer arithmetic by the size of the type, the
1276  * pointer points to.
1277  */
1278 {
1279     int p2;
1280
1281     /* Value may not be zero */
1282     if (val == 0) {
1283         Internal ("Data type has no size");
1284     } else if (val > 0) {
1285
1286         /* Scale up */
1287         if ((p2 = powerof2 (val)) > 0 && p2 <= 4) {
1288
1289             /* Factor is 2, 4, 8 and 16, use special function */
1290             switch (flags & CF_TYPE) {
1291
1292                 case CF_CHAR:
1293                     if (flags & CF_FORCECHAR) {
1294                         while (p2--) {
1295                             AddCodeLine ("asl a");
1296                         }
1297                         break;
1298                     }
1299                     /* FALLTHROUGH */
1300
1301                 case CF_INT:
1302                     if (CodeSizeFactor >= (p2+1)*130U) {
1303                         AddCodeLine ("stx tmp1");
1304                         while (p2--) {
1305                             AddCodeLine ("asl a");
1306                             AddCodeLine ("rol tmp1");
1307                         }
1308                         AddCodeLine ("ldx tmp1");
1309                     } else {
1310                         if (flags & CF_UNSIGNED) {
1311                             AddCodeLine ("jsr shlax%d", p2);
1312                         } else {
1313                             AddCodeLine ("jsr aslax%d", p2);
1314                         }
1315                     }
1316                     break;
1317
1318                 case CF_LONG:
1319                     if (flags & CF_UNSIGNED) {
1320                         AddCodeLine ("jsr shleax%d", p2);
1321                     } else {
1322                         AddCodeLine ("jsr asleax%d", p2);
1323                     }
1324                     break;
1325
1326                 default:
1327                     typeerror (flags);
1328
1329             }
1330
1331         } else if (val != 1) {
1332
1333             /* Use a multiplication instead */
1334             g_mul (flags | CF_CONST, val);
1335
1336         }
1337
1338     } else {
1339
1340         /* Scale down */
1341         val = -val;
1342         if ((p2 = powerof2 (val)) > 0 && p2 <= 4) {
1343
1344             /* Factor is 2, 4, 8 and 16 use special function */
1345             switch (flags & CF_TYPE) {
1346
1347                 case CF_CHAR:
1348                     if (flags & CF_FORCECHAR) {
1349                         if (flags & CF_UNSIGNED) {
1350                             while (p2--) {
1351                                 AddCodeLine ("lsr a");
1352                             }
1353                             break;
1354                         } else if (p2 <= 2) {
1355                             AddCodeLine ("cmp #$80");
1356                             AddCodeLine ("ror a");
1357                             break;
1358                         }
1359                     }
1360                     /* FALLTHROUGH */
1361
1362                 case CF_INT:
1363                     if (flags & CF_UNSIGNED) {
1364                         if (CodeSizeFactor >= (p2+1)*130U) {
1365                             AddCodeLine ("stx tmp1");
1366                             while (p2--) {
1367                                 AddCodeLine ("lsr tmp1");
1368                                 AddCodeLine ("ror a");
1369                             }
1370                             AddCodeLine ("ldx tmp1");
1371                         } else {
1372                             AddCodeLine ("jsr lsrax%d", p2);
1373                         }
1374                     } else {
1375                         if (CodeSizeFactor >= (p2+1)*150U) {
1376                             AddCodeLine ("stx tmp1");
1377                             while (p2--) {
1378                                 AddCodeLine ("cpx #$80");
1379                                 AddCodeLine ("ror tmp1");
1380                                 AddCodeLine ("ror a");
1381                             }
1382                             AddCodeLine ("ldx tmp1");
1383                         } else {
1384                             AddCodeLine ("jsr asrax%d", p2);
1385                         }
1386                     }
1387                     break;
1388
1389                 case CF_LONG:
1390                     if (flags & CF_UNSIGNED) {
1391                         AddCodeLine ("jsr lsreax%d", p2);
1392                     } else {
1393                         AddCodeLine ("jsr asreax%d", p2);
1394                     }
1395                     break;
1396
1397                 default:
1398                     typeerror (flags);
1399
1400             }
1401
1402         } else if (val != 1) {
1403
1404             /* Use a division instead */
1405             g_div (flags | CF_CONST, val);
1406
1407         }
1408     }
1409 }
1410
1411
1412
1413 /*****************************************************************************/
1414 /*              Adds and subs of variables fix a fixed address               */
1415 /*****************************************************************************/
1416
1417
1418
1419 void g_addlocal (unsigned flags, int offs)
1420 /* Add a local variable to ax */
1421 {
1422     unsigned L;
1423
1424     /* Correct the offset and check it */
1425     offs -= oursp;
1426     CheckLocalOffs (offs);
1427
1428     switch (flags & CF_TYPE) {
1429
1430         case CF_CHAR:
1431             L = GetLocalLabel();
1432             AddCodeLine ("ldy #$%02X", offs & 0xFF);
1433             AddCodeLine ("clc");
1434             AddCodeLine ("adc (sp),y");
1435             AddCodeLine ("bcc %s", LocalLabelName (L));
1436             AddCodeLine ("inx");
1437             g_defcodelabel (L);
1438             break;
1439
1440         case CF_INT:
1441             AddCodeLine ("ldy #$%02X", offs & 0xFF);
1442             AddCodeLine ("clc");
1443             AddCodeLine ("adc (sp),y");
1444             AddCodeLine ("pha");
1445             AddCodeLine ("txa");
1446             AddCodeLine ("iny");
1447             AddCodeLine ("adc (sp),y");
1448             AddCodeLine ("tax");
1449             AddCodeLine ("pla");
1450             break;
1451
1452         case CF_LONG:
1453             /* Do it the old way */
1454             g_push (flags, 0);
1455             g_getlocal (flags, offs);
1456             g_add (flags, 0);
1457             break;
1458
1459         default:
1460             typeerror (flags);
1461
1462     }
1463 }
1464
1465
1466
1467 void g_addstatic (unsigned flags, unsigned long label, unsigned offs)
1468 /* Add a static variable to ax */
1469 {
1470     unsigned L;
1471
1472     /* Create the correct label name */
1473     char* lbuf = GetLabelName (flags, label, offs);
1474
1475     switch (flags & CF_TYPE) {
1476
1477         case CF_CHAR:
1478             L = GetLocalLabel();
1479             AddCodeLine ("clc");
1480             AddCodeLine ("adc %s", lbuf);
1481             AddCodeLine ("bcc %s", LocalLabelName (L));
1482             AddCodeLine ("inx");
1483             g_defcodelabel (L);
1484             break;
1485
1486         case CF_INT:
1487             AddCodeLine ("clc");
1488             AddCodeLine ("adc %s", lbuf);
1489             AddCodeLine ("tay");
1490             AddCodeLine ("txa");
1491             AddCodeLine ("adc %s+1", lbuf);
1492             AddCodeLine ("tax");
1493             AddCodeLine ("tya");
1494             break;
1495
1496         case CF_LONG:
1497             /* Do it the old way */
1498             g_push (flags, 0);
1499             g_getstatic (flags, label, offs);
1500             g_add (flags, 0);
1501             break;
1502
1503         default:
1504             typeerror (flags);
1505
1506     }
1507 }
1508
1509
1510
1511 /*****************************************************************************/
1512 /*                           Special op= functions                           */
1513 /*****************************************************************************/
1514
1515
1516
1517 void g_addeqstatic (unsigned flags, unsigned long label, unsigned offs,
1518                     unsigned long val)
1519 /* Emit += for a static variable */
1520 {
1521     /* Create the correct label name */
1522     char* lbuf = GetLabelName (flags, label, offs);
1523
1524     /* Check the size and determine operation */
1525     switch (flags & CF_TYPE) {
1526
1527         case CF_CHAR:
1528             if (flags & CF_FORCECHAR) {
1529                 AddCodeLine ("ldx #$00");
1530                 if (flags & CF_CONST) {
1531                     if (val == 1) {
1532                         AddCodeLine ("inc %s", lbuf);
1533                         AddCodeLine ("lda %s", lbuf);
1534                     } else {
1535                         AddCodeLine ("lda #$%02X", (int)(val & 0xFF));
1536                         AddCodeLine ("clc");
1537                         AddCodeLine ("adc %s", lbuf);
1538                         AddCodeLine ("sta %s", lbuf);
1539                     }
1540                 } else {
1541                     AddCodeLine ("clc");
1542                     AddCodeLine ("adc %s", lbuf);
1543                     AddCodeLine ("sta %s", lbuf);
1544                 }
1545                 if ((flags & CF_UNSIGNED) == 0) {
1546                     unsigned L = GetLocalLabel();
1547                     AddCodeLine ("bpl %s", LocalLabelName (L));
1548                     AddCodeLine ("dex");
1549                     g_defcodelabel (L);
1550                 }
1551                 break;
1552             }
1553             /* FALLTHROUGH */
1554
1555         case CF_INT:
1556             if (flags & CF_CONST) {
1557                 if (val == 1) {
1558                     unsigned L = GetLocalLabel ();
1559                     AddCodeLine ("inc %s", lbuf);
1560                     AddCodeLine ("bne %s", LocalLabelName (L));
1561                     AddCodeLine ("inc %s+1", lbuf);
1562                     g_defcodelabel (L);
1563                     AddCodeLine ("lda %s", lbuf);               /* Hmmm... */
1564                     AddCodeLine ("ldx %s+1", lbuf);
1565                 } else {
1566                     AddCodeLine ("lda #$%02X", (int)(val & 0xFF));
1567                     AddCodeLine ("clc");
1568                     AddCodeLine ("adc %s", lbuf);
1569                     AddCodeLine ("sta %s", lbuf);
1570                     if (val < 0x100) {
1571                         unsigned L = GetLocalLabel ();
1572                         AddCodeLine ("bcc %s", LocalLabelName (L));
1573                         AddCodeLine ("inc %s+1", lbuf);
1574                         g_defcodelabel (L);
1575                         AddCodeLine ("ldx %s+1", lbuf);
1576                     } else {
1577                         AddCodeLine ("lda #$%02X", (unsigned char)(val >> 8));
1578                         AddCodeLine ("adc %s+1", lbuf);
1579                         AddCodeLine ("sta %s+1", lbuf);
1580                         AddCodeLine ("tax");
1581                         AddCodeLine ("lda %s", lbuf);
1582                     }
1583                 }
1584             } else {
1585                 AddCodeLine ("clc");
1586                 AddCodeLine ("adc %s", lbuf);
1587                 AddCodeLine ("sta %s", lbuf);
1588                 AddCodeLine ("txa");
1589                 AddCodeLine ("adc %s+1", lbuf);
1590                 AddCodeLine ("sta %s+1", lbuf);
1591                 AddCodeLine ("tax");
1592                 AddCodeLine ("lda %s", lbuf);
1593             }
1594             break;
1595
1596         case CF_LONG:
1597             if (flags & CF_CONST) {
1598                 if (val < 0x100) {
1599                     AddCodeLine ("ldy #<(%s)", lbuf);
1600                     AddCodeLine ("sty ptr1");
1601                     AddCodeLine ("ldy #>(%s+1)", lbuf);
1602                     if (val == 1) {
1603                         AddCodeLine ("jsr laddeq1");
1604                     } else {
1605                         AddCodeLine ("lda #$%02X", (int)(val & 0xFF));
1606                         AddCodeLine ("jsr laddeqa");
1607                     }
1608                 } else {
1609                     g_getstatic (flags, label, offs);
1610                     g_inc (flags, val);
1611                     g_putstatic (flags, label, offs);
1612                 }
1613             } else {
1614                 AddCodeLine ("ldy #<(%s)", lbuf);
1615                 AddCodeLine ("sty ptr1");
1616                 AddCodeLine ("ldy #>(%s+1)", lbuf);
1617                 AddCodeLine ("jsr laddeq");
1618             }
1619             break;
1620
1621         default:
1622             typeerror (flags);
1623     }
1624 }
1625
1626
1627
1628 void g_addeqlocal (unsigned flags, int offs, unsigned long val)
1629 /* Emit += for a local variable */
1630 {
1631     /* Calculate the true offset, check it, load it into Y */
1632     offs -= oursp;
1633     CheckLocalOffs (offs);
1634
1635     /* Check the size and determine operation */
1636     switch (flags & CF_TYPE) {
1637
1638         case CF_CHAR:
1639             if (flags & CF_FORCECHAR) {
1640                 ldyconst (offs);
1641                 AddCodeLine ("ldx #$00");
1642                 if (flags & CF_CONST) {
1643                     AddCodeLine ("clc");
1644                     AddCodeLine ("lda #$%02X", (int)(val & 0xFF));
1645                     AddCodeLine ("adc (sp),y");
1646                     AddCodeLine ("sta (sp),y");
1647                 } else {
1648                     AddCodeLine ("clc");
1649                     AddCodeLine ("adc (sp),y");
1650                     AddCodeLine ("sta (sp),y");
1651                 }
1652                 if ((flags & CF_UNSIGNED) == 0) {
1653                     unsigned L = GetLocalLabel();
1654                     AddCodeLine ("bpl %s", LocalLabelName (L));
1655                     AddCodeLine ("dex");
1656                     g_defcodelabel (L);
1657                 }
1658                 break;
1659             }
1660             /* FALLTHROUGH */
1661
1662         case CF_INT:
1663             ldyconst (offs);
1664             if (flags & CF_CONST) {
1665                 if (CodeSizeFactor >= 400) {
1666                     AddCodeLine ("clc");
1667                     AddCodeLine ("lda #$%02X", (int)(val & 0xFF));
1668                     AddCodeLine ("adc (sp),y");
1669                     AddCodeLine ("sta (sp),y");
1670                     AddCodeLine ("iny");
1671                     AddCodeLine ("lda #$%02X", (int) ((val >> 8) & 0xFF));
1672                     AddCodeLine ("adc (sp),y");
1673                     AddCodeLine ("sta (sp),y");
1674                     AddCodeLine ("tax");
1675                     AddCodeLine ("dey");
1676                     AddCodeLine ("lda (sp),y");
1677                 } else {
1678                     g_getimmed (flags, val, 0);
1679                     AddCodeLine ("jsr addeqysp");
1680                 }
1681             } else {
1682                 AddCodeLine ("jsr addeqysp");
1683             }
1684             break;
1685
1686         case CF_LONG:
1687             if (flags & CF_CONST) {
1688                 g_getimmed (flags, val, 0);
1689             }
1690             ldyconst (offs);
1691             AddCodeLine ("jsr laddeqysp");
1692             break;
1693
1694         default:
1695             typeerror (flags);
1696     }
1697 }
1698
1699
1700
1701 void g_addeqind (unsigned flags, unsigned offs, unsigned long val)
1702 /* Emit += for the location with address in ax */
1703 {
1704     /* If the offset is too large for a byte register, add the high byte
1705      * of the offset to the primary. Beware: We need a special correction
1706      * if the offset in the low byte will overflow in the operation.
1707      */
1708     offs = MakeByteOffs (flags, offs);
1709
1710     /* Check the size and determine operation */
1711     switch (flags & CF_TYPE) {
1712
1713         case CF_CHAR:
1714             AddCodeLine ("sta ptr1");
1715             AddCodeLine ("stx ptr1+1");
1716             AddCodeLine ("ldy #$%02X", offs);
1717             AddCodeLine ("ldx #$00");
1718             AddCodeLine ("lda #$%02X", (int)(val & 0xFF));
1719             AddCodeLine ("clc");
1720             AddCodeLine ("adc (ptr1),y");
1721             AddCodeLine ("sta (ptr1),y");
1722             break;
1723
1724         case CF_INT:
1725             if (CodeSizeFactor >= 200) {
1726                 /* Lots of code, use only if size is not important */
1727                 AddCodeLine ("sta ptr1");
1728                 AddCodeLine ("stx ptr1+1");
1729                 AddCodeLine ("ldy #$%02X", offs);
1730                 AddCodeLine ("lda #$%02X", (int)(val & 0xFF));
1731                 AddCodeLine ("clc");
1732                 AddCodeLine ("adc (ptr1),y");
1733                 AddCodeLine ("sta (ptr1),y");
1734                 AddCodeLine ("pha");
1735                 AddCodeLine ("iny");
1736                 AddCodeLine ("lda #$%02X", (unsigned char)(val >> 8));
1737                 AddCodeLine ("adc (ptr1),y");
1738                 AddCodeLine ("sta (ptr1),y");
1739                 AddCodeLine ("tax");
1740                 AddCodeLine ("pla");
1741                 break;
1742             }
1743             /* FALL THROUGH */
1744
1745         case CF_LONG:
1746             AddCodeLine ("jsr pushax");         /* Push the address */
1747             push (CF_PTR);                      /* Correct the internal sp */
1748             g_getind (flags, offs);             /* Fetch the value */
1749             g_inc (flags, val);                 /* Increment value in primary */
1750             g_putind (flags, offs);             /* Store the value back */
1751             break;
1752
1753         default:
1754             typeerror (flags);
1755     }
1756 }
1757
1758
1759
1760 void g_subeqstatic (unsigned flags, unsigned long label, unsigned offs,
1761                     unsigned long val)
1762 /* Emit -= for a static variable */
1763 {
1764     /* Create the correct label name */
1765     char* lbuf = GetLabelName (flags, label, offs);
1766
1767     /* Check the size and determine operation */
1768     switch (flags & CF_TYPE) {
1769
1770         case CF_CHAR:
1771             if (flags & CF_FORCECHAR) {
1772                 AddCodeLine ("ldx #$00");
1773                 if (flags & CF_CONST) {
1774                     if (val == 1) {
1775                         AddCodeLine ("dec %s", lbuf);
1776                         AddCodeLine ("lda %s", lbuf);
1777                     } else {
1778                         AddCodeLine ("sec");
1779                         AddCodeLine ("lda %s", lbuf);
1780                         AddCodeLine ("sbc #$%02X", (int)(val & 0xFF));
1781                         AddCodeLine ("sta %s", lbuf);
1782                     }
1783                 } else {
1784                     AddCodeLine ("sec");
1785                     AddCodeLine ("sta tmp1");
1786                     AddCodeLine ("lda %s", lbuf);
1787                     AddCodeLine ("sbc tmp1");
1788                     AddCodeLine ("sta %s", lbuf);
1789                 }
1790                 if ((flags & CF_UNSIGNED) == 0) {
1791                     unsigned L = GetLocalLabel();
1792                     AddCodeLine ("bpl %s", LocalLabelName (L));
1793                     AddCodeLine ("dex");
1794                     g_defcodelabel (L);
1795                 }
1796                 break;
1797             }
1798             /* FALLTHROUGH */
1799
1800         case CF_INT:
1801             AddCodeLine ("sec");
1802             if (flags & CF_CONST) {
1803                 AddCodeLine ("lda %s", lbuf);
1804                 AddCodeLine ("sbc #$%02X", (unsigned char)val);
1805                 AddCodeLine ("sta %s", lbuf);
1806                 if (val < 0x100) {
1807                     unsigned L = GetLocalLabel ();
1808                     AddCodeLine ("bcs %s", LocalLabelName (L));
1809                     AddCodeLine ("dec %s+1", lbuf);
1810                     g_defcodelabel (L);
1811                     AddCodeLine ("ldx %s+1", lbuf);
1812                 } else {
1813                     AddCodeLine ("lda %s+1", lbuf);
1814                     AddCodeLine ("sbc #$%02X", (unsigned char)(val >> 8));
1815                     AddCodeLine ("sta %s+1", lbuf);
1816                     AddCodeLine ("tax");
1817                     AddCodeLine ("lda %s", lbuf);
1818                 }
1819             } else {
1820                 AddCodeLine ("sta tmp1");
1821                 AddCodeLine ("lda %s", lbuf);
1822                 AddCodeLine ("sbc tmp1");
1823                 AddCodeLine ("sta %s", lbuf);
1824                 AddCodeLine ("stx tmp1");
1825                 AddCodeLine ("lda %s+1", lbuf);
1826                 AddCodeLine ("sbc tmp1");
1827                 AddCodeLine ("sta %s+1", lbuf);
1828                 AddCodeLine ("tax");
1829                 AddCodeLine ("lda %s", lbuf);
1830             }
1831             break;
1832
1833         case CF_LONG:
1834             if (flags & CF_CONST) {
1835                 if (val < 0x100) {
1836                     AddCodeLine ("ldy #<(%s)", lbuf);
1837                     AddCodeLine ("sty ptr1");
1838                     AddCodeLine ("ldy #>(%s+1)", lbuf);
1839                     AddCodeLine ("lda #$%02X", (unsigned char)val);
1840                     AddCodeLine ("jsr lsubeqa");
1841                 } else {
1842                     g_getstatic (flags, label, offs);
1843                     g_dec (flags, val);
1844                     g_putstatic (flags, label, offs);
1845                 }
1846             } else {
1847                 AddCodeLine ("ldy #<(%s)", lbuf);
1848                 AddCodeLine ("sty ptr1");
1849                 AddCodeLine ("ldy #>(%s+1)", lbuf);
1850                 AddCodeLine ("jsr lsubeq");
1851             }
1852             break;
1853
1854         default:
1855             typeerror (flags);
1856     }
1857 }
1858
1859
1860
1861 void g_subeqlocal (unsigned flags, int offs, unsigned long val)
1862 /* Emit -= for a local variable */
1863 {
1864     /* Calculate the true offset, check it, load it into Y */
1865     offs -= oursp;
1866     CheckLocalOffs (offs);
1867
1868     /* Check the size and determine operation */
1869     switch (flags & CF_TYPE) {
1870
1871         case CF_CHAR:
1872             if (flags & CF_FORCECHAR) {
1873                 ldyconst (offs);
1874                 AddCodeLine ("ldx #$00");
1875                 AddCodeLine ("sec");
1876                 if (flags & CF_CONST) {
1877                     AddCodeLine ("lda (sp),y");
1878                     AddCodeLine ("sbc #$%02X", (unsigned char)val);
1879                 } else {
1880                     AddCodeLine ("sta tmp1");
1881                     AddCodeLine ("lda (sp),y");
1882                     AddCodeLine ("sbc tmp1");
1883                 }
1884                 AddCodeLine ("sta (sp),y");
1885                 if ((flags & CF_UNSIGNED) == 0) {
1886                     unsigned L = GetLocalLabel();
1887                     AddCodeLine ("bpl %s", LocalLabelName (L));
1888                     AddCodeLine ("dex");
1889                     g_defcodelabel (L);
1890                 }
1891                 break;
1892             }
1893             /* FALLTHROUGH */
1894
1895         case CF_INT:
1896             if (flags & CF_CONST) {
1897                 g_getimmed (flags, val, 0);
1898             }
1899             ldyconst (offs);
1900             AddCodeLine ("jsr subeqysp");
1901             break;
1902
1903         case CF_LONG:
1904             if (flags & CF_CONST) {
1905                 g_getimmed (flags, val, 0);
1906             }
1907             ldyconst (offs);
1908             AddCodeLine ("jsr lsubeqysp");
1909             break;
1910
1911         default:
1912             typeerror (flags);
1913     }
1914 }
1915
1916
1917
1918 void g_subeqind (unsigned flags, unsigned offs, unsigned long val)
1919 /* Emit -= for the location with address in ax */
1920 {
1921     /* If the offset is too large for a byte register, add the high byte
1922      * of the offset to the primary. Beware: We need a special correction
1923      * if the offset in the low byte will overflow in the operation.
1924      */
1925     offs = MakeByteOffs (flags, offs);
1926
1927     /* Check the size and determine operation */
1928     switch (flags & CF_TYPE) {
1929
1930         case CF_CHAR:
1931             AddCodeLine ("sta ptr1");
1932             AddCodeLine ("stx ptr1+1");
1933             AddCodeLine ("ldy #$%02X", offs);
1934             AddCodeLine ("ldx #$00");
1935             AddCodeLine ("lda (ptr1),y");
1936             AddCodeLine ("sec");
1937             AddCodeLine ("sbc #$%02X", (unsigned char)val);
1938             AddCodeLine ("sta (ptr1),y");
1939             break;
1940
1941         case CF_INT:
1942             if (CodeSizeFactor >= 200) {
1943                 /* Lots of code, use only if size is not important */
1944                 AddCodeLine ("sta ptr1");
1945                 AddCodeLine ("stx ptr1+1");
1946                 AddCodeLine ("ldy #$%02X", offs);
1947                 AddCodeLine ("lda (ptr1),y");
1948                 AddCodeLine ("sec");
1949                 AddCodeLine ("sbc #$%02X", (unsigned char)val);
1950                 AddCodeLine ("sta (ptr1),y");
1951                 AddCodeLine ("pha");
1952                 AddCodeLine ("iny");
1953                 AddCodeLine ("lda (ptr1),y");
1954                 AddCodeLine ("sbc #$%02X", (unsigned char)(val >> 8));
1955                 AddCodeLine ("sta (ptr1),y");
1956                 AddCodeLine ("tax");
1957                 AddCodeLine ("pla");
1958                 break;
1959             }
1960             /* FALL THROUGH */
1961
1962         case CF_LONG:
1963             AddCodeLine ("jsr pushax");         /* Push the address */
1964             push (CF_PTR);                      /* Correct the internal sp */
1965             g_getind (flags, offs);             /* Fetch the value */
1966             g_dec (flags, val);                 /* Increment value in primary */
1967             g_putind (flags, offs);             /* Store the value back */
1968             break;
1969
1970         default:
1971             typeerror (flags);
1972     }
1973 }
1974
1975
1976
1977 /*****************************************************************************/
1978 /*                 Add a variable address to the value in ax                 */
1979 /*****************************************************************************/
1980
1981
1982
1983 void g_addaddr_local (unsigned flags attribute ((unused)), int offs)
1984 /* Add the address of a local variable to ax */
1985 {
1986     unsigned L = 0;
1987
1988     /* Add the offset */
1989     offs -= oursp;
1990     if (offs != 0) {
1991         /* We cannot address more then 256 bytes of locals anyway */
1992         L = GetLocalLabel();
1993         CheckLocalOffs (offs);
1994         AddCodeLine ("clc");
1995         AddCodeLine ("adc #$%02X", offs & 0xFF);
1996         /* Do also skip the CLC insn below */
1997         AddCodeLine ("bcc %s", LocalLabelName (L));
1998         AddCodeLine ("inx");
1999     }
2000
2001     /* Add the current stackpointer value */
2002     AddCodeLine ("clc");
2003     if (L != 0) {
2004         /* Label was used above */
2005         g_defcodelabel (L);
2006     }
2007     AddCodeLine ("adc sp");
2008     AddCodeLine ("tay");
2009     AddCodeLine ("txa");
2010     AddCodeLine ("adc sp+1");
2011     AddCodeLine ("tax");
2012     AddCodeLine ("tya");
2013 }
2014
2015
2016
2017 void g_addaddr_static (unsigned flags, unsigned long label, unsigned offs)
2018 /* Add the address of a static variable to ax */
2019 {
2020     /* Create the correct label name */
2021     char* lbuf = GetLabelName (flags, label, offs);
2022
2023     /* Add the address to the current ax value */
2024     AddCodeLine ("clc");
2025     AddCodeLine ("adc #<(%s)", lbuf);
2026     AddCodeLine ("tay");
2027     AddCodeLine ("txa");
2028     AddCodeLine ("adc #>(%s)", lbuf);
2029     AddCodeLine ("tax");
2030     AddCodeLine ("tya");
2031 }
2032
2033
2034
2035 /*****************************************************************************/
2036 /*                                                                           */
2037 /*****************************************************************************/
2038
2039
2040
2041 void g_save (unsigned flags)
2042 /* Copy primary register to hold register. */
2043 {
2044     /* Check the size and determine operation */
2045     switch (flags & CF_TYPE) {
2046
2047         case CF_CHAR:
2048             if (flags & CF_FORCECHAR) {
2049                 AddCodeLine ("pha");
2050                 break;
2051             }
2052             /* FALLTHROUGH */
2053
2054         case CF_INT:
2055             AddCodeLine ("sta regsave");
2056             AddCodeLine ("stx regsave+1");
2057             break;
2058
2059         case CF_LONG:
2060             AddCodeLine ("jsr saveeax");
2061             break;
2062
2063         default:
2064             typeerror (flags);
2065     }
2066 }
2067
2068
2069
2070 void g_restore (unsigned flags)
2071 /* Copy hold register to primary. */
2072 {
2073     /* Check the size and determine operation */
2074     switch (flags & CF_TYPE) {
2075
2076         case CF_CHAR:
2077             if (flags & CF_FORCECHAR) {
2078                 AddCodeLine ("pla");
2079                 break;
2080             }
2081             /* FALLTHROUGH */
2082
2083         case CF_INT:
2084             AddCodeLine ("lda regsave");
2085             AddCodeLine ("ldx regsave+1");
2086             break;
2087
2088         case CF_LONG:
2089             AddCodeLine ("jsr resteax");
2090             break;
2091
2092         default:
2093             typeerror (flags);
2094     }
2095 }
2096
2097
2098
2099 void g_cmp (unsigned flags, unsigned long val)
2100 /* Immidiate compare. The primary register will not be changed, Z flag
2101  * will be set.
2102  */
2103 {
2104     unsigned L;
2105
2106     /* Check the size and determine operation */
2107     switch (flags & CF_TYPE) {
2108
2109         case CF_CHAR:
2110             if (flags & CF_FORCECHAR) {
2111                 AddCodeLine ("cmp #$%02X", (unsigned char)val);
2112                 break;
2113             }
2114             /* FALLTHROUGH */
2115
2116         case CF_INT:
2117             L = GetLocalLabel();
2118             AddCodeLine ("cmp #$%02X", (unsigned char)val);
2119             AddCodeLine ("bne %s", LocalLabelName (L));
2120             AddCodeLine ("cpx #$%02X", (unsigned char)(val >> 8));
2121             g_defcodelabel (L);
2122             break;
2123
2124         case CF_LONG:
2125             Internal ("g_cmp: Long compares not implemented");
2126             break;
2127
2128         default:
2129             typeerror (flags);
2130     }
2131 }
2132
2133
2134
2135 static void oper (unsigned flags, unsigned long val, char** subs)
2136 /* Encode a binary operation. subs is a pointer to four groups of three
2137  * strings:
2138  *      0-2     --> Operate on ints
2139  *      3-5     --> Operate on unsigneds
2140  *      6-8     --> Operate on longs
2141  *      9-11    --> Operate on unsigned longs
2142  *
2143  * The first subroutine names in each string group is used to encode an
2144  * operation with a zero constant, the second to encode an operation with
2145  * a 8 bit constant, and the third is used in all other cases.
2146  */
2147 {
2148     unsigned offs;
2149
2150     /* Determine the offset into the array */
2151     offs = (flags & CF_UNSIGNED)? 3 : 0;
2152     switch (flags & CF_TYPE) {
2153         case CF_CHAR:
2154         case CF_INT:
2155             break;
2156
2157         case CF_LONG:
2158             offs += 6;
2159             break;
2160
2161         default:
2162             typeerror (flags);
2163     }
2164
2165     /* Encode the operation */
2166     if (flags & CF_CONST) {
2167         /* Constant value given */
2168         if (val == 0 && subs [offs+0]) {
2169             /* Special case: constant with value zero */
2170             AddCodeLine ("jsr %s", subs [offs+0]);
2171         } else if (val < 0x100 && subs [offs+1]) {
2172             /* Special case: constant with high byte zero */
2173             ldaconst (val);             /* Load low byte */
2174             AddCodeLine ("jsr %s", subs [offs+1]);
2175         } else {
2176             /* Others: arbitrary constant value */
2177             g_getimmed (flags, val, 0);                 /* Load value */
2178             AddCodeLine ("jsr %s", subs [offs+2]);
2179         }
2180     } else {
2181         /* Value not constant (is already in (e)ax) */
2182         AddCodeLine ("jsr %s", subs [offs+2]);
2183     }
2184
2185     /* The operation will pop it's argument */
2186     pop (flags);
2187 }
2188
2189
2190
2191 void g_test (unsigned flags)
2192 /* Test the value in the primary and set the condition codes */
2193 {
2194     switch (flags & CF_TYPE) {
2195
2196         case CF_CHAR:
2197             if (flags & CF_FORCECHAR) {
2198                 AddCodeLine ("tax");
2199                 break;
2200             }
2201             /* FALLTHROUGH */
2202
2203         case CF_INT:
2204             AddCodeLine ("stx tmp1");
2205             AddCodeLine ("ora tmp1");
2206             break;
2207
2208         case CF_LONG:
2209             if (flags & CF_UNSIGNED) {
2210                 AddCodeLine ("jsr utsteax");
2211             } else {
2212                 AddCodeLine ("jsr tsteax");
2213             }
2214             break;
2215
2216         default:
2217             typeerror (flags);
2218
2219     }
2220 }
2221
2222
2223
2224 void g_push (unsigned flags, unsigned long val)
2225 /* Push the primary register or a constant value onto the stack */
2226 {
2227     if (flags & CF_CONST && (flags & CF_TYPE) != CF_LONG) {
2228
2229         /* We have a constant 8 or 16 bit value */
2230         if ((flags & CF_TYPE) == CF_CHAR && (flags & CF_FORCECHAR)) {
2231
2232             /* Handle as 8 bit value */
2233             ldaconst (val);
2234             AddCodeLine ("jsr pusha");
2235
2236         } else {
2237
2238             /* Handle as 16 bit value */
2239             g_getimmed (flags, val, 0);
2240             AddCodeLine ("jsr pushax");
2241         }
2242
2243     } else {
2244
2245         /* Value is not 16 bit or not constant */
2246         if (flags & CF_CONST) {
2247             /* Constant 32 bit value, load into eax */
2248             g_getimmed (flags, val, 0);
2249         }
2250
2251         /* Push the primary register */
2252         switch (flags & CF_TYPE) {
2253
2254             case CF_CHAR:
2255                 if (flags & CF_FORCECHAR) {
2256                     /* Handle as char */
2257                     AddCodeLine ("jsr pusha");
2258                     break;
2259                 }
2260                 /* FALL THROUGH */
2261             case CF_INT:
2262                 AddCodeLine ("jsr pushax");
2263                 break;
2264
2265             case CF_LONG:
2266                 AddCodeLine ("jsr pusheax");
2267                 break;
2268
2269             default:
2270                 typeerror (flags);
2271
2272         }
2273
2274     }
2275
2276     /* Adjust the stack offset */
2277     push (flags);
2278 }
2279
2280
2281
2282 void g_swap (unsigned flags)
2283 /* Swap the primary register and the top of the stack. flags give the type
2284  * of *both* values (must have same size).
2285  */
2286 {
2287     switch (flags & CF_TYPE) {
2288
2289         case CF_CHAR:
2290         case CF_INT:
2291             AddCodeLine ("jsr swapstk");
2292             break;
2293
2294         case CF_LONG:
2295             AddCodeLine ("jsr swapestk");
2296             break;
2297
2298         default:
2299             typeerror (flags);
2300
2301     }
2302 }
2303
2304
2305
2306 void g_call (unsigned Flags, const char* Label, unsigned ArgSize)
2307 /* Call the specified subroutine name */
2308 {
2309     if ((Flags & CF_FIXARGC) == 0) {
2310         /* Pass the argument count */
2311         ldyconst (ArgSize);
2312     }
2313     AddCodeLine ("jsr _%s", Label);
2314     oursp += ArgSize;           /* callee pops args */
2315 }
2316
2317
2318
2319 void g_callind (unsigned Flags, unsigned ArgSize, int Offs)
2320 /* Call subroutine indirect */
2321 {
2322     if ((Flags & CF_LOCAL) == 0) {
2323         /* Address is in a/x */
2324         if ((Flags & CF_FIXARGC) == 0) {
2325             /* Pass arg count */
2326             ldyconst (ArgSize);
2327         }
2328         AddCodeLine ("jsr callax");
2329     } else {
2330         /* The address is on stack, offset is on Val */
2331         Offs -= oursp;
2332         CheckLocalOffs (Offs);
2333         AddCodeLine ("pha");
2334         AddCodeLine ("ldy #$%02X", Offs);
2335         AddCodeLine ("lda (sp),y");
2336         AddCodeLine ("sta jmpvec+1");
2337         AddCodeLine ("iny");
2338         AddCodeLine ("lda (sp),y");
2339         AddCodeLine ("sta jmpvec+2");
2340         AddCodeLine ("pla");
2341         AddCodeLine ("jsr jmpvec");
2342     }
2343
2344     /* Callee pops args */
2345     oursp += ArgSize;
2346 }
2347
2348
2349
2350 void g_jump (unsigned Label)
2351 /* Jump to specified internal label number */
2352 {
2353     AddCodeLine ("jmp %s", LocalLabelName (Label));
2354 }
2355
2356
2357
2358 void g_truejump (unsigned flags attribute ((unused)), unsigned label)
2359 /* Jump to label if zero flag clear */
2360 {
2361     AddCodeLine ("jne %s", LocalLabelName (label));
2362 }
2363
2364
2365
2366 void g_falsejump (unsigned flags attribute ((unused)), unsigned label)
2367 /* Jump to label if zero flag set */
2368 {
2369     AddCodeLine ("jeq %s", LocalLabelName (label));
2370 }
2371
2372
2373
2374 static void mod_internal (int k, char* verb1, char* verb2)
2375 {
2376     if (k <= 8) {
2377         AddCodeLine ("jsr %ssp%c", verb1, k + '0');
2378     } else {
2379         CheckLocalOffs (k);
2380         ldyconst (k);
2381         AddCodeLine ("jsr %ssp", verb2);
2382     }
2383 }
2384
2385
2386
2387 void g_space (int space)
2388 /* Create or drop space on the stack */
2389 {
2390     if (space < 0) {
2391         mod_internal (-space, "inc", "addy");
2392     } else if (space > 0) {
2393         mod_internal (space, "dec", "suby");
2394     }
2395 }
2396
2397
2398
2399 void g_cstackcheck (void)
2400 /* Check for a C stack overflow */
2401 {
2402     AddCodeLine ("jsr cstkchk");
2403 }
2404
2405
2406
2407 void g_stackcheck (void)
2408 /* Check for a stack overflow */
2409 {
2410     AddCodeLine ("jsr stkchk");
2411 }
2412
2413
2414
2415 void g_add (unsigned flags, unsigned long val)
2416 /* Primary = TOS + Primary */
2417 {
2418     static char* ops [12] = {
2419         0,              "tosadda0",     "tosaddax",
2420         0,              "tosadda0",     "tosaddax",
2421         0,              0,              "tosaddeax",
2422         0,              0,              "tosaddeax",
2423     };
2424
2425     if (flags & CF_CONST) {
2426         flags &= ~CF_FORCECHAR; /* Handle chars as ints */
2427         g_push (flags & ~CF_CONST, 0);
2428     }
2429     oper (flags, val, ops);
2430 }
2431
2432
2433
2434 void g_sub (unsigned flags, unsigned long val)
2435 /* Primary = TOS - Primary */
2436 {
2437     static char* ops [12] = {
2438         0,              "tossuba0",     "tossubax",
2439         0,              "tossuba0",     "tossubax",
2440         0,              0,              "tossubeax",
2441         0,              0,              "tossubeax",
2442     };
2443
2444     if (flags & CF_CONST) {
2445         flags &= ~CF_FORCECHAR; /* Handle chars as ints */
2446         g_push (flags & ~CF_CONST, 0);
2447     }
2448     oper (flags, val, ops);
2449 }
2450
2451
2452
2453 void g_rsub (unsigned flags, unsigned long val)
2454 /* Primary = Primary - TOS */
2455 {
2456     static char* ops [12] = {
2457         0,              "tosrsuba0",    "tosrsubax",
2458         0,              "tosrsuba0",    "tosrsubax",
2459         0,              0,              "tosrsubeax",
2460         0,              0,              "tosrsubeax",
2461     };
2462     oper (flags, val, ops);
2463 }
2464
2465
2466
2467 void g_mul (unsigned flags, unsigned long val)
2468 /* Primary = TOS * Primary */
2469 {
2470     static char* ops [12] = {
2471         0,              "tosmula0",     "tosmulax",
2472         0,              "tosumula0",    "tosumulax",
2473         0,              0,              "tosmuleax",
2474         0,              0,              "tosumuleax",
2475     };
2476
2477     int p2;
2478
2479     /* Do strength reduction if the value is constant and a power of two */
2480     if (flags & CF_CONST && (p2 = powerof2 (val)) >= 0) {
2481         /* Generate a shift instead */
2482         g_asl (flags, p2);
2483         return;
2484     }
2485
2486     /* If the right hand side is const, the lhs is not on stack but still
2487      * in the primary register.
2488      */
2489     if (flags & CF_CONST) {
2490
2491         switch (flags & CF_TYPE) {
2492
2493             case CF_CHAR:
2494                 if (flags & CF_FORCECHAR) {
2495                     /* Handle some special cases */
2496                     switch (val) {
2497
2498                         case 3:
2499                             AddCodeLine ("sta tmp1");
2500                             AddCodeLine ("asl a");
2501                             AddCodeLine ("clc");
2502                             AddCodeLine ("adc tmp1");
2503                             return;
2504
2505                         case 5:
2506                             AddCodeLine ("sta tmp1");
2507                             AddCodeLine ("asl a");
2508                             AddCodeLine ("asl a");
2509                             AddCodeLine ("clc");
2510                             AddCodeLine ("adc tmp1");
2511                             return;
2512
2513                         case 10:
2514                             AddCodeLine ("sta tmp1");
2515                             AddCodeLine ("asl a");
2516                             AddCodeLine ("asl a");
2517                             AddCodeLine ("clc");
2518                             AddCodeLine ("adc tmp1");
2519                             AddCodeLine ("asl a");
2520                             return;
2521                     }
2522                 }
2523                 /* FALLTHROUGH */
2524
2525             case CF_INT:
2526                 switch (val) {
2527                     case 3:
2528                         AddCodeLine ("jsr mulax3");
2529                         return;
2530                     case 5:
2531                         AddCodeLine ("jsr mulax5");
2532                         return;
2533                     case 10:
2534                         AddCodeLine ("jsr mulax10");
2535                         return;
2536                 }
2537                 break;
2538
2539             case CF_LONG:
2540                 break;
2541
2542             default:
2543                 typeerror (flags);
2544         }
2545
2546         /* If we go here, we didn't emit code. Push the lhs on stack and fall
2547          * into the normal, non-optimized stuff.
2548          */
2549         flags &= ~CF_FORCECHAR; /* Handle chars as ints */
2550         g_push (flags & ~CF_CONST, 0);
2551
2552     }
2553
2554     /* Use long way over the stack */
2555     oper (flags, val, ops);
2556 }
2557
2558
2559
2560 void g_div (unsigned flags, unsigned long val)
2561 /* Primary = TOS / Primary */
2562 {
2563     static char* ops [12] = {
2564         0,              "tosdiva0",     "tosdivax",
2565         0,              "tosudiva0",    "tosudivax",
2566         0,              0,              "tosdiveax",
2567         0,              0,              "tosudiveax",
2568     };
2569
2570     /* Do strength reduction if the value is constant and a power of two */
2571     int p2;
2572     if ((flags & CF_CONST) && (p2 = powerof2 (val)) >= 0) {
2573         /* Generate a shift instead */
2574         g_asr (flags, p2);
2575     } else {
2576         /* Generate a division */
2577         if (flags & CF_CONST) {
2578             /* lhs is not on stack */
2579             flags &= ~CF_FORCECHAR;     /* Handle chars as ints */
2580             g_push (flags & ~CF_CONST, 0);
2581         }
2582         oper (flags, val, ops);
2583     }
2584 }
2585
2586
2587
2588 void g_mod (unsigned flags, unsigned long val)
2589 /* Primary = TOS % Primary */
2590 {
2591     static char* ops [12] = {
2592         0,              "tosmoda0",     "tosmodax",
2593         0,              "tosumoda0",    "tosumodax",
2594         0,              0,              "tosmodeax",
2595         0,              0,              "tosumodeax",
2596     };
2597     int p2;
2598
2599     /* Check if we can do some cost reduction */
2600     if ((flags & CF_CONST) && (flags & CF_UNSIGNED) && val != 0xFFFFFFFF && (p2 = powerof2 (val)) >= 0) {
2601         /* We can do that with an AND operation */
2602         g_and (flags, val - 1);
2603     } else {
2604         /* Do it the hard way... */
2605         if (flags & CF_CONST) {
2606             /* lhs is not on stack */
2607             flags &= ~CF_FORCECHAR;     /* Handle chars as ints */
2608             g_push (flags & ~CF_CONST, 0);
2609         }
2610         oper (flags, val, ops);
2611     }
2612 }
2613
2614
2615
2616 void g_or (unsigned flags, unsigned long val)
2617 /* Primary = TOS | Primary */
2618 {
2619     static char* ops [12] = {
2620         0,              "tosora0",      "tosorax",
2621         0,              "tosora0",      "tosorax",
2622         0,              0,              "tosoreax",
2623         0,              0,              "tosoreax",
2624     };
2625
2626     /* If the right hand side is const, the lhs is not on stack but still
2627      * in the primary register.
2628      */
2629     if (flags & CF_CONST) {
2630
2631         switch (flags & CF_TYPE) {
2632
2633             case CF_CHAR:
2634                 if (flags & CF_FORCECHAR) {
2635                     if ((val & 0xFF) != 0xFF) {
2636                         AddCodeLine ("ora #$%02X", (unsigned char)val);
2637                     }
2638                     return;
2639                 }
2640                 /* FALLTHROUGH */
2641
2642             case CF_INT:
2643                 if (val <= 0xFF) {
2644                     AddCodeLine ("ora #$%02X", (unsigned char)val);
2645                     return;
2646                 }
2647                 break;
2648
2649             case CF_LONG:
2650                 if (val <= 0xFF) {
2651                     AddCodeLine ("ora #$%02X", (unsigned char)val);
2652                     return;
2653                 }
2654                 break;
2655
2656             default:
2657                 typeerror (flags);
2658         }
2659
2660         /* If we go here, we didn't emit code. Push the lhs on stack and fall
2661          * into the normal, non-optimized stuff.
2662          */
2663         g_push (flags & ~CF_CONST, 0);
2664
2665     }
2666
2667     /* Use long way over the stack */
2668     oper (flags, val, ops);
2669 }
2670
2671
2672
2673 void g_xor (unsigned flags, unsigned long val)
2674 /* Primary = TOS ^ Primary */
2675 {
2676     static char* ops [12] = {
2677         0,              "tosxora0",     "tosxorax",
2678         0,              "tosxora0",     "tosxorax",
2679         0,              0,              "tosxoreax",
2680         0,              0,              "tosxoreax",
2681     };
2682
2683
2684     /* If the right hand side is const, the lhs is not on stack but still
2685      * in the primary register.
2686      */
2687     if (flags & CF_CONST) {
2688
2689         switch (flags & CF_TYPE) {
2690
2691             case CF_CHAR:
2692                 if (flags & CF_FORCECHAR) {
2693                     if ((val & 0xFF) != 0) {
2694                         AddCodeLine ("eor #$%02X", (unsigned char)val);
2695                     }
2696                     return;
2697                 }
2698                 /* FALLTHROUGH */
2699
2700             case CF_INT:
2701                 if (val <= 0xFF) {
2702                     if (val != 0) {
2703                         AddCodeLine ("eor #$%02X", (unsigned char)val);
2704                     }
2705                     return;
2706                 } else if ((val & 0xFF) == 0) {
2707                     AddCodeLine ("pha");
2708                     AddCodeLine ("txa");
2709                     AddCodeLine ("eor #$%02X", (unsigned char)(val >> 8));
2710                     AddCodeLine ("tax");
2711                     AddCodeLine ("pla");
2712                     return;
2713                 }
2714                 break;
2715
2716             case CF_LONG:
2717                 if (val <= 0xFF) {
2718                     if (val != 0) {
2719                         AddCodeLine ("eor #$%02X", (unsigned char)val);
2720                     }
2721                     return;
2722                 }
2723                 break;
2724
2725             default:
2726                 typeerror (flags);
2727         }
2728
2729         /* If we go here, we didn't emit code. Push the lhs on stack and fall
2730          * into the normal, non-optimized stuff.
2731          */
2732         g_push (flags & ~CF_CONST, 0);
2733
2734     }
2735
2736     /* Use long way over the stack */
2737     oper (flags, val, ops);
2738 }
2739
2740
2741
2742 void g_and (unsigned flags, unsigned long val)
2743 /* Primary = TOS & Primary */
2744 {
2745     static char* ops [12] = {
2746         0,              "tosanda0",     "tosandax",
2747         0,              "tosanda0",     "tosandax",
2748         0,              0,              "tosandeax",
2749         0,              0,              "tosandeax",
2750     };
2751
2752     /* If the right hand side is const, the lhs is not on stack but still
2753      * in the primary register.
2754      */
2755     if (flags & CF_CONST) {
2756
2757         switch (flags & CF_TYPE) {
2758
2759             case CF_CHAR:
2760                 if (flags & CF_FORCECHAR) {
2761                     AddCodeLine ("and #$%02X", (unsigned char)val);
2762                     return;
2763                 }
2764                 /* FALLTHROUGH */
2765             case CF_INT:
2766                 if ((val & 0xFFFF) != 0xFFFF) {
2767                     if (val <= 0xFF) {
2768                         ldxconst (0);
2769                         if (val == 0) {
2770                             ldaconst (0);
2771                         } else if (val != 0xFF) {
2772                             AddCodeLine ("and #$%02X", (unsigned char)val);
2773                         }
2774                     } else if ((val & 0xFF00) == 0xFF00) {
2775                         AddCodeLine ("and #$%02X", (unsigned char)val);
2776                     } else if ((val & 0x00FF) == 0x0000) {
2777                         AddCodeLine ("txa");
2778                         AddCodeLine ("and #$%02X", (unsigned char)(val >> 8));
2779                         AddCodeLine ("tax");
2780                         ldaconst (0);
2781                     } else {
2782                         AddCodeLine ("tay");
2783                         AddCodeLine ("txa");
2784                         AddCodeLine ("and #$%02X", (unsigned char)(val >> 8));
2785                         AddCodeLine ("tax");
2786                         AddCodeLine ("tya");
2787                         if ((val & 0x00FF) != 0x00FF) {
2788                             AddCodeLine ("and #$%02X", (unsigned char)val);
2789                         }
2790                     }
2791                 }
2792                 return;
2793
2794             case CF_LONG:
2795                 if (val <= 0xFF) {
2796                     ldxconst (0);
2797                     AddCodeLine ("stx sreg+1");
2798                     AddCodeLine ("stx sreg");
2799                     if ((val & 0xFF) != 0xFF) {
2800                          AddCodeLine ("and #$%02X", (unsigned char)val);
2801                     }
2802                     return;
2803                 } else if (val == 0xFF00) {
2804                     ldaconst (0);
2805                     AddCodeLine ("sta sreg+1");
2806                     AddCodeLine ("sta sreg");
2807                     return;
2808                 }
2809                 break;
2810
2811             default:
2812                 typeerror (flags);
2813         }
2814
2815         /* If we go here, we didn't emit code. Push the lhs on stack and fall
2816          * into the normal, non-optimized stuff.
2817          */
2818         g_push (flags & ~CF_CONST, 0);
2819
2820     }
2821
2822     /* Use long way over the stack */
2823     oper (flags, val, ops);
2824 }
2825
2826
2827
2828 void g_asr (unsigned flags, unsigned long val)
2829 /* Primary = TOS >> Primary */
2830 {
2831     static char* ops [12] = {
2832         0,              "tosasra0",     "tosasrax",
2833         0,              "tosshra0",     "tosshrax",
2834         0,              0,              "tosasreax",
2835         0,              0,              "tosshreax",
2836     };
2837
2838     /* If the right hand side is const, the lhs is not on stack but still
2839      * in the primary register.
2840      */
2841     if (flags & CF_CONST) {
2842
2843         switch (flags & CF_TYPE) {
2844
2845             case CF_CHAR:
2846             case CF_INT:
2847                 if (val >= 8 && (flags & CF_UNSIGNED)) {
2848                     AddCodeLine ("txa");
2849                     ldxconst (0);
2850                     val -= 8;
2851                     if (val == 0) {
2852                         /* Done */
2853                         return;
2854                     }
2855                 }
2856                 if (val >= 1 && val <= 4) {
2857                     if (flags & CF_UNSIGNED) {
2858                         AddCodeLine ("jsr shrax%ld", val);
2859                     } else {
2860                         AddCodeLine ("jsr asrax%ld", val);
2861                     }
2862                     return;
2863                 }
2864                 break;
2865
2866             case CF_LONG:
2867                 if (val >= 1 && val <= 4) {
2868                     if (flags & CF_UNSIGNED) {
2869                         AddCodeLine ("jsr shreax%ld", val);
2870                     } else {
2871                         AddCodeLine ("jsr asreax%ld", val);
2872                     }
2873                     return;
2874                 } else if (val == 8 && (flags & CF_UNSIGNED)) {
2875                     AddCodeLine ("txa");
2876                     AddCodeLine ("ldx sreg");
2877                     AddCodeLine ("ldy sreg+1");
2878                     AddCodeLine ("sty sreg");
2879                     AddCodeLine ("ldy #$00");
2880                     AddCodeLine ("sty sreg+1");
2881                     return;
2882                 } else if (val == 16) {
2883                     AddCodeLine ("ldy #$00");
2884                     AddCodeLine ("ldx sreg+1");
2885                     if ((flags & CF_UNSIGNED) == 0) {
2886                         unsigned L = GetLocalLabel();
2887                         AddCodeLine ("bpl %s", LocalLabelName (L));
2888                         AddCodeLine ("dey");
2889                         g_defcodelabel (L);
2890                     }
2891                     AddCodeLine ("lda sreg");
2892                     AddCodeLine ("sty sreg+1");
2893                     AddCodeLine ("sty sreg");
2894                     return;
2895                 }
2896                 break;
2897
2898             default:
2899                 typeerror (flags);
2900         }
2901
2902         /* If we go here, we didn't emit code. Push the lhs on stack and fall
2903          * into the normal, non-optimized stuff.
2904          */
2905         g_push (flags & ~CF_CONST, 0);
2906
2907     }
2908
2909     /* Use long way over the stack */
2910     oper (flags, val, ops);
2911 }
2912
2913
2914
2915 void g_asl (unsigned flags, unsigned long val)
2916 /* Primary = TOS << Primary */
2917 {
2918     static char* ops [12] = {
2919         0,              "tosasla0",     "tosaslax",
2920         0,              "tosshla0",     "tosshlax",
2921         0,              0,              "tosasleax",
2922         0,              0,              "tosshleax",
2923     };
2924
2925
2926     /* If the right hand side is const, the lhs is not on stack but still
2927      * in the primary register.
2928      */
2929     if (flags & CF_CONST) {
2930
2931         switch (flags & CF_TYPE) {
2932
2933             case CF_CHAR:
2934             case CF_INT:
2935                 if (val >= 8) {
2936                     AddCodeLine ("tax");
2937                     AddCodeLine ("lda #$00");
2938                     val -= 8;
2939                     if (val == 0) {
2940                         /* Done */
2941                         return;
2942                     }
2943                 }
2944                 if (val >= 1 && val <= 4) {
2945                     if (flags & CF_UNSIGNED) {
2946                         AddCodeLine ("jsr shlax%ld", val);
2947                     } else {
2948                         AddCodeLine ("jsr aslax%ld", val);
2949                     }
2950                     return;
2951                 }
2952                 break;
2953
2954             case CF_LONG:
2955                 if (val >= 1 && val <= 4) {
2956                     if (flags & CF_UNSIGNED) {
2957                         AddCodeLine ("jsr shleax%ld", val);
2958                     } else {
2959                         AddCodeLine ("jsr asleax%ld", val);
2960                     }
2961                     return;
2962                 } else if (val == 8) {
2963                     AddCodeLine ("ldy sreg");
2964                     AddCodeLine ("sty sreg+1");
2965                     AddCodeLine ("stx sreg");
2966                     AddCodeLine ("tax");
2967                     AddCodeLine ("lda #$00");
2968                     return;
2969                 } else if (val == 16) {
2970                     AddCodeLine ("stx sreg+1");
2971                     AddCodeLine ("sta sreg");
2972                     AddCodeLine ("lda #$00");
2973                     AddCodeLine ("tax");
2974                     return;
2975                 }
2976                 break;
2977
2978             default:
2979                 typeerror (flags);
2980         }
2981
2982         /* If we go here, we didn't emit code. Push the lhs on stack and fall
2983          * into the normal, non-optimized stuff.
2984          */
2985         g_push (flags & ~CF_CONST, 0);
2986
2987     }
2988
2989     /* Use long way over the stack */
2990     oper (flags, val, ops);
2991 }
2992
2993
2994
2995 void g_neg (unsigned flags)
2996 /* Primary = -Primary */
2997 {
2998     switch (flags & CF_TYPE) {
2999
3000         case CF_CHAR:
3001         case CF_INT:
3002             AddCodeLine ("jsr negax");
3003             break;
3004
3005         case CF_LONG:
3006             AddCodeLine ("jsr negeax");
3007             break;
3008
3009         default:
3010             typeerror (flags);
3011     }
3012 }
3013
3014
3015
3016 void g_bneg (unsigned flags)
3017 /* Primary = !Primary */
3018 {
3019     switch (flags & CF_TYPE) {
3020
3021         case CF_CHAR:
3022             AddCodeLine ("jsr bnega");
3023             break;
3024
3025         case CF_INT:
3026             AddCodeLine ("jsr bnegax");
3027             break;
3028
3029         case CF_LONG:
3030             AddCodeLine ("jsr bnegeax");
3031             break;
3032
3033         default:
3034             typeerror (flags);
3035     }
3036 }
3037
3038
3039
3040 void g_com (unsigned flags)
3041 /* Primary = ~Primary */
3042 {
3043     switch (flags & CF_TYPE) {
3044
3045         case CF_CHAR:
3046         case CF_INT:
3047             AddCodeLine ("jsr complax");
3048             break;
3049
3050         case CF_LONG:
3051             AddCodeLine ("jsr compleax");
3052             break;
3053
3054         default:
3055             typeerror (flags);
3056     }
3057 }
3058
3059
3060
3061 void g_inc (unsigned flags, unsigned long val)
3062 /* Increment the primary register by a given number */
3063 {
3064     /* Don't inc by zero */
3065     if (val == 0) {
3066         return;
3067     }
3068
3069     /* Generate code for the supported types */
3070     flags &= ~CF_CONST;
3071     switch (flags & CF_TYPE) {
3072
3073         case CF_CHAR:
3074             if (flags & CF_FORCECHAR) {
3075                 if (CPU == CPU_65C02 && val <= 2) {
3076                     while (val--) {
3077                         AddCodeLine ("ina");
3078                     }
3079                 } else {
3080                     AddCodeLine ("clc");
3081                     AddCodeLine ("adc #$%02X", (unsigned char)val);
3082                 }
3083                 break;
3084             }
3085             /* FALLTHROUGH */
3086
3087         case CF_INT:
3088             if (CPU == CPU_65C02 && val == 1) {
3089                 unsigned L = GetLocalLabel();
3090                 AddCodeLine ("ina");
3091                 AddCodeLine ("bne %s", LocalLabelName (L));
3092                 AddCodeLine ("inx");
3093                 g_defcodelabel (L);
3094             } else if (CodeSizeFactor < 200) {
3095                 /* Use jsr calls */
3096                 if (val <= 8) {
3097                     AddCodeLine ("jsr incax%lu", val);
3098                 } else if (val <= 255) {
3099                     ldyconst (val);
3100                     AddCodeLine ("jsr incaxy");
3101                 } else {
3102                     g_add (flags | CF_CONST, val);
3103                 }
3104             } else {
3105                 /* Inline the code */
3106                 if (val < 0x300) {
3107                     if ((val & 0xFF) != 0) {
3108                         unsigned L = GetLocalLabel();
3109                         AddCodeLine ("clc");
3110                         AddCodeLine ("adc #$%02X", (unsigned char) val);
3111                         AddCodeLine ("bcc %s", LocalLabelName (L));
3112                         AddCodeLine ("inx");
3113                         g_defcodelabel (L);
3114                     }
3115                     if (val >= 0x100) {
3116                         AddCodeLine ("inx");
3117                     }
3118                     if (val >= 0x200) {
3119                         AddCodeLine ("inx");
3120                     }
3121                 } else {
3122                     AddCodeLine ("clc");
3123                     if ((val & 0xFF) != 0) {
3124                         AddCodeLine ("adc #$%02X", (unsigned char) val);
3125                     }
3126                     AddCodeLine ("pha");
3127                     AddCodeLine ("txa");
3128                     AddCodeLine ("adc #$%02X", (unsigned char) (val >> 8));
3129                     AddCodeLine ("tax");
3130                     AddCodeLine ("pla");
3131                 }
3132             }
3133             break;
3134
3135         case CF_LONG:
3136             if (val <= 255) {
3137                 ldyconst (val);
3138                 AddCodeLine ("jsr inceaxy");
3139             } else {
3140                 g_add (flags | CF_CONST, val);
3141             }
3142             break;
3143
3144         default:
3145             typeerror (flags);
3146
3147     }
3148 }
3149
3150
3151
3152 void g_dec (unsigned flags, unsigned long val)
3153 /* Decrement the primary register by a given number */
3154 {
3155     /* Don't dec by zero */
3156     if (val == 0) {
3157         return;
3158     }
3159
3160     /* Generate code for the supported types */
3161     flags &= ~CF_CONST;
3162     switch (flags & CF_TYPE) {
3163
3164         case CF_CHAR:
3165             if (flags & CF_FORCECHAR) {
3166                 if (CPU == CPU_65C02 && val <= 2) {
3167                     while (val--) {
3168                         AddCodeLine ("dea");
3169                     }
3170                 } else {
3171                     AddCodeLine ("sec");
3172                     AddCodeLine ("sbc #$%02X", (unsigned char)val);
3173                 }
3174                 break;
3175             }
3176             /* FALLTHROUGH */
3177
3178         case CF_INT:
3179             if (CodeSizeFactor < 200) {
3180                 /* Use subroutines */
3181                 if (val <= 8) {
3182                     AddCodeLine ("jsr decax%d", (int) val);
3183                 } else if (val <= 255) {
3184                     ldyconst (val);
3185                     AddCodeLine ("jsr decaxy");
3186                 } else {
3187                     g_sub (flags | CF_CONST, val);
3188                 }
3189             } else {
3190                 /* Inline the code */
3191                 if (val < 0x300) {
3192                     if ((val & 0xFF) != 0) {
3193                         unsigned L = GetLocalLabel();
3194                         AddCodeLine ("sec");
3195                         AddCodeLine ("sbc #$%02X", (unsigned char) val);
3196                         AddCodeLine ("bcs %s", LocalLabelName (L));
3197                         AddCodeLine ("dex");
3198                         g_defcodelabel (L);
3199                     }
3200                     if (val >= 0x100) {
3201                         AddCodeLine ("dex");
3202                     }
3203                     if (val >= 0x200) {
3204                         AddCodeLine ("dex");
3205                     }
3206                 } else {
3207                     AddCodeLine ("sec");
3208                     if ((val & 0xFF) != 0) {
3209                         AddCodeLine ("sbc #$%02X", (unsigned char) val);
3210                     }
3211                     AddCodeLine ("pha");
3212                     AddCodeLine ("txa");
3213                     AddCodeLine ("sbc #$%02X", (unsigned char) (val >> 8));
3214                     AddCodeLine ("tax");
3215                     AddCodeLine ("pla");
3216                 }
3217             }
3218             break;
3219
3220         case CF_LONG:
3221             if (val <= 255) {
3222                 ldyconst (val);
3223                 AddCodeLine ("jsr deceaxy");
3224             } else {
3225                 g_sub (flags | CF_CONST, val);
3226             }
3227             break;
3228
3229         default:
3230             typeerror (flags);
3231
3232     }
3233 }
3234
3235
3236
3237 /*
3238  * Following are the conditional operators. They compare the TOS against
3239  * the primary and put a literal 1 in the primary if the condition is
3240  * true, otherwise they clear the primary register
3241  */
3242
3243
3244
3245 void g_eq (unsigned flags, unsigned long val)
3246 /* Test for equal */
3247 {
3248     static char* ops [12] = {
3249         "toseq00",      "toseqa0",      "toseqax",
3250         "toseq00",      "toseqa0",      "toseqax",
3251         0,              0,              "toseqeax",
3252         0,              0,              "toseqeax",
3253     };
3254
3255     unsigned L;
3256
3257     /* If the right hand side is const, the lhs is not on stack but still
3258      * in the primary register.
3259      */
3260     if (flags & CF_CONST) {
3261
3262         switch (flags & CF_TYPE) {
3263
3264             case CF_CHAR:
3265                 if (flags & CF_FORCECHAR) {
3266                     AddCodeLine ("cmp #$%02X", (unsigned char)val);
3267                     AddCodeLine ("jsr booleq");
3268                     return;
3269                 }
3270                 /* FALLTHROUGH */
3271
3272             case CF_INT:
3273                 L = GetLocalLabel();
3274                 AddCodeLine ("cpx #$%02X", (unsigned char)(val >> 8));
3275                 AddCodeLine ("bne %s", LocalLabelName (L));
3276                 AddCodeLine ("cmp #$%02X", (unsigned char)val);
3277                 g_defcodelabel (L);
3278                 AddCodeLine ("jsr booleq");
3279                 return;
3280
3281             case CF_LONG:
3282                 break;
3283
3284             default:
3285                 typeerror (flags);
3286         }
3287
3288         /* If we go here, we didn't emit code. Push the lhs on stack and fall
3289          * into the normal, non-optimized stuff.
3290          */
3291         g_push (flags & ~CF_CONST, 0);
3292
3293     }
3294
3295     /* Use long way over the stack */
3296     oper (flags, val, ops);
3297 }
3298
3299
3300
3301 void g_ne (unsigned flags, unsigned long val)
3302 /* Test for not equal */
3303 {
3304     static char* ops [12] = {
3305         "tosne00",      "tosnea0",      "tosneax",
3306         "tosne00",      "tosnea0",      "tosneax",
3307         0,              0,              "tosneeax",
3308         0,              0,              "tosneeax",
3309     };
3310
3311     unsigned L;
3312
3313     /* If the right hand side is const, the lhs is not on stack but still
3314      * in the primary register.
3315      */
3316     if (flags & CF_CONST) {
3317
3318         switch (flags & CF_TYPE) {
3319
3320             case CF_CHAR:
3321                 if (flags & CF_FORCECHAR) {
3322                     AddCodeLine ("cmp #$%02X", (unsigned char)val);
3323                     AddCodeLine ("jsr boolne");
3324                     return;
3325                 }
3326                 /* FALLTHROUGH */
3327
3328             case CF_INT:
3329                 L = GetLocalLabel();
3330                 AddCodeLine ("cpx #$%02X", (unsigned char)(val >> 8));
3331                 AddCodeLine ("bne %s", LocalLabelName (L));
3332                 AddCodeLine ("cmp #$%02X", (unsigned char)val);
3333                 g_defcodelabel (L);
3334                 AddCodeLine ("jsr boolne");
3335                 return;
3336
3337             case CF_LONG:
3338                 break;
3339
3340             default:
3341                 typeerror (flags);
3342         }
3343
3344         /* If we go here, we didn't emit code. Push the lhs on stack and fall
3345          * into the normal, non-optimized stuff.
3346          */
3347         g_push (flags & ~CF_CONST, 0);
3348
3349     }
3350
3351     /* Use long way over the stack */
3352     oper (flags, val, ops);
3353 }
3354
3355
3356
3357 void g_lt (unsigned flags, unsigned long val)
3358 /* Test for less than */
3359 {
3360     static char* ops [12] = {
3361         "toslt00",      "toslta0",      "tosltax",
3362         "tosult00",     "tosulta0",     "tosultax",
3363         0,              0,              "toslteax",
3364         0,              0,              "tosulteax",
3365     };
3366
3367     /* If the right hand side is const, the lhs is not on stack but still
3368      * in the primary register.
3369      */
3370     if (flags & CF_CONST) {
3371
3372         /* Give a warning in some special cases */
3373         if ((flags & CF_UNSIGNED) && val == 0) {
3374             Warning ("Condition is never true");
3375         }
3376
3377         /* Look at the type */
3378         switch (flags & CF_TYPE) {
3379
3380             case CF_CHAR:
3381                 if (flags & CF_FORCECHAR) {
3382                     AddCodeLine ("cmp #$%02X", (unsigned char)val);
3383                     if (flags & CF_UNSIGNED) {
3384                         AddCodeLine ("jsr boolult");
3385                     } else {
3386                         AddCodeLine ("jsr boollt");
3387                     }
3388                     return;
3389                 }
3390                 /* FALLTHROUGH */
3391
3392             case CF_INT:
3393                 if ((flags & CF_UNSIGNED) == 0 && val == 0) {
3394                     /* If we have a signed compare against zero, we only need to
3395                      * test the high byte.
3396                      */
3397                     AddCodeLine ("txa");
3398                     AddCodeLine ("jsr boollt");
3399                     return;
3400                 }
3401                 /* Direct code only for unsigned data types */
3402                 if (flags & CF_UNSIGNED) {
3403                     unsigned L = GetLocalLabel();
3404                     AddCodeLine ("cpx #$%02X", (unsigned char)(val >> 8));
3405                     AddCodeLine ("bne %s", LocalLabelName (L));
3406                     AddCodeLine ("cmp #$%02X", (unsigned char)val);
3407                     g_defcodelabel (L);
3408                     AddCodeLine ("jsr boolult");
3409                     return;
3410                 }
3411                 break;
3412
3413             case CF_LONG:
3414                 if ((flags & CF_UNSIGNED) == 0 && val == 0) {
3415                     /* If we have a signed compare against zero, we only need to
3416                      * test the high byte.
3417                      */
3418                     AddCodeLine ("lda sreg+1");
3419                     AddCodeLine ("jsr boollt");
3420                     return;
3421                 }
3422                 break;
3423
3424             default:
3425                 typeerror (flags);
3426         }
3427
3428         /* If we go here, we didn't emit code. Push the lhs on stack and fall
3429          * into the normal, non-optimized stuff.
3430          */
3431         g_push (flags & ~CF_CONST, 0);
3432
3433     }
3434
3435     /* Use long way over the stack */
3436     oper (flags, val, ops);
3437 }
3438
3439
3440
3441 void g_le (unsigned flags, unsigned long val)
3442 /* Test for less than or equal to */
3443 {
3444     static char* ops [12] = {
3445         "tosle00",      "toslea0",      "tosleax",
3446         "tosule00",     "tosulea0",     "tosuleax",
3447         0,              0,              "tosleeax",
3448         0,              0,              "tosuleeax",
3449     };
3450
3451
3452     /* If the right hand side is const, the lhs is not on stack but still
3453      * in the primary register.
3454      */
3455     if (flags & CF_CONST) {
3456
3457         /* <= is not very effective on the 6502, so try to convert
3458          * it into < if the value is in a valid range.
3459          */
3460
3461         /* Look at the type */
3462         switch (flags & CF_TYPE) {
3463
3464             case CF_CHAR:
3465                 if (flags & CF_FORCECHAR) {
3466                     if (flags & CF_UNSIGNED) {
3467                         if (val < 255) {
3468                             AddCodeLine ("cmp #$%02X", (unsigned char)val+1);
3469                             AddCodeLine ("jsr boolult");
3470                         } else {
3471                             AddCodeLine ("cmp #$%02X", (unsigned char)val);
3472                             AddCodeLine ("jsr boolule");
3473                         }
3474                     } else {
3475                         if (val < 127) {
3476                             AddCodeLine ("cmp #$%02X", (unsigned char)val+1);
3477                             AddCodeLine ("jsr boollt");
3478                         } else {
3479                             AddCodeLine ("cmp #$%02X", (unsigned char)val);
3480                             AddCodeLine ("jsr boolle");
3481                         }
3482                     }
3483                     return;
3484                 }
3485                 /* FALLTHROUGH */
3486
3487             case CF_INT:
3488                 if (flags & CF_UNSIGNED) {
3489                     unsigned L = GetLocalLabel();
3490                     const char* Name = "boolule";
3491                     if (val < 65535) {
3492                         ++val;
3493                         Name = "boolult";
3494                     }
3495                     AddCodeLine ("cpx #$%02X", (unsigned char)(val >> 8));
3496                     AddCodeLine ("bne %s", LocalLabelName (L));
3497                     AddCodeLine ("cmp #$%02X", (unsigned char)val);
3498                     g_defcodelabel (L);
3499                     AddCodeLine ("jsr %s", Name);
3500                     return;
3501                 }
3502                 break;
3503
3504             case CF_LONG:
3505                 break;
3506
3507             default:
3508                 typeerror (flags);
3509         }
3510
3511         /* If we go here, we didn't emit code. Push the lhs on stack and fall
3512          * into the normal, non-optimized stuff.
3513          */
3514         g_push (flags & ~CF_CONST, 0);
3515
3516     }
3517
3518     /* Use long way over the stack */
3519     oper (flags, val, ops);
3520 }
3521
3522
3523
3524 void g_gt (unsigned flags, unsigned long val)
3525 /* Test for greater than */
3526 {
3527     static char* ops [12] = {
3528         "tosgt00",      "tosgta0",      "tosgtax",
3529         "tosugt00",     "tosugta0",     "tosugtax",
3530         0,              0,              "tosgteax",
3531         0,              0,              "tosugteax",
3532     };
3533
3534
3535     /* If the right hand side is const, the lhs is not on stack but still
3536      * in the primary register.
3537      */
3538     if (flags & CF_CONST) {
3539
3540         /* > is not very effective on the 6502, so try to convert
3541          * it into >= if the value is in a valid range.
3542          */
3543
3544         /* Look at the type */
3545         switch (flags & CF_TYPE) {
3546
3547             case CF_CHAR:
3548                 if (flags & CF_FORCECHAR) {
3549                     if (flags & CF_UNSIGNED) {
3550                         /* If we have a compare > 0, we will replace it by
3551                          * != 0 here, since both are identical but the latter
3552                          * is easier to optimize.
3553                          */
3554                         if (val == 0) {
3555                             AddCodeLine ("cmp #$%02X", (unsigned char)val);
3556                             AddCodeLine ("jsr boolne");
3557                         } else if (val < 255) {
3558                             AddCodeLine ("cmp #$%02X", (unsigned char)val+1);
3559                             AddCodeLine ("jsr booluge");
3560                         } else {
3561                             AddCodeLine ("cmp #$%02X", (unsigned char)val);
3562                             AddCodeLine ("jsr boolugt");
3563                         }
3564                     } else {
3565                         if (val < 127) {
3566                             AddCodeLine ("cmp #$%02X", (unsigned char)val+1);
3567                             AddCodeLine ("jsr boolge");
3568                         } else {
3569                             AddCodeLine ("cmp #$%02X", (unsigned char)val);
3570                             AddCodeLine ("jsr boolgt");
3571                         }
3572                     }
3573                     return;
3574                 }
3575                 /* FALLTHROUGH */
3576
3577             case CF_INT:
3578                 if (flags & CF_UNSIGNED) {
3579                     /* If we have a compare > 0, we will replace it by
3580                      * != 0 here, since both are identical but the latter
3581                      * is easier to optimize.
3582                      */
3583                     if (val == 0) {
3584                         AddCodeLine ("stx tmp1");
3585                         AddCodeLine ("ora tmp1");
3586                         AddCodeLine ("jsr boolne");
3587                     } else {
3588                         unsigned L = GetLocalLabel();
3589                         const char* Name = "boolugt";
3590                         if (val < 65535) {
3591                             ++val;
3592                             Name = "booluge";
3593                         }
3594                         AddCodeLine ("cpx #$%02X", (unsigned char)(val >> 8));
3595                         AddCodeLine ("bne %s", LocalLabelName (L));
3596                         AddCodeLine ("cmp #$%02X", (unsigned char)val);
3597                         g_defcodelabel (L);
3598                         AddCodeLine ("jsr %s", Name);
3599                     }
3600                     return;
3601                 }
3602                 break;
3603
3604             case CF_LONG:
3605                 break;
3606
3607             default:
3608                 typeerror (flags);
3609         }
3610
3611         /* If we go here, we didn't emit code. Push the lhs on stack and fall
3612          * into the normal, non-optimized stuff.
3613          */
3614         g_push (flags & ~CF_CONST, 0);
3615
3616     }
3617
3618     /* Use long way over the stack */
3619     oper (flags, val, ops);
3620 }
3621
3622
3623
3624 void g_ge (unsigned flags, unsigned long val)
3625 /* Test for greater than or equal to */
3626 {
3627     static char* ops [12] = {
3628         "tosge00",      "tosgea0",      "tosgeax",
3629         "tosuge00",     "tosugea0",     "tosugeax",
3630         0,              0,              "tosgeeax",
3631         0,              0,              "tosugeeax",
3632     };
3633
3634
3635     /* If the right hand side is const, the lhs is not on stack but still
3636      * in the primary register.
3637      */
3638     if (flags & CF_CONST) {
3639
3640         /* Give a warning in some special cases */
3641         if ((flags & CF_UNSIGNED) && val == 0) {
3642             Warning ("Condition is always true");
3643         }
3644
3645         /* Look at the type */
3646         switch (flags & CF_TYPE) {
3647
3648             case CF_CHAR:
3649                 if (flags & CF_FORCECHAR) {
3650                     AddCodeLine ("cmp #$%02X", (unsigned char)val);
3651                     if (flags & CF_UNSIGNED) {
3652                         AddCodeLine ("jsr booluge");
3653                     } else {
3654                         AddCodeLine ("jsr boolge");
3655                     }
3656                     return;
3657                 }
3658                 /* FALLTHROUGH */
3659
3660             case CF_INT:
3661                 if ((flags & CF_UNSIGNED) == 0 && val == 0) {
3662                     /* If we have a signed compare against zero, we only need to
3663                      * test the high byte.
3664                      */
3665                     AddCodeLine ("txa");
3666                     AddCodeLine ("jsr boolge");
3667                     return;
3668                 }
3669                 /* Direct code only for unsigned data types */
3670                 if (flags & CF_UNSIGNED) {
3671                     unsigned L = GetLocalLabel();
3672                     AddCodeLine ("cpx #$%02X", (unsigned char)(val >> 8));
3673                     AddCodeLine ("bne %s", LocalLabelName (L));
3674                     AddCodeLine ("cmp #$%02X", (unsigned char)val);
3675                     g_defcodelabel (L);
3676                     AddCodeLine ("jsr booluge");
3677                     return;
3678                 }
3679                 break;
3680
3681             case CF_LONG:
3682                 if ((flags & CF_UNSIGNED) == 0 && val == 0) {
3683                     /* If we have a signed compare against zero, we only need to
3684                      * test the high byte.
3685                      */
3686                     AddCodeLine ("lda sreg+1");
3687                     AddCodeLine ("jsr boolge");
3688                     return;
3689                 }
3690                 break;
3691
3692             default:
3693                 typeerror (flags);
3694         }
3695
3696         /* If we go here, we didn't emit code. Push the lhs on stack and fall
3697          * into the normal, non-optimized stuff.
3698          */
3699         g_push (flags & ~CF_CONST, 0);
3700
3701     }
3702
3703     /* Use long way over the stack */
3704     oper (flags, val, ops);
3705 }
3706
3707
3708
3709 /*****************************************************************************/
3710 /*                         Allocating static storage                         */
3711 /*****************************************************************************/
3712
3713
3714
3715 void g_res (unsigned n)
3716 /* Reserve static storage, n bytes */
3717 {
3718     AddDataLine ("\t.res\t%u,$00", n);
3719 }
3720
3721
3722
3723 void g_defdata (unsigned flags, unsigned long val, unsigned offs)
3724 /* Define data with the size given in flags */
3725 {
3726     if (flags & CF_CONST) {
3727
3728         /* Numeric constant */
3729         switch (flags & CF_TYPE) {
3730
3731             case CF_CHAR:
3732                 AddDataLine ("\t.byte\t$%02lX", val & 0xFF);
3733                 break;
3734
3735             case CF_INT:
3736                 AddDataLine ("\t.word\t$%04lX", val & 0xFFFF);
3737                 break;
3738
3739             case CF_LONG:
3740                 AddDataLine ("\t.dword\t$%08lX", val & 0xFFFFFFFF);
3741                 break;
3742
3743             default:
3744                 typeerror (flags);
3745                 break;
3746
3747         }
3748
3749     } else {
3750
3751         /* Create the correct label name */
3752         const char* Label = GetLabelName (flags, val, offs);
3753
3754         /* Labels are always 16 bit */
3755         AddDataLine ("\t.addr\t%s", Label);
3756
3757     }
3758 }
3759
3760
3761
3762 void g_defbytes (const void* Bytes, unsigned Count)
3763 /* Output a row of bytes as a constant */
3764 {
3765     unsigned Chunk;
3766     char Buf [128];
3767     char* B;
3768
3769     /* Cast the buffer pointer */
3770     const unsigned char* Data = (const unsigned char*) Bytes;
3771
3772     /* Output the stuff */
3773     while (Count) {
3774
3775         /* How many go into this line? */
3776         if ((Chunk = Count) > 16) {
3777             Chunk = 16;
3778         }
3779         Count -= Chunk;
3780
3781         /* Output one line */
3782         strcpy (Buf, "\t.byte\t");
3783         B = Buf + 7;
3784         do {
3785             B += sprintf (B, "$%02X", *Data++);
3786             if (--Chunk) {
3787                 *B++ = ',';
3788             }
3789         } while (Chunk);
3790
3791         /* Output the line */
3792         AddDataLine (Buf);
3793     }
3794 }
3795
3796
3797
3798 void g_zerobytes (unsigned n)
3799 /* Output n bytes of data initialized with zero */
3800 {
3801     AddDataLine ("\t.res\t%u,$00", n);
3802 }
3803
3804
3805
3806 /*****************************************************************************/
3807 /*                             Switch statement                              */
3808 /*****************************************************************************/
3809
3810
3811
3812 void g_switch (Collection* Nodes, unsigned DefaultLabel, unsigned Depth)
3813 /* Generate code for a switch statement */
3814 {
3815     unsigned NextLabel = 0;
3816     unsigned I;
3817
3818     /* Setup registers and determine which compare insn to use */
3819     const char* Compare;
3820     switch (Depth) {
3821         case 1:
3822             Compare = "cmp #$%02X";
3823             break;
3824         case 2:
3825             Compare = "cpx #$%02X";
3826             break;
3827         case 3:
3828             AddCodeLine ("ldy sreg");
3829             Compare = "cpy #$%02X";
3830             break;
3831         case 4:
3832             AddCodeLine ("ldy sreg+1");
3833             Compare = "cpy #$%02X";
3834             break;
3835         default:
3836             Internal ("Invalid depth in g_switch: %u", Depth);
3837     }
3838
3839     /* Walk over all nodes */
3840     for (I = 0; I < CollCount (Nodes); ++I) {
3841
3842         /* Get the next case node */
3843         CaseNode* N = CollAtUnchecked (Nodes, I);
3844
3845         /* If we have a next label, define it */
3846         if (NextLabel) {
3847             g_defcodelabel (NextLabel);
3848             NextLabel = 0;
3849         }
3850
3851         /* Do the compare */
3852         AddCodeLine (Compare, CN_GetValue (N));
3853
3854         /* If this is the last level, jump directly to the case code if found */
3855         if (Depth == 1) {
3856
3857             /* Branch if equal */
3858             g_falsejump (0, CN_GetLabel (N));
3859
3860         } else {
3861
3862             /* Determine the next label */
3863             if (I == CollCount (Nodes) - 1) {
3864                 /* Last node means not found */
3865                 g_truejump (0, DefaultLabel);
3866             } else {
3867                 /* Jump to the next check */
3868                 NextLabel = GetLocalLabel ();
3869                 g_truejump (0, NextLabel);
3870             }
3871
3872             /* Check the next level */
3873             g_switch (N->Nodes, DefaultLabel, Depth-1);
3874
3875         }
3876     }
3877
3878     /* If we go here, we haven't found the label */
3879     g_jump (DefaultLabel);
3880 }
3881
3882
3883
3884 /*****************************************************************************/
3885 /*                       User supplied assembler code                        */
3886 /*****************************************************************************/
3887
3888
3889
3890 void g_asmcode (struct StrBuf* B)
3891 /* Output one line of assembler code. */
3892 {
3893     AddCodeLine ("%.*s", SB_GetLen (B), SB_GetConstBuf (B));
3894 }
3895
3896
3897
3898 /*****************************************************************************/
3899 /*                          Inlined known functions                          */
3900 /*****************************************************************************/
3901
3902
3903
3904 void g_strlen (unsigned flags, unsigned long val, unsigned offs)
3905 /* Inline the strlen() function */
3906 {
3907     /* We need a label in both cases */
3908     unsigned label = GetLocalLabel ();
3909
3910     /* Two different encodings */
3911     if (flags & CF_CONST) {
3912
3913         /* The address of the string is constant. Create the correct label name */
3914         char* lbuf = GetLabelName (flags, val, offs);
3915
3916         /* Generate the strlen code */
3917         AddCodeLine ("ldy #$FF");
3918         g_defcodelabel (label);
3919         AddCodeLine ("iny");
3920         AddCodeLine ("lda %s,y", lbuf);
3921         AddCodeLine ("bne %s", LocalLabelName (label));
3922         AddCodeLine ("tax");
3923         AddCodeLine ("tya");
3924
3925     } else {
3926
3927         /* Address not constant but in primary */
3928         if (CodeSizeFactor < 400) {
3929             /* This is too much code, so call strlen instead of inlining */
3930             AddCodeLine ("jsr _strlen");
3931         } else {
3932             /* Inline the function */
3933             AddCodeLine ("sta ptr1");
3934             AddCodeLine ("stx ptr1+1");
3935             AddCodeLine ("ldy #$FF");
3936             g_defcodelabel (label);
3937             AddCodeLine ("iny");
3938             AddCodeLine ("lda (ptr1),y");
3939             AddCodeLine ("bne %s", LocalLabelName (label));
3940             AddCodeLine ("tax");
3941             AddCodeLine ("tya");
3942         }
3943     }
3944 }
3945
3946
3947