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