From 2138f3c902f2bcbe538a62fae5e7e36c36ea2c2a Mon Sep 17 00:00:00 2001
From: rumbledethumps <16963588+rumbledethumps@users.noreply.github.com>
Date: Wed, 10 Jan 2024 21:24:55 -0800
Subject: [PATCH 01/50] add clock() to RP6502

---
 include/rp6502.h      | 1 +
 include/time.h        | 2 ++
 libsrc/rp6502/clock.c | 7 +++++++
 3 files changed, 10 insertions(+)
 create mode 100644 libsrc/rp6502/clock.c

diff --git a/include/rp6502.h b/include/rp6502.h
index 2b40cfc711..61664c78f3 100644
--- a/include/rp6502.h
+++ b/include/rp6502.h
@@ -101,6 +101,7 @@ long __fastcall__ ria_call_long_errno (unsigned char op);
 #define RIA_OP_CODEPAGE 0x03
 #define RIA_OP_LRAND 0x04
 #define RIA_OP_STDIN_OPT 0x05
+#define RIA_OP_CLOCK 0x0F
 #define RIA_OP_CLOCK_GETRES 0x10
 #define RIA_OP_CLOCK_GETTIME 0x11
 #define RIA_OP_CLOCK_SETTIME 0x12
diff --git a/include/time.h b/include/time.h
index f8977ab0c8..5eb6f144a5 100644
--- a/include/time.h
+++ b/include/time.h
@@ -86,6 +86,8 @@ struct tm {
 #  define CLOCKS_PER_SEC        135   /* FIXME */
 #elif defined(__GEOS__)
 #  define CLOCKS_PER_SEC        1
+#elif defined (__RP6502__)
+#  define CLOCKS_PER_SEC        100
 #elif defined(__TELESTRAT__)
 #  define CLOCKS_PER_SEC        10
 #elif defined(__ATARI__) || defined (__LYNX__)
diff --git a/libsrc/rp6502/clock.c b/libsrc/rp6502/clock.c
new file mode 100644
index 0000000000..f8756f553e
--- /dev/null
+++ b/libsrc/rp6502/clock.c
@@ -0,0 +1,7 @@
+#include <rp6502.h>
+#include <time.h>
+
+clock_t __fastcall__ clock (void)
+{
+    return ria_call_long (RIA_OP_CLOCK);
+}

From 9ffa2d05e65fd0aa3455235ffc5cc74cd9159c58 Mon Sep 17 00:00:00 2001
From: rumbledethumps <16963588+rumbledethumps@users.noreply.github.com>
Date: Tue, 30 Jan 2024 00:17:28 -0800
Subject: [PATCH 02/50] rp6502 validate write_xstack count

---
 include/rp6502.h             | 3 +--
 libsrc/rp6502/write_xstack.c | 4 ++++
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/include/rp6502.h b/include/rp6502.h
index 61664c78f3..53028c35a3 100644
--- a/include/rp6502.h
+++ b/include/rp6502.h
@@ -47,8 +47,7 @@ struct __RP6502
     unsigned char step1;
     unsigned int addr1;
     unsigned char xstack;
-    unsigned char errno_lo;
-    unsigned char errno_hi;
+    unsigned int errno;
     unsigned char op;
     unsigned char irq;
     const unsigned char spin;
diff --git a/libsrc/rp6502/write_xstack.c b/libsrc/rp6502/write_xstack.c
index b53aa95e73..ff979899d5 100644
--- a/libsrc/rp6502/write_xstack.c
+++ b/libsrc/rp6502/write_xstack.c
@@ -1,8 +1,12 @@
 #include <rp6502.h>
+#include <errno.h>
 
 int __fastcall__ write_xstack (const void* buf, unsigned count, int fildes)
 {
     unsigned i;
+    if (count > 256) {
+        return _mappederrno (EINVAL);
+    }
     for (i = count; i;) {
         ria_push_char (((char*)buf)[--i]);
     }

From 7b790cf8833668c21447490b8b84a0e704a3f134 Mon Sep 17 00:00:00 2001
From: rumbledethumps <16963588+rumbledethumps@users.noreply.github.com>
Date: Sun, 4 Feb 2024 23:38:44 -0800
Subject: [PATCH 03/50] add RIA_OP_CLOCK to asm inc

---
 asminc/rp6502.inc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/asminc/rp6502.inc b/asminc/rp6502.inc
index 7dd1b8fcd8..816712abb7 100644
--- a/asminc/rp6502.inc
+++ b/asminc/rp6502.inc
@@ -37,6 +37,7 @@ RIA_OP_PHI2               := $02
 RIA_OP_CODEPAGE           := $03
 RIA_OP_LRAND              := $04
 RIA_OP_STDIN_OPT          := $05
+RIA_OP_CLOCK              := $0F
 RIA_OP_CLOCK_GETRES       := $10
 RIA_OP_CLOCK_GETTIME      := $11
 RIA_OP_CLOCK_SETTIME      := $12

From f42e6a26b2b6f5f7df260cec15e21b04c8fee12c Mon Sep 17 00:00:00 2001
From: rumbledethumps <16963588+rumbledethumps@users.noreply.github.com>
Date: Sat, 17 Feb 2024 15:47:51 -0800
Subject: [PATCH 04/50] xstack bump to 512

---
 libsrc/rp6502/read.c         | 2 +-
 libsrc/rp6502/sysrename.c    | 2 +-
 libsrc/rp6502/write.c        | 2 +-
 libsrc/rp6502/write_xstack.c | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/libsrc/rp6502/read.c b/libsrc/rp6502/read.c
index eb96f779cf..87a9bbf7d5 100644
--- a/libsrc/rp6502/read.c
+++ b/libsrc/rp6502/read.c
@@ -5,7 +5,7 @@ int __fastcall__ read (int fildes, void* buf, unsigned count)
 {
     int total = 0;
     while (count) {
-        unsigned blockcount = (count > 256) ? 256 : count;
+        unsigned blockcount = (count > 512) ? 512 : count;
         int bytes_read = read_xstack (&((char*)buf)[total], blockcount, fildes);
         if (bytes_read < 0) {
             return bytes_read;
diff --git a/libsrc/rp6502/sysrename.c b/libsrc/rp6502/sysrename.c
index 96eca24cf3..46bdd8b314 100644
--- a/libsrc/rp6502/sysrename.c
+++ b/libsrc/rp6502/sysrename.c
@@ -7,7 +7,7 @@ unsigned char __fastcall__ _sysrename (const char* oldpath, const char* newpath)
     size_t oldpathlen, newpathlen;
     oldpathlen = strlen (oldpath);
     newpathlen = strlen (newpath);
-    if (oldpathlen + newpathlen > 254) {
+    if (oldpathlen + newpathlen > 510) {
         return _mappederrno (EINVAL);
     }
     while (oldpathlen) {
diff --git a/libsrc/rp6502/write.c b/libsrc/rp6502/write.c
index 11241dab58..23877b6e8d 100644
--- a/libsrc/rp6502/write.c
+++ b/libsrc/rp6502/write.c
@@ -5,7 +5,7 @@ int __fastcall__ write (int fildes, const void* buf, unsigned count)
 {
     int ax, total = 0;
     while (count) {
-        int blockcount = (count > 256) ? 256 : count;
+        int blockcount = (count > 512) ? 512 : count;
         ax = write_xstack (&((char*)buf)[total], blockcount, fildes);
         if (ax < 0) {
             return ax;
diff --git a/libsrc/rp6502/write_xstack.c b/libsrc/rp6502/write_xstack.c
index ff979899d5..29285a87ef 100644
--- a/libsrc/rp6502/write_xstack.c
+++ b/libsrc/rp6502/write_xstack.c
@@ -4,7 +4,7 @@
 int __fastcall__ write_xstack (const void* buf, unsigned count, int fildes)
 {
     unsigned i;
-    if (count > 256) {
+    if (count > 512) {
         return _mappederrno (EINVAL);
     }
     for (i = count; i;) {

From 4d3153e10e185323ca0d89c4d17b43bdffa803ca Mon Sep 17 00:00:00 2001
From: rumbledethumps <16963588+rumbledethumps@users.noreply.github.com>
Date: Sat, 17 Feb 2024 16:02:57 -0800
Subject: [PATCH 05/50] add rp6502 xregn

---
 include/rp6502.h      |  2 ++
 libsrc/rp6502/xregn.c | 19 +++++++++++++++++++
 2 files changed, 21 insertions(+)
 create mode 100644 libsrc/rp6502/xregn.c

diff --git a/include/rp6502.h b/include/rp6502.h
index 53028c35a3..7deeebc4c1 100644
--- a/include/rp6502.h
+++ b/include/rp6502.h
@@ -117,6 +117,8 @@ long __fastcall__ ria_call_long_errno (unsigned char op);
 
 /* C API for the operating system. */
 
+int __cdecl__ xregn (char device, char channel, unsigned char address, unsigned count,
+    ...);
 int __cdecl__ xreg (char device, char channel, unsigned char address, ...);
 int phi2 (void);
 int codepage (void);
diff --git a/libsrc/rp6502/xregn.c b/libsrc/rp6502/xregn.c
new file mode 100644
index 0000000000..ec040be208
--- /dev/null
+++ b/libsrc/rp6502/xregn.c
@@ -0,0 +1,19 @@
+#include <rp6502.h>
+#include <stdarg.h>
+
+int __cdecl__ xregn (char device, char channel, unsigned char address, unsigned count,
+    ...)
+{
+    va_list args;
+    va_start (args, count);
+    RIA.xstack = device;
+    RIA.xstack = channel;
+    RIA.xstack = address;
+    while (count--) {
+        unsigned v = va_arg (args, unsigned);
+        RIA.xstack = v >> 8;
+        RIA.xstack = v;
+    }
+    va_end (args);
+    return ria_call_int_errno (RIA_OP_XREG);
+}

From 622793e343b6241c00f5a13ce7b74a3a2f93b544 Mon Sep 17 00:00:00 2001
From: Colin Leroy-Mira <colin@colino.net>
Date: Sat, 24 Aug 2024 17:03:27 +0200
Subject: [PATCH 06/50] Apple II: Move _exit out of STARTUP segment

---
 libsrc/apple2/callmain.s | 75 ++++++++++++++++++++++++++++++++++++++++
 libsrc/apple2/crt0.s     | 44 +++--------------------
 2 files changed, 79 insertions(+), 40 deletions(-)
 create mode 100644 libsrc/apple2/callmain.s

diff --git a/libsrc/apple2/callmain.s b/libsrc/apple2/callmain.s
new file mode 100644
index 0000000000..71a8b56117
--- /dev/null
+++ b/libsrc/apple2/callmain.s
@@ -0,0 +1,75 @@
+;
+; Ullrich von Bassewitz, 2003-03-07
+;
+; Push arguments and call main()
+;
+
+
+        .export         callmain, _exit
+        .export         __argc, __argv
+
+        .import         _main, pushax, done, donelib
+        .import         zpsave, rvsave, reset
+
+        .include        "zeropage.inc"
+        .include        "apple2.inc"
+
+
+;---------------------------------------------------------------------------
+; Setup the stack for main(), then jump to it
+
+callmain:
+        lda     __argc
+        ldx     __argc+1
+        jsr     pushax          ; Push argc
+
+        lda     __argv
+        ldx     __argv+1
+        jsr     pushax          ; Push argv
+
+        ldy     #4              ; Argument size
+        jsr     _main
+
+        ; Avoid a re-entrance of donelib. This is also the exit() entry.
+_exit:  ldx     #<exit
+        lda     #>exit
+        jsr     reset           ; Setup RESET vector
+
+        ; Switch in LC bank 2 for R/O in case it was switched out by a RESET.
+        bit     $C080
+
+        ; Call the module destructors.
+        jsr     donelib
+
+        ; Switch in ROM.
+        bit     $C082
+
+        ; Restore the original RESET vector.
+exit:   ldx     #$02
+:       lda     rvsave,x
+        sta     SOFTEV,x
+        dex
+        bpl     :-
+
+        ; Copy back the zero-page stuff.
+        ldx     #zpspace-1
+:       lda     zpsave,x
+        sta     sp,x
+        dex
+        bpl     :-
+
+        ; ProDOS TechRefMan, chapter 5.2.1:
+        ; "System programs should set the stack pointer to $FF at the
+        ;  warm-start entry point."
+        ldx     #$FF
+        txs                     ; Re-init stack pointer
+
+        ; We're done
+        jmp     done
+
+;---------------------------------------------------------------------------
+; Data
+
+.data
+__argc:         .word   0
+__argv:         .addr   0
diff --git a/libsrc/apple2/crt0.s b/libsrc/apple2/crt0.s
index c129cdbf89..42e26c27be 100644
--- a/libsrc/apple2/crt0.s
+++ b/libsrc/apple2/crt0.s
@@ -4,10 +4,11 @@
 ; Startup code for cc65 (Apple2 version)
 ;
 
-        .export         _exit, done, return
+        .export         done, return
+        .export         zpsave, rvsave, reset
         .export         __STARTUP__ : absolute = 1      ; Mark as startup
 
-        .import         initlib, donelib
+        .import         initlib, _exit
         .import         zerobss, callmain
         .import         __ONCE_LOAD__, __ONCE_SIZE__    ; Linker generated
         .import         __LC_START__, __LC_LAST__       ; Linker generated
@@ -33,44 +34,7 @@
         jsr     zerobss
 
         ; Push the command-line arguments; and, call main().
-        jsr     callmain
-
-        ; Avoid a re-entrance of donelib. This is also the exit() entry.
-_exit:  ldx     #<exit
-        lda     #>exit
-        jsr     reset           ; Setup RESET vector
-
-        ; Switch in LC bank 2 for R/O in case it was switched out by a RESET.
-        bit     $C080
-
-        ; Call the module destructors.
-        jsr     donelib
-
-        ; Switch in ROM.
-        bit     $C082
-
-        ; Restore the original RESET vector.
-exit:   ldx     #$02
-:       lda     rvsave,x
-        sta     SOFTEV,x
-        dex
-        bpl     :-
-
-        ; Copy back the zero-page stuff.
-        ldx     #zpspace-1
-:       lda     zpsave,x
-        sta     sp,x
-        dex
-        bpl     :-
-
-        ; ProDOS TechRefMan, chapter 5.2.1:
-        ; "System programs should set the stack pointer to $FF at the
-        ;  warm-start entry point."
-        ldx     #$FF
-        txs                     ; Re-init stack pointer
-
-        ; We're done
-        jmp     done
+        jmp     callmain
 
 ; ------------------------------------------------------------------------
 

From 58b1c219965754f9a9367d1e75637d54998c8365 Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Sun, 1 Sep 2024 10:22:40 +0200
Subject: [PATCH 07/50] Removed #pragma names that have been obsolete for over
 a decade.

---
 src/cc65/pragma.c | 44 --------------------------------------------
 1 file changed, 44 deletions(-)

diff --git a/src/cc65/pragma.c b/src/cc65/pragma.c
index b9394494b3..31cfe3b733 100644
--- a/src/cc65/pragma.c
+++ b/src/cc65/pragma.c
@@ -68,28 +68,20 @@ typedef enum {
     PRAGMA_ALIGN,
     PRAGMA_ALLOW_EAGER_INLINE,
     PRAGMA_BSS_NAME,
-    PRAGMA_BSSSEG,                                      /* obsolete */
     PRAGMA_CHARMAP,
     PRAGMA_CHECK_STACK,
-    PRAGMA_CHECKSTACK,                                  /* obsolete */
     PRAGMA_CODE_NAME,
-    PRAGMA_CODESEG,                                     /* obsolete */
     PRAGMA_CODESIZE,
     PRAGMA_DATA_NAME,
-    PRAGMA_DATASEG,                                     /* obsolete */
     PRAGMA_INLINE_STDFUNCS,
     PRAGMA_LOCAL_STRINGS,
     PRAGMA_MESSAGE,
     PRAGMA_OPTIMIZE,
     PRAGMA_REGISTER_VARS,
     PRAGMA_REGVARADDR,
-    PRAGMA_REGVARS,                                     /* obsolete */
     PRAGMA_RODATA_NAME,
-    PRAGMA_RODATASEG,                                   /* obsolete */
     PRAGMA_SIGNED_CHARS,
-    PRAGMA_SIGNEDCHARS,                                 /* obsolete */
     PRAGMA_STATIC_LOCALS,
-    PRAGMA_STATICLOCALS,                                /* obsolete */
     PRAGMA_WARN,
     PRAGMA_WRAPPED_CALL,
     PRAGMA_WRITABLE_STRINGS,
@@ -105,28 +97,20 @@ static const struct Pragma {
     { "align",                  PRAGMA_ALIGN              },
     { "allow-eager-inline",     PRAGMA_ALLOW_EAGER_INLINE },
     { "bss-name",               PRAGMA_BSS_NAME           },
-    { "bssseg",                 PRAGMA_BSSSEG             },      /* obsolete */
     { "charmap",                PRAGMA_CHARMAP            },
     { "check-stack",            PRAGMA_CHECK_STACK        },
-    { "checkstack",             PRAGMA_CHECKSTACK         },      /* obsolete */
     { "code-name",              PRAGMA_CODE_NAME          },
-    { "codeseg",                PRAGMA_CODESEG            },      /* obsolete */
     { "codesize",               PRAGMA_CODESIZE           },
     { "data-name",              PRAGMA_DATA_NAME          },
-    { "dataseg",                PRAGMA_DATASEG            },      /* obsolete */
     { "inline-stdfuncs",        PRAGMA_INLINE_STDFUNCS    },
     { "local-strings",          PRAGMA_LOCAL_STRINGS      },
     { "message",                PRAGMA_MESSAGE            },
     { "optimize",               PRAGMA_OPTIMIZE           },
     { "register-vars",          PRAGMA_REGISTER_VARS      },
     { "regvaraddr",             PRAGMA_REGVARADDR         },
-    { "regvars",                PRAGMA_REGVARS            },      /* obsolete */
     { "rodata-name",            PRAGMA_RODATA_NAME        },
-    { "rodataseg",              PRAGMA_RODATASEG          },      /* obsolete */
     { "signed-chars",           PRAGMA_SIGNED_CHARS       },
-    { "signedchars",            PRAGMA_SIGNEDCHARS        },      /* obsolete */
     { "static-locals",          PRAGMA_STATIC_LOCALS      },
-    { "staticlocals",           PRAGMA_STATICLOCALS       },      /* obsolete */
     { "warn",                   PRAGMA_WARN               },
     { "wrapped-call",           PRAGMA_WRAPPED_CALL       },
     { "writable-strings",       PRAGMA_WRITABLE_STRINGS   },
@@ -402,22 +386,18 @@ static void ApplySegNamePragma (pragma_t Token, int PushPop, const char* Name, u
 
     switch (Token) {
         case PRAGMA_CODE_NAME:
-        case PRAGMA_CODESEG:
             Seg = SEG_CODE;
             break;
 
         case PRAGMA_RODATA_NAME:
-        case PRAGMA_RODATASEG:
             Seg = SEG_RODATA;
             break;
 
         case PRAGMA_DATA_NAME:
-        case PRAGMA_DATASEG:
             Seg = SEG_DATA;
             break;
 
         case PRAGMA_BSS_NAME:
-        case PRAGMA_BSSSEG:
             Seg = SEG_BSS;
             break;
 
@@ -933,9 +913,6 @@ static void ParsePragmaString (void)
             FlagPragma (PES_STMT, Pragma, &B, &EagerlyInlineFuncs);
             break;
 
-        case PRAGMA_BSSSEG:
-            Warning ("#pragma bssseg is obsolete, please use #pragma bss-name instead");
-            /* FALLTHROUGH */
         case PRAGMA_BSS_NAME:
             /* TODO: PES_STMT or even PES_EXPR (PES_DECL) maybe? */
             SegNamePragma (PES_FUNC, PRAGMA_BSS_NAME, &B);
@@ -945,17 +922,11 @@ static void ParsePragmaString (void)
             CharMapPragma (PES_IMM, &B);
             break;
 
-        case PRAGMA_CHECKSTACK:
-            Warning ("#pragma checkstack is obsolete, please use #pragma check-stack instead");
-            /* FALLTHROUGH */
         case PRAGMA_CHECK_STACK:
             /* TODO: PES_SCOPE maybe? */
             FlagPragma (PES_FUNC, Pragma, &B, &CheckStack);
             break;
 
-        case PRAGMA_CODESEG:
-            Warning ("#pragma codeseg is obsolete, please use #pragma code-name instead");
-            /* FALLTHROUGH */
         case PRAGMA_CODE_NAME:
             /* PES_FUNC is the only sensible option so far */
             SegNamePragma (PES_FUNC, PRAGMA_CODE_NAME, &B);
@@ -966,9 +937,6 @@ static void ParsePragmaString (void)
             IntPragma (PES_STMT, Pragma, &B, &CodeSizeFactor, 10, 1000);
             break;
 
-        case PRAGMA_DATASEG:
-            Warning ("#pragma dataseg is obsolete, please use #pragma data-name instead");
-            /* FALLTHROUGH */
         case PRAGMA_DATA_NAME:
             /* TODO: PES_STMT or even PES_EXPR (PES_DECL) maybe? */
             SegNamePragma (PES_FUNC, PRAGMA_DATA_NAME, &B);
@@ -999,33 +967,21 @@ static void ParsePragmaString (void)
             FlagPragma (PES_FUNC, Pragma, &B, &AllowRegVarAddr);
             break;
 
-        case PRAGMA_REGVARS:
-            Warning ("#pragma regvars is obsolete, please use #pragma register-vars instead");
-            /* FALLTHROUGH */
         case PRAGMA_REGISTER_VARS:
             /* TODO: PES_STMT or even PES_EXPR (PES_DECL) maybe? */
             FlagPragma (PES_FUNC, Pragma, &B, &EnableRegVars);
             break;
 
-        case PRAGMA_RODATASEG:
-            Warning ("#pragma rodataseg is obsolete, please use #pragma rodata-name instead");
-            /* FALLTHROUGH */
         case PRAGMA_RODATA_NAME:
             /* TODO: PES_STMT or even PES_EXPR maybe? */
             SegNamePragma (PES_FUNC, PRAGMA_RODATA_NAME, &B);
             break;
 
-        case PRAGMA_SIGNEDCHARS:
-            Warning ("#pragma signedchars is obsolete, please use #pragma signed-chars instead");
-            /* FALLTHROUGH */
         case PRAGMA_SIGNED_CHARS:
             /* TODO: PES_STMT or even PES_EXPR maybe? */
             FlagPragma (PES_FUNC, Pragma, &B, &SignedChars);
             break;
 
-        case PRAGMA_STATICLOCALS:
-            Warning ("#pragma staticlocals is obsolete, please use #pragma static-locals instead");
-            /* FALLTHROUGH */
         case PRAGMA_STATIC_LOCALS:
             /* TODO: PES_STMT or even PES_EXPR (PES_DECL) maybe? */
             FlagPragma (PES_FUNC, Pragma, &B, &StaticLocals);

From ba263d13a7c7e99b07e080e68184bc6df17a7146 Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Sun, 1 Sep 2024 10:22:57 +0200
Subject: [PATCH 08/50] Allow alternative #pragma names using underscores.

---
 src/cc65/pragma.c | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/src/cc65/pragma.c b/src/cc65/pragma.c
index 31cfe3b733..ee71b42d8b 100644
--- a/src/cc65/pragma.c
+++ b/src/cc65/pragma.c
@@ -86,36 +86,49 @@ typedef enum {
     PRAGMA_WRAPPED_CALL,
     PRAGMA_WRITABLE_STRINGS,
     PRAGMA_ZPSYM,
-    PRAGMA_COUNT
 } pragma_t;
 
 /* Pragma table */
 static const struct Pragma {
     const char* Key;            /* Keyword */
     pragma_t    Tok;            /* Token */
-} Pragmas[PRAGMA_COUNT] = {
+} Pragmas[] = {
     { "align",                  PRAGMA_ALIGN              },
     { "allow-eager-inline",     PRAGMA_ALLOW_EAGER_INLINE },
+    { "allow_eager_inline",     PRAGMA_ALLOW_EAGER_INLINE },
     { "bss-name",               PRAGMA_BSS_NAME           },
+    { "bss_name",               PRAGMA_BSS_NAME           },
     { "charmap",                PRAGMA_CHARMAP            },
     { "check-stack",            PRAGMA_CHECK_STACK        },
+    { "check_stack",            PRAGMA_CHECK_STACK        },
     { "code-name",              PRAGMA_CODE_NAME          },
+    { "code_name",              PRAGMA_CODE_NAME          },
     { "codesize",               PRAGMA_CODESIZE           },
     { "data-name",              PRAGMA_DATA_NAME          },
+    { "data_name",              PRAGMA_DATA_NAME          },
     { "inline-stdfuncs",        PRAGMA_INLINE_STDFUNCS    },
+    { "inline_stdfuncs",        PRAGMA_INLINE_STDFUNCS    },
     { "local-strings",          PRAGMA_LOCAL_STRINGS      },
+    { "local_strings",          PRAGMA_LOCAL_STRINGS      },
     { "message",                PRAGMA_MESSAGE            },
     { "optimize",               PRAGMA_OPTIMIZE           },
     { "register-vars",          PRAGMA_REGISTER_VARS      },
+    { "register_vars",          PRAGMA_REGISTER_VARS      },
     { "regvaraddr",             PRAGMA_REGVARADDR         },
     { "rodata-name",            PRAGMA_RODATA_NAME        },
+    { "rodata_name",            PRAGMA_RODATA_NAME        },
     { "signed-chars",           PRAGMA_SIGNED_CHARS       },
+    { "signed_chars",           PRAGMA_SIGNED_CHARS       },
     { "static-locals",          PRAGMA_STATIC_LOCALS      },
+    { "static_locals",          PRAGMA_STATIC_LOCALS      },
     { "warn",                   PRAGMA_WARN               },
     { "wrapped-call",           PRAGMA_WRAPPED_CALL       },
+    { "wrapped_call",           PRAGMA_WRAPPED_CALL       },
     { "writable-strings",       PRAGMA_WRITABLE_STRINGS   },
+    { "writable_strings",       PRAGMA_WRITABLE_STRINGS   },
     { "zpsym",                  PRAGMA_ZPSYM              },
 };
+#define PRAGMA_COUNT    (sizeof (Pragmas) / sizeof (Pragmas[0]))
 
 /* Result of ParsePushPop */
 typedef enum {

From 4008ec581423d5e17ac5e35ca9ee307f79f20a49 Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Sun, 1 Sep 2024 10:23:10 +0200
Subject: [PATCH 09/50] Document the new #pragma names.

---
 doc/cc65.sgml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/doc/cc65.sgml b/doc/cc65.sgml
index efe48b61b6..2219ccf6a4 100644
--- a/doc/cc65.sgml
+++ b/doc/cc65.sgml
@@ -1273,6 +1273,12 @@ If the first parameter is <tt/push/, the old value is saved onto a stack
 before changing it. The value may later be restored by using the <tt/pop/
 parameter with the <tt/#pragma/.
 
+For all pragma names that contain hyphens, the same name using underlines
+instead of the hyphens is available as an alternative. While the former
+resembles the corresponding command line option and is more orthogonal, the
+latter may be more compatible with external tools that rewrite the token
+sequences of the input.
+
 
 <sect1><tt>#pragma allow-eager-inline ([push,] on|off)</tt><label id="pragma-allow-eager-inline"><p>
 

From e40058257eb3798ea46a47957d95d87e7e78721c Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Sun, 1 Sep 2024 10:23:29 +0200
Subject: [PATCH 10/50] Added a test for the available #pragmas.

---
 test/val/pragmas.c | 44 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 test/val/pragmas.c

diff --git a/test/val/pragmas.c b/test/val/pragmas.c
new file mode 100644
index 0000000000..802c7a5c3f
--- /dev/null
+++ b/test/val/pragmas.c
@@ -0,0 +1,44 @@
+/* Note: This tests just if the #pragmas are understood. It doesn't test if
+** they do really work. This would require much more work.
+*/
+
+void func(void);
+#pragma align(push, 1024)
+#pragma allow-eager-inline(push, on)
+#pragma allow_eager_inline(pop)
+#pragma bss-name(push, "BSS")
+#pragma bss_name(pop)
+#pragma charmap(1, 1)
+#pragma check-stack(on)
+#pragma check_stack(off)
+#pragma code-name(push, "CODE")
+#pragma code_name("CODE")
+#pragma codesize(200)
+#pragma data-name("DATA")
+#pragma data_name("DATA")
+#pragma inline-stdfuncs(off)
+#pragma inline_stdfuncs(on)
+#pragma local-strings(off)
+#pragma local_strings(off)
+#pragma message("in a bottle")
+#pragma optimize(off)
+#pragma register-vars(off)
+#pragma register_vars(on)
+#pragma regvaraddr(on)
+#pragma rodata-name("RODATA")
+#pragma rodata_name("RODATA")
+#pragma signed-chars(off)
+#pragma signed_chars(on)
+#pragma static-locals(off)
+#pragma static_locals(on)
+#pragma warn(unused-param, on)
+#pragma wrapped-call(push, func, 0)     // push is required for this #pragma
+#pragma wrapped_call(push, func, 1)
+#pragma writable-strings(on)
+#pragma writable_strings(off)
+#pragma zpsym("func")
+
+int main ()
+{
+    return 0;
+}

From ef17250c64b2e7842e0807ccb63156c05cde35df Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Sun, 1 Sep 2024 10:26:45 +0200
Subject: [PATCH 11/50] Fixed a compiler warning.

---
 src/cc65/scanner.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cc65/scanner.c b/src/cc65/scanner.c
index 6b5235679b..879925c7c4 100644
--- a/src/cc65/scanner.c
+++ b/src/cc65/scanner.c
@@ -1267,7 +1267,7 @@ static int CloseBrace (Collection* C, token_t Tok)
 */
 {
     if (CollCount (C) > 0) {
-        token_t LastTok = (token_t)CollLast (C);
+        token_t LastTok = (token_t)(intptr_t)CollLast (C);
         if (LastTok == Tok) {
             CollPop (C);
             NextToken ();

From 35c3fe5d0a8710312e5722ad9fad1581784c80fa Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Sun, 1 Sep 2024 10:29:59 +0200
Subject: [PATCH 12/50] Fix issue #2044. While doing so, cleanup copy&pasted
 code.

---
 src/ld65/config.c  | 15 +++++---
 src/ld65/exports.c | 89 +++++++++++++++++++---------------------------
 2 files changed, 48 insertions(+), 56 deletions(-)

diff --git a/src/ld65/config.c b/src/ld65/config.c
index 6c1f6ad4cd..947302e981 100644
--- a/src/ld65/config.c
+++ b/src/ld65/config.c
@@ -889,6 +889,7 @@ static void ParseO65 (void)
         CfgOptionalAssign ();
 
         /* Check which attribute was given */
+        CfgSymbol* Sym;
         switch (AttrTok) {
 
             case CFGTOK_EXPORT:
@@ -896,8 +897,11 @@ static void ParseO65 (void)
                 AttrFlags |= atExport;
                 /* We expect an identifier */
                 CfgAssureIdent ();
-                /* Remember it as an export for later */
-                NewCfgSymbol (CfgSymO65Export, GetStrBufId (&CfgSVal));
+                /* Remember it as an export for later. We do not support o65
+                 * output for the 65816, so the address size is always 16 bit.
+                 */
+                Sym = NewCfgSymbol (CfgSymO65Export, GetStrBufId (&CfgSVal));
+                Sym->AddrSize = ADDR_SIZE_ABS;
                 /* Eat the identifier token */
                 CfgNextTok ();
                 break;
@@ -907,8 +911,11 @@ static void ParseO65 (void)
                 AttrFlags |= atImport;
                 /* We expect an identifier */
                 CfgAssureIdent ();
-                /* Remember it as an import for later */
-                NewCfgSymbol (CfgSymO65Import, GetStrBufId (&CfgSVal));
+                /* Remember it as an import for later. We do not support o65
+                 * output for the 65816, so the address size is always 16 bit.
+                 */
+                Sym = NewCfgSymbol (CfgSymO65Import, GetStrBufId (&CfgSVal));
+                Sym->AddrSize = ADDR_SIZE_ABS;
                 /* Eat the identifier token */
                 CfgNextTok ();
                 break;
diff --git a/src/ld65/exports.c b/src/ld65/exports.c
index 9149f54d18..9fa0e4019b 100644
--- a/src/ld65/exports.c
+++ b/src/ld65/exports.c
@@ -808,6 +808,15 @@ static int CmpExpName (const void* K1, const void* K2)
 
 
 
+static int CmpExpValue (const void* K1, const void* K2)
+/* Compare function for qsort */
+{
+    long Diff = GetExportVal (*(Export**)K1) - GetExportVal (*(Export**)K2);
+    return Diff < 0? -1 : Diff > 0? 1 : 0;
+}
+
+
+
 static void CreateExportPool (void)
 /* Create an array with pointer to all exports */
 {
@@ -880,19 +889,25 @@ static char GetAddrSizeCode (unsigned char AddrSize)
 
 
 
-void PrintExportMapByName (FILE* F)
-/* Print an export map, sorted by symbol name, to the given file */
+static void PrintExportMap (Export** Pool, unsigned Count, FILE* F)
+/* Print an export map to the given file */
 {
     unsigned I;
-    unsigned Count;
 
     /* Print all exports */
-    Count = 0;
-    for (I = 0; I < ExpCount; ++I) {
-        const Export* E = ExpPool [I];
-
-        /* Print unreferenced symbols only if explictly requested */
-        if (VerboseMap || E->ImpCount > 0 || SYM_IS_CONDES (E->Type)) {
+    unsigned Col = 0;
+    for (I = 0; I < Count; ++I) {
+        const Export* E = Pool [I];
+
+        /* Print unreferenced symbols only if explictly requested. If Expr is
+        ** NULL, the export is undefined. This happens for imports that don't
+        ** have a matching export, but if we have one of those, we don't come
+        ** here. It does also happen for imports that where satisfied from
+        ** elsewhere, like o65 imports defined in the linker config.
+        ** So ignore exports here that have an invalid Expr.
+        */
+        if (E->Expr != 0 &&
+            (VerboseMap || E->ImpCount > 0 || SYM_IS_CONDES (E->Type))) {
             fprintf (F,
                      "%-25s %06lX %c%c%c%c   ",
                      GetString (E->Name),
@@ -901,8 +916,8 @@ void PrintExportMapByName (FILE* F)
                      SYM_IS_LABEL (E->Type)? 'L' : 'E',
                      GetAddrSizeCode ((unsigned char) E->AddrSize),
                      SYM_IS_CONDES (E->Type)? 'I' : ' ');
-            if (++Count == 2) {
-                Count = 0;
+            if (++Col == 2) {
+                Col = 0;
                 fprintf (F, "\n");
             }
         }
@@ -912,13 +927,10 @@ void PrintExportMapByName (FILE* F)
 
 
 
-static int CmpExpValue (const void* I1, const void* I2)
-/* Compare function for qsort */
+void PrintExportMapByName (FILE* F)
+/* Print an export map, sorted by symbol name, to the given file */
 {
-    long V1 = GetExportVal (ExpPool [*(unsigned *)I1]);
-    long V2 = GetExportVal (ExpPool [*(unsigned *)I2]);
-
-    return V1 < V2 ? -1 : V1 == V2 ? 0 : 1;
+    PrintExportMap (ExpPool, ExpCount, F);
 }
 
 
@@ -926,43 +938,16 @@ static int CmpExpValue (const void* I1, const void* I2)
 void PrintExportMapByValue (FILE* F)
 /* Print an export map, sorted by symbol value, to the given file */
 {
-    unsigned I;
-    unsigned Count;
-    unsigned *ExpValXlat;
-
-    /* Create a translation table where the symbols are sorted by value. */
-    ExpValXlat = xmalloc (ExpCount * sizeof (unsigned));
-    for (I = 0; I < ExpCount; ++I) {
-        /* Initialize table with current sort order.  */
-        ExpValXlat [I] = I;
-    }
-
-    /* Sort them by value */
-    qsort (ExpValXlat, ExpCount, sizeof (unsigned), CmpExpValue);
+    /* Create a new pool that is sorted by value */
+    Export** Pool = xmalloc (ExpCount * sizeof (Export*));
+    memcpy (Pool, ExpPool, ExpCount * sizeof (Export*));
+    qsort (Pool, ExpCount, sizeof (Export*), CmpExpValue);
 
-    /* Print all exports */
-    Count = 0;
-    for (I = 0; I < ExpCount; ++I) {
-        const Export* E = ExpPool [ExpValXlat [I]];
+    /* Print the exports */
+    PrintExportMap (Pool, ExpCount, F);
 
-        /* Print unreferenced symbols only if explictly requested */
-        if (VerboseMap || E->ImpCount > 0 || SYM_IS_CONDES (E->Type)) {
-            fprintf (F,
-                     "%-25s %06lX %c%c%c%c   ",
-                     GetString (E->Name),
-                     GetExportVal (E),
-                     E->ImpCount? 'R' : ' ',
-                     SYM_IS_LABEL (E->Type)? 'L' : 'E',
-                     GetAddrSizeCode ((unsigned char) E->AddrSize),
-                     SYM_IS_CONDES (E->Type)? 'I' : ' ');
-            if (++Count == 2) {
-                Count = 0;
-                fprintf (F, "\n");
-            }
-        }
-    }
-    fprintf (F, "\n");
-    xfree (ExpValXlat);
+    /* Free the allocated buffer */
+    xfree (Pool);
 }
 
 

From 4b68d19993c41da4f77342e8bc4dea74a9d4f80c Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Sun, 1 Sep 2024 10:42:18 +0200
Subject: [PATCH 13/50] Fix issue #1663.

---
 src/ca65/condasm.c | 76 +++++++++++++++++++++++++---------------------
 1 file changed, 42 insertions(+), 34 deletions(-)

diff --git a/src/ca65/condasm.c b/src/ca65/condasm.c
index 6198f4017a..f872ec9eda 100644
--- a/src/ca65/condasm.c
+++ b/src/ca65/condasm.c
@@ -133,24 +133,26 @@ static void SetIfCond (IfDesc* ID, int C)
 
 
 
-static void ElseClause (IfDesc* ID, const char* Directive)
-/* Enter an .ELSE clause */
+static int ElseClause (IfDesc* ID, const char* Directive)
+/* Enter an .ELSE clause. Return true if this was ok, zero on errors. */
 {
     /* Check if we have an open .IF - otherwise .ELSE is not allowed */
     if (ID == 0) {
         Error ("Unexpected %s", Directive);
-        return;
+        return 0;
     }
 
     /* Check for a duplicate else, then remember that we had one */
     if (ID->Flags & ifElse) {
         /* We already had a .ELSE ! */
         Error ("Duplicate .ELSE");
+        return 0;
     }
     ID->Flags |= ifElse;
 
     /* Condition is inverted now */
     ID->Flags ^= ifCond;
+    return 1;
 }
 
 
@@ -226,46 +228,52 @@ void DoConditionals (void)
                 D = GetCurrentIf ();
 
                 /* Allow an .ELSE */
-                ElseClause (D, ".ELSE");
-
-                /* Remember the data for the .ELSE */
-                if (D) {
-                    ReleaseFullLineInfo (&D->LineInfos);
-                    GetFullLineInfo (&D->LineInfos);
-                    D->Name = ".ELSE";
-                }
+                if (ElseClause (D, ".ELSE")) {
+                    /* Remember the data for the .ELSE */
+                    if (D) {
+                        ReleaseFullLineInfo (&D->LineInfos);
+                        GetFullLineInfo (&D->LineInfos);
+                        D->Name = ".ELSE";
+                    }
 
-                /* Calculate the new overall condition */
-                CalcOverallIfCond ();
+                    /* Calculate the new overall condition */
+                    CalcOverallIfCond ();
 
-                /* Skip .ELSE */
-                NextTok ();
-                ExpectSep ();
+                    /* Skip .ELSE */
+                    NextTok ();
+                    ExpectSep ();
+                } else {
+                    /* Problem with .ELSE, ignore remainder of line */
+                    SkipUntilSep ();
+                }
                 break;
 
             case TOK_ELSEIF:
                 D = GetCurrentIf ();
                 /* Handle as if there was an .ELSE first */
-                ElseClause (D, ".ELSEIF");
-
-                /* Calculate the new overall if condition */
-                CalcOverallIfCond ();
-
-                /* Allocate and prepare a new descriptor */
-                D = AllocIf (".ELSEIF", 0);
-                NextTok ();
+                if (ElseClause (D, ".ELSEIF")) {
+                    /* Calculate the new overall if condition */
+                    CalcOverallIfCond ();
+
+                    /* Allocate and prepare a new descriptor */
+                    D = AllocIf (".ELSEIF", 0);
+                    NextTok ();
+
+                    /* Ignore the new condition if we are inside a false .ELSE
+                    ** branch. This way we won't get any errors about undefined
+                    ** symbols or similar...
+                    */
+                    if (IfCond) {
+                        SetIfCond (D, ConstExpression ());
+                        ExpectSep ();
+                    }
 
-                /* Ignore the new condition if we are inside a false .ELSE
-                ** branch. This way we won't get any errors about undefined
-                ** symbols or similar...
-                */
-                if (IfCond) {
-                    SetIfCond (D, ConstExpression ());
-                    ExpectSep ();
+                    /* Get the new overall condition */
+                    CalcOverallIfCond ();
+                } else {
+                    /* Problem with .ELSEIF, ignore remainder of line */
+                    SkipUntilSep ();
                 }
-
-                /* Get the new overall condition */
-                CalcOverallIfCond ();
                 break;
 
             case TOK_ENDIF:

From b5cc68d6e2afe6d249ad31c83bf64382eade7b49 Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Sun, 1 Sep 2024 12:41:25 +0200
Subject: [PATCH 14/50] Do not save any register variables when entering
 main(). Do not restore the C stack when leaving main(). Both are unnecessary
 and just bloat the executable.

---
 src/cc65/codegen.c  | 43 ++++++++++++++++++++++++-------------------
 src/cc65/codegen.h  |  2 +-
 src/cc65/function.c |  8 +++++---
 src/cc65/locals.c   | 44 ++++++++++++++++++++++++++++++++++----------
 4 files changed, 64 insertions(+), 33 deletions(-)

diff --git a/src/cc65/codegen.c b/src/cc65/codegen.c
index 69dcc1c6c2..45823fab6d 100644
--- a/src/cc65/codegen.c
+++ b/src/cc65/codegen.c
@@ -507,34 +507,39 @@ void g_enter (unsigned flags, unsigned argsize)
 
 
 
-void g_leave (void)
+void g_leave (int IsMainFunc)
 /* Function epilogue */
 {
-    /* How many bytes of locals do we have to drop? */
-    unsigned ToDrop = (unsigned) -StackPtr;
+    /* In the main function nothing has to be dropped because the program
+    ** is terminated anyway.
+    */
+    if (!IsMainFunc) {
+        /* How many bytes of locals do we have to drop? */
+        unsigned ToDrop = (unsigned) -StackPtr;
 
-    /* If we didn't have a variable argument list, don't call leave */
-    if (funcargs >= 0) {
+        /* If we didn't have a variable argument list, don't call leave */
+        if (funcargs >= 0) {
 
-        /* Drop stackframe if needed */
-        g_drop (ToDrop + funcargs);
+            /* Drop stackframe if needed */
+            g_drop (ToDrop + funcargs);
 
-    } else if (StackPtr != 0) {
+        } else if (StackPtr != 0) {
 
-        /* We've a stack frame to drop */
-        if (ToDrop > 255) {
-            g_drop (ToDrop);            /* Inlines the code */
-            AddCodeLine ("jsr leave");
-        } else {
-            AddCodeLine ("ldy #$%02X", ToDrop);
-            AddCodeLine ("jsr leavey");
-        }
+            /* We've a stack frame to drop */
+            if (ToDrop > 255) {
+                g_drop (ToDrop);            /* Inlines the code */
+                AddCodeLine ("jsr leave");
+            } else {
+                AddCodeLine ("ldy #$%02X", ToDrop);
+                AddCodeLine ("jsr leavey");
+            }
 
-    } else {
+        } else {
 
-        /* Nothing to drop */
-        AddCodeLine ("jsr leave");
+            /* Nothing to drop */
+            AddCodeLine ("jsr leave");
 
+        }
     }
 
     /* Add the final rts */
diff --git a/src/cc65/codegen.h b/src/cc65/codegen.h
index 8e04b45e49..b95df5cfba 100644
--- a/src/cc65/codegen.h
+++ b/src/cc65/codegen.h
@@ -247,7 +247,7 @@ void g_scale (unsigned flags, long val);
 void g_enter (unsigned flags, unsigned argsize);
 /* Function prologue */
 
-void g_leave (void);
+void g_leave (int IsMainFunc);
 /* Function epilogue */
 
 
diff --git a/src/cc65/function.c b/src/cc65/function.c
index a4b8602516..d5cab3993e 100644
--- a/src/cc65/function.c
+++ b/src/cc65/function.c
@@ -646,11 +646,13 @@ void NewFunc (SymEntry* Func, FuncDesc* D)
     /* Output the function exit code label */
     g_defcodelabel (F_GetRetLab (CurrentFunc));
 
-    /* Restore the register variables */
-    F_RestoreRegVars (CurrentFunc);
+    /* Restore the register variables (not necessary for main function) */
+    if (!F_IsMainFunc (CurrentFunc)) {
+        F_RestoreRegVars (CurrentFunc);
+    }
 
     /* Generate the exit code */
-    g_leave ();
+    g_leave (F_IsMainFunc (CurrentFunc));
 
     /* Emit references to imports/exports */
     EmitExternals ();
diff --git a/src/cc65/locals.c b/src/cc65/locals.c
index 34d7623242..c4d0aa25b2 100644
--- a/src/cc65/locals.c
+++ b/src/cc65/locals.c
@@ -111,22 +111,31 @@ static void ParseRegisterDecl (Declarator* Decl, int Reg)
     /* Get the size of the variable */
     unsigned Size = SizeOf (Decl->Type);
 
-    /* Save the current contents of the register variable on stack */
-    F_AllocLocalSpace (CurrentFunc);
-    g_save_regvars (Reg, Size);
-
-    /* Add the symbol to the symbol table. We do that now, because for register
-    ** variables the current stack pointer is implicitly used as location for
-    ** the save area.
-    */
-    Sym = AddLocalSym (Decl->Ident, Decl->Type, Decl->StorageClass, Reg);
-
     /* Check for an optional initialization */
     if (CurTok.Tok == TOK_ASSIGN) {
 
         /* Skip the '=' */
         NextToken ();
 
+        /* If the register variable is initialized, the initialization code may
+        ** access other already declared variables. This means that we have to
+        ** allocate them now.
+        */
+        F_AllocLocalSpace (CurrentFunc);
+
+        /* Save the current contents of the register variable on stack. This is
+        ** not necessary for the main function.
+        */
+        if (!F_IsMainFunc (CurrentFunc)) {
+            g_save_regvars (Reg, Size);
+        }
+
+        /* Add the symbol to the symbol table. We do that now, because for
+        ** register variables the current stack pointer is implicitly used
+        ** as location for the save area (unused in case of main()).
+        */
+        Sym = AddLocalSym (Decl->Ident, Decl->Type, Decl->StorageClass, Reg);
+
         /* Special handling for compound types */
         if (IsCompound) {
 
@@ -173,6 +182,21 @@ static void ParseRegisterDecl (Declarator* Decl, int Reg)
 
         /* Mark the variable as referenced */
         Sym->Flags |= SC_REF;
+    } else {
+
+        /* Save the current contents of the register variable on stack. This is
+        ** not necessary for the main function.
+        */
+        if (!F_IsMainFunc (CurrentFunc)) {
+            F_AllocLocalSpace (CurrentFunc);
+            g_save_regvars (Reg, Size);
+        }
+
+        /* Add the symbol to the symbol table. We do that now, because for
+        ** register variables the current stack pointer is implicitly used
+        ** as location for the save area (unused in case of main()).
+        */
+        Sym = AddLocalSym (Decl->Ident, Decl->Type, Decl->StorageClass, Reg);
     }
 
     /* Cannot allocate a variable of unknown size */

From b4aef6eac4f81ab2e29fc301559e23b4d464d1cc Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Sun, 1 Sep 2024 13:16:35 +0200
Subject: [PATCH 15/50] Fix macro preprocessing for #include. Arguments
 enclosed in "" or <> must not be preprocessed. See ISO/IEC 9899 1990 (E)
 section 6.8.2.

---
 src/cc65/preproc.c | 27 +++++++++++++++++++++++----
 test/val/bug2458.c | 10 ++++++++++
 test/val/bug2458.h |  1 +
 3 files changed, 34 insertions(+), 4 deletions(-)
 create mode 100644 test/val/bug2458.c
 create mode 100644 test/val/bug2458.h

diff --git a/src/cc65/preproc.c b/src/cc65/preproc.c
index 66cbb2a9d0..1ee810060d 100644
--- a/src/cc65/preproc.c
+++ b/src/cc65/preproc.c
@@ -2812,11 +2812,30 @@ static void DoInclude (void)
     InputType   IT;
     StrBuf      Filename = AUTO_STRBUF_INITIALIZER;
 
-    /* Macro-replace a single line with special support for <filename> */
-    SB_Clear (MLine);
-    PreprocessDirective (Line, MLine, MSM_TOK_HEADER);
+    /* Skip whitespace so the input pointer points to the argument */
+    SkipWhitespace (0);
 
-    /* Read from the processed line */
+    /* We may have three forms of the #include directive:
+    **
+    ** - # include "q-char-sequence" new-line
+    ** - # include <h-char-sequence> new-line
+    ** - # include pp-tokens new-line
+    **
+    ** The former two are processed as is while the latter is preprocessed and
+    ** must then resemble one of the first two forms.
+    */
+    if (CurC == '"' || CurC == '<') {
+        /* Copy the argument part over to MLine */
+        unsigned Start = SB_GetIndex (Line);
+        unsigned Length = SB_GetLen (Line) - Start;
+        SB_Slice (MLine, Line, Start, Length);
+    } else {
+        /* Macro-replace a single line with special support for <filename> */
+        SB_Clear (MLine);
+        PreprocessDirective (Line, MLine, MSM_TOK_HEADER);
+    }
+
+    /* Read from the copied/preprocessed line */
     SB_Reset (MLine);
     MLine = InitLine (MLine);
 
diff --git a/test/val/bug2458.c b/test/val/bug2458.c
new file mode 100644
index 0000000000..1494a7946d
--- /dev/null
+++ b/test/val/bug2458.c
@@ -0,0 +1,10 @@
+#define str(arg) #arg
+#include str(bug2458.h)         /* Ok, macro replacement */
+
+#define string foo
+#include <string.h>             /* Ok, no macro replacement */
+
+int main()
+{
+    return 0;
+}
diff --git a/test/val/bug2458.h b/test/val/bug2458.h
new file mode 100644
index 0000000000..8b13789179
--- /dev/null
+++ b/test/val/bug2458.h
@@ -0,0 +1 @@
+

From b2aceaea241d39cc7f821790579e77e70c71fd4a Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Sun, 1 Sep 2024 19:58:07 +0200
Subject: [PATCH 16/50] Fix behavior of .INCLUDE within a macro or .REPEAT. In
 the original code .INCLUDE was executed after expansion of the macro or
 .REPEAT - which was wrong and caused all sorts of unexpected behavior.
 Related issues/PRs are #231, #1473, #2159 and maybe others.

Note: After this change error messages for nested macro/.include statements
may be wrong. This is an unrelated bug that was always there and got exposed
by this fix. The bug needs to be addressed in a separate PR.
---
 src/ca65/istack.c  | 26 ++++++++++++++++++++++++++
 src/ca65/istack.h  | 20 ++++++++++++++++++++
 src/ca65/scanner.c | 11 +++++++++--
 3 files changed, 55 insertions(+), 2 deletions(-)

diff --git a/src/ca65/istack.c b/src/ca65/istack.c
index 7a95e7e8c2..979c097407 100644
--- a/src/ca65/istack.c
+++ b/src/ca65/istack.c
@@ -156,3 +156,29 @@ void CheckInputStack (void)
         Error ("Open %s", IStack->Desc);
     }
 }
+
+
+
+InputStack RetrieveInputStack (void)
+/* Retrieve the current input stack. This will also clear it. Used when
+** including a file. The current input stack is stored together with the old
+** input file and restored when the file is closed.
+ */
+{
+    /* We do not touch the counter so input sources are counted across
+    ** includes.
+     */
+    InputStack S = IStack;
+    IStack = 0;
+    return S;
+}
+
+
+
+void RestoreInputStack (InputStack S)
+/* Restore an old input stack that was retrieved by RetrieveInputStack(). */
+{
+    CHECK (IStack == 0);
+    IStack = S;
+}
+
diff --git a/src/ca65/istack.h b/src/ca65/istack.h
index aa37bab146..28c413d39c 100644
--- a/src/ca65/istack.h
+++ b/src/ca65/istack.h
@@ -38,6 +38,17 @@
 
 
 
+/*****************************************************************************/
+/*                                   Data                                    */
+/*****************************************************************************/
+
+
+
+/* Opaque pointer to an input stack */
+typedef void* InputStack;
+
+
+
 /*****************************************************************************/
 /*                                   Code                                    */
 /*****************************************************************************/
@@ -63,6 +74,15 @@ void CheckInputStack (void);
 ** stuff on the input stack.
 */
 
+InputStack RetrieveInputStack (void);
+/* Retrieve the current input stack. This will also clear it. Used when
+** including a file. The current input stack is stored together with the old
+** input file and restored when the file is closed.
+ */
+
+void RestoreInputStack (InputStack S);
+/* Restore an old input stack that was retrieved by RetrieveInputStack(). */
+
 
 
 /* End of istack.h */
diff --git a/src/ca65/scanner.c b/src/ca65/scanner.c
index 146c749586..89ff851fc1 100644
--- a/src/ca65/scanner.c
+++ b/src/ca65/scanner.c
@@ -113,6 +113,7 @@ struct CharSource {
     token_t                     Tok;    /* Last token */
     int                         C;      /* Last character */
     int                         SkipN;  /* For '\r\n' line endings, skip '\n\ if next */
+    InputStack                  IStack; /* Saved input stack */
     const CharSourceFunctions*  Func;   /* Pointer to function table */
     union {
         InputFile               File;   /* File data */
@@ -321,6 +322,9 @@ static void UseCharSource (CharSource* S)
     S->Tok      = CurTok.Tok;
     S->C        = C;
 
+    /* Remember the current input stack */
+    S->IStack   = RetrieveInputStack ();
+
     /* Use the new input source */
     S->Next     = Source;
     Source      = S;
@@ -347,7 +351,10 @@ static void DoneCharSource (void)
 
     /* Restore the old token */
     CurTok.Tok = Source->Tok;
-    C   = Source->C;
+    C = Source->C;
+
+    /* Restore the old input source */
+    RestoreInputStack (Source->IStack);
 
     /* Remember the last stacked input source */
     S = Source->Next;
@@ -1521,7 +1528,7 @@ void NextRawTok (void)
             /* In case of the main file, do not close it, but return EOF. */
             if (Source && Source->Next) {
                 DoneCharSource ();
-                goto Again;
+                goto Restart;
             } else {
                 CurTok.Tok = TOK_EOF;
             }

From cc0db26e20d4508f63db539ea619c57863e47d27 Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Sun, 1 Sep 2024 20:22:29 +0200
Subject: [PATCH 17/50] Added some tests.

---
 test/asm/listing/070-include-macro.inc          |  1 +
 test/asm/listing/070-include-macro.s            | 13 +++++++++++++
 test/asm/listing/070-include-repeat.inc         |  1 +
 test/asm/listing/070-include-repeat.s           |  4 ++++
 test/asm/listing/ref/070-include-macro.err-ref  |  1 +
 test/asm/listing/ref/070-include-repeat.err-ref |  6 ++++++
 6 files changed, 26 insertions(+)
 create mode 100644 test/asm/listing/070-include-macro.inc
 create mode 100644 test/asm/listing/070-include-macro.s
 create mode 100644 test/asm/listing/070-include-repeat.inc
 create mode 100644 test/asm/listing/070-include-repeat.s
 create mode 100644 test/asm/listing/ref/070-include-macro.err-ref
 create mode 100644 test/asm/listing/ref/070-include-repeat.err-ref

diff --git a/test/asm/listing/070-include-macro.inc b/test/asm/listing/070-include-macro.inc
new file mode 100644
index 0000000000..0152a79652
--- /dev/null
+++ b/test/asm/listing/070-include-macro.inc
@@ -0,0 +1 @@
+foo:
diff --git a/test/asm/listing/070-include-macro.s b/test/asm/listing/070-include-macro.s
new file mode 100644
index 0000000000..aad55cb52d
--- /dev/null
+++ b/test/asm/listing/070-include-macro.s
@@ -0,0 +1,13 @@
+.macro IncludeFile FilePath
+    .proc bar
+        .include FilePath
+    .endproc
+.endmacro
+
+IncludeFile "070-include-macro.inc"
+
+.ifdef bar::foo
+    .out "bar::foo is defined"
+.else
+    .out "bar::foo is undefined"
+.endif
diff --git a/test/asm/listing/070-include-repeat.inc b/test/asm/listing/070-include-repeat.inc
new file mode 100644
index 0000000000..0eb22a710c
--- /dev/null
+++ b/test/asm/listing/070-include-repeat.inc
@@ -0,0 +1 @@
+.out "include file"
diff --git a/test/asm/listing/070-include-repeat.s b/test/asm/listing/070-include-repeat.s
new file mode 100644
index 0000000000..20170255f6
--- /dev/null
+++ b/test/asm/listing/070-include-repeat.s
@@ -0,0 +1,4 @@
+.repeat 3
+    .include "070-include-repeat.inc"
+    .out "main file"
+.endrepeat
diff --git a/test/asm/listing/ref/070-include-macro.err-ref b/test/asm/listing/ref/070-include-macro.err-ref
new file mode 100644
index 0000000000..5faf98c4ba
--- /dev/null
+++ b/test/asm/listing/ref/070-include-macro.err-ref
@@ -0,0 +1 @@
+bar::foo is defined
diff --git a/test/asm/listing/ref/070-include-repeat.err-ref b/test/asm/listing/ref/070-include-repeat.err-ref
new file mode 100644
index 0000000000..d42e70ee70
--- /dev/null
+++ b/test/asm/listing/ref/070-include-repeat.err-ref
@@ -0,0 +1,6 @@
+include file
+main file
+include file
+main file
+include file
+main file

From e2014611ef7932b7ef8f1e97c637e8fc29a6447a Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Mon, 2 Sep 2024 07:02:41 +0200
Subject: [PATCH 18/50] Improve the usage output for the '-W' option.

---
 doc/cc65.sgml   | 5 +++--
 src/cc65/main.c | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/doc/cc65.sgml b/doc/cc65.sgml
index 2219ccf6a4..5c074991b7 100644
--- a/doc/cc65.sgml
+++ b/doc/cc65.sgml
@@ -61,7 +61,7 @@ Short options:
   -Os                           Inline some standard functions
   -T                            Include source as comment
   -V                            Print the compiler version number
-  -W warning[,...]              Suppress warnings
+  -W [-+]warning[,...]          Control warnings ('-' disables, '+' enables)
   -d                            Debug mode
   -g                            Add debug info to object file
   -h                            Help (this text)
@@ -84,8 +84,9 @@ Long options:
   --create-full-dep name        Create a full make dependency file
   --data-name seg               Set the name of the DATA segment
   --debug                       Debug mode
+  --debug-tables name           Write symbol table debug info to a file
   --debug-info                  Add debug info to object file
-  --debug-opt name              Configure optimizations with a file
+  --debug-opt name              Debug optimization steps
   --debug-opt-output            Debug output of each optimization step
   --dep-target target           Use this dependency target
   --disable-opt name            Disable an optimization step
diff --git a/src/cc65/main.c b/src/cc65/main.c
index 7dc5417f60..47435757c7 100644
--- a/src/cc65/main.c
+++ b/src/cc65/main.c
@@ -91,7 +91,7 @@ static void Usage (void)
             "  -Os\t\t\t\tInline some standard functions\n"
             "  -T\t\t\t\tInclude source as comment\n"
             "  -V\t\t\t\tPrint the compiler version number\n"
-            "  -W warning[,...]\t\tSuppress warnings\n"
+            "  -W [-+]warning[,...]\t\tControl warnings ('-' disables, '+' enables)\n"
             "  -d\t\t\t\tDebug mode\n"
             "  -g\t\t\t\tAdd debug info to object file\n"
             "  -h\t\t\t\tHelp (this text)\n"

From cd4357057f53a7a7fac0bb9dd39c7bfbe5a7a46a Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Mon, 2 Sep 2024 10:39:42 +0200
Subject: [PATCH 19/50] The change from #2495 didn't take into account that
 recursive calls to main() are legal in C. With the changes from #2495, such
 calls will usually crash the machine. But recursive calls to main() are rare
 and on the 6502 every byte saved is precious. So this change limits the
 effect of #2495 to cc65 mode and at the same time disallows recursive calls
 to main() in this mode. If recursive calls to main() are actually required,
 the code must be compiled in c89 or c99 mode.

---
 doc/cc65.sgml                     |  5 +++++
 src/cc65/codegen.c                |  8 ++++----
 src/cc65/codegen.h                |  2 +-
 src/cc65/expr.c                   | 26 ++++++++++++++++++++++----
 src/cc65/function.c               | 10 +++++++---
 src/cc65/locals.c                 | 15 +++++++++++----
 test/ref/custom-reference-error.c |  3 +--
 test/val/nullptr.c                |  4 +++-
 8 files changed, 54 insertions(+), 19 deletions(-)

diff --git a/doc/cc65.sgml b/doc/cc65.sgml
index 2219ccf6a4..8dd6d0202a 100644
--- a/doc/cc65.sgml
+++ b/doc/cc65.sgml
@@ -823,6 +823,11 @@ and the one defined by the ISO standard:
         as it sounds, since the 6502 has so few registers that it isn't
         possible to keep values in registers anyway.
         <p>
+<item>  In <tt/cc65/ mode, <tt/main()/ cannot be called recursively. If this
+        is necessary, the program must be compiled in <tt/c89/ or <tt/c99/ mode
+        using the <tt><ref id="option--standard" name="--standard"></tt>
+        command line option.
+        <p>
 </itemize>
 
 There may be some more minor differences I'm currently not aware of. The
diff --git a/src/cc65/codegen.c b/src/cc65/codegen.c
index 45823fab6d..166176f5e0 100644
--- a/src/cc65/codegen.c
+++ b/src/cc65/codegen.c
@@ -507,13 +507,13 @@ void g_enter (unsigned flags, unsigned argsize)
 
 
 
-void g_leave (int IsMainFunc)
+void g_leave (int DoCleanup)
 /* Function epilogue */
 {
-    /* In the main function nothing has to be dropped because the program
-    ** is terminated anyway.
+    /* In the main function in cc65 mode nothing has to be dropped because
+    ** the program is terminated anyway.
     */
-    if (!IsMainFunc) {
+    if (DoCleanup) {
         /* How many bytes of locals do we have to drop? */
         unsigned ToDrop = (unsigned) -StackPtr;
 
diff --git a/src/cc65/codegen.h b/src/cc65/codegen.h
index b95df5cfba..734c95372d 100644
--- a/src/cc65/codegen.h
+++ b/src/cc65/codegen.h
@@ -247,7 +247,7 @@ void g_scale (unsigned flags, long val);
 void g_enter (unsigned flags, unsigned argsize);
 /* Function prologue */
 
-void g_leave (int IsMainFunc);
+void g_leave (int DoCleanup);
 /* Function epilogue */
 
 
diff --git a/src/cc65/expr.c b/src/cc65/expr.c
index f6c681db87..2939ab1cc3 100644
--- a/src/cc65/expr.c
+++ b/src/cc65/expr.c
@@ -1219,9 +1219,6 @@ static void Primary (ExprDesc* E)
             /* Is the symbol known? */
             if (Sym) {
 
-                /* We found the symbol - skip the name token */
-                NextToken ();
-
                 /* Check for illegal symbol types */
                 CHECK ((Sym->Flags & SC_TYPEMASK) != SC_LABEL);
                 if ((Sym->Flags & SC_TYPEMASK) == SC_TYPEDEF) {
@@ -1230,9 +1227,14 @@ static void Primary (ExprDesc* E)
                     /* Assume an int type to make E valid */
                     E->Flags = E_LOC_STACK | E_RTYPE_LVAL;
                     E->Type  = type_int;
+                    /* Skip the erroneous token */
+                    NextToken ();
                     break;
                 }
 
+                /* Skip the name token */
+                NextToken ();
+
                 /* Mark the symbol as referenced */
                 Sym->Flags |= SC_REF;
 
@@ -1286,7 +1288,23 @@ static void Primary (ExprDesc* E)
                 ** rvalue, too, because we cannot store anything in a function.
                 ** So fix the flags depending on the type.
                 */
-                if (IsTypeArray (E->Type) || IsTypeFunc (E->Type)) {
+                if (IsTypeArray (E->Type)) {
+                    ED_AddrExpr (E);
+                } else if (IsTypeFunc (E->Type)) {
+                    /* In cc65 mode we cannot call or take the address of
+                    ** main().
+                    */
+                    if (IS_Get (&Standard) == STD_CC65 &&
+                        strcmp (Sym->Name, "main") == 0) {
+                        /* Adjust the error message depending on a call or an
+                        ** address operation.
+                        */
+                        if (CurTok.Tok == TOK_LPAREN) {
+                            Error ("'main' must not be called recursively");
+                        } else {
+                            Error ("The address of 'main' cannot be taken");
+                        }
+                    }
                     ED_AddrExpr (E);
                 }
 
diff --git a/src/cc65/function.c b/src/cc65/function.c
index d5cab3993e..fed0349dde 100644
--- a/src/cc65/function.c
+++ b/src/cc65/function.c
@@ -646,13 +646,17 @@ void NewFunc (SymEntry* Func, FuncDesc* D)
     /* Output the function exit code label */
     g_defcodelabel (F_GetRetLab (CurrentFunc));
 
-    /* Restore the register variables (not necessary for main function) */
-    if (!F_IsMainFunc (CurrentFunc)) {
+    /* Restore the register variables (not necessary for the main function in
+    ** cc65 mode)
+    */
+    int CleanupOnExit = (IS_Get (&Standard) != STD_CC65) ||
+                        !F_IsMainFunc (CurrentFunc);
+    if (CleanupOnExit) {
         F_RestoreRegVars (CurrentFunc);
     }
 
     /* Generate the exit code */
-    g_leave (F_IsMainFunc (CurrentFunc));
+    g_leave (CleanupOnExit);
 
     /* Emit references to imports/exports */
     EmitExternals ();
diff --git a/src/cc65/locals.c b/src/cc65/locals.c
index c4d0aa25b2..08e41918e9 100644
--- a/src/cc65/locals.c
+++ b/src/cc65/locals.c
@@ -111,6 +111,13 @@ static void ParseRegisterDecl (Declarator* Decl, int Reg)
     /* Get the size of the variable */
     unsigned Size = SizeOf (Decl->Type);
 
+    /* Check if this is the main function and we are in cc65 mode. If so, we
+    ** won't save the old contents of the register variables since in cc65
+    ** mode main() may not be called recursively.
+    */
+    int SaveRegVars = (IS_Get (&Standard) != STD_CC65) ||
+                      !F_IsMainFunc (CurrentFunc);
+
     /* Check for an optional initialization */
     if (CurTok.Tok == TOK_ASSIGN) {
 
@@ -126,13 +133,13 @@ static void ParseRegisterDecl (Declarator* Decl, int Reg)
         /* Save the current contents of the register variable on stack. This is
         ** not necessary for the main function.
         */
-        if (!F_IsMainFunc (CurrentFunc)) {
+        if (SaveRegVars) {
             g_save_regvars (Reg, Size);
         }
 
         /* Add the symbol to the symbol table. We do that now, because for
         ** register variables the current stack pointer is implicitly used
-        ** as location for the save area (unused in case of main()).
+        ** as location for the save area (maybe unused in case of main()).
         */
         Sym = AddLocalSym (Decl->Ident, Decl->Type, Decl->StorageClass, Reg);
 
@@ -187,14 +194,14 @@ static void ParseRegisterDecl (Declarator* Decl, int Reg)
         /* Save the current contents of the register variable on stack. This is
         ** not necessary for the main function.
         */
-        if (!F_IsMainFunc (CurrentFunc)) {
+        if (SaveRegVars) {
             F_AllocLocalSpace (CurrentFunc);
             g_save_regvars (Reg, Size);
         }
 
         /* Add the symbol to the symbol table. We do that now, because for
         ** register variables the current stack pointer is implicitly used
-        ** as location for the save area (unused in case of main()).
+        ** as location for the save area (maybe unused in case of main()).
         */
         Sym = AddLocalSym (Decl->Ident, Decl->Type, Decl->StorageClass, Reg);
     }
diff --git a/test/ref/custom-reference-error.c b/test/ref/custom-reference-error.c
index e98fb024dd..455e0276de 100644
--- a/test/ref/custom-reference-error.c
+++ b/test/ref/custom-reference-error.c
@@ -22,6 +22,5 @@ return_t main(int argc, char* argv[])
     n = 0;                /* produce an error */
     /* produce a warning */
 }
-
-int arr[main(0, 0)]; /* produce an error */
 int b = 0;
+int arr[b]; /* produce an error */
diff --git a/test/val/nullptr.c b/test/val/nullptr.c
index e64b82ee27..a5b72e8c5e 100644
--- a/test/val/nullptr.c
+++ b/test/val/nullptr.c
@@ -28,6 +28,8 @@ struct S {
         } \
     } while(0);
 
+void func() { }
+
 int main()
 {
     int a;
@@ -60,7 +62,7 @@ int main()
     TEST_NON_NULL(((struct S*)&a)->a)
 
     /* Non-null pointer obtained with cast and -> */
-    TEST_NON_NULL(((struct S*)&main)->a)
+    TEST_NON_NULL(((struct S*)&func)->a)
 
     if (failures != 0)
     {

From 79606c4d20e00db5be257d25bf7ab78109e1df3e Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Mon, 2 Sep 2024 16:55:58 +0200
Subject: [PATCH 20/50] Overlooked a few target tests that take the address of
 main().

---
 targettest/atari/mem.c  | 4 +++-
 targettest/pce/conio.c  | 4 +++-
 targettest/scanf-test.c | 4 +++-
 3 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/targettest/atari/mem.c b/targettest/atari/mem.c
index bc70aded64..b15b215edf 100644
--- a/targettest/atari/mem.c
+++ b/targettest/atari/mem.c
@@ -21,6 +21,8 @@ unsigned int *MEMTOP = (unsigned int *)741;
 unsigned int *MEMLO = (unsigned int *)743;
 void *allocmem;
 
+void code(void) { }
+
 int main(void)
 {
   allocmem = malloc(257);
@@ -35,7 +37,7 @@ int main(void)
   printf("  MEMLO  = $%04X (%u)\n", *MEMLO, *MEMLO);
 
   printf("  ----------------------\n");
-  printf("  main:            $%04X  (code)\n", &main);
+  printf("  code:            $%04X  (code)\n", &code);
   printf("  data:            $%04X  (data)\n", &data);
   printf("  _dos_type:       $%04X  (bss)\n", &_dos_type);
   printf("  allocmem:        $%04X  (dyn. data)\n", allocmem);
diff --git a/targettest/pce/conio.c b/targettest/pce/conio.c
index 55f828f264..819e601be8 100644
--- a/targettest/pce/conio.c
+++ b/targettest/pce/conio.c
@@ -11,6 +11,8 @@ static char hex[16] = { "0123456789abcdef" };
 static char charbuf[0x20];
 static char colbuf[0x20];
 
+void func(void) { }
+
 void main(void)
 {
         int stackvar = 42;
@@ -65,7 +67,7 @@ void main(void)
                         p[8],p[9],p[10],p[11],p[12],p[13],p[14],p[15]
                 );
         }
-        memcpy(p, main, i = 0);     /* test that a zero length doesn't copy 64K */
+        memcpy(p, func, i = 0);     /* test that a zero length doesn't copy 64K */
 
         gotoxy(0,ysize - 1);
         for (i = 0; i < xsize; ++i) {
diff --git a/targettest/scanf-test.c b/targettest/scanf-test.c
index f17b62294d..e0ab957568 100644
--- a/targettest/scanf-test.c
+++ b/targettest/scanf-test.c
@@ -159,12 +159,14 @@ static void Pause(void) {
 #endif
         }
 
+static void Nil() { }
+
 int main(void) {
         long n0;
         unsigned t;
         int c, n1 = 12345, n2, n3;
         char s1[80], s2[80];
-        void *p1 = main, *p2 = main, *p3 = main, *p4 = main;
+        void *p1 = Nil, *p2 = Nil, *p3 = Nil, *p4 = Nil;
 
 #ifndef USE_STDIO
         clrscr();

From d996e20c5f187023a39498aa4bf3e2b888aad362 Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Tue, 3 Sep 2024 20:21:48 +0200
Subject: [PATCH 21/50] Fix issues #2461. This was always wrong even in cases
 where it seemed to work. If it did, it was by coincidence.

---
 src/cc65/codeoptutil.c |  6 ++--
 test/val/bug2461.c     | 67 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 71 insertions(+), 2 deletions(-)
 create mode 100644 test/val/bug2461.c

diff --git a/src/cc65/codeoptutil.c b/src/cc65/codeoptutil.c
index 173d5185fd..43b1dee221 100644
--- a/src/cc65/codeoptutil.c
+++ b/src/cc65/codeoptutil.c
@@ -1128,8 +1128,10 @@ void AddOpHigh (StackOpData* D, opc_t OPC, LoadInfo* LI, int KeepResult)
             InsertEntry (D, X, D->IP++);
         }
 
-        /* In both cases, we can remove the load */
-        LI->X.Flags |= LI_REMOVE;
+        /* If this is the right hand side, we can remove the load. */
+        if (LI == &D->Rhs) {
+            LI->X.Flags |= LI_REMOVE;
+        }
 
     } else {
         /* opc zphi */
diff --git a/test/val/bug2461.c b/test/val/bug2461.c
new file mode 100644
index 0000000000..e8340b224f
--- /dev/null
+++ b/test/val/bug2461.c
@@ -0,0 +1,67 @@
+/* related to bug #2461 */
+
+/* Note: The values for MASK1, MASK2, the return values of GarbleAX and the 
+ * arguments for CALC() are carefully chosen to elicit the bug.
+ */
+
+#include <stdio.h>
+
+#define MASK1           0x000FU
+#define MASK2           0x00FFU
+#define CALC(num, op)   (((num) & (~MASK1)) op ((num) & MASK2))
+
+static unsigned Failures = 0;
+static unsigned TestCount = 0;
+
+unsigned GarbleAX(void)
+{
+    static const unsigned Garbage[] = {
+        0x1234, 0x0000, 0x1234, 0x1234
+    };
+    return Garbage[TestCount - 1];
+}
+
+unsigned WrongAdd(unsigned num)
+{
+    unsigned ret=GarbleAX();
+    return CALC(num, +);
+}
+
+unsigned WrongAnd(unsigned num)
+{
+    unsigned ret=GarbleAX();
+    return CALC(num, &);
+}
+
+unsigned WrongOr(unsigned num)
+{
+    unsigned ret=GarbleAX();
+    return CALC(num, |);
+}
+
+unsigned WrongXor(unsigned num)
+{
+    unsigned ret=GarbleAX();
+    return CALC(num, ^);
+}
+
+void Test(unsigned (*F)(unsigned), unsigned Num, unsigned Ref)
+{
+    unsigned Res;
+    ++TestCount;
+    Res = F(Num);
+    if (Res != Ref) {
+        printf("Test %u failed: got %04X, expected %04X\n", TestCount, Res, Ref);
+        ++Failures;
+    }
+}
+
+int main(void)
+{
+    Test(WrongAdd, 0x4715, CALC(0x4715, +));
+    Test(WrongAnd, 0x4715, CALC(0x4715, &));
+    Test(WrongOr,  0x4715, CALC(0x4715, |));
+    Test(WrongXor, 0x4715, CALC(0x4715, ^));
+    printf("Failures: %u\n", Failures);
+    return Failures;
+}

From 38f54875d053e62e3bab991facb8e13cdbc1e258 Mon Sep 17 00:00:00 2001
From: Stefan <stefan.haubenthal@gmail.com>
Date: Sat, 7 Sep 2024 17:06:45 +0200
Subject: [PATCH 22/50] Add files via upload

---
 libsrc/atmos/waitvsync.s | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 libsrc/atmos/waitvsync.s

diff --git a/libsrc/atmos/waitvsync.s b/libsrc/atmos/waitvsync.s
new file mode 100644
index 0000000000..6113f3da26
--- /dev/null
+++ b/libsrc/atmos/waitvsync.s
@@ -0,0 +1,18 @@
+;
+; Written by Stefan Haubenthal <polluks@sdf.org>, requires VSync hack
+;
+; void waitvsync (void);
+;
+
+        .export _waitvsync
+
+        .include "atmos.inc"
+
+.proc   _waitvsync
+
+wait:   lda     VIA::PRA2
+        and     #%00010000      ; CB1
+        bne     wait
+        rts
+
+.endproc

From 033fd9e0dcc891c00df01dba611b1fffb5fb5591 Mon Sep 17 00:00:00 2001
From: Stefan <stefan.haubenthal@gmail.com>
Date: Sat, 7 Sep 2024 17:19:21 +0200
Subject: [PATCH 23/50] Update funcref.sgml

---
 doc/funcref.sgml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/doc/funcref.sgml b/doc/funcref.sgml
index 130646538d..ea2350aad7 100644
--- a/doc/funcref.sgml
+++ b/doc/funcref.sgml
@@ -155,6 +155,7 @@ function.
 <item><ref id="atmos_tick" name="atmos_tick">
 <item><ref id="atmos_tock" name="atmos_tock">
 <item><ref id="atmos_zap" name="atmos_zap">
+<item><ref id="waitvsync" name="waitvsync">
 </itemize>
 
 
@@ -8358,6 +8359,7 @@ only in the presence of a prototype.
 <descrip>
 <tag/Function/Wait until the start of the next video frame.
 <tag/Header/<tt/
+<ref id="atmos.h" name="atmos.h">,
 <ref id="cbm.h" name="cbm.h">,
 <ref id="gamate.h" name="gamate.h">,
 <ref id="nes.h" name="nes.h">,
@@ -8365,6 +8367,7 @@ only in the presence of a prototype.
 <tag/Declaration/<tt/void waitvsync (void);/
 <tag/Description/Wait for vertical sync, to reduce flickering.
 <tag/Availability/Platforms served by the headers above
+(Atmos requires the VSync hack)
 <tag/Example/None.
 </descrip>
 </quote>

From f430341d5d46bd11a006b9fdb731d56c746394c7 Mon Sep 17 00:00:00 2001
From: Stefan <stefan.haubenthal@gmail.com>
Date: Sat, 7 Sep 2024 17:23:17 +0200
Subject: [PATCH 24/50] Update atmos.h

---
 include/atmos.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/include/atmos.h b/include/atmos.h
index 38d423c460..460a0010fd 100644
--- a/include/atmos.h
+++ b/include/atmos.h
@@ -169,6 +169,9 @@ void atmos_tock (void);
 void atmos_zap (void);
 /* Raygun sound effect */
 
+void waitvsync (void);
+/* Wait for start of next frame */
+
 
 
 /* End of atmos.h */

From ab4cdafacb66f226afcd1c0ee77b49c670130c79 Mon Sep 17 00:00:00 2001
From: Stefan <stefan.haubenthal@gmail.com>
Date: Sat, 7 Sep 2024 18:07:35 +0200
Subject: [PATCH 25/50] Update atari7800.h

---
 include/atari7800.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/atari7800.h b/include/atari7800.h
index 3cbeedb8ba..b289bb41e7 100644
--- a/include/atari7800.h
+++ b/include/atari7800.h
@@ -52,7 +52,7 @@
 /* No support for dynamically loadable drivers */
 #define DYN_DRV 0
 
-extern unsigned char get_tv(void);           /* get TV system */
+unsigned char get_tv(void);           /* get TV system */
 
 #include <_tia.h>
 #define TIA (*(struct __tia*)0x0000)

From c9fa9f00023a1ee6c26e66e5b4ce81b54d465e96 Mon Sep 17 00:00:00 2001
From: Stefan <stefan.haubenthal@gmail.com>
Date: Sat, 7 Sep 2024 18:08:18 +0200
Subject: [PATCH 26/50] Update atari5200.h

---
 include/atari5200.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/atari5200.h b/include/atari5200.h
index ff176c15b8..9a0399d0ea 100644
--- a/include/atari5200.h
+++ b/include/atari5200.h
@@ -94,7 +94,7 @@ extern void atr5200std_joy[];        /* referred to by joy_static_stddrv[] */
 #define _bordercolor(color) 0
 
 /* wait for start of next frame */
-extern void waitvsync (void);
+void waitvsync (void);
 
 /* end of atari5200.h */
 #endif

From 44aa5dca910db8bd96ef09d57d424707f582602f Mon Sep 17 00:00:00 2001
From: Stefan <stefan.haubenthal@gmail.com>
Date: Sat, 7 Sep 2024 18:12:37 +0200
Subject: [PATCH 27/50] Update atari.h

---
 include/atari.h | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/include/atari.h b/include/atari.h
index 04cacab33c..0af109264d 100644
--- a/include/atari.h
+++ b/include/atari.h
@@ -220,17 +220,17 @@
 /* Color register functions                                                  */
 /*****************************************************************************/
 
-extern void __fastcall__ _setcolor     (unsigned char color_reg, unsigned char hue, unsigned char luminance);
-extern void __fastcall__ _setcolor_low (unsigned char color_reg, unsigned char color_value);
-extern unsigned char __fastcall__ _getcolor (unsigned char color_reg);
+void __fastcall__ _setcolor     (unsigned char color_reg, unsigned char hue, unsigned char luminance);
+void __fastcall__ _setcolor_low (unsigned char color_reg, unsigned char color_value);
+unsigned char __fastcall__ _getcolor (unsigned char color_reg);
 
 /*****************************************************************************/
 /* Other screen functions                                                    */
 /*****************************************************************************/
 
-extern void waitvsync (void);                            /* wait for start of next frame */
-extern int  __fastcall__ _graphics (unsigned char mode); /* mode value same as in BASIC */
-extern void __fastcall__ _scroll (signed char numlines);
+void waitvsync (void);                            /* wait for start of next frame */
+int  __fastcall__ _graphics (unsigned char mode); /* mode value same as in BASIC */
+void __fastcall__ _scroll (signed char numlines);
                                           /* numlines > 0  scrolls up */
                                           /* numlines < 0  scrolls down */
 
@@ -239,18 +239,18 @@ extern void __fastcall__ _scroll (signed char numlines);
 /*    Sound function                                                         */
 /*****************************************************************************/
 
-extern void  __fastcall__ _sound (unsigned char voice, unsigned char frequency, unsigned char distortion, unsigned char volume);
+void  __fastcall__ _sound (unsigned char voice, unsigned char frequency, unsigned char distortion, unsigned char volume);
 
 /*****************************************************************************/
 /* Misc. functions                                                           */
 /*****************************************************************************/
 
-extern unsigned char get_ostype(void);       /* get ROM version */
-extern unsigned char get_tv(void);           /* get TV system */
-extern void _save_vecs(void);                /* save system vectors */
-extern void _rest_vecs(void);                /* restore system vectors */
-extern char *_getdefdev(void);               /* get default floppy device */
-extern unsigned char _is_cmdline_dos(void);  /* does DOS support command lines */
+unsigned char get_ostype(void);       /* get ROM version */
+unsigned char get_tv(void);           /* get TV system */
+void _save_vecs(void);                /* save system vectors */
+void _rest_vecs(void);                /* restore system vectors */
+char *_getdefdev(void);               /* get default floppy device */
+unsigned char _is_cmdline_dos(void);  /* does DOS support command lines */
 
 
 /*****************************************************************************/

From b355620939a9720da91cb90408439ff90868ab84 Mon Sep 17 00:00:00 2001
From: Stefan <stefan.haubenthal@gmail.com>
Date: Sat, 7 Sep 2024 18:49:53 +0200
Subject: [PATCH 28/50] Optimise waitvsync.s

---
 libsrc/atmos/waitvsync.s | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libsrc/atmos/waitvsync.s b/libsrc/atmos/waitvsync.s
index 6113f3da26..15abe19261 100644
--- a/libsrc/atmos/waitvsync.s
+++ b/libsrc/atmos/waitvsync.s
@@ -10,8 +10,8 @@
 
 .proc   _waitvsync
 
-wait:   lda     VIA::PRA2
-        and     #%00010000      ; CB1
+        lda     #%00010000
+wait:   and     VIA::PRA2       ; CB1
         bne     wait
         rts
 

From be5a9f92ec814868e4eaa432159dc1a6ffe54b2a Mon Sep 17 00:00:00 2001
From: Stefan <stefan.haubenthal@gmail.com>
Date: Sat, 7 Sep 2024 18:51:20 +0200
Subject: [PATCH 29/50] oops

---
 libsrc/atmos/waitvsync.s | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libsrc/atmos/waitvsync.s b/libsrc/atmos/waitvsync.s
index 15abe19261..85e50a7951 100644
--- a/libsrc/atmos/waitvsync.s
+++ b/libsrc/atmos/waitvsync.s
@@ -10,8 +10,8 @@
 
 .proc   _waitvsync
 
-        lda     #%00010000
-wait:   and     VIA::PRA2       ; CB1
+        lda     #%00010000      ; CB1
+wait:   and     VIA::PRA2
         bne     wait
         rts
 

From f5e434c6c815d4816813cafdb817c235946c29cf Mon Sep 17 00:00:00 2001
From: Stefan <stefan.haubenthal@gmail.com>
Date: Sat, 7 Sep 2024 19:14:59 +0200
Subject: [PATCH 30/50] Update waitvsync.s

---
 libsrc/pet/waitvsync.s | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/libsrc/pet/waitvsync.s b/libsrc/pet/waitvsync.s
index 39b562e434..d74f76c9fd 100644
--- a/libsrc/pet/waitvsync.s
+++ b/libsrc/pet/waitvsync.s
@@ -9,8 +9,7 @@
         .include        "pet.inc"
 
 _waitvsync:
-@l1:
-        lda     VIA_PB
-        and     #%00100000
-        bne     @l1
+        lda     #%00100000
+:       and     VIA_PB
+        bne     :-
         rts

From 461554e616e41252ffef3e1b337ed2d993613e1a Mon Sep 17 00:00:00 2001
From: Stefan <stefan.haubenthal@gmail.com>
Date: Sat, 7 Sep 2024 19:17:00 +0200
Subject: [PATCH 31/50] Update waitvsync.s

---
 libsrc/c128/waitvsync.s | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libsrc/c128/waitvsync.s b/libsrc/c128/waitvsync.s
index e4bbbf7c9b..573f574a70 100644
--- a/libsrc/c128/waitvsync.s
+++ b/libsrc/c128/waitvsync.s
@@ -23,8 +23,8 @@ _waitvsync:
 
 @c80:
         ;FIXME: do we have to switch banks?
+        lda     #$20
 @l3:
-        lda     VDC_INDEX
-        and     #$20
+        and     VDC_INDEX
         beq     @l3
         rts

From 55d3a6ea39c3275958d2ac9a666b7bf8ffeb6ed7 Mon Sep 17 00:00:00 2001
From: Colin Leroy-Mira <colin@colino.net>
Date: Wed, 4 Sep 2024 22:52:52 +0200
Subject: [PATCH 32/50] Optimize stpcpy's size and speed

---
 libsrc/common/stpcpy.c |  7 -------
 libsrc/common/stpcpy.s | 22 ++++++++++++++++++++++
 libsrc/common/strcpy.s |  7 +++++--
 test/val/stpcpy.c      | 13 +++++++++++--
 4 files changed, 38 insertions(+), 11 deletions(-)
 delete mode 100644 libsrc/common/stpcpy.c
 create mode 100644 libsrc/common/stpcpy.s

diff --git a/libsrc/common/stpcpy.c b/libsrc/common/stpcpy.c
deleted file mode 100644
index 12af47f2f3..0000000000
--- a/libsrc/common/stpcpy.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <string.h>
-
-char * __fastcall__ stpcpy (char * dst, const char * src)
-{
-    strcpy (dst, src);
-    return dst + strlen (src);
-}
diff --git a/libsrc/common/stpcpy.s b/libsrc/common/stpcpy.s
new file mode 100644
index 0000000000..c8a10db947
--- /dev/null
+++ b/libsrc/common/stpcpy.s
@@ -0,0 +1,22 @@
+;
+; Colin Leroy-Mira, 4 Sept. 2024
+;
+; char* stpcpy (char* dest, const char* src);
+;
+
+        .export         _stpcpy
+        .import         _strcpy
+
+        .importzp       tmp1, ptr2
+
+_stpcpy:
+        jsr     _strcpy
+
+        ldx     ptr2+1        ; Load dest pointer's last high byte
+        tya                   ; Get the last offset strcpy wrote to
+
+        clc
+        adc     ptr2          ; Add to low byte value
+        bcc     :+
+        inx
+:       rts                   ; Return pointer to dest's terminator
diff --git a/libsrc/common/strcpy.s b/libsrc/common/strcpy.s
index 77b39fe761..9a100f5408 100644
--- a/libsrc/common/strcpy.s
+++ b/libsrc/common/strcpy.s
@@ -25,6 +25,9 @@ L1:     lda     (ptr1),y
         inc     ptr2+1
         bne     L1
 
-L9:     lda     ptr2            ; X still contains high byte
-        rts
+L9:     lda     ptr2            ; X still contains dest's original high byte
 
+        ; On exit, we want AX to be dest (as this is what strcpy returns).
+        ; We also want (ptr2),y to still point to dest's terminator, as this
+        ; is used by stpcpy().
+        rts
diff --git a/test/val/stpcpy.c b/test/val/stpcpy.c
index 8bdbfb9263..1cc6458edf 100644
--- a/test/val/stpcpy.c
+++ b/test/val/stpcpy.c
@@ -8,10 +8,12 @@
 #define STR_SHORT   "Hello, World!"
 #define STR_LONG    "This is a longer test string for stpcpy."
 
+char dest[512];
+char multi_page[300];
+
 int
 main ()
 {
-    char dest[50];
     const char *src_empty;
     const char *src_short;
     const char *src_long;
@@ -38,7 +40,14 @@ main ()
     assert(end == &dest[sizeof (STR_LONG) - 1]);
     printf ("Test 3 passed.\n");
 
+    memset(multi_page, 'a', sizeof(multi_page)-1);
+    multi_page[sizeof(multi_page)-1] = '\0';
+    end = stpcpy (dest, multi_page);
+    assert(!strcmp (dest, multi_page));
+    assert(!*end);
+    assert(end == &dest[sizeof (multi_page) - 1]);
+    printf ("Test 4 passed.\n");
+
     printf ("All tests passed.\n");
     return EXIT_SUCCESS;
 }
-

From 838c8b48b744460f5cf1ee80164029d6c572878d Mon Sep 17 00:00:00 2001
From: coronax <coronax@gmail.com>
Date: Sat, 7 Sep 2024 22:16:22 -0500
Subject: [PATCH 33/50] Set the clock id to CLOCK_REALTIME when calling
 clock_gettime.

Previously, time() allocated stack space for the clock id argument, but didn't actually set a value.
---
 asminc/time.inc      | 6 ++++++
 libsrc/common/time.s | 5 +++--
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/asminc/time.inc b/asminc/time.inc
index 6064b4ba36..7c1ab3177a 100644
--- a/asminc/time.inc
+++ b/asminc/time.inc
@@ -66,3 +66,9 @@
 .global         _clock_settime
 .global         _localtime
 .global         _mktime
+
+
+;------------------------------------------------------------------------------
+; Constants
+
+CLOCK_REALTIME = 0
diff --git a/libsrc/common/time.s b/libsrc/common/time.s
index 40b470f5ba..36fd36323a 100644
--- a/libsrc/common/time.s
+++ b/libsrc/common/time.s
@@ -6,7 +6,7 @@
 
         .export         _time
 
-        .import         decsp1, ldeaxi
+        .import         pusha, ldeaxi
         .importzp       ptr1, sreg, tmp1, tmp2
 
         .include        "time.inc"
@@ -22,7 +22,8 @@
 
 ; Get the time (machine dependent)
 
-        jsr     decsp1
+        lda     #CLOCK_REALTIME
+        jsr     pusha
         lda     #<time
         ldx     #>time
         jsr     _clock_gettime

From 3c5269dede70a6dbe3ec40952595dd8c82d07a5e Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Sun, 8 Sep 2024 09:11:47 +0200
Subject: [PATCH 34/50] Warn for braces around a pointer initializer.

---
 src/cc65/initdata.c   | 7 +++++++
 test/ref/bug2134.c    | 2 ++
 test/ref/bug2134.cref | 2 ++
 3 files changed, 11 insertions(+)
 create mode 100644 test/ref/bug2134.c
 create mode 100644 test/ref/bug2134.cref

diff --git a/src/cc65/initdata.c b/src/cc65/initdata.c
index 82cebefc27..addc7421b3 100644
--- a/src/cc65/initdata.c
+++ b/src/cc65/initdata.c
@@ -302,6 +302,13 @@ static unsigned ParsePointerInit (const Type* T)
     /* Optional opening brace */
     unsigned BraceCount = OpeningCurlyBraces (0);
 
+    /* We warn if an initializer for a scalar contains braces, because this is
+    ** quite unusual and often a sign for some problem in the input.
+    */
+    if (BraceCount > 0) {
+        Warning ("Braces around scalar initializer");
+    }
+
     /* Expression */
     ExprDesc ED = NoCodeConstExpr (hie1);
     TypeConversion (&ED, T);
diff --git a/test/ref/bug2134.c b/test/ref/bug2134.c
new file mode 100644
index 0000000000..9e95e1daa2
--- /dev/null
+++ b/test/ref/bug2134.c
@@ -0,0 +1,2 @@
+int i = { 0 };
+char* p = { 0 };
diff --git a/test/ref/bug2134.cref b/test/ref/bug2134.cref
new file mode 100644
index 0000000000..72bbbad04a
--- /dev/null
+++ b/test/ref/bug2134.cref
@@ -0,0 +1,2 @@
+bug2134.c:1: Warning: Braces around scalar initializer
+bug2134.c:2: Warning: Braces around scalar initializer

From d825a40add4ceb23c3b09840b6f0fe29ebe93b3a Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Sun, 8 Sep 2024 09:36:40 +0200
Subject: [PATCH 35/50] The test needs a main() function.

---
 test/ref/bug2134.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/ref/bug2134.c b/test/ref/bug2134.c
index 9e95e1daa2..9dd1e5c55f 100644
--- a/test/ref/bug2134.c
+++ b/test/ref/bug2134.c
@@ -1,2 +1,3 @@
 int i = { 0 };
 char* p = { 0 };
+int main() { return 0; }

From aff82483411bc8c505ef024ad18778fc902fdbe3 Mon Sep 17 00:00:00 2001
From: Bob Andrews <mrdudz@users.noreply.github.com>
Date: Sun, 8 Sep 2024 17:08:40 +0200
Subject: [PATCH 36/50] add comment on function prototypes

---
 Contributing.md | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/Contributing.md b/Contributing.md
index 5b53e04672..10d687424f 100644
--- a/Contributing.md
+++ b/Contributing.md
@@ -204,6 +204,18 @@ char* nextLine (FILE* f);
 
 ### Header files
 
+* All Headers should start with a copyright/license banner
+* Function prototypes must be a single line, not contain the redundant
+  "extern" keyword, and followed by a brief comment that explains what
+  the function does, and separated from the next prototype by a blank
+  line:
+
+~~~C
+void __fastcall__ cclear (unsigned char length);
+/* Clear part of a line (write length spaces). */
+
+~~~
+
 Headers that belong to the standard library (libc) must
 conform with the C standard. That means:
 

From 6113dc5995ed2db57fb38d31cb18bbdf8e4a38ce Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Tue, 10 Sep 2024 08:12:31 +0200
Subject: [PATCH 37/50] Removed casts from stdint.h. Added a test. Fixes #2505.

---
 include/stdint.h  |  76 ++++++++++-----------
 test/val/stdint.c | 167 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 205 insertions(+), 38 deletions(-)
 create mode 100644 test/val/stdint.c

diff --git a/include/stdint.h b/include/stdint.h
index 5d6f047692..6d51565e04 100644
--- a/include/stdint.h
+++ b/include/stdint.h
@@ -52,15 +52,15 @@ typedef unsigned char       uint8_t;
 typedef unsigned            uint16_t;
 typedef unsigned long       uint32_t;
 
-#define INT8_MIN            ((int8_t) 0x80)
-#define INT8_MAX            ((int8_t) 0x7F)
-#define INT16_MIN           ((int16_t) 0x8000)
-#define INT16_MAX           ((int16_t) 0x7FFF)
-#define INT32_MIN           ((int32_t) 0x80000000)
-#define INT32_MAX           ((int32_t) 0x7FFFFFFF)
-#define UINT8_MAX           ((uint8_t) 0xFF)
-#define UINT16_MAX          ((uint16_t) 0xFFFF)
-#define UINT32_MAX          ((uint32_t) 0xFFFFFFFF)
+#define INT8_MIN            -128
+#define INT8_MAX            127
+#define INT16_MIN           (-32767 - 1)
+#define INT16_MAX           32767
+#define INT32_MIN           (-2147483647L - 1L)
+#define INT32_MAX           2147483647L
+#define UINT8_MAX           255
+#define UINT16_MAX          65535U
+#define UINT32_MAX          4294967295UL
 
 /* Minimum-width integer types */
 typedef signed char         int_least8_t;
@@ -70,15 +70,15 @@ typedef unsigned char       uint_least8_t;
 typedef unsigned            uint_least16_t;
 typedef unsigned long       uint_least32_t;
 
-#define INT_LEAST8_MIN      ((int_least8_t) 0x80)
-#define INT_LEAST8_MAX      ((int_least8_t) 0x7F)
-#define INT_LEAST16_MIN     ((int_least16_t) 0x8000)
-#define INT_LEAST16_MAX     ((int_least16_t) 0x7FFF)
-#define INT_LEAST32_MIN     ((int_least32_t) 0x80000000)
-#define INT_LEAST32_MAX     ((int_least32_t) 0x7FFFFFFF)
-#define UINT_LEAST8_MAX     ((uint_least8_t) 0xFF)
-#define UINT_LEAST16_MAX    ((uint_least16_t) 0xFFFF)
-#define UINT_LEAST32_MAX    ((uint_least32_t) 0xFFFFFFFF)
+#define INT_LEAST8_MIN      INT8_MIN
+#define INT_LEAST8_MAX      INT8_MAX
+#define INT_LEAST16_MIN     INT16_MIN
+#define INT_LEAST16_MAX     INT16_MAX
+#define INT_LEAST32_MIN     INT32_MIN
+#define INT_LEAST32_MAX     INT32_MAX
+#define UINT_LEAST8_MAX     UINT8_MAX
+#define UINT_LEAST16_MAX    UINT16_MAX
+#define UINT_LEAST32_MAX    UINT32_MAX
 
 /* Fastest minimum-width integer types */
 typedef signed char         int_fast8_t;
@@ -88,40 +88,40 @@ typedef unsigned char       uint_fast8_t;
 typedef unsigned            uint_fast16_t;
 typedef unsigned long       uint_fast32_t;
 
-#define INT_FAST8_MIN       ((int_fast8_t) 0x80)
-#define INT_FAST8_MAX       ((int_fast8_t) 0x7F)
-#define INT_FAST16_MIN      ((int_fast16_t) 0x8000)
-#define INT_FAST16_MAX      ((int_fast16_t) 0x7FFF)
-#define INT_FAST32_MIN      ((int_fast32_t) 0x80000000)
-#define INT_FAST32_MAX      ((int_fast32_t) 0x7FFFFFFF)
-#define UINT_FAST8_MAX      ((uint_fast8_t) 0xFF)
-#define UINT_FAST16_MAX     ((uint_fast16_t) 0xFFFF)
-#define UINT_FAST32_MAX     ((uint_fast32_t) 0xFFFFFFFF)
+#define INT_FAST8_MIN       INT8_MIN
+#define INT_FAST8_MAX       INT8_MAX
+#define INT_FAST16_MIN      INT16_MIN
+#define INT_FAST16_MAX      INT16_MAX
+#define INT_FAST32_MIN      INT32_MIN
+#define INT_FAST32_MAX      INT32_MAX
+#define UINT_FAST8_MAX      UINT8_MAX
+#define UINT_FAST16_MAX     UINT16_MAX
+#define UINT_FAST32_MAX     UINT32_MAX
 
 /* Integer types capable of holding object pointers */
 typedef int                 intptr_t;
 typedef unsigned            uintptr_t;
 
-#define INTPTR_MIN          ((intptr_t)0x8000)
-#define INTPTR_MAX          ((intptr_t)0x7FFF)
-#define UINTPTR_MAX         ((uintptr_t) 0xFFFF)
+#define INTPTR_MIN          INT16_MIN
+#define INTPTR_MAX          INT16_MAX
+#define UINTPTR_MAX         UINT16_MAX
 
 /* Greatest width integer types */
 typedef long                intmax_t;
 typedef unsigned long       uintmax_t;
 
-#define INTMAX_MIN          ((intmax_t) 0x80000000)
-#define INTMAX_MAX          ((intmax_t) 0x7FFFFFFF)
-#define UINTMAX_MAX         ((uintmax_t) 0xFFFFFFFF)
+#define INTMAX_MIN          INT32_MIN
+#define INTMAX_MAX          INT32_MAX
+#define UINTMAX_MAX         UINT32_MAX
 
 /* Limits of other integer types */
-#define PTRDIFF_MIN         ((int) 0x8000)
-#define PTRDIFF_MAX         ((int) 0x7FFF)
+#define PTRDIFF_MIN         INT16_MIN
+#define PTRDIFF_MAX         INT16_MAX
 
-#define SIG_ATOMIC_MIN      ((unsigned char) 0x00)
-#define SIG_ATOMIC_MAX      ((unsigned char) 0xFF)
+#define SIG_ATOMIC_MIN      0
+#define SIG_ATOMIC_MAX      UINT8_MAX
 
-#define SIZE_MAX            0xFFFF
+#define SIZE_MAX            UINT16_MAX
 
 /* Macros for minimum width integer constants */
 #define INT8_C(c)           c
diff --git a/test/val/stdint.c b/test/val/stdint.c
new file mode 100644
index 0000000000..29b48346a4
--- /dev/null
+++ b/test/val/stdint.c
@@ -0,0 +1,167 @@
+/* Test definitions from stdint.h */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <signal.h>
+
+/* All macros from stdint.h must be evaluatable by the preprocessor */
+#if INT8_MIN
+#endif
+#if INT8_MAX
+#endif
+#if INT16_MIN
+#endif
+#if INT16_MAX
+#endif
+#if INT32_MIN
+#endif
+#if INT32_MAX
+#endif
+#if UINT8_MAX
+#endif
+#if UINT16_MAX
+#endif
+#if UINT32_MAX
+#endif
+#if INT_LEAST8_MIN
+#endif
+#if INT_LEAST8_MAX
+#endif
+#if INT_LEAST16_MIN
+#endif
+#if INT_LEAST16_MAX
+#endif
+#if INT_LEAST32_MIN
+#endif
+#if INT_LEAST32_MAX
+#endif
+#if UINT_LEAST8_MAX
+#endif
+#if UINT_LEAST16_MAX
+#endif
+#if UINT_LEAST32_MAX
+#endif
+#if INT_FAST8_MIN
+#endif
+#if INT_FAST8_MAX
+#endif
+#if INT_FAST16_MIN
+#endif
+#if INT_FAST16_MAX
+#endif
+#if INT_FAST32_MIN
+#endif
+#if INT_FAST32_MAX
+#endif
+#if UINT_FAST8_MAX
+#endif
+#if UINT_FAST16_MAX
+#endif
+#if UINT_FAST32_MAX
+#endif
+#if INTPTR_MIN
+#endif
+#if INTPTR_MAX
+#endif
+#if UINTPTR_MAX
+#endif
+#if INTMAX_MIN
+#endif
+#if INTMAX_MAX
+#endif
+#if UINTMAX_MAX
+#endif
+#if PTRDIFF_MIN
+#endif
+#if PTRDIFF_MAX
+#endif
+#if SIG_ATOMIC_MIN
+#endif
+#if SIG_ATOMIC_MAX
+#endif
+#if SIZE_MAX
+#endif
+
+#define SMIN(type)      ((type)(1L << (sizeof(type) * CHAR_BIT - 1)))
+#define SMAX(type)      ((type)(~SMIN(type)))
+#define UMAX(type)      ((type)(~(type)0))
+
+#define SMIN_CHECK(type, val)                                           \
+    if (SMIN(type) != val) {                                            \
+        ++failures;                                                     \
+        printf("Mismatch for %s, minimum (%ld) is not %s (%ld)\n",      \
+               #type, (long)SMIN(type), #val, (long)val);               \
+    }
+#define SMAX_CHECK(type, val)                                           \
+    if (SMAX(type) != val) {                                            \
+        ++failures;                                                     \
+        printf("Mismatch for %s, maximum (%ld) is not %s (%ld)\n",      \
+               #type, (long)SMAX(type), #val, (long)val);               \
+    }
+#define UMAX_CHECK(type, val)                                           \
+    if (UMAX(type) != val) {                                            \
+        ++failures;                                                     \
+        printf("Mismatch for %s, maximum (%lu) is not %s (%lu)\n",      \
+               #type, (unsigned long)UMAX(type), #val,                  \
+               (unsigned long)val);                                     \
+    }
+
+static unsigned failures = 0;
+
+int main()
+{
+    SMIN_CHECK(int8_t, INT8_MIN);
+    SMAX_CHECK(int8_t, INT8_MAX);
+    SMIN_CHECK(int16_t, INT16_MIN);
+    SMAX_CHECK(int16_t, INT16_MAX);
+    SMIN_CHECK(int32_t, INT32_MIN);
+    SMAX_CHECK(int32_t, INT32_MAX);
+    UMAX_CHECK(uint8_t, UINT8_MAX);
+    UMAX_CHECK(uint16_t, UINT16_MAX);
+    UMAX_CHECK(uint32_t, UINT32_MAX);
+
+    SMIN_CHECK(int_least8_t, INT_LEAST8_MIN);
+    SMAX_CHECK(int_least8_t, INT_LEAST8_MAX);
+    SMIN_CHECK(int_least16_t, INT_LEAST16_MIN);
+    SMAX_CHECK(int_least16_t, INT_LEAST16_MAX);
+    SMIN_CHECK(int_least32_t, INT_LEAST32_MIN);
+    SMAX_CHECK(int_least32_t, INT_LEAST32_MAX);
+    UMAX_CHECK(uint_least8_t, UINT_LEAST8_MAX);
+    UMAX_CHECK(uint_least16_t, UINT_LEAST16_MAX);
+    UMAX_CHECK(uint_least32_t, UINT_LEAST32_MAX);
+
+    SMIN_CHECK(int_fast8_t, INT_FAST8_MIN);
+    SMAX_CHECK(int_fast8_t, INT_FAST8_MAX);
+    SMIN_CHECK(int_fast16_t, INT_FAST16_MIN);
+    SMAX_CHECK(int_fast16_t, INT_FAST16_MAX);
+    SMIN_CHECK(int_fast32_t, INT_FAST32_MIN);
+    SMAX_CHECK(int_fast32_t, INT_FAST32_MAX);
+    UMAX_CHECK(uint_fast8_t, UINT_FAST8_MAX);
+    UMAX_CHECK(uint_fast16_t, UINT_FAST16_MAX);
+    UMAX_CHECK(uint_fast32_t, UINT_FAST32_MAX);
+
+    SMIN_CHECK(intptr_t, INTPTR_MIN);
+    SMAX_CHECK(intptr_t, INTPTR_MAX);
+    UMAX_CHECK(uintptr_t, UINTPTR_MAX);
+
+    SMIN_CHECK(intmax_t, INTMAX_MIN);
+    SMAX_CHECK(intmax_t, INTMAX_MAX);
+    UMAX_CHECK(uintmax_t, UINTMAX_MAX);
+
+    SMIN_CHECK(ptrdiff_t, PTRDIFF_MIN);
+    SMAX_CHECK(ptrdiff_t, PTRDIFF_MAX);
+
+#if SIG_ATOMIC_MIN < 0
+    SMIN_CHECK(sig_atomic_t, SIG_ATOMIC_MIN);
+    SMAX_CHECK(sig_atomic_t, SIG_ATOMIC_MAX);
+#else
+    UMAX_CHECK(sig_atomic_t, SIG_ATOMIC_MAX);
+#endif
+
+    UMAX_CHECK(size_t, SIZE_MAX);
+
+    return failures;
+}

From 2f6f5f0da142f2a21f30449fe6de78d24e2987ae Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Wed, 11 Sep 2024 19:20:01 +0200
Subject: [PATCH 38/50] Fix problem with #line when there is no whitespace
 between line number and filename. y

---
 src/cc65/preproc.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/cc65/preproc.c b/src/cc65/preproc.c
index 1ee810060d..96db1d8fe1 100644
--- a/src/cc65/preproc.c
+++ b/src/cc65/preproc.c
@@ -2913,7 +2913,7 @@ static unsigned GetLineDirectiveNum (void)
 
     /* Ensure the buffer is terminated with a '\0' */
     SB_Terminate (&Buf);
-    if (SkipWhitespace (0) != 0 || CurC == '\0') {
+    if (SB_GetLen (&Buf) > 0) {
         const char* Str = SB_GetConstBuf (&Buf);
         if (Str[0] == '\0') {
             PPWarning ("#line directive interprets number as decimal, not octal");
@@ -2929,9 +2929,10 @@ static unsigned GetLineDirectiveNum (void)
             }
         }
     } else {
-        PPError ("#line directive requires a simple decimal digit sequence");
+        PPError ("#line directive requires a decimal digit sequence");
         ClearLine ();
     }
+    SkipWhitespace (0);
 
     /* Done with the buffer */
     SB_Done (&Buf);

From 70ca6d420063c0fe0b9abb731232ca533a1d958e Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Wed, 11 Sep 2024 19:21:19 +0200
Subject: [PATCH 39/50] Fixed a standard noncompliance: In C99 and above there
 must be whitespace between a name of an object like macro and its replacement
 list.

---
 src/cc65/preproc.c | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/cc65/preproc.c b/src/cc65/preproc.c
index 96db1d8fe1..d033520b83 100644
--- a/src/cc65/preproc.c
+++ b/src/cc65/preproc.c
@@ -2640,6 +2640,18 @@ static void DoDefine (void)
             goto Error_Handler;
         }
         NextChar ();
+
+    } else {
+
+        /* Object like macro. Check ISO/IEC 9899:1999 (E) 6.10.3p3:
+        ** "There shall be white-space between the identifier and the
+        ** replacement list in the definition of an object-like macro."
+        ** Note: C89 doesn't have this constraint.
+        */
+        if (Std == STD_C99 && !IsSpace (CurC)) {
+            PPWarning ("ISO C99 requires whitespace after the macro name");
+        }
+
     }
 
     /* Remove whitespace and comments from the line, store the preprocessed

From 36a810cdb23b903ca4f3771a94b3b9a2489e634a Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Thu, 12 Sep 2024 09:10:37 +0200
Subject: [PATCH 40/50] Make lastline.sh ignore empty files. Fixes #2514.

---
 .github/checks/lastline.sh | 2 +-
 .gitignore                 | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/checks/lastline.sh b/.github/checks/lastline.sh
index d80d2fb573..d243a01e17 100755
--- a/.github/checks/lastline.sh
+++ b/.github/checks/lastline.sh
@@ -9,7 +9,7 @@ nl='
 '
 nl=$'\n'
 r1="${nl}$"
-FILES=`find $CHECK_PATH -type f \( -name \*.inc -o -name Makefile -o -name \*.cfg -o -name \*.\[chs\] -o -name \*.mac -o -name \*.asm -o -name \*.sgml \) -print | while read f; do
+FILES=`find $CHECK_PATH -type f -size +0 \( -name \*.inc -o -name Makefile -o -name \*.cfg -o -name \*.\[chs\] -o -name \*.mac -o -name \*.asm -o -name \*.sgml \) -print | while read f; do
     t=$(tail -c2 $f; printf x)
     [[ ${t%x} =~ $r1 ]] || echo "$f"
 done`
diff --git a/.gitignore b/.gitignore
index 9112484b8e..772a2f2044 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,4 +9,4 @@
 /cc65.zip
 /util/atari/*.exe
 /util/gamate/*.exe
-
+targettest/cbm/cbmread.prg

From efa2020d932e645de0fa21af4c36db16654ff0b4 Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Thu, 12 Sep 2024 09:14:57 +0200
Subject: [PATCH 41/50] Improved/fixed the time() function: - When the
 underlying clock_gettime function returned an error, the value   returned via
 *timep was wrong. - Reduced code size by 7 bytes. - Don't suck in ldeaxi.

---
 libsrc/common/time.s  | 51 ++++++++++++++++--------------------
 test/val/time-test2.c | 61 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 84 insertions(+), 28 deletions(-)
 create mode 100644 test/val/time-test2.c

diff --git a/libsrc/common/time.s b/libsrc/common/time.s
index 36fd36323a..4092e71c69 100644
--- a/libsrc/common/time.s
+++ b/libsrc/common/time.s
@@ -22,55 +22,50 @@
 
 ; Get the time (machine dependent)
 
+        .assert timespec::tv_sec = 0, error
         lda     #CLOCK_REALTIME
         jsr     pusha
         lda     #<time
         ldx     #>time
         jsr     _clock_gettime
-        sta     tmp2
-        lda     #<time
-        ldx     #>time
-        .assert timespec::tv_sec = 0, error
-        jsr     ldeaxi
-        sta     tmp1            ; Save low byte of result
+
+; _clock_gettime returns 0 on success and -1 on error. Check that.
+
+        inx                     ; Did _clock_gettime return -1?
+        bne     @L2             ; Jump if not
+
+; We had an error so invalidate time. A contains $FF.
+
+        ldy     #3
+@L1:    sta     time,y
+        dey
+        bpl     @L1
 
 ; Restore timep and check if it is NULL
 
-        pla
+@L2:    pla
         sta     ptr1+1
         pla
         sta     ptr1            ; Restore timep
         ora     ptr1+1          ; timep == 0?
-        beq     @L1
+        beq     @L4
 
 ; timep is not NULL, store the result there
 
         ldy     #3
-        lda     sreg+1
+@L3:    lda     time,y
         sta     (ptr1),y
         dey
-        lda     sreg
-        sta     (ptr1),y
-        dey
-        txa
-        sta     (ptr1),y
-        dey
-        lda     tmp1
-        sta     (ptr1),y
-
-; If the result is != 0, return -1
+        bpl     @L3
 
-@L1:    lda     tmp2
-        beq     @L2
+; Load the final result.
 
-        tax
-        sta     sreg
+@L4:    lda     time+3
         sta     sreg+1
-        rts
-
-; Reload the low byte of the result and return
-
-@L2:    lda     tmp1
+        lda     time+2
+        sta     sreg
+        ldx     time+1
+        lda     time
         rts
 
 .endproc
diff --git a/test/val/time-test2.c b/test/val/time-test2.c
new file mode 100644
index 0000000000..725bbd0e6d
--- /dev/null
+++ b/test/val/time-test2.c
@@ -0,0 +1,61 @@
+/* Another test for time() */
+
+#include <stdio.h>
+#include <time.h>
+
+static int failures = 0;
+#define INV_TIME        ((time_t)-1)
+#define TEST_TIME       ((time_t)0x78AB1234)
+
+/* We supply our own clock_gettime function so we can control the values
+** supplied to time() internally.
+*/
+static time_t timeval;
+static int timeres;
+int __fastcall__ clock_gettime (clockid_t, struct timespec *tp)
+{
+    /* Don't touch tp in case of an error */
+    if (timeres != -1) {
+        tp->tv_sec = timeval;
+        tp->tv_nsec = 0;
+    }
+    return timeres;
+}
+
+int main()
+{
+    time_t res, pres;
+
+    /* First test: Force time() to return an error. Check that both, the
+    ** returned value and the value passed via pointer are (time_t)-1.
+    */
+    timeval = 42;
+    timeres = -1;
+    res = time(&pres);
+    if (res != INV_TIME || pres != INV_TIME) {
+        printf("Error in test 1\n");
+        ++failures;
+    }
+
+    /* Second test: Return a valid value and check both results */
+    timeval = TEST_TIME;
+    timeres = 0;
+    res = time(&pres);
+    if (res != TEST_TIME || pres != TEST_TIME) {
+        printf("Error in test 2\n");
+        ++failures;
+    }
+
+    /* Third test: Return no error but an invalid value and check both
+    ** results
+    */
+    timeval = INV_TIME;
+    timeres = 0;
+    res = time(&pres);
+    if (res != INV_TIME || pres != INV_TIME) {
+        printf("Error in test 3\n");
+        ++failures;
+    }
+
+    return failures;
+}

From 3f83cf81f3c62f91eeed4097f01a91fa020c2c02 Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Fri, 13 Sep 2024 19:02:13 +0200
Subject: [PATCH 42/50] Revert the change to .gitignore so git status doesn't
 report a clean status as before.

---
 .gitignore | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index 772a2f2044..9112484b8e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,4 +9,4 @@
 /cc65.zip
 /util/atari/*.exe
 /util/gamate/*.exe
-targettest/cbm/cbmread.prg
+

From 001fa05d48bddc68b8369bbb460e11e333a56f79 Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Fri, 13 Sep 2024 19:18:31 +0200
Subject: [PATCH 43/50] Move the test to the test/standard directory.

---
 test/{val => standard}/stdint.c | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename test/{val => standard}/stdint.c (100%)

diff --git a/test/val/stdint.c b/test/standard/stdint.c
similarity index 100%
rename from test/val/stdint.c
rename to test/standard/stdint.c

From 6e18e0880adcaf6201e5c805b3905a8b2e0f7924 Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Thu, 5 Sep 2024 19:59:02 +0200
Subject: [PATCH 44/50] Added/improved the optimizations: * Added a new pass
 that optimizes PHA/PLA sequences * Added a new pass that optimizes
 AND/EOR/ORA when an operand is known * Added a run of an existing pass at
 later stages to remove code that   otherwise goes unchanged. * Handle binary
 operations in OptUnusedLoads in addition to real loads.

---
 src/cc65/codeent.c  |  18 +++++
 src/cc65/codeopt.c  |   8 +++
 src/cc65/coptind.c  | 110 ++++++++++++++++++++++++++--
 src/cc65/coptind.h  |   7 +-
 src/cc65/coptmisc.c | 172 ++++++++++++++++++++++++++++++++++++++++++++
 src/cc65/coptmisc.h |   6 ++
 6 files changed, 315 insertions(+), 6 deletions(-)

diff --git a/src/cc65/codeent.c b/src/cc65/codeent.c
index 928815934d..a870ee981d 100644
--- a/src/cc65/codeent.c
+++ b/src/cc65/codeent.c
@@ -2445,6 +2445,24 @@ static char* RegContentDesc (const RegContents* RC, char* Buf)
         sprintf (B, "Y:%02X ", RC->RegY);
     }
     B += 5;
+    if (RegValIsUnknown (RC->Ptr1Lo)) {
+        strcpy (B, "P1L:XX ");
+    } else {
+        sprintf (B, "P1L:%02X ", RC->Ptr1Lo);
+    }
+    B += 7;
+    if (RegValIsUnknown (RC->Ptr1Hi)) {
+        strcpy (B, "P1H:XX ");
+    } else {
+        sprintf (B, "P1H:%02X ", RC->Ptr1Hi);
+    }
+    B += 7;
+    if (RegValIsUnknown (RC->Tmp1)) {
+        strcpy (B, "T1:XX ");
+    } else {
+        sprintf (B, "T1:%02X ", RC->Tmp1);
+    }
+    B += 6;
     if (PStatesAreUnknown (RC->PFlags, PSTATE_C)) {
         strcpy (B, "~");
     } else {
diff --git a/src/cc65/codeopt.c b/src/cc65/codeopt.c
index c9c1592bc0..a716ad4311 100644
--- a/src/cc65/codeopt.c
+++ b/src/cc65/codeopt.c
@@ -117,6 +117,7 @@ static OptFunc DOptBNegAX1      = { OptBNegAX1,      "OptBNegAX1",      100, 0,
 static OptFunc DOptBNegAX2      = { OptBNegAX2,      "OptBNegAX2",      100, 0, 0, 0, 0, 0 };
 static OptFunc DOptBNegAX3      = { OptBNegAX3,      "OptBNegAX3",      100, 0, 0, 0, 0, 0 };
 static OptFunc DOptBNegAX4      = { OptBNegAX4,      "OptBNegAX4",      100, 0, 0, 0, 0, 0 };
+static OptFunc DOptBinOps       = { OptBinOps,       "OptBinOps",         0, 0, 0, 0, 0, 0 };
 static OptFunc DOptBoolCmp      = { OptBoolCmp,      "OptBoolCmp",      100, 0, 0, 0, 0, 0 };
 static OptFunc DOptBoolTrans    = { OptBoolTrans,    "OptBoolTrans",    100, 0, 0, 0, 0, 0 };
 static OptFunc DOptBoolUnary1   = { OptBoolUnary1,   "OptBoolUnary1",    40, 0, 0, 0, 0, 0 };
@@ -179,6 +180,7 @@ static OptFunc DOptPush1        = { OptPush1,        "OptPush1",         65, 0,
 static OptFunc DOptPush2        = { OptPush2,        "OptPush2",         50, 0, 0, 0, 0, 0 };
 static OptFunc DOptPushPop1     = { OptPushPop1,     "OptPushPop1",       0, 0, 0, 0, 0, 0 };
 static OptFunc DOptPushPop2     = { OptPushPop2,     "OptPushPop2",       0, 0, 0, 0, 0, 0 };
+static OptFunc DOptPushPop3     = { OptPushPop3,     "OptPushPop3",       0, 0, 0, 0, 0, 0 };
 static OptFunc DOptRTS          = { OptRTS,          "OptRTS",          100, 0, 0, 0, 0, 0 };
 static OptFunc DOptRTSJumps1    = { OptRTSJumps1,    "OptRTSJumps1",    100, 0, 0, 0, 0, 0 };
 static OptFunc DOptRTSJumps2    = { OptRTSJumps2,    "OptRTSJumps2",    100, 0, 0, 0, 0, 0 };
@@ -231,6 +233,7 @@ static OptFunc* OptFuncs[] = {
     &DOptBNegAX2,
     &DOptBNegAX3,
     &DOptBNegAX4,
+    &DOptBinOps,
     &DOptBoolCmp,
     &DOptBoolTrans,
     &DOptBoolUnary1,
@@ -292,6 +295,8 @@ static OptFunc* OptFuncs[] = {
     &DOptPush1,
     &DOptPush2,
     &DOptPushPop1,
+    &DOptPushPop2,
+    &DOptPushPop3,
     &DOptRTS,
     &DOptRTSJumps1,
     &DOptRTSJumps2,
@@ -740,9 +745,11 @@ static unsigned RunOptGroup3 (CodeSeg* S)
         C += RunOptFunc (S, &DOptStore5, 1);
         C += RunOptFunc (S, &DOptPushPop1, 1);
         C += RunOptFunc (S, &DOptPushPop2, 1);
+        C += RunOptFunc (S, &DOptPushPop3, 1);
         C += RunOptFunc (S, &DOptPrecalc, 1);
         C += RunOptFunc (S, &DOptShiftBack, 1);
         C += RunOptFunc (S, &DOptSignExtended, 1);
+        C += RunOptFunc (S, &DOptBinOps, 1);
 
         Changes += C;
 
@@ -849,6 +856,7 @@ static unsigned RunOptGroup7 (CodeSeg* S)
         Changes += RunOptFunc (S, &DOptUnusedStores, 1);
         Changes += RunOptFunc (S, &DOptJumpTarget1, 5);
         Changes += RunOptFunc (S, &DOptStore5, 1);
+        Changes += RunOptFunc (S, &DOptTransfers1, 1);
     }
 
     C = RunOptFunc (S, &DOptSize2, 1);
diff --git a/src/cc65/coptind.c b/src/cc65/coptind.c
index 9e9985c100..49855a3452 100644
--- a/src/cc65/coptind.c
+++ b/src/cc65/coptind.c
@@ -151,7 +151,9 @@ static short ZPRegVal (unsigned short Use, const RegContents* RC)
 
 
 unsigned OptUnusedLoads (CodeSeg* S)
-/* Remove loads of registers where the value loaded is not used later. */
+/* Remove loads of or operations with registers where the value loaded or 
+** produced is not used later. 
+*/
 {
     unsigned Changes = 0;
 
@@ -164,17 +166,24 @@ unsigned OptUnusedLoads (CodeSeg* S)
         /* Get next entry */
         CodeEntry* E = CS_GetEntry (S, I);
 
-        /* Check if it's a register load or transfer insn */
-        if ((E->Info & (OF_LOAD | OF_XFR | OF_REG_INCDEC)) != 0         &&
-            (N = CS_GetNextEntry (S, I)) != 0                           &&
-            !CE_UseLoadFlags (N)) {
+        /* Check if this is one of the instruction we can operate on */
+        int IsOp = (E->Info & (OF_LOAD | OF_XFR | OF_REG_INCDEC)) != 0  ||
+                   E->OPC == OP65_AND                                   ||
+                   E->OPC == OP65_EOR                                   ||
+                   E->OPC == OP65_ORA;
+
+        /* Check for the necessary preconditions */
+        if (IsOp && (N = CS_GetNextEntry (S, I)) != 0 && !CE_UseLoadFlags (N)) {
 
             /* Check which sort of load or transfer it is */
             unsigned R;
             switch (E->OPC) {
+                case OP65_AND:
                 case OP65_DEA:
+                case OP65_EOR:
                 case OP65_INA:
                 case OP65_LDA:
+                case OP65_ORA:
                 case OP65_TXA:
                 case OP65_TYA:  R = REG_A;      break;
                 case OP65_DEX:
@@ -1342,6 +1351,97 @@ unsigned OptPushPop2 (CodeSeg* S)
 
 
 
+unsigned OptPushPop3 (CodeSeg* S)
+/* Remove a pha/pla sequence where the contents of A are known */
+{
+    unsigned Changes    = 0;
+    unsigned Pha        = 0;          /* Index of PHA insn */
+    unsigned Pla        = 0;          /* Index of PLA insn */
+    CodeEntry* PhaEntry = 0;          /* Pointer to PHA */
+
+    enum {
+        Searching,
+        FoundPha,
+        FoundPla
+    } State = Searching;
+
+    /* Walk over the entries. Look for a PHA instruction where the contents
+    ** of A is known followed by a PLA later.
+    */
+    unsigned I = 0;
+    while (I < CS_GetEntryCount (S)) {
+
+        /* Get next entry */
+        CodeEntry* E = CS_GetEntry (S, I);
+
+        /* Get the input registers */
+        const RegInfo* RI = E->RI;
+
+
+        const char* Arg;
+        CodeEntry* X;
+        switch (State) {
+
+            case Searching:
+                if (E->OPC == OP65_PHA && RegValIsKnown (RI->In.RegA)) {
+                    /* Found start of sequence */
+                    Pha = I;
+                    PhaEntry = E;
+                    State = FoundPha;
+                }
+                break;
+
+            case FoundPha:
+                /* Check for several things that abort the sequence:
+                ** - End of the basic block
+                ** - Another PHA or any other stack manipulating instruction
+                ** If we find something that aborts the sequence, start over
+                ** searching for the next PHA.
+                */
+                if (CE_HasLabel (E)) {
+                    /* Switch back to searching at this instruction */
+                    State = Searching;
+                    continue;
+                }
+                if (E->OPC == OP65_PHA) {
+                    /* Start over at this instruction */
+                    State = Searching;
+                    continue;
+                }
+                if (E->OPC == OP65_PHP || E->OPC == OP65_PLP || E->OPC == OP65_TXS) {
+                    /* Start over at the next instruction */
+                    State = Searching;
+                } else if (E->OPC == OP65_PLA) {
+                    /* Switch state. This will also switch to the next insn
+                    ** which is ok.
+                    */
+                    Pla = I;
+                    State = FoundPla;
+                }
+                break;
+
+            case FoundPla:
+                /* We found the sequence we were looking for. Replace it. */
+                Arg = MakeHexArg (PhaEntry->RI->In.RegA);
+                X = NewCodeEntry (OP65_LDA, AM65_IMM, Arg, 0, E->LI);
+                CS_InsertEntry (S, X, Pla + 1);
+                CS_DelEntry (S, Pla);
+                CS_DelEntry (S, Pha);
+                ++Changes;
+                State = Searching;
+                break;
+        }
+
+        /* Next entry */
+        ++I;
+    }
+
+    /* Return the number of changes made */
+    return Changes;
+}
+
+
+
 unsigned OptPrecalc (CodeSeg* S)
 /* Replace immediate operations with the accu where the current contents are
 ** known by a load of the final value.
diff --git a/src/cc65/coptind.h b/src/cc65/coptind.h
index 6d39ee1f8d..3493543a46 100644
--- a/src/cc65/coptind.h
+++ b/src/cc65/coptind.h
@@ -50,7 +50,9 @@
 
 
 unsigned OptUnusedLoads (CodeSeg* S);
-/* Remove loads of registers where the value loaded is not used later. */
+/* Remove loads of or operations with registers where the value loaded or
+** produced is not used later.
+*/
 
 unsigned OptUnusedStores (CodeSeg* S);
 /* Remove stores into zero page registers that aren't used later */
@@ -91,6 +93,9 @@ unsigned OptPushPop1 (CodeSeg* S);
 unsigned OptPushPop2 (CodeSeg* S);
 /* Remove a PHP/PLP sequence were no processor flags changed inside */
 
+unsigned OptPushPop3 (CodeSeg* S);
+/* Remove a pha/pla sequence where the contents of A are known */
+
 unsigned OptPrecalc (CodeSeg* S);
 /* Replace immediate operations with the accu where the current contents are
 ** known by a load of the final value.
diff --git a/src/cc65/coptmisc.c b/src/cc65/coptmisc.c
index 523fbf17cb..332247cf05 100644
--- a/src/cc65/coptmisc.c
+++ b/src/cc65/coptmisc.c
@@ -733,3 +733,175 @@ unsigned OptLoad2 (CodeSeg* S)
     /* Return the number of changes made */
     return Changes;
 }
+
+
+
+unsigned OptBinOps (CodeSeg* S)
+/* Search for an AND/EOR/ORA where the value of A or the operand is known and
+** replace it by something simpler.
+*/
+{
+    unsigned Changes = 0;
+
+    /* Walk over the entries */
+    unsigned I = 0;
+    while (I < CS_GetEntryCount (S)) {
+
+        /* Get next entry */
+        CodeEntry* E = CS_GetEntry (S, I);
+
+        /* Get a pointer to the input registers of the insn */
+        const RegContents* In  = &E->RI->In;
+
+        /* Check for AND/EOR/ORA and a known value in A */
+        int Delete = 0;
+        CodeEntry* X = 0;
+        switch (E->OPC) {
+
+            case OP65_AND:
+                if (In->RegA == 0x00) {
+                    /* Zero AND anything gives zero. The instruction can be
+                    ** replaced by an immediate load of zero.
+                    */
+                    X = NewCodeEntry (OP65_LDA, AM65_IMM, "$00", 0, E->LI);
+                } else if (In->RegA == 0xFF) {
+                    /* 0xFF AND anything equals the operand. The instruction
+                    ** can be replaced by a simple load of the operand.
+                    */
+                    X = NewCodeEntry (OP65_LDA, E->AM, E->Arg, 0, E->LI);
+                } else if (E->AM == AM65_ZP) {
+                    short Operand = -1;
+                    switch (GetKnownReg (E->Use & REG_ZP, In)) {
+                        case REG_TMP1:      Operand = In->Tmp1;     break;
+                        case REG_PTR1_LO:   Operand = In->Ptr1Lo;   break;
+                        case REG_PTR1_HI:   Operand = In->Ptr1Hi;   break;
+                        case REG_SREG_LO:   Operand = In->SRegLo;   break;
+                        case REG_SREG_HI:   Operand = In->SRegHi;   break;
+                    }
+                    if (Operand == 0x00) {
+                        /* AND with zero gives zero. The instruction can be
+                        ** replaced by an immediate load of zero.
+                        */
+                        X = NewCodeEntry (OP65_LDA, AM65_IMM, "$00", 0, E->LI);
+                    } else if (Operand == 0xFF) {
+                        /* AND with 0xFF is a no-op besides setting the flags.
+                        ** The instruction can be removed if the flags aren't
+                        ** used later.
+                        */
+                        CodeEntry* N = CS_GetNextEntry (S, I);
+                        if (N && !CE_UseLoadFlags (N)) {
+                            Delete = 1;
+                        }
+                    } else if (Operand >= 0) {
+                        /* The instruction can be replaced by an immediate
+                        ** AND.
+                        */
+                        const char* Arg = MakeHexArg (Operand);
+                        X = NewCodeEntry (OP65_AND, AM65_IMM, Arg, 0, E->LI);
+                    }
+                }
+                break;
+
+            case OP65_EOR:
+                if (In->RegA == 0x00) {
+                    /* Zero EOR anything equals the operand. The instruction
+                    ** can be replaced by a simple load.
+                    */
+                    X = NewCodeEntry (OP65_LDA, E->AM, E->Arg, 0, E->LI);
+                } else if (E->AM == AM65_ZP) {
+                    short Operand = -1;
+                    switch (GetKnownReg (E->Use & REG_ZP, In)) {
+                        case REG_TMP1:      Operand = In->Tmp1;     break;
+                        case REG_PTR1_LO:   Operand = In->Ptr1Lo;   break;
+                        case REG_PTR1_HI:   Operand = In->Ptr1Hi;   break;
+                        case REG_SREG_LO:   Operand = In->SRegLo;   break;
+                        case REG_SREG_HI:   Operand = In->SRegHi;   break;
+                    }
+                    if (Operand == 0x00) {
+                        /* EOR with 0x00 is a no-op besides setting the flags.
+                        ** The instruction can be removed if the flags aren't
+                        ** used later.
+                        */
+                        CodeEntry* N = CS_GetNextEntry (S, I);
+                        if (N && !CE_UseLoadFlags (N)) {
+                            Delete = 1;
+                        }
+                    } else if (Operand >= 0) {
+                        /* The instruction can be replaced by an immediate
+                        ** EOR.
+                        */
+                        const char* Arg = MakeHexArg (Operand);
+                        X = NewCodeEntry (OP65_EOR, AM65_IMM, Arg, 0, E->LI);
+                    }
+                }
+                break;
+
+            case OP65_ORA:
+                if (In->RegA == 0x00) {
+                    /* ORA with 0x00 is a no-op. The instruction can be
+                    ** replaced by a simple load.
+                    */
+                    X = NewCodeEntry (OP65_LDA, E->AM, E->Arg, 0, E->LI);
+                } else if (In->RegA == 0xFF) {
+                    /* ORA with 0xFF gives 0xFF. The instruction can be replaced
+                    ** by an immediate load of 0xFF.
+                    */
+                    X = NewCodeEntry (OP65_LDA, AM65_IMM, "$FF", 0, E->LI);
+                } else if (E->AM == AM65_ZP) {
+                    short Operand = -1;
+                    switch (GetKnownReg (E->Use & REG_ZP, In)) {
+                        case REG_TMP1:      Operand = In->Tmp1;     break;
+                        case REG_PTR1_LO:   Operand = In->Ptr1Lo;   break;
+                        case REG_PTR1_HI:   Operand = In->Ptr1Hi;   break;
+                        case REG_SREG_LO:   Operand = In->SRegLo;   break;
+                        case REG_SREG_HI:   Operand = In->SRegHi;   break;
+                    }
+                    if (Operand == 0x00) {
+                        /* ORA with 0x00 is a no-op besides setting the flags.
+                        ** The instruction can be removed if the flags aren't
+                        ** used later.
+                        */
+                        CodeEntry* N = CS_GetNextEntry (S, I);
+                        if (N && !CE_UseLoadFlags (N)) {
+                            Delete = 1;
+                        }
+                    } else if (Operand == 0xFF) {
+                        /* ORA with 0xFF results in 0xFF. The instruction can
+                        ** be replaced by a simple load.
+                        */
+                        X = NewCodeEntry (OP65_LDA, AM65_IMM, "$FF", 0, E->LI);
+                    } else if (Operand >= 0) {
+                        /* The instruction can be replaced by an immediate
+                        ** ORA.
+                        */
+                        const char* Arg = MakeHexArg (Operand);
+                        X = NewCodeEntry (OP65_ORA, AM65_IMM, Arg, 0, E->LI);
+                    }
+                }
+                break;
+
+            default:
+                break;
+
+        }
+
+        /* If we must delete the instruction, do that. If we have a replacement
+        ** entry, place it and remove the old one.
+        */
+        if (X) {
+            CS_InsertEntry (S, X, I+1);
+            Delete = 1;
+        }
+        if (Delete) {
+            CS_DelEntry (S, I);
+            ++Changes;
+        }
+
+        /* Next entry */
+        ++I;
+
+    }
+
+    /* Return the number of changes made */
+    return Changes;
+}
diff --git a/src/cc65/coptmisc.h b/src/cc65/coptmisc.h
index 89242351ce..418b61e943 100644
--- a/src/cc65/coptmisc.h
+++ b/src/cc65/coptmisc.h
@@ -107,6 +107,12 @@ unsigned OptLoad1 (CodeSeg* S);
 unsigned OptLoad2 (CodeSeg* S);
 /* Replace calls to ldaxysp by inline code */
 
+unsigned OptBinOps (CodeSeg* S);
+/* Search for an AND/EOR/ORA where the value of A or the operand is known and
+** replace it by something simpler.
+*/
+
+
 
 /* End of coptmisc.h */
 

From f43cfd1ad0ad2f668a5808ad000bdc2feea5d6da Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Sat, 7 Sep 2024 17:19:13 +0200
Subject: [PATCH 45/50] Fix the check for CPU flags being used after an
 instruction that gets removed. Previously only the next instruction was
 checked for usage of the CPU flags but this fails for certain code.

---
 src/cc65/codeinfo.c | 24 +++++++++++++-----------
 src/cc65/codeinfo.h |  3 +++
 src/cc65/coptind.c  |  6 +++---
 src/cc65/coptmisc.c |  9 +++------
 4 files changed, 22 insertions(+), 20 deletions(-)

diff --git a/src/cc65/codeinfo.c b/src/cc65/codeinfo.c
index 427bfc52b2..435794613c 100644
--- a/src/cc65/codeinfo.c
+++ b/src/cc65/codeinfo.c
@@ -560,11 +560,8 @@ fncls_t GetFuncInfo (const char* Name, unsigned int* Use, unsigned int* Chg)
                 *Use = REG_NONE;
             }
 
-            /* Will destroy all registers */
-            *Chg = REG_ALL;
-
-            /* and will destroy all processor flags */
-            *Chg |= PSTATE_ALL;
+            /* Will destroy all registers and processor flags */
+            *Chg = (REG_ALL | PSTATE_ALL);
 
             /* Done */
             return FNCLS_GLOBAL;
@@ -577,8 +574,7 @@ fncls_t GetFuncInfo (const char* Name, unsigned int* Use, unsigned int* Chg)
         ** are used mostly in inline assembly anyway.
         */
         *Use = REG_ALL;
-        *Chg = REG_ALL;
-        *Chg |= PSTATE_ALL;
+        *Chg = (REG_ALL | PSTATE_ALL);
         return FNCLS_NUMERIC;
 
     } else {
@@ -605,8 +601,7 @@ fncls_t GetFuncInfo (const char* Name, unsigned int* Use, unsigned int* Chg)
                 fprintf (stderr, "No info about internal function '%s'\n", Name);
             }
             *Use = REG_ALL;
-            *Chg = REG_ALL;
-            *Chg |= PSTATE_ALL;
+            *Chg = (REG_ALL | PSTATE_ALL);
         }
         return FNCLS_BUILTIN;
     }
@@ -615,8 +610,7 @@ fncls_t GetFuncInfo (const char* Name, unsigned int* Use, unsigned int* Chg)
     ** registers and processor flags are changed
     */
     *Use = REG_EAXY;
-    *Chg = REG_ALL;
-    *Chg |= PSTATE_ALL;
+    *Chg = (REG_ALL | PSTATE_ALL);
 
     return FNCLS_UNKNOWN;
 }
@@ -899,6 +893,14 @@ int RegEAXUsed (struct CodeSeg* S, unsigned Index)
 
 
 
+int LoadFlagsUsed (struct CodeSeg* S, unsigned Index)
+/* Check if one of the flags set by a register load (Z and N) are used. */
+{
+    return (GetRegInfo (S, Index, PSTATE_ZN) & PSTATE_ZN) != 0;
+}
+
+
+
 unsigned GetKnownReg (unsigned Use, const RegContents* RC)
 /* Return the register or zero page location from the set in Use, thats
 ** contents are known. If Use does not contain any register, or if the
diff --git a/src/cc65/codeinfo.h b/src/cc65/codeinfo.h
index 14ef54d8f3..c57908dad4 100644
--- a/src/cc65/codeinfo.h
+++ b/src/cc65/codeinfo.h
@@ -201,6 +201,9 @@ int RegAXUsed (struct CodeSeg* S, unsigned Index);
 int RegEAXUsed (struct CodeSeg* S, unsigned Index);
 /* Check if any of the four bytes in EAX are used. */
 
+int LoadFlagsUsed (struct CodeSeg* S, unsigned Index);
+/* Check if one of the flags set by a register load (Z and N) are used. */
+
 unsigned GetKnownReg (unsigned Use, const struct RegContents* RC);
 /* Return the register or zero page location from the set in Use, thats
 ** contents are known. If Use does not contain any register, or if the
diff --git a/src/cc65/coptind.c b/src/cc65/coptind.c
index 49855a3452..52c47481e6 100644
--- a/src/cc65/coptind.c
+++ b/src/cc65/coptind.c
@@ -151,8 +151,8 @@ static short ZPRegVal (unsigned short Use, const RegContents* RC)
 
 
 unsigned OptUnusedLoads (CodeSeg* S)
-/* Remove loads of or operations with registers where the value loaded or 
-** produced is not used later. 
+/* Remove loads of or operations with registers where the value loaded or
+** produced is not used later.
 */
 {
     unsigned Changes = 0;
@@ -173,7 +173,7 @@ unsigned OptUnusedLoads (CodeSeg* S)
                    E->OPC == OP65_ORA;
 
         /* Check for the necessary preconditions */
-        if (IsOp && (N = CS_GetNextEntry (S, I)) != 0 && !CE_UseLoadFlags (N)) {
+        if (IsOp && (N = CS_GetNextEntry (S, I)) != 0 && !LoadFlagsUsed (S, I+1)) {
 
             /* Check which sort of load or transfer it is */
             unsigned R;
diff --git a/src/cc65/coptmisc.c b/src/cc65/coptmisc.c
index 332247cf05..e48d469a1c 100644
--- a/src/cc65/coptmisc.c
+++ b/src/cc65/coptmisc.c
@@ -788,8 +788,7 @@ unsigned OptBinOps (CodeSeg* S)
                         ** The instruction can be removed if the flags aren't
                         ** used later.
                         */
-                        CodeEntry* N = CS_GetNextEntry (S, I);
-                        if (N && !CE_UseLoadFlags (N)) {
+                        if (!LoadFlagsUsed (S, I+1)) {
                             Delete = 1;
                         }
                     } else if (Operand >= 0) {
@@ -822,8 +821,7 @@ unsigned OptBinOps (CodeSeg* S)
                         ** The instruction can be removed if the flags aren't
                         ** used later.
                         */
-                        CodeEntry* N = CS_GetNextEntry (S, I);
-                        if (N && !CE_UseLoadFlags (N)) {
+                        if (!LoadFlagsUsed (S, I+1)) {
                             Delete = 1;
                         }
                     } else if (Operand >= 0) {
@@ -861,8 +859,7 @@ unsigned OptBinOps (CodeSeg* S)
                         ** The instruction can be removed if the flags aren't
                         ** used later.
                         */
-                        CodeEntry* N = CS_GetNextEntry (S, I);
-                        if (N && !CE_UseLoadFlags (N)) {
+                        if (!LoadFlagsUsed (S, I+1)) {
                             Delete = 1;
                         }
                     } else if (Operand == 0xFF) {

From 231ab4169bd54696d3742214eb73a6527f9b7ff1 Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Sat, 7 Sep 2024 17:20:27 +0200
Subject: [PATCH 46/50] Added a test.

---
 test/val/and-eor-ora-optimizations.c | 86 ++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)
 create mode 100644 test/val/and-eor-ora-optimizations.c

diff --git a/test/val/and-eor-ora-optimizations.c b/test/val/and-eor-ora-optimizations.c
new file mode 100644
index 0000000000..6b5aba68c5
--- /dev/null
+++ b/test/val/and-eor-ora-optimizations.c
@@ -0,0 +1,86 @@
+/* Test some new optimization passes */
+
+#include <stdio.h>
+
+static unsigned failures = 0;
+
+int func0()
+{
+    unsigned a = 0x1234, b = 0x55AA;
+    return (a & 0x00FF) & (b & 0xFF00);
+}
+
+int func1()
+{
+    unsigned a = 0x1234, b = 0x55AA;
+    return (0x00FF & a) & (0xFF00 & b);
+}
+
+int func2()
+{
+    unsigned a = 0x1234, b = 0x55AA;
+    return (a | 0x00FF) & (b | 0xFF00);
+}
+
+int func3()
+{
+    unsigned a = 0x1234, b = 0x55AA;
+    return (0x00FF | a) & (0xFF00 | b);
+}
+
+int func4()
+{
+    unsigned a = 0x1234, b = 0x55AA;
+    return (a | 0x00FF) | (b | 0xFF00);
+}
+
+int func5()
+{
+    unsigned a = 0x1234, b = 0x55AA;
+    return (0x00FF | a) | (0xFF00 | b);
+}
+
+int func6()
+{
+    unsigned a = 0x1234, b = 0x55AA;
+    return (a ^ 0x00FF) & (b & 0xFF00);
+}
+
+int func7()
+{
+    unsigned a = 0x1234, b = 0x55AA;
+    return (0x00FF ^ a) & (0xFF00 & b);
+}
+
+int func8()
+{
+    unsigned a = 0x1234, b = 0x55AA;
+    return (a | 0x00FF) | (b ^ 0xFF00);
+}
+
+int func9()
+{
+    unsigned a = 0x1234, b = 0x55AA;
+    return (0x00FF | a) | (0xFF00 ^ b);
+}
+
+void onetest(unsigned count, int (*f1)(void), int (*f2)(void), int result)
+{
+    int r1 = f1();
+    int r2 = f2();
+    if (r1 != result || r2 != result) {
+        printf("Test %u failed! Expected 0x%04X but got 0x%04X/0x%04X\n",
+               count, result, r1, r2);
+        ++failures;
+    }
+}
+
+int main()
+{
+    onetest(1, func0, func1, 0x0000);
+    onetest(2, func2, func3, 0x12AA);
+    onetest(3, func4, func5, 0xFFFF);
+    onetest(4, func6, func7, 0x1000);
+    onetest(5, func8, func9, 0xBAFF);
+    return failures;
+}

From 175ec65af1324ac5f3737c336e7b7b049b777a27 Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Sat, 14 Sep 2024 21:12:19 +0200
Subject: [PATCH 47/50] Fix #2520.

---
 src/cc65/ppexpr.c  | 2 +-
 test/val/bug2520.c | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)
 create mode 100644 test/val/bug2520.c

diff --git a/src/cc65/ppexpr.c b/src/cc65/ppexpr.c
index 8d8c0b65d7..dc6803f915 100644
--- a/src/cc65/ppexpr.c
+++ b/src/cc65/ppexpr.c
@@ -726,7 +726,7 @@ static void PPhieQuest (PPExpr* Expr)
         PPhieQuest (&Expr3);
 
         /* Set the result */
-        Expr->IVal = Expr->IVal ? Expr2.IVal != 0 : Expr3.IVal != 0;
+        Expr->IVal = Expr->IVal ? Expr2.IVal : Expr3.IVal;
 
         /* Restore evaluation as before */
         PPEvaluationEnabled = PPEvaluationEnabledPrev;
diff --git a/test/val/bug2520.c b/test/val/bug2520.c
new file mode 100644
index 0000000000..7a216df4d6
--- /dev/null
+++ b/test/val/bug2520.c
@@ -0,0 +1,4 @@
+#if (1 ? 2 : 0) != 2
+#error
+#endif
+int main() { return 0; }

From 7dc09fdb05051de5273abb83679924b7b265a680 Mon Sep 17 00:00:00 2001
From: mrdudz <mrdudz@users.noreply.github.com>
Date: Sun, 15 Sep 2024 19:22:16 +0200
Subject: [PATCH 48/50] add test related to bug#2515 / pr#2518

---
 test/misc/Makefile        | 8 ++++++++
 test/misc/bug2515.c       | 4 ++++
 test/misc/bug2515.c99.ref | 2 ++
 test/misc/bug2515.ref     | 1 +
 4 files changed, 15 insertions(+)
 create mode 100644 test/misc/bug2515.c
 create mode 100644 test/misc/bug2515.c99.ref
 create mode 100644 test/misc/bug2515.ref

diff --git a/test/misc/Makefile b/test/misc/Makefile
index cfcae0530d..ebae0964ef 100644
--- a/test/misc/Makefile
+++ b/test/misc/Makefile
@@ -102,6 +102,14 @@ $(WORKDIR)/bug1265.$1.$2.prg: bug1265.c | $(WORKDIR)
 	$(LD65) -t sim$2 -o $$@ $$(@:.prg=.o) sim$2.lib $(NULLERR)
 	$(SIM65) $(SIM65FLAGS) $$@ $(NULLOUT) $(NULLERR)
 
+# should not compile, but gives different diagnostics in C99 mode than in others
+$(WORKDIR)/bug2515.$1.$2.prg: bug2515.c | $(WORKDIR)
+	$(if $(QUIET),echo misc/bug2515.$1.$2.prg)
+	$(NOT) $(CC65) --standard c99 -t sim$2 -$1 -o $$(@:.prg=.s) $$< 2>$(WORKDIR)/bug2515.$1.$2.out
+	$(ISEQUAL) $(WORKDIR)/bug2515.$1.$2.out bug2515.c99.ref
+	$(NOT) $(CC65) -t sim$2 -$1 -o $$(@:.prg=.s) $$< 2>$(WORKDIR)/bug2515.$1.$2.out
+	$(ISEQUAL) $(WORKDIR)/bug2515.$1.$2.out bug2515.ref
+
 # this one requires -Werror
 $(WORKDIR)/bug1768.$1.$2.prg: bug1768.c | $(WORKDIR)
 	$(if $(QUIET),echo misc/bug1768.$1.$2.prg)
diff --git a/test/misc/bug2515.c b/test/misc/bug2515.c
new file mode 100644
index 0000000000..62ee52a251
--- /dev/null
+++ b/test/misc/bug2515.c
@@ -0,0 +1,4 @@
+
+#line 13"x"
+#define X"y"
+int main() { foo; }
diff --git a/test/misc/bug2515.c99.ref b/test/misc/bug2515.c99.ref
new file mode 100644
index 0000000000..f6cf2fcea7
--- /dev/null
+++ b/test/misc/bug2515.c99.ref
@@ -0,0 +1,2 @@
+x:13: Warning: ISO C99 requires whitespace after the macro name
+x:14: Error: Undeclared identifier 'foo'
diff --git a/test/misc/bug2515.ref b/test/misc/bug2515.ref
new file mode 100644
index 0000000000..affbaebb9d
--- /dev/null
+++ b/test/misc/bug2515.ref
@@ -0,0 +1 @@
+x:14: Error: Undeclared identifier 'foo'

From 9c69aac09769810efe1ab92d748e2d93abcfaf19 Mon Sep 17 00:00:00 2001
From: Kugel Fuhr <98353208+kugelfuhr@users.noreply.github.com>
Date: Tue, 17 Sep 2024 11:45:46 +0200
Subject: [PATCH 49/50] Fix some issues with signedness in preprocessor
 expressions. Do also disallow comma expressions since the aren't compliant
 and collide with macro invocations.

---
 src/cc65/ppexpr.c  | 31 +++++++------------------------
 test/err/bug2523.c |  3 +++
 test/val/bug2523.c | 29 +++++++++++++++++++++++++++++
 3 files changed, 39 insertions(+), 24 deletions(-)
 create mode 100644 test/err/bug2523.c
 create mode 100644 test/val/bug2523.c

diff --git a/src/cc65/ppexpr.c b/src/cc65/ppexpr.c
index 8d8c0b65d7..bedb015074 100644
--- a/src/cc65/ppexpr.c
+++ b/src/cc65/ppexpr.c
@@ -55,7 +55,6 @@ static int PPEvaluationFailed  = 0;
 
 
 
-static void PPhie0 (PPExpr* Expr);
 static void PPhie1 (PPExpr* Expr);
 
 
@@ -138,7 +137,7 @@ static void PPhiePrimary (PPExpr* Expr)
             ** recursively.
             */
             NextToken ();
-            PPhie0 (Expr);
+            PPhie1 (Expr);
             ConsumeRParen ();
             break;
 
@@ -263,6 +262,7 @@ void PPhie10 (PPExpr* Expr)
             NextToken ();
             PPhie10 (Expr);
             Expr->IVal = !Expr->IVal;
+            Expr->Flags &= ~PPEXPR_UNSIGNED;    /* Result is signed */
             break;
 
         case TOK_CEOF:
@@ -424,10 +424,10 @@ static void PPhie_compare (const token_t* Ops,    /* List of generators */
                 }
             }
         }
-    }
 
-    /* The result is signed */
-    Expr->Flags &= ~PPEXPR_UNSIGNED;
+        /* The result is signed */
+        Expr->Flags &= ~PPEXPR_UNSIGNED;
+    }
 }
 
 
@@ -711,7 +711,7 @@ static void PPhieQuest (PPExpr* Expr)
 
         /* Parse second expression */
         PPExprInit (&Expr2);
-        PPhie0 (&Expr2);
+        PPhie1 (&Expr2);
 
         /* Skip the colon */
         ConsumeColon ();
@@ -809,23 +809,6 @@ static void PPhie1 (PPExpr* Expr)
 
 
 
-static void PPhie0 (PPExpr* Expr)
-/* Handle the comma "," operator */
-{
-    PPhie1 (Expr);
-
-    while (CurTok.Tok == TOK_COMMA) {
-        /* Skip the comma */
-        NextToken ();
-        /* Reset the expression */
-        PPExprInit (Expr);
-        /* Use the next operand as the value instead */
-        PPhie1 (Expr);
-    }
-}
-
-
-
 void ParsePPExprInLine (PPExpr* Expr)
 /* Parse a line for PP expression */
 {
@@ -836,7 +819,7 @@ void ParsePPExprInLine (PPExpr* Expr)
 
     /* Parse */
     PPExprInit (Expr);
-    PPhie0 (Expr);
+    PPhie1 (Expr);
 
     /* If the evaluation fails, the result is always zero */
     if (PPEvaluationFailed) {
diff --git a/test/err/bug2523.c b/test/err/bug2523.c
new file mode 100644
index 0000000000..7ab7985572
--- /dev/null
+++ b/test/err/bug2523.c
@@ -0,0 +1,3 @@
+#if (1, 0) < 0
+#error
+#endif
diff --git a/test/val/bug2523.c b/test/val/bug2523.c
new file mode 100644
index 0000000000..8db72d055f
--- /dev/null
+++ b/test/val/bug2523.c
@@ -0,0 +1,29 @@
+#if (0u - 1) < 0
+#error
+#endif
+
+#if !1u - 1 > 0
+#error
+#endif
+
+#if (1 & 1u) - 2 < 0
+#error
+#endif
+
+#if (1 | 1u) - 2 < 0
+#error
+#endif
+
+#if (1 ^ 1u) - 2 < 0
+#error
+#endif
+
+#if (1u >> 1) - 2 < 0
+#error
+#endif
+
+#if (0u << 1) - 1 < 0
+#error
+#endif
+
+int main() { return 0; }

From 41951a1345c301986b473ed113ad20f6497e6bcd Mon Sep 17 00:00:00 2001
From: Sven Oliver Moll <svolli@svolli.de>
Date: Thu, 26 Sep 2024 19:33:26 +0200
Subject: [PATCH 50/50] updated customizing documentation

"weak = yes" is now "type = weak"
---
 doc/customizing.sgml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/customizing.sgml b/doc/customizing.sgml
index e18bcf86c9..58631eb3c6 100644
--- a/doc/customizing.sgml
+++ b/doc/customizing.sgml
@@ -140,7 +140,7 @@ FEATURES {
 
 SYMBOLS {
     # Define the stack size for the application
-    __STACKSIZE__:  value = $0200, weak = yes;
+    __STACKSIZE__:  value = $0200, type = weak;
 }
 </code></tscreen>