/mou/
/ser/
/targetutil/
+/testwrk/
/tgi/
/wrk/
language:
- c
install:
- - sudo apt-get install linuxdoc-tools linuxdoc-tools-info binutils-mingw-w64-i686 gcc-mingw-w64-i686
+ - sudo apt-get install linuxdoc-tools linuxdoc-tools-info binutils-mingw-w64-i686 gcc-mingw-w64-i686 sshpass
script:
- make bin USER_CFLAGS=-Werror
- make lib QUIET=1
- make bin USER_CFLAGS=-Werror CROSS_COMPILE=i686-w64-mingw32-
- make doc zip
after_success:
- - make -f Makefile.gh-pages
+ - make -f Makefile.travis
env:
global:
- secure: "h+hoQdEHGPLNwaqGKmSaM8NBRDLc2X+W05VsnNG2Feq/wPv/AiBjONNlzN7jRf6D6f3aoPXaQ2Lc3bYWdxGvFRCmwiofdxkJI9n5L8HPHLZ2lf37MQsXmGJzoTFOvjPLj73H6HlbI9Ux0El3zO6hvalxiXj6TfoZ41dbhNyvpYk="
+ - secure: "A4hMEe5RRfUtYjFGbT7QAvT1Tyo434N+/TiuQeQ4q0L46c79LnXuGQzbFLOFZshZiplLkJr7lFg466CoI1bf2L0cQOew/LesMhE75v0HQ7tZnExWhdpAk0ri6nWixbjn/dmQ0+HxjzJ48A44DMMBYcvSIsO4vflvuJ8etfSg42k="
+++ /dev/null
-.PHONY: all
-
-.SUFFIXES:
-
-GH_PAGES = ../gh-pages
-
-all:
- echo $(TRAVIS_COMMIT) | zip -z cc65
-ifdef GH_TOKEN
- git clone --branch=gh-pages https://$(GH_TOKEN)@github.com/cc65/cc65.git $(GH_PAGES)
- cd $(GH_PAGES) && git config user.name "Oliver Schmidt"
- cd $(GH_PAGES) && git config user.email "ol.sc@web.de"
- cd $(GH_PAGES) && git config push.default simple
- cd $(GH_PAGES) && $(RM) -r doc download
- cd $(GH_PAGES) && mkdir doc download
- cp html/*.* $(GH_PAGES)/doc
- cp cc65.zip $(GH_PAGES)/download/cc65-snapshot-win32.zip
- cd $(GH_PAGES) && git add -A doc download
- cd $(GH_PAGES) && git commit -m "Updated from commit $(TRAVIS_COMMIT)."
- cd $(GH_PAGES) && git push
-endif
--- /dev/null
+.PHONY: all gh-pages sf-files
+
+.SUFFIXES:
+
+all: gh-pages sf-files
+
+GH_NAME = Oliver Schmidt
+GH_MAIL = ol.sc@web.de
+GH_PATH = ../doc
+
+gh-pages:
+ifdef GH_TOKEN
+ @echo 'git clone --branch=gh-pages https://$$(GH_TOKEN)@github.com/cc65/doc.git $(GH_PATH)'
+ @git clone --branch=gh-pages https://$(GH_TOKEN)@github.com/cc65/doc.git $(GH_PATH)
+ cd $(GH_PATH) && git config user.name "$(GH_NAME)"
+ cd $(GH_PATH) && git config user.email "$(GH_MAIL)"
+ cd $(GH_PATH) && git config push.default simple
+ $(RM) $(GH_PATH)/*.*
+ cp html/*.* $(GH_PATH)
+ cd $(GH_PATH) && git add -A
+ -cd $(GH_PATH) && git commit -m "Updated from commit $(TRAVIS_COMMIT)."
+ cd $(GH_PATH) && git push -q
+endif
+
+SF_USER = oliverschmidt
+SF_HOST = frs.sourceforge.net
+SF_FILE = /home/frs/project/cc65/cc65-snapshot-win64.zip
+
+SCPFLAGS = -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -q
+
+sf-files:
+ifdef SF_PASS
+ echo $(TRAVIS_COMMIT) | zip -z cc65
+ @echo 'sshpass -p $$(SF_PASS) scp $(SCPFLAGS) cc65.zip $(SF_USER)@$(SF_HOST):$(SF_FILE)'
+ @sshpass -p $(SF_PASS) scp $(SCPFLAGS) cc65.zip $(SF_USER)@$(SF_HOST):$(SF_FILE)
+endif
-[documentation](http://cc65.github.io/cc65/doc)
+[documentation](http://cc65.github.io/doc)
-[wiki](https://github.com/cc65/wiki/wiki)
+[wiki](http://github.com/cc65/wiki/wiki)
-[](https://travis-ci.org/cc65/cc65/builds)
+[](http://travis-ci.org/cc65/cc65/builds)
cc65 is a complete cross development package for 65(C)02 systems, including
a powerful macro assembler, a C compiler, linker, librarian and several
<article>
<title>da65 Users Guide
-<author><url url="mailto:uz@cc65.org" name="Ullrich von Bassewitz">
-<date>2003-08-08
+<author>
+<url url="mailto:uz@cc65.org" name="Ullrich von Bassewitz">,<newline>
+<url url="mailto:greg.king5@verizon.net" name="Greg King">
+<date>2014-11-23
<abstract>
-da65 is a 6502/65C02 disassembler that is able to read user supplied
-information about its input data for better results. The output is ready for
+da65 is a 6502/65C02 disassembler that is able to read user-supplied
+information about its input data, for better results. The output is ready for
feeding into ca65, the macro assembler supplied with the cc65 C compiler.
</abstract>
macro assembler.
Besides generating output for ca65, one of the design goals was that the user
-is able to feed additional information about the code into the disassembler
+is able to feed additional information about the code into the disassembler,
for improved results. This information may include the location and size of
tables, and their format.
<tag><tt>--cpu type</tt></tag>
Set the CPU type. The option takes a parameter, which may be one of
+ <itemize>
+ <item>6502
+ <item>6502x
+ <item>65sc02
+ <item>65c02
+ <item>huc6280
+ </itemize>
- 6502, 6502x, 65sc02, 65c02, huc6280
-
- 6502x is the NMOS 6502 with illegal opcodes. huc6280 is the CPU of the PC
- engine. Support for the 65816 is currently not available.
+ 6502x is for the NMOS 6502 with unofficial opcodes. huc6280 is the CPU of
+ the PC engine. Support for the 65816 currently is not available.
<label id="option--formfeeds">
<tag><tt>-g, --debug-info</tt></tag>
This option adds the <tt/.DEBUGINFO/ command to the output file, so the
- assembler will generate debug information when reassembling the generated
+ assembler will generate debug information when re-assembling the generated
output.
The disassembler works by creating an attribute map for the whole address
space ($0000 - $FFFF). Initially, all attributes are cleared. Then, an
external info file (if given) is read. Disassembly is done in several passes.
-In all passes with the exception of the last one, information about the
+In all passes, with the exception of the last one, information about the
disassembled code is gathered and added to the symbol and attribute maps. The
last pass generates output using the information from the maps.
depends on the type of the attribute. String attributes are places in double
quotes, numeric attributes may be specified as decimal numbers or hexadecimal
with a leading dollar sign. There are also attributes where the attribute
-value is a keyword, in this case the keyword is given as is (without quotes or
+value is a keyword; in this case, the keyword is given as-is (without quotes or
anything). Each attribute is terminated by a semicolon.
<tscreen><verb>
- group-name { attribute1 attribute-value; attribute2 attribute-value; }
+ group-name { attribute1 attribute-value; attribute2 attribute-value; }
</verb></tscreen>
<sect1>Comments<p>
-Comments start with a hash mark (<tt/#/) and extend from the position of
+Comments start with a hash mark (<tt/#/); and, extend from the position of
the mark to the end of the current line. Hash marks inside of strings will
-of course <em/not/ start a comment.
+<em/not/ start a comment, of course.
<sect1>Specifying global options<label id="global-options"><p>
<tag><tt>END</tt></tag>
Followed by a numerical value. Specifies the end address of the segment. The
- end address is last the address that is part of the segment.
+ end address is the last address that is a part of the segment.
<tag><tt>NAME</tt></tag>
The attribute is followed by a string value which gives the name of the
segment.
</descrip>
-All attributes are mandatory. Segments may not overlap. Since there is no
-explicit "end this segment" pseudo op, the disassembler cannot notify the
-assembler that one segment has ended. This may lead to errors if you don't
-define your segments carefully. As a rule of thumb, if you're using segments,
-your should define segments for all disassembled code.
+All attributes are mandatory. Segments must not overlap. The disassembler will
+change back to the (default) <tt/.code/ segment after the end of each defined
+segment. That might not be what you want. As a rule of thumb, if you're using
+segments, you should define segments for all disassembled code.
<sect1>Specifying Assembler Includes<label id="infofile-asminc"><p>
symbol assignments in assembler syntax:
<tscreen><verb>
- Name = value
- Name := value
+ Name = value
+ Name := value
</verb></tscreen>
The usual conventions apply for symbol names. Values may be specified as hex
};
# One segment for the whole stuff
- SEGMENT { START $E000; END $FFFF; NAME kernal; };
+ SEGMENT { START $E000; END $FFFF; NAME "kernal"; };
- RANGE { START $E612; END $E631; TYPE Code; };
- RANGE { START $E632; END $E640; TYPE ByteTable; };
- RANGE { START $EA51; END $EA84; TYPE RtsTable; };
- RANGE { START $EC6C; END $ECAB; TYPE RtsTable; };
- RANGE { START $ED08; END $ED11; TYPE AddrTable; };
+ RANGE { START $E612; END $E631; TYPE Code; };
+ RANGE { START $E632; END $E640; TYPE ByteTable; };
+ RANGE { START $EA51; END $EA84; TYPE RtsTable; };
+ RANGE { START $EC6C; END $ECAB; TYPE RtsTable; };
+ RANGE { START $ED08; END $ED11; TYPE AddrTable; };
- # Zero page variables
- LABEL { NAME "fnadr"; ADDR $90; SIZE 3; };
- LABEL { NAME "sal"; ADDR $93; };
- LABEL { NAME "sah"; ADDR $94; };
- LABEL { NAME "sas"; ADDR $95; };
+ # Zero-page variables
+ LABEL { NAME "fnadr"; ADDR $90; SIZE 3; };
+ LABEL { NAME "sal"; ADDR $93; };
+ LABEL { NAME "sah"; ADDR $94; };
+ LABEL { NAME "sas"; ADDR $95; };
# Stack
- LABEL { NAME "stack"; ADDR $100; SIZE 255; };
+ LABEL { NAME "stack"; ADDR $100; SIZE 255; };
# Indirect vectors
- LABEL { NAME "cinv"; ADDR $300; SIZE 2; }; # IRQ
- LABEL { NAME "cbinv"; ADDR $302; SIZE 2; }; # BRK
- LABEL { NAME "nminv"; ADDR $304; SIZE 2; }; # NMI
+ LABEL { NAME "cinv"; ADDR $300; SIZE 2; }; # IRQ
+ LABEL { NAME "cbinv"; ADDR $302; SIZE 2; }; # BRK
+ LABEL { NAME "nminv"; ADDR $304; SIZE 2; }; # NMI
# Jump table at end of kernal ROM
- LABEL { NAME "kscrorg"; ADDR $FFED; };
- LABEL { NAME "kplot"; ADDR $FFF0; };
- LABEL { NAME "kiobase"; ADDR $FFF3; };
- LABEL { NAME "kgbye"; ADDR $FFF6; };
+ LABEL { NAME "kscrorg"; ADDR $FFED; };
+ LABEL { NAME "kplot"; ADDR $FFF0; };
+ LABEL { NAME "kiobase"; ADDR $FFF3; };
+ LABEL { NAME "kgbye"; ADDR $FFF6; };
# Hardware vectors
- LABEL { NAME "hanmi"; ADDR $FFFA; };
- LABEL { NAME "hares"; ADDR $FFFC; };
- LABEL { NAME "hairq"; ADDR $FFFE; };
+ LABEL { NAME "hanmi"; ADDR $FFFA; };
+ LABEL { NAME "hares"; ADDR $FFFC; };
+ LABEL { NAME "hairq"; ADDR $FFFE; };
</verb></tscreen>
-
-
<sect>Copyright<p>
-da65 (and all cc65 binutils) are (C) Copyright 1998-2007 Ullrich von
-Bassewitz. For usage of the binaries and/or sources the following
+da65 (and all cc65 binutils) is (C) Copyright 1998-2011, Ullrich von
+Bassewitz. For usage of the binaries and/or sources, the following
conditions do apply:
This software is provided 'as-is', without any expressed or implied
freely, subject to the following restrictions:
<enum>
-<item> The origin of this software must not be misrepresented; you must not
- claim that you wrote the original software. If you use this software
- in a product, an acknowledgment in the product documentation would be
- appreciated but is not required.
-<item> Altered source versions must be plainly marked as such, and must not
- be misrepresented as being the original software.
-<item> This notice may not be removed or altered from any source
- distribution.
+<item> The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+<item> Altered source versions must be plainly marked as such, and must not
+ be misrepresented as being the original software.
+<item> This notice may not be removed or altered from any source
+ distribution.
</enum>
</article>
-
-
-
-
<article>
<title>cc65 Documentation Overview
-<author><url url="https://github.com/cc65/cc65/">
+<author><url url="http://cc65.github.io/doc">
<date>
<sect>Program documentation<p>
--- /dev/null
+;
+; Peter Ferrie, 21.11.2014
+;
+; off_t __fastcall__ lseek(int fd, off_t offset, int whence);
+;
+
+ .export _lseek
+ .import popax
+
+ .include "zeropage.inc"
+ .include "errno.inc"
+ .include "mli.inc"
+ .include "filedes.inc"
+
+_lseek:
+ ; Save whence
+ sta tmp1
+ stx tmp2
+
+ ; Get and save offset
+ jsr popax
+ sta ptr1
+ stx ptr1+1
+ jsr popax
+ sta ptr2
+
+ ; Get and process fd
+ jsr popax
+ jsr getfd ; Returns A, Y and C
+ bcs errno
+
+ ; Check for device
+ cmp #$80
+ bcs einval
+
+ ; Valid whence values are 0..2
+ ldx tmp2
+ bne einval
+ ldx tmp1
+ cpx #3
+ bcs einval
+
+ ; Set fd
+ sta mliparam + MLI::MARK::REF_NUM
+
+ txa
+ beq cur
+ lda #GET_EOF_CALL
+ dex
+ beq end
+
+; SEEK_SET
+ dex
+ txa
+ tay
+ beq seek_common
+
+; SEEK_CUR
+cur:
+ lda #GET_MARK_CALL
+
+; SEEK_END
+end:
+ ; MARK_COUNT must == EOF_COUNT, otherwise unexpected behaviour
+ .assert MARK_COUNT = EOF_COUNT, error
+ ldx #MARK_COUNT
+ jsr callmli
+ bcs oserr
+ lda mliparam + MLI::MARK::POSITION
+ ldx mliparam + MLI::MARK::POSITION+1
+ ldy mliparam + MLI::MARK::POSITION+2
+
+seek_common:
+ adc ptr1
+ sta mliparam + MLI::MARK::POSITION
+ txa
+ adc ptr1+1
+ sta mliparam + MLI::MARK::POSITION+1
+ tya
+ adc ptr2
+ sta mliparam + MLI::MARK::POSITION+2
+
+ ; Set file pointer
+ lda #SET_MARK_CALL
+ ldx #MARK_COUNT
+ jsr callmli
+ bcs oserr
+
+ rts
+
+ ; Load errno code
+einval: lda #EINVAL
+
+ ; Set __errno
+errno: jmp __directerrno
+
+ ; Set __oserror
+oserr: jmp __mappederrno
/* Instruction table for the 6502 with illegal instructions */
static const struct {
unsigned Count;
- InsDesc Ins[70];
+ InsDesc Ins[75];
} InsTab6502X = {
sizeof (InsTab6502X.Ins) / sizeof (InsTab6502X.Ins[0]),
{
{ "ALR", 0x0800000, 0x4B, 0, PutAll }, /* X */
{ "ANC", 0x0800000, 0x0B, 0, PutAll }, /* X */
{ "AND", 0x080A26C, 0x20, 0, PutAll },
+ { "ANE", 0x0800000, 0x8B, 0, PutAll }, /* X */
{ "ARR", 0x0800000, 0x6B, 0, PutAll }, /* X */
{ "ASL", 0x000006e, 0x02, 1, PutAll },
{ "AXS", 0x0800000, 0xCB, 0, PutAll }, /* X */
{ "JMP", 0x0000808, 0x4c, 6, PutJMP },
{ "JSR", 0x0000008, 0x20, 7, PutAll },
{ "LAS", 0x0000200, 0xBB, 0, PutAll }, /* X */
- { "LAX", 0x000A30C, 0xA3, 1, PutAll }, /* X */
+ { "LAX", 0x080A30C, 0xA3, 11, PutAll }, /* X */
{ "LDA", 0x080A26C, 0xa0, 0, PutAll },
{ "LDX", 0x080030C, 0xa2, 1, PutAll },
{ "LDY", 0x080006C, 0xa0, 1, PutAll },
{ "LSR", 0x000006F, 0x42, 1, PutAll },
- { "NOP", 0x0000001, 0xea, 0, PutAll },
+ { "NOP", 0x080006D, 0x00, 10, PutAll }, /* X */
{ "ORA", 0x080A26C, 0x00, 0, PutAll },
{ "PHA", 0x0000001, 0x48, 0, PutAll },
{ "PHP", 0x0000001, 0x08, 0, PutAll },
{ "SEC", 0x0000001, 0x38, 0, PutAll },
{ "SED", 0x0000001, 0xf8, 0, PutAll },
{ "SEI", 0x0000001, 0x78, 0, PutAll },
+ { "SHA", 0x0002200, 0x93, 1, PutAll }, /* X */
+ { "SHX", 0x0000200, 0x9e, 1, PutAll }, /* X */
+ { "SHY", 0x0000040, 0x9c, 1, PutAll }, /* X */
{ "SLO", 0x000A26C, 0x03, 0, PutAll }, /* X */
{ "SRE", 0x000A26C, 0x43, 0, PutAll }, /* X */
{ "STA", 0x000A26C, 0x80, 0, PutAll },
{ "STX", 0x000010c, 0x82, 1, PutAll },
{ "STY", 0x000002c, 0x80, 1, PutAll },
+ { "TAS", 0x0000200, 0x9b, 0, PutAll }, /* X */
{ "TAX", 0x0000001, 0xaa, 0, PutAll },
{ "TAY", 0x0000001, 0xa8, 0, PutAll },
{ "TSX", 0x0000001, 0xba, 0, PutAll },
const InsTable* InsTab = (const InsTable*) &InsTab6502;
/* Table to build the effective 65xx opcode from a base opcode and an
-** addressing mode.
+** addressing mode. (The value in the table is ORed with the base opcode)
*/
-static unsigned char EATab[10][AM65I_COUNT] = {
+static unsigned char EATab[12][AM65I_COUNT] = {
{ /* Table 0 */
0x00, 0x00, 0x05, 0x0D, 0x0F, 0x15, 0x1D, 0x1F,
0x00, 0x19, 0x12, 0x00, 0x07, 0x11, 0x17, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00
},
+ { /* Table 10 (NOPs) */
+ 0xea, 0x00, 0x04, 0x0c, 0x00, 0x14, 0x1c, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+ 0x00, 0x00, 0x00
+ },
+ { /* Table 11 (LAX) */
+ 0x08, 0x08, 0x04, 0x0C, 0x00, 0x14, 0x1C, 0x00,
+ 0x14, 0x1C, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
+ 0x00, 0x00, 0x80
+ },
};
/* Table to build the effective SWEET16 opcode from a base opcode and an
-void g_regint (unsigned Flags)
-/* Make sure, the value in the primary register an int. Convert if necessary */
+static void g_regchar (unsigned Flags)
+/* Make sure, the value in the primary register is in the range of char. Truncate if necessary */
{
unsigned L;
+ AddCodeLine ("ldx #$00");
+
+ if ((Flags & CF_UNSIGNED) == 0) {
+ /* Sign extend */
+ L = GetLocalLabel();
+ AddCodeLine ("cmp #$80");
+ AddCodeLine ("bcc %s", LocalLabelName (L));
+ AddCodeLine ("dex");
+ g_defcodelabel (L);
+ }
+}
+
+
+
+void g_regint (unsigned Flags)
+/* Make sure, the value in the primary register an int. Convert if necessary */
+{
switch (Flags & CF_TYPEMASK) {
case CF_CHAR:
if (Flags & CF_FORCECHAR) {
/* Conversion is from char */
- if (Flags & CF_UNSIGNED) {
- AddCodeLine ("ldx #$00");
- } else {
- L = GetLocalLabel();
- AddCodeLine ("ldx #$00");
- AddCodeLine ("cmp #$80");
- AddCodeLine ("bcc %s", LocalLabelName (L));
- AddCodeLine ("dex");
- g_defcodelabel (L);
- }
+ g_regchar (Flags);
}
/* FALLTHROUGH */
void g_reglong (unsigned Flags)
/* Make sure, the value in the primary register a long. Convert if necessary */
{
- unsigned L;
-
switch (Flags & CF_TYPEMASK) {
case CF_CHAR:
}
} else {
if (IS_Get (&CodeSizeFactor) >= 366) {
- L = GetLocalLabel();
- AddCodeLine ("ldx #$00");
- AddCodeLine ("cmp #$80");
- AddCodeLine ("bcc %s", LocalLabelName (L));
- AddCodeLine ("dex");
- g_defcodelabel (L);
+ g_regchar (Flags);
AddCodeLine ("stx sreg");
AddCodeLine ("stx sreg+1");
} else {
** by the lhs value. Return the result value.
*/
{
- unsigned ltype, rtype;
-
- /* Get the type spec from the flags */
- ltype = lhs & CF_TYPEMASK;
- rtype = rhs & CF_TYPEMASK;
-
/* Check if a conversion is needed */
if ((rhs & CF_CONST) == 0) {
- if (ltype == CF_LONG && rtype != CF_LONG) {
- /* We must promote the primary register to long */
- g_reglong (rhs);
- } else if (ltype == CF_INT && rtype != CF_INT) {
- /* We must promote the primary register to int */
- g_regint (rhs);
+ switch (lhs & CF_TYPEMASK) {
+
+ case CF_LONG:
+ /* We must promote the primary register to long */
+ g_reglong (rhs);
+ break;
+
+ case CF_INT:
+ /* We must promote the primary register to int */
+ g_regint (rhs);
+ break;
+
+ case CF_CHAR:
+ /* We must truncate the primary register to char */
+ g_regchar (lhs);
+ break;
+
+ default:
+ typeerror (lhs);
}
}
InsertEntry (D, X, D->IP++);
/* Lhs load entries can be removed */
- D->Lhs.X.Flags |= LI_REMOVE;
- D->Lhs.A.Flags |= LI_REMOVE;
+ if (LoadX->AM != AM65_IMM) {
+ D->Lhs.X.Flags |= LI_REMOVE;
+ }
+ if (LoadA->AM != AM65_IMM) {
+ D->Lhs.A.Flags |= LI_REMOVE;
+ }
} else if ((D->Rhs.A.Flags & (LI_DIRECT | LI_RELOAD_Y)) == LI_DIRECT &&
(D->Rhs.X.Flags & (LI_DIRECT | LI_RELOAD_Y)) == LI_DIRECT) {
InsertEntry (D, X, D->IP++);
/* Rhs load entries can be removed */
- D->Rhs.X.Flags |= LI_REMOVE;
- D->Rhs.A.Flags |= LI_REMOVE;
+ if (LoadX->AM != AM65_IMM) {
+ D->Rhs.X.Flags |= LI_REMOVE;
+ }
+ if (LoadA->AM != AM65_IMM) {
+ D->Rhs.A.Flags |= LI_REMOVE;
+ }
} else if ((D->Rhs.A.Flags & LI_DIRECT) != 0 &&
(D->Rhs.X.Flags & LI_DIRECT) != 0) {
TagTab = S;
/* Create and assign a new label table */
- LabelTab = NewSymTable (SYMTAB_SIZE_LABEL);
+ S = NewSymTable (SYMTAB_SIZE_LABEL);
+ S->PrevTab = LabelTab;
+ LabelTab = S;
}
/* Don't delete the tables */
SymTab = SymTab->PrevTab;
TagTab = TagTab->PrevTab;
+ LabelTab = LabelTab->PrevTab;
}
/* */
/* */
/* */
-/* (C) 2000-2006 Ullrich von Bassewitz */
-/* Römerstrasse 52 */
-/* D-70794 Filderstadt */
-/* EMail: uz@cc65.org */
+/* (C) 2000-2014, Ullrich von Bassewitz */
+/* Roemerstrasse 52 */
+/* D-70794 Filderstadt */
+/* EMail: uz@cc65.org */
/* */
/* */
/* This software is provided 'as-is', without any expressed or implied */
+attr_t GetAttr (unsigned Addr)
+/* Return the attribute for the given address */
+{
+ /* Check the given address */
+ AddrCheck (Addr);
+
+ /* Return the attribute */
+ return AttrTab[Addr];
+}
+
+
+
int SegmentDefined (unsigned Start, unsigned End)
/* Return true if the atSegment bit is set somewhere in the given range */
{
-int HaveSegmentChange (unsigned Addr)
-/* Return true if the segment change attribute is set for the given address */
+int IsSegmentEnd (unsigned Addr)
+/* Return true if a segment ends at the given address */
{
- /* Check the given address */
- AddrCheck (Addr);
+ return (GetAttr (Addr) & atSegmentEnd) != 0x0000;
+}
- /* Return the attribute */
- return (AttrTab[Addr] & atSegmentChange) != 0;
+
+
+int IsSegmentStart (unsigned Addr)
+/* Return true if a segment starts at the given address */
+{
+ return (GetAttr (Addr) & atSegmentStart) != 0x0000;
}
-attr_t GetAttr (unsigned Addr)
-/* Return the attribute for the given address */
-{
- /* Check the given address */
- AddrCheck (Addr);
-
- /* Return the attribute */
- return AttrTab[Addr];
-}
-
-
-
attr_t GetStyleAttr (unsigned Addr)
/* Return the style attribute for the given address */
{
/* */
/* */
/* */
-/* (C) 2000-2006 Ullrich von Bassewitz */
-/* Römerstrasse 52 */
-/* D-70794 Filderstadt */
-/* EMail: uz@cc65.org */
+/* (C) 2000-2014, Ullrich von Bassewitz */
+/* Roemerstrasse 52 */
+/* D-70794 Filderstadt */
+/* EMail: uz@cc65.org */
/* */
/* */
/* This software is provided 'as-is', without any expressed or implied */
typedef enum attr_t {
/* Styles */
- atDefault = 0x0000, /* Default style */
- atCode = 0x0001,
- atIllegal = 0x0002,
- atByteTab = 0x0003, /* Same as illegal */
- atDByteTab = 0x0004,
- atWordTab = 0x0005,
- atDWordTab = 0x0006,
- atAddrTab = 0x0007,
- atRtsTab = 0x0008,
- atTextTab = 0x0009,
- atSkip = 0x000A, /* Skip code completely */
+ atDefault = 0x0000, /* Default style */
+ atCode = 0x0001,
+ atIllegal = 0x0002,
+ atByteTab = 0x0003, /* Same as illegal */
+ atDByteTab = 0x0004,
+ atWordTab = 0x0005,
+ atDWordTab = 0x0006,
+ atAddrTab = 0x0007,
+ atRtsTab = 0x0008,
+ atTextTab = 0x0009,
+ atSkip = 0x000A, /* Skip code completely */
/* Label flags */
- atNoLabel = 0x0000, /* No label for this address */
- atExtLabel = 0x0010, /* External label */
- atIntLabel = 0x0020, /* Internally generated label */
- atDepLabel = 0x0040, /* Dependent label */
- atUnnamedLabel = 0x0080, /* Unnamed label */
+ atNoLabel = 0x0000, /* No label for this address */
+ atExtLabel = 0x0010, /* External label */
+ atIntLabel = 0x0020, /* Internally generated label */
+ atDepLabel = 0x0040, /* Dependent label */
+ atUnnamedLabel = 0x0080, /* Unnamed label */
- atLabelDefined = 0x0100, /* True if we defined the label */
+ atLabelDefined = 0x0100, /* True if we defined the label */
- atStyleMask = 0x000F, /* Output style */
- atLabelMask = 0x00F0, /* Label information */
+ atStyleMask = 0x000F, /* Output style */
+ atLabelMask = 0x00F0, /* Label information */
/* Segment */
- atSegment = 0x0100, /* Code is in a segment */
- atSegmentChange = 0x0200, /* Either segment start or segment end */
+ atSegment = 0x0100, /* Code is in a segment */
+ atSegmentEnd = 0x0200, /* Segment end */
+ atSegmentStart = 0x0400, /* Segment start */
} attr_t;
void AddrCheck (unsigned Addr);
/* Check if the given address has a valid range */
+attr_t GetAttr (unsigned Addr);
+/* Return the attribute for the given address */
+
int SegmentDefined (unsigned Start, unsigned End);
/* Return true if the atSegment bit is set somewhere in the given range */
-int HaveSegmentChange (unsigned Addr);
-/* Return true if the segment change attribute is set for the given address */
+int IsSegmentEnd (unsigned Addr);
+/* Return true if a segment ends at the given address */
+
+int IsSegmentStart (unsigned Addr);
+/* Return true if a segment starts at the given address */
unsigned GetGranularity (attr_t Style);
/* Get the granularity for the given style */
void MarkAddr (unsigned Addr, attr_t Attr);
/* Mark an address with an attribute */
-attr_t GetAttr (unsigned Addr);
-/* Return the attribute for the given address */
-
attr_t GetStyleAttr (unsigned Addr);
/* Return the style attribute for the given address */
/* End of attrtab.h */
-
#endif
/* */
/* */
/* */
-/* (C) 2000-2007 Ullrich von Bassewitz */
-/* Roemerstrasse 52 */
-/* D-70794 Filderstadt */
-/* EMail: uz@cc65.org */
+/* (C) 2000-2014, Ullrich von Bassewitz */
+/* Roemerstrasse 52 */
+/* D-70794 Filderstadt */
+/* EMail: uz@cc65.org */
/* */
/* */
/* This software is provided 'as-is', without any expressed or implied */
attr_t Attr;
if (MustDefLabel(PC+Count)) {
break;
- }
+ }
Attr = GetAttr (PC+Count);
if ((Attr & atStyleMask) != Style) {
break;
}
- if ((Attr & atSegmentChange)) {
+ if ((Attr & (atSegmentStart | atSegmentEnd))) {
break;
}
++Count;
/* */
/* */
/* */
-/* (C) 2000-2011, Ullrich von Bassewitz */
+/* (C) 2000-2014, Ullrich von Bassewitz */
/* Roemerstrasse 52 */
/* D-70794 Filderstadt */
/* EMail: uz@cc65.org */
if (Start < 0) {
InfoError ("Start address is missing");
}
- if (Start == End) {
- InfoError ("Segment is empty");
- }
if (Start > End) {
InfoError ("Start address of segment is greater than end address");
}
/* Check that segments do not overlap */
if (SegmentDefined ((unsigned) Start, (unsigned) End)) {
- InfoError ("Segments cannot overlap");
+ InfoError ("Segments must not overlap");
}
/* Remember the segment data */
/* */
/* */
/* */
-/* (C) 1998-2011, Ullrich von Bassewitz */
+/* (C) 1998-2014, Ullrich von Bassewitz */
/* Roemerstrasse 52 */
/* D-70794 Filderstadt */
/* EMail: uz@cc65.org */
#include "opctable.h"
#include "output.h"
#include "scanner.h"
+#include "segment.h"
static void OneOpcode (unsigned RemainingBytes)
/* Disassemble one opcode */
{
+ unsigned I;
+
/* Get the opcode from the current address */
unsigned char OPC = GetCodeByte (PC);
/* Get the output style for the current PC */
attr_t Style = GetStyleAttr (PC);
+ /* If a segment begins here, then name that segment.
+ ** Note that the segment is named even if its code is being skipped,
+ ** because some of its later code might not be skipped.
+ */
+ if (IsSegmentStart (PC)) {
+ StartSegment (GetSegmentStartName (PC), GetSegmentAddrSize (PC));
+ }
+
/* If we have a label at this address, output the label and an attached
** comment, provided that we aren't in a skip area.
*/
** - ...if we have enough bytes remaining for the code at this address.
** - ...if the current instruction is valid for the given CPU.
** - ...if there is no label somewhere between the instruction bytes.
- ** If any of these conditions is false, switch to data mode.
+ ** - ...if there is no segment change between the instruction bytes.
+ ** If any one of those conditions is false, switch to data mode.
*/
if (Style == atDefault) {
if (D->Size > RemainingBytes) {
Style = atIllegal;
MarkAddr (PC, Style);
} else {
- unsigned I;
- for (I = 1; I < D->Size; ++I) {
- if (HaveLabel (PC+I) || HaveSegmentChange (PC+I)) {
+ for (I = PC + D->Size; --I > PC; ) {
+ if (HaveLabel (I) || IsSegmentStart (I)) {
+ Style = atIllegal;
+ MarkAddr (PC, Style);
+ break;
+ }
+ }
+ for (I = 0; I < D->Size - 1u; ++I) {
+ if (IsSegmentEnd (PC + I)) {
Style = atIllegal;
MarkAddr (PC, Style);
break;
*/
if (D->Size <= RemainingBytes) {
/* Output labels within the next insn */
- unsigned I;
for (I = 1; I < D->Size; ++I) {
ForwardLabel (I);
}
DataByteLine (1);
++PC;
break;
+ }
+ /* Change back to the default CODE segment if
+ ** a named segment stops at the current address.
+ */
+ for (I = D->Size; I >= 1; --I) {
+ if (IsSegmentEnd (PC - I)) {
+ EndSegment ();
+ break;
+ }
}
}
const OpcDesc OpcTable_6502X[256] = {
{ "brk", 1, flNone, OH_Implicit }, /* $00 */
{ "ora", 2, flUseLabel, OH_DirectXIndirect }, /* $01 */
- { "kil", 1, flNone, OH_Implicit }, /* $02 */
+ { "jam", 1, flNone, OH_Implicit }, /* $02 */
{ "slo", 2, flUseLabel, OH_DirectXIndirect }, /* $03 */
{ "nop", 2, flUseLabel, OH_Direct }, /* $04 */
{ "ora", 2, flUseLabel, OH_Direct }, /* $05 */
{ "slo", 3, flUseLabel|flAbsOverride, OH_Absolute }, /* $0f */
{ "bpl", 2, flLabel, OH_Relative }, /* $10 */
{ "ora", 2, flUseLabel, OH_DirectIndirectY }, /* $11 */
- { "kil", 1, flNone, OH_Implicit }, /* $12 */
+ { "jam", 1, flNone, OH_Implicit }, /* $12 */
{ "slo", 2, flUseLabel, OH_DirectIndirectY }, /* $13 */
{ "nop", 2, flUseLabel, OH_DirectX }, /* $14 */
{ "ora", 2, flUseLabel, OH_DirectX }, /* $15 */
{ "slo", 3, flUseLabel|flAbsOverride, OH_AbsoluteX }, /* $1f */
{ "jsr", 3, flLabel, OH_Absolute }, /* $20 */
{ "and", 2, flUseLabel, OH_DirectXIndirect }, /* $21 */
- { "kil", 1, flNone, OH_Implicit, }, /* $22 */
+ { "jam", 1, flNone, OH_Implicit, }, /* $22 */
{ "rla", 2, flUseLabel, OH_DirectXIndirect }, /* $23 */
{ "bit", 2, flUseLabel, OH_Direct }, /* $24 */
{ "and", 2, flUseLabel, OH_Direct }, /* $25 */
{ "rla", 3, flUseLabel|flAbsOverride, OH_Absolute }, /* $2f */
{ "bmi", 2, flLabel, OH_Relative }, /* $30 */
{ "and", 2, flUseLabel, OH_DirectIndirectY }, /* $31 */
- { "kil", 1, flNone, OH_Implicit }, /* $32 */
+ { "jam", 1, flNone, OH_Implicit }, /* $32 */
{ "rla", 2, flUseLabel, OH_DirectIndirectY }, /* $33 */
{ "nop", 2, flUseLabel, OH_DirectX }, /* $34 */
{ "and", 2, flUseLabel, OH_DirectX }, /* $35 */
{ "rla", 3, flUseLabel|flAbsOverride, OH_AbsoluteX }, /* $3f */
{ "rti", 1, flNone, OH_Rts }, /* $40 */
{ "eor", 2, flUseLabel, OH_DirectXIndirect }, /* $41 */
- { "kil", 1, flNone, OH_Implicit }, /* $42 */
+ { "jam", 1, flNone, OH_Implicit }, /* $42 */
{ "sre", 2, flUseLabel, OH_DirectXIndirect }, /* $43 */
{ "nop", 2, flUseLabel, OH_Direct }, /* $44 */
{ "eor", 2, flUseLabel, OH_Direct }, /* $45 */
{ "sre", 3, flUseLabel|flAbsOverride, OH_Absolute }, /* $4f */
{ "bvc", 2, flLabel, OH_Relative }, /* $50 */
{ "eor", 2, flUseLabel, OH_DirectIndirectY }, /* $51 */
- { "kil", 1, flNone, OH_Implicit }, /* $52 */
+ { "jam", 1, flNone, OH_Implicit }, /* $52 */
{ "sre", 2, flUseLabel, OH_DirectIndirectY }, /* $53 */
{ "nop", 2, flUseLabel, OH_DirectX }, /* $54 */
{ "eor", 2, flUseLabel, OH_DirectX }, /* $55 */
{ "sre", 3, flUseLabel|flAbsOverride, OH_AbsoluteX }, /* $5f */
{ "rts", 1, flNone, OH_Rts }, /* $60 */
{ "adc", 2, flUseLabel, OH_DirectXIndirect }, /* $61 */
- { "kil", 1, flNone, OH_Implicit }, /* $62 */
+ { "jam", 1, flNone, OH_Implicit }, /* $62 */
{ "rra", 2, flUseLabel, OH_DirectXIndirect }, /* $63 */
{ "nop", 2, flUseLabel, OH_Direct }, /* $64 */
{ "adc", 2, flUseLabel, OH_Direct }, /* $65 */
{ "rra", 3, flUseLabel|flAbsOverride, OH_Absolute }, /* $6f */
{ "bvs", 2, flLabel, OH_Relative }, /* $70 */
{ "adc", 2, flUseLabel, OH_DirectIndirectY }, /* $71 */
- { "kil", 1, flNone, OH_Implicit }, /* $72 */
+ { "jam", 1, flNone, OH_Implicit }, /* $72 */
{ "rra", 2, flUseLabel, OH_DirectIndirectY }, /* $73 */
{ "nop", 2, flUseLabel, OH_DirectX }, /* $74 */
{ "adc", 2, flUseLabel, OH_DirectX }, /* $75 */
{ "sax", 3, flUseLabel|flAbsOverride, OH_Absolute }, /* $8f */
{ "bcc", 2, flLabel, OH_Relative }, /* $90 */
{ "sta", 2, flUseLabel, OH_DirectIndirectY }, /* $91 */
- { "kil", 1, flNone, OH_Implicit }, /* $92 */
+ { "jam", 1, flNone, OH_Implicit }, /* $92 */
{ "ahx", 2, flUseLabel, OH_DirectIndirectY }, /* $93 */
{ "sty", 2, flUseLabel, OH_DirectX }, /* $94 */
{ "sta", 2, flUseLabel, OH_DirectX }, /* $95 */
{ "lax", 3, flUseLabel|flAbsOverride, OH_Absolute }, /* $af */
{ "bcs", 2, flLabel, OH_Relative }, /* $b0 */
{ "lda", 2, flUseLabel, OH_DirectIndirectY }, /* $b1 */
- { "kil", 1, flNone, OH_Implicit }, /* $b2 */
+ { "jam", 1, flNone, OH_Implicit }, /* $b2 */
{ "lax", 2, flUseLabel, OH_DirectIndirectY }, /* $b3 */
{ "ldy", 2, flUseLabel, OH_DirectX }, /* $b4 */
{ "lda", 2, flUseLabel, OH_DirectX }, /* $b5 */
{ "dcp", 3, flUseLabel|flAbsOverride, OH_Absolute }, /* $cf */
{ "bne", 2, flLabel, OH_Relative }, /* $d0 */
{ "cmp", 2, flUseLabel, OH_DirectIndirectY }, /* $d1 */
- { "kil", 1, flNone, OH_Implicit }, /* $d2 */
+ { "jam", 1, flNone, OH_Implicit }, /* $d2 */
{ "dcp", 2, flUseLabel, OH_DirectIndirectY }, /* $d3 */
{ "nop", 2, flUseLabel, OH_DirectX }, /* $d4 */
{ "cmp", 2, flUseLabel, OH_DirectX }, /* $d5 */
{ "isc", 3, flUseLabel|flAbsOverride, OH_Absolute }, /* $ef */
{ "beq", 2, flLabel, OH_Relative }, /* $f0 */
{ "sbc", 2, flUseLabel, OH_DirectIndirectY }, /* $f1 */
- { "kil", 1, flNone, OH_Implicit }, /* $f2 */
+ { "jam", 1, flNone, OH_Implicit }, /* $f2 */
{ "isc", 2, flUseLabel, OH_DirectIndirectY }, /* $f3 */
{ "nop", 2, flUseLabel, OH_DirectX }, /* $f4 */
{ "sbc", 2, flUseLabel, OH_DirectX }, /* $f5 */
/* */
/* */
/* */
-/* (C) 2000-2009, Ullrich von Bassewitz */
+/* (C) 2000-2014, Ullrich von Bassewitz */
/* Roemerstrasse 52 */
/* D-70794 Filderstadt */
/* EMail: uz@cc65.org */
static unsigned Line = 0; /* Current line on page */
static unsigned Page = 1; /* Current output page */
+static const char* SegmentName = 0; /* Name of current segment */
+
/*****************************************************************************/
-void StartSegment (const char* Name, unsigned AddrSize)
-/* Start a segment */
-{
- if (Pass == PassCount) {
- Output (".segment");
- Indent (ACol);
- if (AddrSize == ADDR_SIZE_DEFAULT) {
- Output ("\"%s\"", Name);
- } else {
- Output ("\"%s\": %s", Name, AddrSizeToStr (AddrSize));
- }
- LineFeed ();
- }
-}
-
-
-
void DataByteLine (unsigned ByteCount)
/* Output a line with bytes */
{
+void StartSegment (const char* Name, unsigned AddrSize)
+/* Start a segment */
+{
+ if (Pass == PassCount) {
+ LineFeed ();
+ Output (".segment");
+ Indent (ACol);
+ SegmentName = Name;
+ Output ("\"%s\"", Name);
+ if (AddrSize != ADDR_SIZE_DEFAULT) {
+ Output (": %s", AddrSizeToStr (AddrSize));
+ }
+ LineFeed ();
+ LineFeed ();
+ }
+}
+
+
+
+void EndSegment (void)
+/* End a segment */
+{
+ LineFeed ();
+ Output ("; End of \"%s\" segment", SegmentName);
+ LineFeed ();
+ SeparatorLine ();
+ Output (".code");
+ LineFeed ();
+ LineFeed ();
+}
+
+
+
void UserComment (const char* Comment)
/* Output a comment line */
{
/* */
/* */
/* */
-/* (C) 2000-2007 Ullrich von Bassewitz */
-/* Roemerstrasse 52 */
-/* D-70794 Filderstadt */
-/* EMail: uz@cc65.org */
+/* (C) 2000-2014, Ullrich von Bassewitz */
+/* Roemerstrasse 52 */
+/* D-70794 Filderstadt */
+/* EMail: uz@cc65.org */
/* */
/* */
/* This software is provided 'as-is', without any expressed or implied */
void DefConst (const char* Name, const char* Comment, unsigned Addr);
/* Define an address constant */
-
-void StartSegment (const char* Name, unsigned AddrSize);
-/* Start a segment */
-
-void EndSegment (void);
-/* End a segment */
void OneDataByte (void);
/* Output a .byte line with the current code byte */
void SeparatorLine (void);
/* Print a separator line */
+void StartSegment (const char* Name, unsigned AddrSize);
+/* Start a segment */
+
+void EndSegment (void);
+/* End a segment */
+
void UserComment (const char* Comment);
/* Output a comment line */
/* End of output.h */
-
#endif
/* */
/* */
/* */
-/* (C) 2007 Ullrich von Bassewitz */
-/* Roemerstrasse 52 */
-/* D-70794 Filderstadt */
-/* EMail: uz@cc65.org */
+/* (C) 2007-2014, Ullrich von Bassewitz */
+/* Roemerstrasse 52 */
+/* D-70794 Filderstadt */
+/* EMail: uz@cc65.org */
/* */
/* */
/* This software is provided 'as-is', without any expressed or implied */
typedef struct Segment Segment;
struct Segment {
Segment* NextStart; /* Pointer to next segment */
- Segment* NextEnd; /* Pointer to next segment */
unsigned long Start;
- unsigned long End;
unsigned AddrSize;
char Name[1]; /* Name, dynamically allocated */
};
-/* Tables containing the segments. A segment is inserted using it's hash
-** value. Collision is done by single linked lists.
+/* Table containing the segments. A segment is inserted using its hash
+** value. Collisions are handled by single-linked lists.
*/
static Segment* StartTab[HASH_SIZE]; /* Table containing segment starts */
-static Segment* EndTab[HASH_SIZE]; /* Table containing segment ends */
/* Fill in the data */
S->Start = Start;
- S->End = End;
S->AddrSize = ADDR_SIZE_ABS;
memcpy (S->Name, Name, Len + 1);
- /* Insert the segment into the hash tables */
+ /* Insert the segment into the hash table */
S->NextStart = StartTab[Start % HASH_SIZE];
StartTab[Start % HASH_SIZE] = S;
- S->NextEnd = EndTab[End % HASH_SIZE];
- EndTab[End % HASH_SIZE] = S;
/* Mark start and end of the segment */
- MarkAddr (Start, atSegmentChange);
- MarkAddr (End, atSegmentChange);
+ MarkAddr (Start, atSegmentStart);
+ MarkAddr (End, atSegmentEnd);
/* Mark the addresses within the segment */
MarkRange (Start, End, atSegment);
}
+
+
+
+char* GetSegmentStartName (unsigned Addr)
+/* Return the name of the segment which starts at the given address */
+{
+ Segment* S = StartTab[Addr % HASH_SIZE];
+
+ /* Search the collision list for the exact address */
+ while (S != 0) {
+ if (S->Start == Addr) {
+ return S->Name;
+ }
+ S = S->NextStart;
+ }
+
+ return 0;
+}
+
+
+
+unsigned GetSegmentAddrSize (unsigned Addr)
+/* Return the address size of the segment which starts at the given address */
+{
+ Segment* S = StartTab[Addr % HASH_SIZE];
+
+ /* Search the collision list for the exact address */
+ while (S != 0) {
+ if (S->Start == Addr) {
+ return S->AddrSize;
+ }
+ S = S->NextStart;
+ }
+
+ return 0;
+}
/* */
/* */
/* */
-/* (C) 2007 Ullrich von Bassewitz */
-/* Roemerstrasse 52 */
-/* D-70794 Filderstadt */
-/* EMail: uz@cc65.org */
+/* (C) 2007-2014, Ullrich von Bassewitz */
+/* Roemerstrasse 52 */
+/* D-70794 Filderstadt */
+/* EMail: uz@cc65.org */
/* */
/* */
/* This software is provided 'as-is', without any expressed or implied */
void AddAbsSegment (unsigned Start, unsigned End, const char* Name);
/* Add an absolute segment to the segment table */
+char* GetSegmentStartName (unsigned Addr);
+/* Return the name of the segment which starts at the given address */
+
+unsigned GetSegmentAddrSize (unsigned Addr);
+/* Return the address size of the segment which starts at the given address */
-/* End of segment.h */
+/* End of segment.h */
#endif
/* Name of program file */
const char* ProgramFile;
-
+/* exit simulator after MaxCycles Cycles */
+unsigned long MaxCycles = 0;
/*****************************************************************************/
/* Code */
" -h\t\t\tHelp (this text)\n"
" -v\t\t\tIncrease verbosity\n"
" -V\t\t\tPrint the simulator version number\n"
+ " -x <num>\t\tExit simulator after <num> cycles\n"
"\n"
"Long options:\n"
" --help\t\tHelp (this text)\n"
fprintf (stderr, "sim65 V%s\n", GetVersionAsString ());
}
-
+static void OptQuitXIns (const char* Opt attribute ((unused)),
+ const char* Arg attribute ((unused)))
+/* quit after MaxCycles cycles */
+{
+ MaxCycles = strtoul(Arg, NULL, 0);
+}
static void ReadProgramFile (void)
/* Load program into memory */
OptVersion (Arg, 0);
break;
+ case 'x':
+ OptQuitXIns (Arg, GetArg (&I, 2));
+ break;
+
default:
UnknownOption (Arg);
break;
while (1) {
ExecuteInsn ();
+ if (MaxCycles && (GetCycles () >= MaxCycles)) {
+ Error ("Maximum number of cycles reached.");
+ exit (-99); /* do not ues EXIT_FAILURE to avoid conflicts with the
+ same value being used in a test program */
+ }
}
/* Return an apropriate exit code */
--- /dev/null
+
+# top-level makefile for the regression tests
+
+# You can comment this special target when you debug the regression tests.
+# Then, make will give you more progress reports.
+.SILENT:
+
+ifneq ($(shell echo),)
+ CMD_EXE := 1
+endif
+
+ifdef CMD_EXE
+ RM := del /f
+ EXE := .exe
+ MKDIR := mkdir
+ RMDIR := rmdir
+else
+ RM := rm -f
+ EXE :=
+ MKDIR := mkdir -p
+ RMDIR := rmdir
+endif
+
+WORKDIR := ../testwrk
+
+.PHONY: all dotests continue mostly-clean clean
+
+all: dotests
+
+$(WORKDIR):
+ $(MKDIR) $(WORKDIR)
+
+$(WORKDIR)/bdiff$(EXE): bdiff.c | $(WORKDIR)
+ $(CC) -O2 -o $@ $<
+
+.NOTPARALLEL:
+
+dotests: mostly-clean continue
+
+continue: $(WORKDIR)/bdiff$(EXE)
+ @$(MAKE) -C val all
+ @$(MAKE) -C ref all
+ @$(MAKE) -C err all
+ @$(MAKE) -C misc all
+
+mostly-clean:
+ @$(MAKE) -C val clean
+ @$(MAKE) -C ref clean
+ @$(MAKE) -C err clean
+ @$(MAKE) -C misc clean
+
+clean: mostly-clean
+ $(RM) $(WORKDIR)/bdiff$(EXE)
+ $(RMDIR) $(WORKDIR)
--- /dev/null
+
+// minimal tool to compare two binaries
+
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+ FILE *f1, *f2;
+ if (argc < 3) {
+ return EXIT_FAILURE;
+ }
+ f1 = fopen(argv[1], "rb");
+ f2 = fopen(argv[2], "rb");
+ if ((f1 == NULL) || (f2 == NULL)) {
+ return EXIT_FAILURE;
+ }
+ for(;;) {
+ if (feof(f1) && feof(f2)) {
+ return EXIT_SUCCESS;
+ } else if (feof(f1) || feof(f2)) {
+ return EXIT_FAILURE;
+ }
+ if (fgetc(f1) != fgetc(f2)) {
+ return EXIT_FAILURE;
+ }
+ }
+}
--- /dev/null
+
+# makefile for the tests that MUST NOT compile
+
+ifneq ($(shell echo),)
+ CMD_EXE := 1
+endif
+
+CC65FLAGS := -t sim6502
+
+CL65 := $(if $(wildcard ../../bin/cl65*),../../bin/cl65,cl65)
+
+ifdef CMD_EXE
+RM := del /f
+else
+RM := rm -f
+endif
+
+WORKDIR := ../../testwrk
+
+.PHONY: all clean
+
+SOURCES := $(wildcard *.c)
+TESTS := $(foreach option,. .o. .os. .osi. .osir. .oi. .oir. .or.,$(SOURCES:%.c=$(WORKDIR)/%$(option)prg))
+
+all: $(TESTS)
+
+$(WORKDIR)/%.prg: %.c
+ ! $(CL65) $(CC65FLAGS) $< -o $@
+$(WORKDIR)/%.o.prg: %.c
+ ! $(CL65) -O $(CC65FLAGS) $< -o $@
+$(WORKDIR)/%.os.prg: %.c
+ ! $(CL65) -Os $(CC65FLAGS) $< -o $@
+$(WORKDIR)/%.osi.prg: %.c
+ ! $(CL65) -Osi $(CC65FLAGS) $< -o $@
+$(WORKDIR)/%.osir.prg: %.c
+ ! $(CL65) -Osir $(CC65FLAGS) $< -o $@
+$(WORKDIR)/%.oi.prg: %.c
+ ! $(CL65) -Oi $(CC65FLAGS) $< -o $@
+$(WORKDIR)/%.oir.prg: %.c
+ ! $(CL65) -Oir $(CC65FLAGS) $< -o $@
+$(WORKDIR)/%.or.prg: %.c
+ ! $(CL65) -Or $(CC65FLAGS) $< -o $@
+
+clean:
+ @$(RM) $(TESTS)
+ @$(RM) $(SOURCES:.c=.o)
--- /dev/null
+/*
+ !!DESCRIPTION!! invalid binary operation on pointer, should not compile
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!!
+*/
+
+/* > Gets stuck in an endless loop with -O. */
+
+#include <assert.h>
+#include <string.h>
+typedef unsigned char U8;
+char var = 0xf0;
+char fn(char bar)
+{
+ char* ptr = (char*)0xf;
+ var |= ptr; /* should throw an error here */
+ while (var > bar)
+ var <<= 1;
+ return 0;
+}
+int main() {
+ fn(0x7f);
+ assert(0);
+
+ printf("it works :)\n");
+
+ return 0;
+}
\ No newline at end of file
--- /dev/null
+/*
+ !!DESCRIPTION!! this code is not supposed to compile
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+main() {
+ return 0;
+}
+
+nested(a,b) {
+ if ((a<4 && b == 'r')
+ || (a == 1 && (b == 'h' || b == 'i'))
+ || (a == 2 && (b == 'o' || b == 'y'))
+ ) a=b;
+}
+
+/* type name scope */
+
+void s(struct D *d) {} /* this struct D differs from the one below */
+typedef struct D D;
+struct D {int x, y;} Dy={0};
+D Dz={1};
+Dfunc(){
+ D a; a.y=1;
+ s(&Dy); /* error */
+}
+
+/* qualifiers */
+
+const a; int b;
+const int a, *x; int b, *y;
+volatile unsigned z;
+
+f() {
+ x = y;
+ z = z + z; /* should be 2 references to z's r-value */
+}
+f1() {
+ x = &a;
+ x = &b;
+ y = &a; /* error */
+ y = &b;
+}
+f2(int **a, int **b) {
+ f(&x, &y);
+ **a = 0;
+ return **b;
+}
+g(const int *p) {
+ g(&a);
+ g(&b);
+ return *p;
+}
+h(int *p) {
+ f(&a);
+ f(&b);
+ return *p;
+}
+h1(const int x, int y) {
+ h1(a,b);
+ h1(b,a);
+ return x + y;
+}
+h2() {
+ char *b; const void *p;
+ p = b;
+ b = p; /* error (incompatible pointer type) */
+}
+
+/* static naming */
+
+extern int yy; set1() { { static yy=1; yy=2;} yy=4;}
+static int yy; set2() { yy=5; {static yy=2; yy=3; }}
+static void goo() {}
+sss() { int goo; { static int goo();} goo=1;}
+
+/*
+rrr(p) float *p; { extern int xr;
+ { static float xr;
+ { extern int *xr; } p=&xr; }}
+*/
+
+/* local extern */
+
+static int ss1;
+int ss3;
+extern int ss5;
+setstatic() { extern int ss1,ss2,ss3,ss4; ss1 = ss2; ss3 = ss4; ss5 = 0;}
+static int ss2;
+int ss4;
+static int ss5;
+
+/* function prototypes */
+
+int fx1(void);
+int fx1();
+
+/*
+int gx1(double x);
+*/
+/* int gx1(x) double x; { gx1(&x); } */ /* error */
+
+int hx1();
+/*
+int hx1(double x,...); */ /* error */
+
+/*
+int ff1(double x, int *y);
+int ff1(x,y) float x; int y[]; {x=y[0];}
+*/
+
+int gg1(int a);
+int gg1(a,b){a=b;}
+
+int hh1(const int x);
+hh1(a) {return a;}
+
+extern int strcmp(const char*, const char*);
+extern void qsort(void*, int, int, int (*)(const void*, const void*));
+extern int cmp(char**a, char**b) { return strcmp(*a,*b); }
+sort() {
+ int n; char *a[100];
+ qsort(a, n, sizeof(char*), (int (*)(const void*, const void*))cmp);
+ qsort(a, n, sizeof(char*), cmp); /* error (incompatible pointer type) */
+}
+
+/* nasty calls */
+
+onearg(){
+ int a,b,c,d;
+ f( ( (a? (b = 1): (c = 2)), (d ? 3 : 4) ) ); /* 1 argument */
+}
--- /dev/null
+
+# makefile for the remaining tests that need special care in one way or another
+
+ifneq ($(shell echo),)
+ CMD_EXE := 1
+endif
+
+CC65FLAGS := -t sim6502
+SIM65FLAGS := -x 200000000
+
+CL65 := $(if $(wildcard ../../bin/cl65*),../../bin/cl65,cl65)
+SIM65 := $(if $(wildcard ../../bin/sim65*),../../bin/sim65,sim65)
+
+ifdef CMD_EXE
+RM := del /f
+else
+RM := rm -f
+endif
+
+WORKDIR := ../../testwrk
+
+DIFF := $(WORKDIR)/bdiff
+
+.PHONY: all clean
+
+SOURCES := $(wildcard *.c)
+TESTS := $(foreach option,. .o. .os. .osi. .osir. .oi. .oir. .or.,$(SOURCES:%.c=$(WORKDIR)/%$(option)prg))
+
+all: $(TESTS)
+
+# should compile, but then hangs in an endless loop
+$(WORKDIR)/endless%prg: endless.c
+ $(CL65) $(subst .,,$(*:.o%=-O%)) $(CC65FLAGS) $< -o $@
+ ! $(SIM65) $(SIM65FLAGS) $@
+
+# these need reference data that can't be generated by a host-compiled program,
+# in a useful way
+$(WORKDIR)/limits%prg: limits.c
+ $(CL65) $(subst .,,$(*:.o%=-O%)) $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/limits.out
+ $(DIFF) $(WORKDIR)/limits.out limits.ref
+
+# the rest are tests that fail currently for one reason or another
+$(WORKDIR)/fields%prg: fields.c
+ @echo "FIXME: " $@ "currently will fail."
+ $(CL65) $(subst .,,$(*:.o%=-O%)) $(CC65FLAGS) $< -o $@
+ -$(SIM65) $(SIM65FLAGS) $@
+$(WORKDIR)/sitest%prg: sitest.c
+ @echo "FIXME: " $@ "currently will fail."
+ -$(CL65) $(subst .,,$(*:.o%=-O%)) $(CC65FLAGS) $< -o $@
+# -$(SIM65) $(SIM65FLAGS) $@
+
+clean:
+ @$(RM) $(TESTS)
+ @$(RM) $(SOURCES:.c=.o)
+ @$(RM) $(SOURCES:%.c=$(WORKDIR)/%.out)
--- /dev/null
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define NO_OLD_FUNC_DECL
+#define NO_TYPELESS_INT
+#define NO_TYPELESS_INT_PTR
+#define MAIN_RETURNS_INT
+#define NO_IMPLICIT_FUNC_PROTOTYPES
+#define NO_FLOATS
+#define NO_WCHAR
+#define NO_EMPTY_FUNC_ARGS
+#define NO_SLOPPY_STRUCT_INIT
+#define NO_FUNCS_TAKE_STRUCTS
+#define NO_FUNCS_RETURN_STRUCTS
+#define CAST_STRUCT_PTR
+#define NO_TYPELESS_STRUCT_PTR
+#define NO_IMPLICIT_FUNCPTR_CONV
+#define SIZEOF_INT_16BIT
+#define SIZEOF_LONG_32BIT
+#define UNSIGNED_CHARS
+#define UNSIGNED_BITFIELDS
--- /dev/null
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+ printf("entering endless loop\n");
+ for(;;) {
+ ;
+ }
+ printf("error: should not come here\n");
+ return EXIT_FAILURE;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! bitfield test
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+#ifdef NO_BITFIELDS
+
+main()
+{
+ printf("NO_BITFIELDS\n\r");
+}
+
+#else
+
+#ifdef SIZEOF_INT_16BIT
+
+#ifdef REFCC
+#include <stdint.h>
+struct foo {
+ int16_t a;
+ char b;
+ int16_t x : 12, y : 4;
+ int16_t zz : 1, : 0, : 4, z : 3;
+ char c;
+} x = { 1, 2, 3, 4, 5, 6 };
+
+struct baz { uint16_t a:2, b:4, c:16;} y = { 7, 8, 9};
+int16_t i = 8;
+
+#else
+
+struct foo {
+ int a;
+ char b;
+ int x : 12, y : 4;
+ int zz : 1, : 0, : 4, z : 3;
+ char c;
+} x = { 1, 2, 3, 4, 5, 6 };
+
+struct baz { unsigned int a:2, b:4, c:16;} y = { 7, 8, 9};
+int i = 8;
+#endif
+
+#else
+struct foo {
+ int a;
+ char b;
+ int x : 12, y : 4, : 0, : 4, z : 3;
+ char c;
+} x = { 1, 2, 3, 4, 5, 6 };
+
+struct baz { unsigned int a:2, b:4, c:32;} y = { 7, 8, 9};
+int i = 16;
+#endif
+
+#ifdef NO_IMPLICIT_FUNC_PROTOTYPES
+f1(struct baz *p);
+f2(struct baz *p);
+#endif
+
+main()
+{
+ printf("x = %d b:%d %d %d %d c:%d\n", x.a, x.b, x.x, x.y, x.z, x.c);
+ printf("y = %d b:%d c:%d\n", y.a, y.b, y.c);
+ x.y = i;
+ x.z = 070;
+ printf("x = %d b:%d %d %d %d c:%d\n", x.a, x.b, x.x, x.y, x.z, x.c);
+ y.a = 2;
+ y.c = i;
+ printf("y = %d b:%d c:%d\n", y.a, y.b, y.c);
+#ifdef CAST_STRUCT_PTR
+ f2((struct baz *)&x);
+#else
+ f2(&x);
+#endif
+ return 0;
+}
+
+f1(struct baz *p) {
+ p->a = p->b = 0;
+ if (p->b)
+ printf("p->b != 0!\n");
+ p->a = 0x3; p->b = 0xf;
+ printf("p->a = 0x%x, p->b = 0x%x\n", p->a, p->b);
+}
+f2(struct baz *p) {
+ p->a = (i==0);
+ p->b = (f1(p),0);
+}
+
+#endif
--- /dev/null
+/*
+ !!DESCRIPTION!! display type limits
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+#define SSHRT_MAX SHRT_MAX
+#define SINT_MAX INT_MAX
+#define SLONG_MAX LONG_MAX
+
+#define UCHAR_MIN 0
+#define USHRT_MIN 0
+#define SSHRT_MIN SHRT_MIN
+#define UINT_MIN 0
+#define SINT_MIN INT_MIN
+#define ULONG_MIN 0l
+#define SLONG_MIN LONG_MIN
+
+int main(void) {
+ printf("CHAR_MAX: 0x%08x=%d\n", CHAR_MAX, CHAR_MAX);
+ printf("UCHAR_MAX: 0x%08x=%d\n", UCHAR_MAX, UCHAR_MAX);
+ printf("SCHAR_MAX: 0x%08x=%d\n", SCHAR_MAX, SCHAR_MAX);
+
+ printf("SHRT_MAX: 0x%08x=%d\n", SHRT_MAX, SHRT_MAX);
+ printf("USHRT_MAX: 0x%08x=%d\n", USHRT_MAX, USHRT_MAX);
+ printf("SSHRT_MAX: 0x%08x=%d\n", SSHRT_MAX, SSHRT_MAX);
+
+ printf("INT_MAX: 0x%08x=%d\n", INT_MAX, INT_MAX);
+ printf("UINT_MAX: 0x%08x=%d\n", UINT_MAX, UINT_MAX);
+ printf("SINT_MAX: 0x%08x=%d\n", SINT_MAX, SINT_MAX);
+
+ printf("LONG_MAX: 0x%08lx=%ld\n", LONG_MAX, LONG_MAX);
+ printf("ULONG_MAX: 0x%08lx=%ld\n", ULONG_MAX, ULONG_MAX);
+ printf("SLONG_MAX: 0x%08lx=%ld\n", SLONG_MAX, SLONG_MAX);
+
+ printf("CHAR_MIN: 0x%08x=%d\n", CHAR_MIN, CHAR_MIN);
+ printf("UCHAR_MIN: 0x%08x=%d\n", UCHAR_MIN, UCHAR_MIN);
+ printf("SCHAR_MIN: 0x%08x=%d\n", SCHAR_MIN, SCHAR_MIN);
+
+ printf("SHRT_MIN: 0x%08x=%d\n", SHRT_MIN, SHRT_MIN);
+ printf("USHRT_MIN: 0x%08x=%d\n", USHRT_MIN, USHRT_MIN);
+ printf("SSHRT_MIN: 0x%08x=%d\n", SSHRT_MIN, SSHRT_MIN);
+
+ printf("INT_MIN: 0x%08x=%d\n", INT_MIN, INT_MIN);
+ printf("UINT_MIN: 0x%08x=%d\n", UINT_MIN, UINT_MIN);
+ printf("SINT_MIN: 0x%08x=%d\n", SINT_MIN, SINT_MIN);
+
+ printf("LONG_MIN: 0x%08lx=%ld\n", LONG_MIN, LONG_MIN);
+ printf("ULONG_MIN: 0x%08lx=%ld\n", ULONG_MIN, ULONG_MIN);
+ printf("SLONG_MIN: 0x%08lx=%ld\n", SLONG_MIN, SLONG_MIN);
+
+ return 0;
+}
--- /dev/null
+CHAR_MAX: 0x000000ff=255
+UCHAR_MAX: 0x000000ff=255
+SCHAR_MAX: 0x0000007f=127
+SHRT_MAX: 0x00007fff=32767
+USHRT_MAX: 0x0000ffff=-1
+SSHRT_MAX: 0x00007fff=32767
+INT_MAX: 0x00007fff=32767
+UINT_MAX: 0x0000ffff=-1
+SINT_MAX: 0x00007fff=32767
+LONG_MAX: 0x7fffffff=2147483647
+ULONG_MAX: 0xffffffff=-1
+SLONG_MAX: 0x7fffffff=2147483647
+CHAR_MIN: 0x00000000=0
+UCHAR_MIN: 0x00000000=0
+SCHAR_MIN: 0x0000ff80=-128
+SHRT_MIN: 0x00008000=-32768
+USHRT_MIN: 0x00000000=0
+SSHRT_MIN: 0x00008000=-32768
+INT_MIN: 0x00008000=-32768
+UINT_MIN: 0x00000000=0
+SINT_MIN: 0x00008000=-32768
+LONG_MIN: 0x80000000=-2147483648
+ULONG_MIN: 0x00000000=0
+SLONG_MIN: 0x80000000=-2147483648
--- /dev/null
+/*
+ !!DESCRIPTION!! C99 WCHAR test
+ !!ORIGIN!!
+ !!LICENCE!! public domain
+*/
+
+/*
+ sitest -- exercise features of C99 <stdint.h> and <inttypes.h>
+
+ This source code has been placed into the PUBLIC DOMAIN by its author.
+
+ last edit: 1999/11/05 gwyn@arl.mil
+
+ Tries to accommodate pre-C99 versions of <inttypes.h>.
+
+ Takes advantage of __Q8_* symbols defined by a particular
+ implementation of <stdint.h>, but doesn't require them.
+
+ NOTE: This is not a thorough validation test of the facilities.
+*/
+
+#define NO_INTERNAL_WCHAR
+/*#define STANDALONE*/
+
+#include <errno.h>
+#include <limits.h> /* for CHAR_BIT */
+#include <stdio.h>
+#include <stddef.h> /* for ptrdiff_t */
+#include <stdlib.h>
+#include <string.h>
+
+#if !defined(STANDARD_C99) && !defined(STANDARD_CC65)
+
+#error "this test checks C99 features, which are not available in the selected standard."
+
+#else
+
+#ifdef NO_WCHAR
+
+#warn "this test checks C99 features, but NO_WCHAR is defined so the test will most definetly fails."
+
+#endif
+
+#include <inttypes.h> /* embeds <stdint.h> */
+
+#include <signal.h> /* for sig_atomic_t */
+
+#if defined(INTMAX_MAX) /* <inttypes.h> has C99 features */
+#include <wchar.h>
+#endif
+
+#include <inttypes.h> /* test idempotency */
+
+#ifdef STANDALONE
+
+FILE *outfile=NULL;
+#define opentest(x) outfile=stdout;
+#define closetest(x)
+
+#else
+
+#endif
+
+#if __STDC_VERSION__ >= 199901
+#ifndef __Q8_QT
+#define __Q8_QT long long
+#endif
+#endif
+
+#ifdef PRIdMAX
+#define HAVE_PRIdMAX
+#ifndef __Q8_MT
+#define __Q8_MT intmax_t
+#endif
+#else
+#ifdef PRIdLEAST64
+#ifndef __Q8_MT
+#define __Q8_MT int_least64_t
+#endif
+#define PRIdMAX PRIdLEAST64
+#else
+#ifndef __Q8_MT
+#define __Q8_MT long
+#endif
+#define PRIdMAX "ld"
+#endif
+#endif
+
+#ifdef PRIuMAX
+#define HAVE_PRIuMAX
+#define U__Q8_MT uintmax_t
+#else
+#ifdef PRIuLEAST64
+#define U__Q8_MT uint_least64_t
+#define PRIuMAX PRIuLEAST64
+#else
+#define U__Q8_MT unsigned long
+#define PRIuMAX "lu"
+#endif
+#endif
+
+#define STR_SUB(s) # s
+#define STRINGIZE(s) STR_SUB(s) /* extra level to expand argument */
+
+#if defined(SCNo32) || defined(PRIo32)
+static int32_t int32;
+#endif
+static int_least16_t intl16;
+static uint_least16_t uintl16;
+static uint_fast16_t uintf16;
+static intmax_t intmax;
+static uintmax_t uintmax;
+
+int
+main() {
+ int status = 0; /* exit status to be returned */
+
+
+ /* <stdint.h> features: */
+
+ printf("CHAR_BIT=%u\n", (unsigned)CHAR_BIT );
+ printf("sizeof(char)=%u\n", (unsigned)sizeof(char)); /* s.b. 1 */
+ printf("sizeof(short)=%u\n", (unsigned)sizeof(short));
+ printf("sizeof(int)=%u\n", (unsigned)sizeof(int));
+ printf("sizeof(long)=%u\n", (unsigned)sizeof(long));
+#ifdef __Q8_QT
+ printf("sizeof(long long)=%u\n", (unsigned)sizeof(__Q8_QT));
+#else
+ printf("*** long long isn't defined ***\n");
+#endif
+ printf("sizeof(intmax_t)=%u\n", (unsigned)sizeof(intmax_t));
+ printf("sizeof(ptrdiff_t)=%u\n", (unsigned)sizeof(ptrdiff_t));
+ printf("sizeof(size_t)=%u\n", (unsigned)sizeof(size_t));
+ printf("sizeof(sig_atomic_t)=%u\n", (unsigned)sizeof(sig_atomic_t));
+ printf("sizeof(wchar_t)=%u\n", (unsigned)sizeof(wchar_t));
+#if defined(WINT_MAX) || __STDC_VERSION__ >= 199901
+ printf("sizeof(wint_t)=%u\n", (unsigned)sizeof(wint_t));
+#else
+ printf("*** wint_t isn't defined ***\n");
+ status = EXIT_FAILURE;
+#endif
+#ifdef INT8_MAX
+ printf("sizeof(int8_t)=%u\n", (unsigned)sizeof(int8_t));
+ printf("sizeof(uint8_t)=%u\n", (unsigned)sizeof(uint8_t));
+#endif
+#ifdef INT9_MAX
+ printf("sizeof(int9_t)=%u\n", (unsigned)sizeof(int9_t));
+ printf("sizeof(uint9_t)=%u\n", (unsigned)sizeof(uint9_t));
+#endif
+#ifdef INT12_MAX
+ printf("sizeof(int12_t)=%u\n", (unsigned)sizeof(int12_t));
+ printf("sizeof(uint12_t)=%u\n", (unsigned)sizeof(uint12_t));
+#endif
+#ifdef INT16_MAX
+ printf("sizeof(int16_t)=%u\n", (unsigned)sizeof(int16_t));
+ printf("sizeof(uint16_t)=%u\n", (unsigned)sizeof(uint16_t));
+#endif
+#ifdef INT18_MAX
+ printf("sizeof(int18_t)=%u\n", (unsigned)sizeof(int18_t));
+ printf("sizeof(uint18_t)=%u\n", (unsigned)sizeof(uint18_t));
+#endif
+#ifdef INT24_MAX
+ printf("sizeof(int24_t)=%u\n", (unsigned)sizeof(int24_t));
+ printf("sizeof(uint24_t)=%u\n", (unsigned)sizeof(uint24_t));
+#endif
+#ifdef INT32_MAX
+ printf("sizeof(int32_t)=%u\n", (unsigned)sizeof(int32_t));
+ printf("sizeof(uint32_t)=%u\n", (unsigned)sizeof(uint32_t));
+#endif
+#ifdef INT36_MAX
+ printf("sizeof(int36_t)=%u\n", (unsigned)sizeof(int36_t));
+ printf("sizeof(uint36_t)=%u\n", (unsigned)sizeof(uint36_t));
+#endif
+#ifdef INT40_MAX
+ printf("sizeof(int40_t)=%u\n", (unsigned)sizeof(int40_t));
+ printf("sizeof(uint40_t)=%u\n", (unsigned)sizeof(uint40_t));
+#endif
+#ifdef INT48_MAX
+ printf("sizeof(int48_t)=%u\n", (unsigned)sizeof(int48_t));
+ printf("sizeof(uint48_t)=%u\n", (unsigned)sizeof(uint48_t));
+#endif
+#ifdef INT60_MAX
+ printf("sizeof(int60_t)=%u\n", (unsigned)sizeof(int60_t));
+ printf("sizeof(uint60_t)=%u\n", (unsigned)sizeof(uint60_t));
+#endif
+#ifdef INT64_MAX
+ printf("sizeof(int64_t)=%u\n", (unsigned)sizeof(int64_t));
+ printf("sizeof(uint64_t)=%u\n", (unsigned)sizeof(uint64_t));
+#endif
+#ifdef INT72_MAX
+ printf("sizeof(int72_t)=%u\n", (unsigned)sizeof(int72_t));
+ printf("sizeof(uint72_t)=%u\n", (unsigned)sizeof(uint72_t));
+#endif
+#ifdef INT128_MAX
+ printf("sizeof(int128_t)=%u\n", (unsigned)sizeof(int128_t));
+ printf("sizeof(uint128_t)=%u\n", (unsigned)sizeof(uint128_t));
+#endif
+ printf("sizeof(int_least8_t)=%u\n", (unsigned)sizeof(int_least8_t));
+ printf("sizeof(uint_least8_t)=%u\n", (unsigned)sizeof(uint_least8_t));
+ printf("sizeof(int_least16_t)=%u\n", (unsigned)sizeof(int_least16_t));
+ printf("sizeof(uint_least16_t)=%u\n", (unsigned)sizeof(uint_least16_t));
+ printf("sizeof(int_least32_t)=%u\n", (unsigned)sizeof(int_least32_t));
+ printf("sizeof(uint_least32_t)=%u\n", (unsigned)sizeof(uint_least32_t));
+#ifdef INT_LEAST64_MAX
+ printf("sizeof(int_least64_t)=%u\n", (unsigned)sizeof(int_least64_t));
+ printf("sizeof(uint_least64_t)=%u\n", (unsigned)sizeof(uint_least64_t));
+#else
+ printf("*** uint_least64_t isn't defined ***\n");
+ status = EXIT_FAILURE;
+#endif
+#ifdef INT_LEAST128_MAX
+ printf("sizeof(int_least128_t)=%u\n", (unsigned)sizeof(int_least128_t));
+ printf("sizeof(uint_least128_t)=%u\n",
+ (unsigned)sizeof(uint_least128_t));
+#endif
+ printf("sizeof(int_fast8_t)=%u\n", (unsigned)sizeof(int_fast8_t));
+ printf("sizeof(uint_fast8_t)=%u\n", (unsigned)sizeof(uint_fast8_t));
+ printf("sizeof(int_fast16_t)=%u\n", (unsigned)sizeof(int_fast16_t));
+ printf("sizeof(uint_fast16_t)=%u\n", (unsigned)sizeof(uint_fast16_t));
+ printf("sizeof(int_fast32_t)=%u\n", (unsigned)sizeof(int_fast32_t));
+ printf("sizeof(uint_fast32_t)=%u\n", (unsigned)sizeof(uint_fast32_t));
+#ifdef INT_FAST64_MAX
+ printf("sizeof(int_fast64_t)=%u\n", (unsigned)sizeof(int_fast64_t));
+ printf("sizeof(uint_fast64_t)=%u\n", (unsigned)sizeof(uint_fast64_t));
+#else
+ printf("*** int_fast64_t isn't defined ***\n");
+ status = EXIT_FAILURE;
+#endif
+#ifdef INT_FAST128_MAX
+ printf("sizeof(int_fast128_t)=%u\n", (unsigned)sizeof(int_fast128_t));
+ printf("sizeof(uint_fast128_t)=%u\n", (unsigned)sizeof(uint_fast128_t));
+#endif
+#if defined(INTPTR_MAX)
+ printf("sizeof(intptr_t)=%u\n", (unsigned)sizeof(intptr_t));
+#if defined(UINTPTR_MAX)
+ printf("sizeof(uintptr_t)=%u\n", (unsigned)sizeof(uintptr_t));
+#else
+ printf("*** intptr_t is defined but uintptr_t isn't ***\n");
+ status = EXIT_FAILURE;
+#endif
+#elif defined(UINTPTR_MAX)
+ printf("sizeof(uintptr_t)=%u\n", (unsigned)sizeof(uintptr_t));
+ printf("*** uintptr_t is defined but intptr_t isn't ***\n");
+ status = EXIT_FAILURE;
+#else
+ printf("*** neither intptr_t nor uintptr_t is defined ***\n");
+ status = EXIT_FAILURE;
+#endif
+#ifdef INTMAX_MAX
+ printf("sizeof(intmax_t)=%u\n", (unsigned)sizeof(intmax_t));
+ printf("sizeof(uintmax_t)=%u\n", (unsigned)sizeof(uintmax_t));
+#else
+ printf("*** intmax_t isn't defined ***\n");
+ status = EXIT_FAILURE;
+#endif
+
+#ifdef INT8_MAX
+ printf("INT8_MIN=%"PRIdMAX"\n", (__Q8_MT)INT8_MIN);
+ printf("INT8_MAX=%"PRIdMAX"\n", (__Q8_MT)INT8_MAX);
+ printf("UINT8_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT8_MAX);
+#endif
+#ifdef INT9_MAX
+ printf("INT9_MIN=%"PRIdMAX"\n", (__Q8_MT)INT9_MIN);
+ printf("INT9_MAX=%"PRIdMAX"\n", (__Q8_MT)INT9_MAX);
+ printf("UINT9_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT9_MAX);
+#endif
+#ifdef INT12_MAX
+ printf("INT12_MIN=%"PRIdMAX"\n", (__Q8_MT)INT12_MIN);
+ printf("INT12_MAX=%"PRIdMAX"\n", (__Q8_MT)INT12_MAX);
+ printf("UINT12_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT12_MAX);
+#endif
+#ifdef INT16_MAX
+ printf("INT16_MIN=%"PRIdMAX"\n", (__Q8_MT)INT16_MIN);
+ printf("INT16_MAX=%"PRIdMAX"\n", (__Q8_MT)INT16_MAX);
+ printf("UINT16_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT16_MAX);
+#endif
+#ifdef INT18_MAX
+ printf("INT18_MIN=%"PRIdMAX"\n", (__Q8_MT)INT18_MIN);
+ printf("INT18_MAX=%"PRIdMAX"\n", (__Q8_MT)INT18_MAX);
+ printf("UINT18_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT18_MAX);
+#endif
+#ifdef INT24_MAX
+ printf("INT24_MIN=%"PRIdMAX"\n", (__Q8_MT)INT24_MIN);
+ printf("INT24_MAX=%"PRIdMAX"\n", (__Q8_MT)INT24_MAX);
+ printf("UINT24_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT24_MAX);
+#endif
+#ifdef INT32_MAX
+ printf("INT32_MIN=%"PRIdMAX"\n", (__Q8_MT)INT32_MIN);
+ printf("INT32_MAX=%"PRIdMAX"\n", (__Q8_MT)INT32_MAX);
+ printf("UINT32_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT32_MAX);
+#endif
+#ifdef INT36_MAX
+ printf("INT36_MIN=%"PRIdMAX"\n", (__Q8_MT)INT36_MIN);
+ printf("INT36_MAX=%"PRIdMAX"\n", (__Q8_MT)INT36_MAX);
+ printf("UINT36_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT36_MAX);
+#endif
+#ifdef INT40_MAX
+ printf("INT40_MIN=%"PRIdMAX"\n", (__Q8_MT)INT40_MIN);
+ printf("INT40_MAX=%"PRIdMAX"\n", (__Q8_MT)INT40_MAX);
+ printf("UINT40_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT40_MAX);
+#endif
+#ifdef INT48_MAX
+ printf("INT48_MIN=%"PRIdMAX"\n", (__Q8_MT)INT48_MIN);
+ printf("INT48_MAX=%"PRIdMAX"\n", (__Q8_MT)INT48_MAX);
+ printf("UINT48_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT48_MAX);
+#endif
+#ifdef INT60_MAX
+ printf("INT60_MIN=%"PRIdMAX"\n", (__Q8_MT)INT60_MIN);
+ printf("INT60_MAX=%"PRIdMAX"\n", (__Q8_MT)INT60_MAX);
+ printf("UINT60_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT60_MAX);
+#endif
+#ifdef INT64_MAX
+ printf("INT64_MIN=%"PRIdMAX"\n", (__Q8_MT)INT64_MIN);
+ printf("INT64_MAX=%"PRIdMAX"\n", (__Q8_MT)INT64_MAX);
+ printf("UINT64_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT64_MAX);
+#endif
+#ifdef INT72_MAX
+ printf("INT72_MIN=%"PRIdMAX"\n", (__Q8_MT)INT72_MIN);
+ printf("INT72_MAX=%"PRIdMAX"\n", (__Q8_MT)INT72_MAX);
+ printf("UINT72_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT72_MAX);
+#endif
+#ifdef INT128_MAX
+ printf("INT128_MIN=%"PRIdMAX"\n", (__Q8_MT)INT128_MIN);
+ printf("INT128_MAX=%"PRIdMAX"\n", (__Q8_MT)INT128_MAX);
+ printf("UINT128_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT128_MAX);
+#endif
+ printf("INT_LEAST8_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST8_MIN);
+ printf("INT_LEAST8_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST8_MAX);
+ printf("UINT_LEAST8_MAX=%"PRIuMAX"\n",
+ (U__Q8_MT)UINT_LEAST8_MAX);
+ printf("INT_LEAST16_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST16_MIN);
+ printf("INT_LEAST16_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST16_MAX);
+ printf("UINT_LEAST16_MAX=%"PRIuMAX"\n",
+ (U__Q8_MT)UINT_LEAST16_MAX);
+ printf("INT_LEAST32_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST32_MIN);
+ printf("INT_LEAST32_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST32_MAX);
+ printf("UINT_LEAST32_MAX=%"PRIuMAX"\n",
+ (U__Q8_MT)UINT_LEAST32_MAX);
+#ifdef INT_LEAST64_MAX
+ printf("INT_LEAST64_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST64_MIN);
+ printf("INT_LEAST64_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST64_MAX);
+ printf("UINT_LEAST64_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT_LEAST64_MAX);
+#endif
+#ifdef INT_LEAST128_MAX
+ printf("INT_LEAST128_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST128_MIN);
+ printf("INT_LEAST128_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_LEAST128_MAX);
+ printf("UINT_LEAST128_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT_LEAST128_MAX);
+#endif
+ printf("INT_FAST8_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_FAST8_MIN);
+ printf("INT_FAST8_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_FAST8_MAX);
+ printf("UINT_FAST8_MAX=%"PRIuMAX"\n",
+ (U__Q8_MT)UINT_FAST8_MAX);
+ printf("INT_FAST16_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_FAST16_MIN);
+ printf("INT_FAST16_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_FAST16_MAX);
+ printf("UINT_FAST16_MAX=%"PRIuMAX"\n",
+ (U__Q8_MT)UINT_FAST16_MAX);
+ printf("INT_FAST32_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_FAST32_MIN);
+ printf("INT_FAST32_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_FAST32_MAX);
+ printf("UINT_FAST32_MAX=%"PRIuMAX"\n",
+ (U__Q8_MT)UINT_FAST32_MAX);
+#ifdef INT_FAST64_MAX
+ printf("INT_FAST64_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_FAST64_MIN);
+ printf("INT_FAST64_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_FAST64_MAX);
+ printf("UINT_FAST64_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT_FAST64_MAX);
+#endif
+#ifdef INT_FAST128_MAX
+ printf("INT_FAST128_MIN=%"PRIdMAX"\n", (__Q8_MT)INT_FAST128_MIN);
+ printf("INT_FAST128_MAX=%"PRIdMAX"\n", (__Q8_MT)INT_FAST128_MAX);
+ printf("UINT_FAST128_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINT_FAST128_MAX);
+#endif
+#ifdef INTPTR_MAX
+ printf("INTPTR_MIN=%"PRIdMAX"\n", (__Q8_MT)INTPTR_MIN);
+ printf("INTPTR_MAX=%"PRIdMAX"\n", (__Q8_MT)INTPTR_MAX);
+#endif
+#ifdef UINTPTR_MAX
+ printf("UINTPTR_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINTPTR_MAX);
+#endif
+#ifdef INTMAX_MAX
+ printf("INTMAX_MIN=%"PRIdMAX"\n", (__Q8_MT)INTMAX_MIN);
+ printf("INTMAX_MAX=%"PRIdMAX"\n", (__Q8_MT)INTMAX_MAX);
+ printf("UINTMAX_MAX=%"PRIuMAX"\n", (U__Q8_MT)UINTMAX_MAX);
+#endif
+#ifdef PTRDIFF_MAX
+ printf("PTRDIFF_MIN=%"PRIdMAX"\n", (__Q8_MT)PTRDIFF_MIN);
+ printf("PTRDIFF_MAX=%"PRIdMAX"\n", (__Q8_MT)PTRDIFF_MAX);
+#endif
+#ifdef SIG_ATOMIC_MAX
+#if SIG_ATOMIC_MIN < 0
+ printf("SIG_ATOMIC_MIN=%"PRIdMAX"\n", (__Q8_MT)SIG_ATOMIC_MIN);
+ printf("SIG_ATOMIC_MAX=%"PRIdMAX"\n", (__Q8_MT)SIG_ATOMIC_MAX);
+#else
+ printf("SIG_ATOMIC_MIN=%"PRIuMAX"\n", (U__Q8_MT)SIG_ATOMIC_MIN);
+ printf("SIG_ATOMIC_MAX=%"PRIuMAX"\n", (U__Q8_MT)SIG_ATOMIC_MAX);
+#endif
+#endif
+#ifdef SIZE_MAX
+ printf("SIZE_MAX=%"PRIuMAX"\n", (U__Q8_MT)SIZE_MAX);
+#endif
+
+#ifdef WCHAR_MAX
+#if WCHAR_MIN < 0
+ printf("WCHAR_MIN=%"PRIdMAX"\n", (__Q8_MT)WCHAR_MIN);
+ printf("WCHAR_MAX=%"PRIdMAX"\n", (__Q8_MT)WCHAR_MAX);
+#else
+ printf("WCHAR_MIN=%"PRIuMAX"\n", (U__Q8_MT)WCHAR_MIN);
+ printf("WCHAR_MAX=%"PRIuMAX"\n", (U__Q8_MT)WCHAR_MAX);
+#endif
+#endif
+#ifdef WINT_MAX
+#if WINT_MIN < 0
+ printf("WINT_MIN=%"PRIdMAX"\n", (__Q8_MT)WINT_MIN);
+ printf("WINT_MAX=%"PRIdMAX"\n", (__Q8_MT)WINT_MAX);
+#else
+ printf("WINT_MIN=%"PRIuMAX"\n", (U__Q8_MT)WINT_MIN);
+ printf("WINT_MAX=%"PRIuMAX"\n", (U__Q8_MT)WINT_MAX);
+#endif
+#endif
+
+ /*
+ 7.18.4 Macros for integer constants
+ */
+
+ /* INTn_C for n=8 and 16 were at one point unimplementable
+ on most platforms, so they're treated as "optional": */
+#ifdef INT8_C
+ if ( INT8_C(-123) != -123 )
+ printf("*** INT8_C(-123) produced %"PRIdMAX" ***\n",
+ (__Q8_MT)INT8_C(-123)
+ );
+ if ( UINT8_C(123) != 123 )
+ printf("*** UINT8_C(123) produced %"PRIuMAX" ***\n",
+ (U__Q8_MT)UINT8_C(123)
+ );
+#endif
+#ifdef INT16_C
+ if ( INT16_C(-12345) != -12345 )
+ printf("*** INT16_C(-12345) produced %"PRIdMAX" ***\n",
+ (__Q8_MT)INT16_C(-12345)
+ );
+ if ( UINT16_C(12345) != 12345 )
+ printf("*** UINT16_C(12345) produced %"PRIuMAX" ***\n",
+ (U__Q8_MT)UINT16_C(12345)
+ );
+#endif
+ if ( INT32_C(-123456789) != -123456789 )
+ printf("*** INT32_C(-123456789) produced %"PRIdMAX" ***\n",
+ (__Q8_MT)INT32_C(-123456789)
+ );
+ if ( UINT32_C(123456789) != 123456789 )
+ printf("*** UINT32_C(123456789) produced %"PRIuMAX" ***\n",
+ (U__Q8_MT)UINT32_C(123456789)
+ );
+#ifdef INT_LEAST64_MAX
+ if ( INT64_C(-1234567890123456789) != -1234567890123456789 )
+ printf("*** INT64_C(-1234567890123456789) produced %"PRIdMAX
+ " ***\n",
+ (__Q8_MT)INT64_C(-1234567890123456789)
+ );
+ if ( UINT64_C(1234567890123456789) != 1234567890123456789 )
+ printf("*** UINT64_C(1234567890123456789) produced %"PRIuMAX
+ " ***\n",
+ (U__Q8_MT)UINT64_C(1234567890123456789)
+ );
+#endif
+#ifdef INTMAX_MAX
+ if ( INTMAX_C(-1234567890123456789) != -1234567890123456789 )
+ printf("*** INTMAX_C(-1234567890123456789) produced %"PRIdMAX
+ " ***\n",
+ (__Q8_MT)INTMAX_C(-1234567890123456789)
+ );
+ if ( UINTMAX_C(1234567890123456789) != 1234567890123456789 )
+ printf("*** UINTMAX_C(1234567890123456789) produced %"PRIuMAX
+ " ***\n",
+ (U__Q8_MT)UINTMAX_C(1234567890123456789)
+ );
+#endif
+
+ /* <inttypes.h> features: */
+
+#if __STDC_VERSION__ >= 199901
+ printf("sizeof(imaxdiv_t)=%u\n", (unsigned)sizeof(imaxdiv_t));
+#endif
+
+ /*
+ 7.8.1 Macros for format specifiers
+ */
+
+ {
+ /* scanf these strings */
+ static const char in_dn[] = "Z119bZ";
+ static const char in_dmo[] = "Z-0119bZ";
+ static const char in_dspx[] = "Z \t\n +0X119bZ";
+ static const char in_dsmx[] = "Z \t\n -0x119bZ";
+ static const char in_dsn[] = "Z \t\n 119bZ";
+ static const char in_dp[] = "Z+119bZ";
+ static const char in_dpx[] = "Z+0X119bz";
+
+ /* sprintf into this */
+ static char buffer[1024];
+
+#if 1
+
+#define SCAN(buf,fs,var,exp) if ( sscanf(buf, "Z%" fs, &var) != 1 ) \
+ { \
+ printf("***%s=",fs, STR_SUB(fs) \
+ " failed ***\n" \
+ ); \
+ status = EXIT_FAILURE; \
+ } \
+ else if ( var != (exp) ) \
+ { \
+ printf("***%s=",fs, STR_SUB(fs) \
+ " should be: " STR_SUB(exp) \
+ ", was: %" fs " ***\n", var \
+ ); \
+ status = EXIT_FAILURE; \
+ } \
+ else /* for trailing semicolon */
+
+#define PRINT(fs,var,exp) if ( sprintf(buffer, "%" fs, var ) <= 0 ) \
+ { \
+ printf("***%s=",fs, STR_SUB(fs) \
+ " failed ***\n" \
+ ); \
+ status = EXIT_FAILURE; \
+ } \
+ else if ( strcmp(buffer, STR_SUB(exp)) != 0 ) \
+ { \
+ printf("***%s=",fs, STR_SUB(fs) \
+ " should be: " STR_SUB(exp) \
+ ", was: %s ***\n", buffer \
+ ); \
+ status = EXIT_FAILURE; \
+ } \
+ else /* for trailing semicolon */
+
+#else
+
+#define SCAN(buf,fs,var,exp)
+#define PRINT(fs,var,exp)
+
+#endif
+
+#ifdef SCNo32
+
+ SCAN(in_dn, SCNo32, int32, 9);
+
+#endif
+#ifdef PRIo32
+ PRINT(PRIo32, int32, 11);
+#endif
+ SCAN(in_dmo, SCNiLEAST16, intl16, -9);
+ SCAN(in_dspx, SCNdLEAST16, intl16, 0);
+ SCAN(in_dsmx, SCNiLEAST16, intl16, -4507);
+ PRINT(PRIdLEAST16, intl16, -4507);
+ PRINT(PRIiLEAST16, intl16, -4507);
+ SCAN(in_dsn, SCNxLEAST16, uintl16, 4507);
+ PRINT(PRIoLEAST16, uintl16, 10633);
+ PRINT(PRIuLEAST16, uintl16, 4507);
+ PRINT(PRIxLEAST16, uintl16, 119b);
+ PRINT(PRIXLEAST16, uintl16, 119B);
+ SCAN(in_dp, SCNxFAST16, uintf16, 4507);
+ PRINT(PRIxFAST16, uintf16, 119b);
+#ifdef SCNdMAX
+ SCAN(in_dp, SCNdMAX, intmax, 119);
+#endif
+#ifdef PRIiMAX
+ PRINT(PRIiMAX, intmax, 119);
+#endif
+#ifdef SCNoMAX
+ SCAN(in_dpx, SCNoMAX, uintmax, 0);
+#endif
+#ifdef PRIxMAX
+ PRINT(PRIxMAX, uintmax, 0);
+#endif
+ /* Obviously there should be a much larger battery of such tests. */
+ }
+
+#if defined(INTMAX_MAX) /* <inttypes.h> has C99 features */
+ /*
+ 7.8.2 Functions for greatest-width integer types
+ */
+
+ {
+ static struct
+ {
+ intmax_t input;
+ intmax_t expect;
+ } abs_data[] =
+ {
+#ifdef INT8_MAX
+ { INT8_MAX, INT8_MAX, },
+ { -INT8_MAX, INT8_MAX, },
+ { UINT8_MAX, UINT8_MAX, },
+#endif
+
+#if 0
+
+#ifdef INT16_MAX
+ { INT16_MAX, INT16_MAX, },
+ { -INT16_MAX, INT16_MAX, },
+ { UINT16_MAX, UINT16_MAX, },
+#endif
+#ifdef INT32_MAX
+ { INT32_MAX, INT32_MAX, },
+ { -INT32_MAX, INT32_MAX, },
+#ifdef INT_LEAST64_MAX /* else might support only 32 bits */
+ { UINT32_MAX, UINT32_MAX, },
+#endif
+#endif
+#ifdef INT64_MAX
+ { INT64_MAX, INT64_MAX, },
+ { -INT64_MAX, INT64_MAX, },
+#endif
+ { INT_LEAST8_MAX, INT_LEAST8_MAX, },
+ { -INT_LEAST8_MAX, INT_LEAST8_MAX, },
+ { UINT_LEAST8_MAX, UINT_LEAST8_MAX, },
+ { INT_LEAST16_MAX, INT_LEAST16_MAX, },
+ { -INT_LEAST16_MAX, INT_LEAST16_MAX, },
+ { UINT_LEAST16_MAX, UINT_LEAST16_MAX, },
+ { INT_LEAST32_MAX, INT_LEAST32_MAX, },
+ { -INT_LEAST32_MAX, INT_LEAST32_MAX, },
+#ifdef INT_LEAST64_MAX
+ { UINT_LEAST32_MAX, UINT_LEAST32_MAX, },
+ { INT_LEAST64_MAX, INT_LEAST64_MAX, },
+ { -INT_LEAST64_MAX, INT_LEAST64_MAX, },
+#endif
+ { INT_FAST8_MAX, INT_FAST8_MAX, },
+ { -INT_FAST8_MAX, INT_FAST8_MAX, },
+ { UINT_FAST8_MAX, UINT_FAST8_MAX, },
+ { INT_FAST16_MAX, INT_FAST16_MAX, },
+ { -INT_FAST16_MAX, INT_FAST16_MAX, },
+ { UINT_FAST16_MAX, UINT_FAST16_MAX, },
+ { INT_FAST32_MAX, INT_FAST32_MAX, },
+ { -INT_FAST32_MAX, INT_FAST32_MAX, },
+#ifdef INT_FAST64_MAX
+ { UINT_FAST32_MAX, UINT_FAST32_MAX, },
+ { INT_FAST64_MAX, INT_FAST64_MAX, },
+ { -INT_FAST64_MAX, INT_FAST64_MAX, },
+#endif
+#ifdef INTPTR_MAX
+ { INTPTR_MAX, INTPTR_MAX, },
+ { -INTPTR_MAX, INTPTR_MAX, },
+#endif
+#ifdef UINTPTR_MAX
+ { UINTPTR_MAX, UINTPTR_MAX, },
+#endif
+ { INTMAX_MAX, INTMAX_MAX, },
+#ifdef PTRDIFF_MAX
+ { PTRDIFF_MAX, PTRDIFF_MAX, },
+#endif
+#ifdef SIG_ATOMIC_MAX
+ { SIG_ATOMIC_MAX, SIG_ATOMIC_MAX, },
+#if SIG_ATOMIC_MIN < 0
+ { -SIG_ATOMIC_MAX, SIG_ATOMIC_MAX, },
+#endif
+#endif
+#ifdef SIZE_MAX
+ { SIZE_MAX, SIZE_MAX, },
+#endif
+#ifdef WCHAR_MAX
+ { WCHAR_MAX, WCHAR_MAX, },
+#if WCHAR_MIN < 0
+ { -WCHAR_MAX, WCHAR_MAX, },
+#endif
+#endif
+#ifdef WINT_MAX
+ { WINT_MAX, WINT_MAX, },
+#if WINT_MIN < 0
+ { -WINT_MAX, WINT_MAX, },
+#endif
+#endif
+ { 127, 127, },
+ { -127, 127, },
+ { 128, 128, },
+ { -127-1, 128, },
+ { 255, 255, },
+ { -256+1, 255, },
+ { 256, 256, },
+ { -256, 256, },
+ { 32767, 32767, },
+ { -32767, 32767, },
+ { 32768, 32768, },
+ { -32767-1, 32768, },
+ { 65535, 65535, },
+ { -65536+1, 65535, },
+ { 65536, 65536, },
+ { -65536, 65536, },
+ { 2147483647, 2147483647, },
+ { -2147483647, 2147483647, },
+ { 2147483648, 2147483648, },
+ { -2147483647-1, 2147483648, },
+#ifdef INT_LEAST64_MAX /* else might support only 32 bits */
+ { 4294967295, 4294967295, },
+ { -4294967296+1, 4294967295, },
+ { 4294967296, 4294967296, },
+ { -4294967296, 4294967296, },
+ { 9223372036854775807, 9223372036854775807, },
+ { -9223372036854775807, 9223372036854775807, },
+ { 1234567890123456789, 1234567890123456789, },
+ { -1234567890123456789, 1234567890123456789, },
+#endif
+ { 1, 1, },
+ { -1, 1, },
+ { 2, 2, },
+ { -2, 2, },
+ { 10, 10, },
+ { -10, 10, },
+ { 16, 16, },
+ { -16, 16, },
+#endif
+ /* Other test cases can be added here. */
+ { 0, 0 /* terminates the list */ },
+ }, *adp = abs_data;
+
+ do {
+ if ( (intmax = imaxabs(adp->input)) != adp->expect )
+ {
+ printf("*** imaxabs(%"PRIdMAX") failed; should be: %"
+ PRIdMAX", was: %"PRIdMAX" ***\n",
+ adp->input, adp->expect, intmax
+ );
+ status = EXIT_FAILURE;
+ }
+// } while ( adp++->input != 0 );
+ } while ( (adp++)->input != 0 );
+ }
+
+ {
+ imaxdiv_t result;
+ static struct
+ {
+ intmax_t numer;
+ intmax_t denom;
+ intmax_t exp_quot;
+ intmax_t exp_rem;
+ } div_data[] =
+ {
+ { 0, 1, 0, 0, },
+#if 0
+ { 0, -1, 0, 0, },
+ { 0, 2, 0, 0, },
+ { 0, -2, 0, 0, },
+ { 0, 5, 0, 0, },
+ { 0, -5, 0, 0, },
+ { 1, 1, 1, 0, },
+ { 1, -1, -1, 0, },
+ { 1, 2, 0, 1, },
+ { 1, -2, 0, 1, },
+ { 1, 5, 0, 1, },
+ { 1, -5, 0, 1, },
+ { -1, 1, -1, 0, },
+ { -1, -1, 1, 0, },
+ { -1, 2, 0, -1, },
+ { -1, -2, 0, -1, },
+ { -1, 5, 0, -1, },
+ { -1, -5, 0, -1, },
+ { 2, 1, 2, 0, },
+ { 2, -1, -2, 0, },
+ { 2, 2, 1, 0, },
+ { 2, -2, -1, 0, },
+ { 2, 5, 0, 2, },
+ { 2, -5, 0, 2, },
+ { -2, 1, -2, 0, },
+ { -2, -1, 2, 0, },
+ { -2, 2, -1, 0, },
+ { -2, -2, 1, 0, },
+ { -2, 5, 0, -2, },
+ { -2, -5, 0, -2, },
+ { 17, 5, 3, 2, },
+ { -17, -5, 3, -2, },
+ { 17, -5, -3, 2, },
+ { -17, 5, -3, -2, },
+ { 2147483647, 1, 2147483647, 0, },
+ { -2147483647, 1, -2147483647, 0, },
+ { 2147483648, 1, 2147483648, 0, },
+ { -2147483647-1, 1, -2147483647-1, 0, },
+ { 2147483647, 2, 1073741823, 1, },
+ { -2147483647, 2, -1073741823, -1, },
+ { 2147483648, 2, 1073741824, 0, },
+ { -2147483647-1, 2, -1073741824, 0, },
+#ifdef INT_LEAST64_MAX /* else might support only 32 bits */
+ { 4294967295, 1, 4294967295, 0, },
+ { -4294967296+1, 1, -4294967296+1, 0, },
+ { 4294967296, 1, 4294967296, 0, },
+ { -4294967296, 1, -4294967296, 0, },
+ { 4294967295, -1, -4294967296+1, 0, },
+ { -4294967296+1, -1, 4294967295, 0, },
+ { 4294967296, -1, -4294967296, 0, },
+ { -4294967296, -1, 4294967296, 0, },
+ { 4294967295, 2, 2147483647, 1, },
+ { -4294967296+1, 2, -2147483647, -1, },
+ { 4294967296, 2, 2147483648, 0, },
+ { -4294967296, 2, -2147483647-1, 0, },
+ { 4294967295, 2147483647, 2, 1, },
+ { -4294967296+1, 2147483647, -2, -1, },
+ { 4294967296, 2147483647, 2, 2, },
+ { -4294967296, 2147483647, -2, -2, },
+ { 4294967295, -2147483647, -2, 1, },
+ { -4294967296+1, -2147483647, 2, -1, },
+ { 4294967296, -2147483647, -2, 2, },
+ { -4294967296, -2147483647, 2, -2, },
+ { 4294967295, 2147483648, 1, 2147483647, },
+ { -4294967296+1, 2147483648, -1, -2147483647, },
+ { 4294967296, 2147483648, 2, 0, },
+ { -4294967296, 2147483648, -2, 0, },
+ { 4294967295, -2147483647-1, -1, 2147483647, },
+ { -4294967296+1, -2147483647-1, 1, -2147483647,},
+ { 4294967296, -2147483647-1, -2, 0, },
+ { -4294967296, -2147483647-1, 2, 0, },
+ { 9223372036854775807, 1, 9223372036854775807, 0, },
+ { -9223372036854775807, 1, -9223372036854775807, 0, },
+ { 9223372036854775807, 2, 4611686018427387903, 1, },
+ { -9223372036854775807, 2, -4611686018427387903, -1, },
+#endif
+#endif
+ /* There should be a much larger battery of such tests. */
+ { 0, 0, 0, 0 }, /* 0 denom terminates the list */
+ }, *ddp;
+
+#if 0
+ for ( ddp = div_data; ddp->denom != 0; ++ddp )
+ if ( (result = imaxdiv(ddp->numer, ddp->denom)).quot
+ != ddp->exp_quot || result.rem != ddp->exp_rem
+ ) {
+// printf("*** imaxdiv(%"PRIdMAX",%"PRIdMAX
+// ") failed; should be: (%"PRIdMAX",%"PRIdMAX
+// "), was: (%"PRIdMAX",%"PRIdMAX") ***\n",
+// ddp->numer, ddp->denom, ddp->exp_quot,
+// ddp->exp_rem, result.quot, result.rem
+// );
+ printf("err:imaxdiv(%"PRIdMAX",%"PRIdMAX
+ ") = (%"PRIdMAX",%"PRIdMAX
+ "), is: (%"PRIdMAX",%"PRIdMAX")\n",
+ ddp->numer, ddp->denom, ddp->exp_quot,
+ ddp->exp_rem, result.quot, result.rem
+ );
+ status = EXIT_FAILURE;
+ }
+#endif
+ }
+
+ {
+ char *endptr;
+ wchar_t *wendptr;
+ static char saved[64]; /* holds copy of input string */
+ static wchar_t wnptr[64]; /* holds wide copy of test string */
+ static int warned; /* "warned for null endptr" flag */
+ register int i;
+ static struct
+ {
+ char * nptr;
+ int base;
+ intmax_t exp_val;
+ int exp_len;
+ } str_data[] =
+ {
+ { "", 0, 0, 0, },
+ { "", 2, 0, 0, },
+ { "", 8, 0, 0, },
+ { "", 9, 0, 0, },
+ { "", 10, 0, 0, },
+ { "", 16, 0, 0, },
+ { "", 36, 0, 0, },
+ { "0", 0, 0, 1, },
+ { "0", 2, 0, 1, },
+ { "0", 8, 0, 1, },
+ { "0", 9, 0, 1, },
+ { "0", 10, 0, 1, },
+ { "0", 16, 0, 1, },
+ { "0", 36, 0, 1, },
+ { "+0", 0, 0, 2, },
+ { "+0", 2, 0, 2, },
+ { "+0", 8, 0, 2, },
+ { "+0", 9, 0, 2, },
+ { "+0", 10, 0, 2, },
+ { "+0", 16, 0, 2, },
+ { "+0", 36, 0, 2, },
+ { "-0", 0, 0, 2, },
+ { "-0", 2, 0, 2, },
+ { "-0", 8, 0, 2, },
+ { "-0", 9, 0, 2, },
+ { "-0", 10, 0, 2, },
+ { "-0", 16, 0, 2, },
+ { "-0", 36, 0, 2, },
+ { "Inf", 0, 0, 0, },
+ { "Inf", 2, 0, 0, },
+ { "Inf", 8, 0, 0, },
+ { "Inf", 9, 0, 0, },
+ { "Inf", 10, 0, 0, },
+ { "Inf", 16, 0, 0, },
+ { "Inf", 36, 24171, 3, },
+ { "+Inf", 0, 0, 0, },
+ { "+Inf", 2, 0, 0, },
+ { "+Inf", 8, 0, 0, },
+ { "+Inf", 9, 0, 0, },
+ { "+Inf", 10, 0, 0, },
+ { "+Inf", 16, 0, 0, },
+ { "+Inf", 36, 24171, 4, },
+ { "-Inf", 0, 0, 0, },
+ { "-Inf", 2, 0, 0, },
+ { "-Inf", 8, 0, 0, },
+ { "-Inf", 9, 0, 0, },
+ { "-Inf", 10, 0, 0, },
+ { "-Inf", 16, 0, 0, },
+ { "-Inf", 36, -24171, 4, },
+ { "inf", 0, 0, 0, },
+ { "inf", 2, 0, 0, },
+ { "inf", 8, 0, 0, },
+ { "inf", 9, 0, 0, },
+ { "inf", 10, 0, 0, },
+ { "inf", 16, 0, 0, },
+ { "inf", 36, 24171, 3, },
+ { "+inf", 0, 0, 0, },
+ { "+inf", 2, 0, 0, },
+ { "+inf", 8, 0, 0, },
+ { "+inf", 9, 0, 0, },
+ { "+inf", 10, 0, 0, },
+ { "+inf", 16, 0, 0, },
+ { "+inf", 36, 24171, 4, },
+ { "-inf", 0, 0, 0, },
+ { "-inf", 2, 0, 0, },
+ { "-inf", 8, 0, 0, },
+ { "-inf", 9, 0, 0, },
+ { "-inf", 10, 0, 0, },
+ { "-inf", 16, 0, 0, },
+ { "-inf", 36, -24171, 4, },
+ { "119b8Z", 0, 119, 3, },
+ { "119bZ", 0, 119, 3, },
+ { "-0119bZ", 0, -9, 4, },
+ { " \t\n 0X119bZ", 0, 4507, 10, },
+ { " \t\n +0X119bZ", 0, 4507, 11, },
+ { " \t\n -0x119bZ", 0, -4507, 11, },
+ { " \t\n 119bZ", 0, 119, 7, },
+ { "+119bZ", 0, 119, 4, },
+ { "+0X119bz", 0, 4507, 7, },
+ { "119b8Z", 2, 3, 2, },
+ { "119bZ", 2, 3, 2, },
+ { "-0119bZ", 2, -3, 4, },
+ { " \t\n 0X119bZ", 2, 0, 5, },
+ { " \t\n +0X119bZ", 2, 0, 6, },
+ { " \t\n -0x119bZ", 2, 0, 6, },
+ { " \t\n 119bZ", 2, 3, 6, },
+ { "+119bZ", 2, 3, 3, },
+ { "+0X119bz", 2, 0, 2, },
+ { "119b8Z", 8, 9, 2, },
+ { "119bZ", 8, 9, 2, },
+ { "-0119bZ", 8, -9, 4, },
+ { " \t\n 0X119bZ", 8, 0, 5, },
+ { " \t\n +0X119bZ", 8, 0, 6, },
+ { " \t\n -0x119bZ", 8, 0, 6, },
+ { " \t\n 119bZ", 8, 9, 6, },
+ { "+119bZ", 8, 9, 3, },
+ { "+0X119bz", 8, 0, 2, },
+ { "119b8Z", 9, 10, 2, },
+ { "119bZ", 9, 10, 2, },
+ { "-0119bZ", 9, -10, 4, },
+ { " \t\n 0X119bZ", 9, 0, 5, },
+ { " \t\n +0X119bZ", 9, 0, 6, },
+ { " \t\n -0x119bZ", 9, 0, 6, },
+ { " \t\n 119bZ", 9, 10, 6, },
+ { "+119bZ", 9, 10, 3, },
+ { "+0X119bz", 9, 0, 2, },
+ { "119b8Z", 10, 119, 3, },
+ { "119bZ", 10, 119, 3, },
+ { "-0119bZ", 10, -119, 5, },
+ { " \t\n 0X119bZ", 10, 0, 5, },
+ { " \t\n +0X119bZ", 10, 0, 6, },
+ { " \t\n -0x119bZ", 10, 0, 6, },
+ { " \t\n 119bZ", 10, 119, 7, },
+ { "+119bZ", 10, 119, 4, },
+ { "+0X119bz", 10, 0, 2, },
+ { "119b8Z", 16, 72120, 5, },
+ { "119bZ", 16, 4507, 4, },
+ { "-0119bZ", 16, -4507, 6, },
+ { " \t\n 0X119bZ", 16, 4507, 10, },
+ { " \t\n +0X119bZ", 16, 4507, 11, },
+ { " \t\n -0x119bZ", 16, -4507, 11, },
+ { " \t\n 119bZ", 16, 4507,8, },
+ { "+119bZ", 16, 4507, 5, },
+ { "+0X119bz", 16, 4507, 7, },
+ { "119b8Z", 36, 62580275, 6, },
+ { "119bZ", 36, 1738367, 5, },
+ { "-0119bZ", 36, -1738367, 7, },
+ { " \t\n 0X119bZ", 36, 1997122175, 11, },
+ { " \t\n +0X119bZ", 36, 1997122175, 12, },
+ { " \t\n -0x119bZ", 36, -1997122175, 12, },
+ { " \t\n 119bZ", 36, 1738367, 9, },
+ { "+119bZ", 36, 1738367, 6, },
+ { "+0X119bz", 36, 1997122175, 8, },
+ /* There should be a much larger battery of such tests. */
+ { "127", 0, 127, 3, },
+ { "-127", 0, -127, 4, },
+ { "128", 0, 128, 3, },
+ { "-128", 0, -127-1, 4, },
+ { "255", 0, 255, 3, },
+ { "-255", 0, -255, 4, },
+ { "256", 0, 256, 3, },
+ { "-256", 0, -255-1, 4, },
+ { "32767", 0, 32767, 5, },
+ { "-32767", 0, -32767, 6, },
+ { "32768", 0, 32768, 5, },
+ { "-32768", 0, -32767-1, 6, },
+ { "65535", 0, 65535, 5, },
+ { "-65535", 0, -65536+1, 6, },
+ { "65536", 0, 65536, 5, },
+ { "-65536", 0, -65536, 6, },
+ { "2147483647", 0, 2147483647, 10, },
+ { "-2147483647", 0, -2147483647, 11, },
+ { "2147483648", 0, 2147483648, 10, },
+ { "-2147483648", 0, -2147483647-1, 11, },
+ { "4294967295", 0, 4294967295, 10, },
+ { "-4294967295", 0, -4294967296+1, 11, },
+ { "4294967296", 0, 4294967296, 10, },
+ { "-4294967296", 0, -4294967296, 11, },
+ { "9223372036854775807", 0, 9223372036854775807, 19, },
+ { "-9223372036854775807", 0, -9223372036854775807, 20, },
+ { "1234567890123456789", 0, 1234567890123456789, 19, },
+ { "-1234567890123456789", 0, -1234567890123456789, 20, },
+ { "1", 0, 1, 1, },
+ { "-1", 0, -1, 2, },
+ { "2", 0, 2, 1, },
+ { "-2", 0, -2, 2, },
+ { "10", 0, 10, 2, },
+ { "-10", 0, -10, 3, },
+ { "16", 0, 16, 2, },
+ { "-16", 0, -16, 3, },
+ /* Other test cases can be added here. */
+ { NULL, 0, 0, 0 }, /* terminates the list */
+ }, *sdp;
+
+ for ( sdp = str_data; sdp->nptr != NULL ; ++sdp )
+ {
+ /*
+ 7.8.2.3 The strtoimax and strtoumax functions
+ */
+
+ strcpy(saved, sdp->nptr);
+
+ errno = 0; /* shouldn't be changed */
+
+ if ( (intmax = strtoimax(sdp->nptr, &endptr, sdp->base))
+ != sdp->exp_val
+ ) {
+ int save = errno;
+
+ printf("*** strtoimax(%s,,%d) failed; should be: %"
+ PRIdMAX", was: %"PRIdMAX" ***\n", sdp->nptr,
+ sdp->base, sdp->exp_val, intmax
+ );
+ status = EXIT_FAILURE;
+ errno = save;
+ }
+ else if ( endptr != sdp->nptr + sdp->exp_len )
+ {
+ int save = errno;
+
+ printf("*** strtoimax(%s,,%d) returned wrong endptr"
+ " ***\n", sdp->nptr, sdp->base
+ );
+ status = EXIT_FAILURE;
+ errno = save;
+ }
+
+ if ( errno != 0 )
+ {
+ printf("*** strtoimax modified errno ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ if ( strcmp(sdp->nptr, saved) != 0 )
+ {
+ printf("*** strtoimax modified its input ***\n");
+ status = EXIT_FAILURE;
+ strcpy(saved, sdp->nptr);
+ }
+
+ if ( sdp->exp_val >= 0 ) /* else some sign extension */
+ {
+ errno = 0; /* shouldn't be changed */
+
+ if ( (uintmax = strtoumax(sdp->nptr, &endptr, sdp->base
+ )
+ ) != sdp->exp_val
+ ) {
+ int save = errno;
+
+ printf("*** strtoumax(%s,,%d) failed; "
+ "should be: %"PRIuMAX", was: %"PRIuMAX
+ " ***\n", sdp->nptr, sdp->base,
+ sdp->exp_val, uintmax
+ );
+ status = EXIT_FAILURE;
+ errno = save;
+ }
+ else if ( endptr != sdp->nptr + sdp->exp_len )
+ {
+ int save = errno;
+
+ printf("*** strtoumax(%s,,%d) returned wrong "
+ "endptr ***\n", sdp->nptr, sdp->base
+ );
+ status = EXIT_FAILURE;
+ errno = save;
+ }
+
+ if ( errno != 0 )
+ {
+ printf("*** strtoumax modified errno ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ if ( strcmp(sdp->nptr, saved) != 0 )
+ {
+ printf("*** strtoumax"
+ " modified its input ***\n"
+ );
+ status = EXIT_FAILURE;
+ strcpy(saved, sdp->nptr);
+ }
+ }
+
+ /* tests for null endptr */
+
+#define WARN() if (!warned) warned = 1, printf("*** Using null endptr: ***\n")
+
+ warned = 0;
+ errno = 0; /* shouldn't be changed */
+
+ if ( (intmax = strtoimax(sdp->nptr, (char **)NULL, sdp->base))
+ != sdp->exp_val
+ ) {
+ int save = errno;
+
+ WARN();
+ printf("*** strtoimax(%s,NULL,%d) failed; "
+ "should be: %"PRIdMAX", was: %"PRIdMAX" ***\n",
+ sdp->nptr, sdp->base, sdp->exp_val, intmax
+ );
+ status = EXIT_FAILURE;
+ errno = save;
+ }
+
+ if ( errno != 0 )
+ {
+ WARN();
+ printf("*** strtoimax modified errno ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ if ( strcmp(sdp->nptr, saved) != 0 )
+ {
+ WARN();
+ printf("*** strtoimax modified its input ***\n");
+ status = EXIT_FAILURE;
+ strcpy(saved, sdp->nptr);
+ }
+
+ if ( sdp->exp_val >= 0 ) /* else some sign extension */
+ {
+ errno = 0; /* shouldn't be changed */
+
+ if ( (uintmax = strtoumax(sdp->nptr, (char **)NULL,
+ sdp->base
+ )
+ ) != sdp->exp_val
+ ) {
+ int save = errno;
+
+ WARN();
+ printf("*** strtoumax(%s,NULL,%d) failed; "
+ "should be: %"PRIuMAX", was: %"PRIuMAX
+ " ***\n", sdp->nptr, sdp->base,
+ sdp->exp_val, uintmax
+ );
+ status = EXIT_FAILURE;
+ errno = save;
+ }
+
+ if ( errno != 0 )
+ {
+ WARN();
+ printf("*** strtoumax modified errno ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ if ( strcmp(sdp->nptr, saved) != 0 )
+ {
+ WARN();
+ printf("*** strtoumax"
+ " modified its input ***\n"
+ );
+ status = EXIT_FAILURE;
+ strcpy(saved, sdp->nptr);
+ }
+ }
+
+ /*
+ 7.8.2.4 The wcstoimax and wcstoumax functions
+ */
+
+ for ( i = 0; i < 64; ++i )
+ if ( (wnptr[i] = sdp->nptr[i]) == '\0' )
+ break;
+
+ errno = 0; /* shouldn't be changed */
+
+ if ( (intmax = wcstoimax(wnptr, &wendptr, sdp->base))
+ != sdp->exp_val
+ ) {
+ int save = errno;
+
+ printf("*** wcstoimax(%s,,%d) failed; should be: %"
+ PRIdMAX", was: %"PRIdMAX" ***\n", sdp->nptr,
+ sdp->base, sdp->exp_val, intmax
+ );
+ status = EXIT_FAILURE;
+ errno = save;
+ }
+ else if ( wendptr != wnptr + sdp->exp_len )
+ {
+ int save = errno;
+
+ printf("*** wcstoimax(%s,,%d) returned wrong endptr"
+ " ***\n", sdp->nptr, sdp->base
+ );
+ status = EXIT_FAILURE;
+ errno = save;
+ }
+
+ if ( errno != 0 )
+ {
+ printf("*** wcstoimax modified errno ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ for ( i = 0; i < 64; ++i )
+ if ( wnptr[i] != sdp->nptr[i] )
+ {
+ printf("*** wcstoimax modified its input ***\n"
+ );
+ status = EXIT_FAILURE;
+
+ for ( ; i < 64; ++i )
+ if ( (wnptr[i] = sdp->nptr[i]) == '\0' )
+ break;
+
+ break;
+ }
+ else if ( wnptr[i] == '\0' )
+ break;
+
+ if ( sdp->exp_val >= 0 ) /* else some sign extension */
+ {
+ errno = 0; /* shouldn't be changed */
+
+ if ( (uintmax = wcstoumax(wnptr, &wendptr, sdp->base)
+ ) != sdp->exp_val
+ ) {
+ int save = errno;
+
+ printf("*** wcstoumax(%s,,%d) failed; "
+ "should be: %"PRIuMAX", was: %"PRIuMAX
+ " ***\n", sdp->nptr, sdp->base,
+ sdp->exp_val, uintmax
+ );
+ status = EXIT_FAILURE;
+ errno = save;
+ }
+ else if ( wendptr != wnptr + sdp->exp_len )
+ {
+ int save = errno;
+
+ printf("*** wcstoumax(%s,,%d) returned wrong "
+ "endptr ***\n", sdp->nptr, sdp->base
+ );
+ status = EXIT_FAILURE;
+ errno = save;
+ }
+
+ if ( errno != 0 )
+ {
+ printf("*** wcstoumax modified errno ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ for ( i = 0; i < 64; ++i )
+ if ( wnptr[i] != sdp->nptr[i] )
+ {
+ printf("*** wcstoumax"
+ " modified its input ***\n"
+ );
+ status = EXIT_FAILURE;
+
+ for ( ; i < 64; ++i )
+ if ( (wnptr[i] = sdp->nptr[i])
+ == '\0'
+ )
+ break;
+
+ break;
+ }
+ else if ( wnptr[i] == '\0' )
+ break;
+ }
+
+ /* tests for null endptr */
+
+ warned = 0;
+ errno = 0; /* shouldn't be changed */
+
+ if ( (intmax = wcstoimax(wnptr, (wchar_t **)NULL, sdp->base))
+ != sdp->exp_val
+ ) {
+ int save = errno;
+
+ WARN();
+ printf("*** wcstoimax(%s,NULL,%d) failed; should be: %"
+ PRIdMAX", was: %"PRIdMAX" ***\n", sdp->nptr,
+ sdp->base, sdp->exp_val, intmax
+ );
+ status = EXIT_FAILURE;
+ errno = save;
+ }
+
+ if ( errno != 0 )
+ {
+ WARN();
+ printf("*** wcstoimax modified errno ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ for ( i = 0; i < 64; ++i )
+ if ( wnptr[i] != sdp->nptr[i] )
+ {
+ WARN();
+ printf("*** wcstoimax modified its input ***\n"
+ );
+ status = EXIT_FAILURE;
+
+ for ( ; i < 64; ++i )
+ if ( (wnptr[i] = sdp->nptr[i])
+ == '\0'
+ )
+ break;
+
+ break;
+ }
+ else if ( wnptr[i] == '\0' )
+ break;
+
+ if ( sdp->exp_val >= 0 ) /* else some sign extension */
+ {
+ errno = 0; /* shouldn't be changed */
+
+ if ( (uintmax = wcstoumax(wnptr, (wchar_t **)NULL,
+ sdp->base
+ )
+ ) != sdp->exp_val
+ ) {
+ int save = errno;
+
+ WARN();
+ printf("*** wcstoumax(%s,NULL,%d) failed; "
+ "should be: %"PRIuMAX", was: %"PRIuMAX
+ " ***\n", sdp->nptr, sdp->base,
+ sdp->exp_val, uintmax
+ );
+ status = EXIT_FAILURE;
+ errno = save;
+ }
+
+ if ( errno != 0 )
+ {
+ WARN();
+ printf("*** wcstoumax modified errno ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ for ( i = 0; i < 64; ++i )
+ if ( wnptr[i] != sdp->nptr[i] )
+ {
+ WARN();
+ printf("*** wcstoumax"
+ " modified its input ***\n"
+ );
+ status = EXIT_FAILURE;
+
+ for ( ; i < 64; ++i )
+ if ( (wnptr[i] = sdp->nptr[i])
+ == '\0'
+ )
+ break;
+
+ break;
+ }
+ else if ( wnptr[i] == '\0' )
+ break;
+ }
+ }
+
+ /*
+ 7.8.2.3 The strtoimax and strtoumax functions (continued)
+ */
+
+ if ( (intmax = strtoimax("1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890",
+ &endptr, 0
+ )
+ ) != INTMAX_MAX || errno != ERANGE
+ ) {
+ printf("*** strtoimax failed overflow test ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ if ( (intmax = strtoimax("+1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890",
+ &endptr, 0
+ )
+ ) != INTMAX_MAX || errno != ERANGE
+ ) {
+ printf("*** strtoimax failed +overflow test ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ if ( (intmax = strtoimax("-1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890",
+ &endptr, 0
+ )
+ ) != INTMAX_MIN || errno != ERANGE
+ ) {
+ printf("*** strtoimax failed -overflow test ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ if ( (uintmax = strtoumax("1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890",
+ &endptr, 0
+ )
+ ) != UINTMAX_MAX || errno != ERANGE
+ ) {
+ printf("*** strtoumax failed overflow test ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ if ( (uintmax = strtoumax("+1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890",
+ &endptr, 0
+ )
+ ) != UINTMAX_MAX || errno != ERANGE
+ ) {
+ printf("*** strtoumax failed +overflow test ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ if ( (uintmax = strtoumax("-1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890",
+ &endptr, 0
+ )
+ ) != UINTMAX_MAX || errno != ERANGE
+ ) {
+ printf("*** strtoumax failed -overflow test ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ /*
+ 7.8.2.4 The wcstoimax and wcstoumax functions (continued)
+ */
+
+#ifdef NO_INTERNAL_WCHAR
+ printf("NO_INTERNAL_WCHAR\n");
+#else
+
+ if ( (intmax = wcstoimax(L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890",
+ &wendptr, 0
+ )
+ ) != INTMAX_MAX || errno != ERANGE
+ ) {
+ printf("*** wcstoimax failed overflow test ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ if ( (intmax = wcstoimax(L"+1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890",
+ &wendptr, 0
+ )
+ ) != INTMAX_MAX || errno != ERANGE
+ ) {
+ printf("*** wcstoimax failed +overflow test ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ if ( (intmax = wcstoimax(L"-1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890",
+ &wendptr, 0
+ )
+ ) != INTMAX_MIN || errno != ERANGE
+ ) {
+ printf("*** wcstoimax failed -overflow test ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ if ( (uintmax = wcstoumax(L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890",
+ &wendptr, 0
+ )
+ ) != UINTMAX_MAX || errno != ERANGE
+ ) {
+ printf("*** wcstoumax failed overflow test ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ if ( (uintmax = wcstoumax(L"+1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890",
+ &wendptr, 0
+ )
+ ) != UINTMAX_MAX || errno != ERANGE
+ ) {
+ printf("*** wcstoumax failed +overflow test ***\n");
+ status = EXIT_FAILURE;
+ }
+
+ if ( (uintmax = wcstoumax(L"-1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890"
+ L"1234567890123456789012345678901234567890",
+ &wendptr, 0
+ )
+ ) != UINTMAX_MAX || errno != ERANGE
+ ) {
+ printf("*** wcstoumax failed -overflow test ***\n");
+ status = EXIT_FAILURE;
+ }
+#endif // NO_INTERNAL_WCHAR
+ }
+#endif /* defined(INTMAX_MAX) */
+
+ if ( status != 0 )
+ printf("sitest failed.\n");
+
+ return status;
+}
+
+#endif
\ No newline at end of file
--- /dev/null
+This directory contains test code for automatic regression testing of the CC65
+compiler.
+
+
+/val - the bulk of tests are contained here, individual tests should exit with
+ an exit code of EXIT_SUCCESS when they pass, or EXIT_FAILURE on error
+
+/ref - these tests produce output that must be compared with reference output
+
+/err - contains tests that MUST NOT compile
+
+/misc - a few tests that need special care of some sort
+
+
+to run the tests use "make" in this (top) directory, the makefile should exit
+with no error.
+
+when a test failed you can use "make continue" to run further tests
+
+--------------------------------------------------------------------------------
+
+TODO:
+
+- reduce usage of "common.h" to a minimum
+- convert more tests from using reference output to returning an exit code
--- /dev/null
+/*
+ !!DESCRIPTION!! solves the "8 queens" chess problem
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include <stdio.h>
+
+int up[15], down[15], rows[8], x[8];
+void queens(int c);
+void print(void);
+
+int main(void)
+{
+ int i;
+ for (i = 0; i < 15; i++)
+ up[i] = down[i] = 1;
+ for (i = 0; i < 8; i++)
+ rows[i] = 1;
+ queens(0);
+ return 0;
+}
+
+void queens(int c)
+{
+ int r;
+
+ for (r = 0; r < 8; r++)
+ if (rows[r] && up[r-c+7] && down[r+c]) {
+ rows[r] = up[r-c+7] = down[r+c] = 0;
+ x[c] = r;
+ if (c == 7)
+ print();
+ else
+ queens(c + 1);
+ rows[r] = up[r-c+7] = down[r+c] = 1;
+ }
+}
+
+void print(void)
+{
+ int k;
+
+ for (k = 0; k < 8; k++) {
+ printf("%c", x[k]+'1');
+ if(k<7) printf(" ");
+ }
+ printf("\n");
+}
--- /dev/null
+
+# makefile for the regression tests that generate output which has to be
+# compared with reference output
+
+ifneq ($(shell echo),)
+ CMD_EXE := 1
+endif
+
+CC65FLAGS := -t sim6502
+SIM65FLAGS := -x 200000000
+
+CL65 := $(if $(wildcard ../../bin/cl65*),../../bin/cl65,cl65)
+SIM65 := $(if $(wildcard ../../bin/sim65*),../../bin/sim65,sim65)
+
+ifdef CMD_EXE
+RM := del /f
+else
+RM := rm -f
+endif
+
+WORKDIR := ../../testwrk
+
+DIFF := $(WORKDIR)/bdiff
+
+CFLAGS := -O2 -Wall -W -Wextra -fwrapv -fno-strict-overflow
+
+.PHONY: all clean
+
+SOURCES := $(wildcard *.c)
+REFS := $(SOURCES:%.c=$(WORKDIR)/%.ref)
+TESTS := $(foreach option,. .o. .os. .osi. .osir. .oi. .oir. .or.,$(SOURCES:%.c=$(WORKDIR)/%$(option)prg))
+
+all: $(REFS) $(TESTS)
+
+$(WORKDIR)/%.ref: %.c
+ $(CC) $(CFLAGS) $< -o $(WORKDIR)/$*.host
+ $(WORKDIR)/$*.host > $@
+
+$(WORKDIR)/%.prg: %.c $(WORKDIR)/%.ref
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
+ $(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
+
+$(WORKDIR)/%.o.prg: %.c $(WORKDIR)/%.ref
+ $(CL65) -O $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
+ $(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
+
+$(WORKDIR)/%.os.prg: %.c $(WORKDIR)/%.ref
+ $(CL65) -Os $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
+ $(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
+
+$(WORKDIR)/%.osi.prg: %.c $(WORKDIR)/%.ref
+ $(CL65) -Osi $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
+ $(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
+
+$(WORKDIR)/%.osir.prg: %.c $(WORKDIR)/%.ref
+ $(CL65) -Osir $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
+ $(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
+
+$(WORKDIR)/%.oi.prg: %.c $(WORKDIR)/%.ref
+ $(CL65) -Oi $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
+ $(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
+
+$(WORKDIR)/%.oir.prg: %.c $(WORKDIR)/%.ref
+ $(CL65) -Oir $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
+ $(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
+
+$(WORKDIR)/%.or.prg: %.c $(WORKDIR)/%.ref
+ $(CL65) -Or $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@ > $(WORKDIR)/$*.out
+ $(DIFF) $(WORKDIR)/$*.out $(WORKDIR)/$*.ref
+
+clean:
+ @$(RM) $(TESTS)
+ @$(RM) $(SOURCES:.c=.o)
+ @$(RM) $(SOURCES:%.c=$(WORKDIR)/%.out)
+ @$(RM) $(SOURCES:%.c=$(WORKDIR)/%.ref)
+ @$(RM) $(SOURCES:%.c=$(WORKDIR)/%.host)
--- /dev/null
+/*
+ !!DESCRIPTION!! basic array properties
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include <stdio.h>
+
+#ifndef NO_NEW_PROTOTYPES_FOR_OLD_FUNC_DECL
+int f(void);
+int g(int x[][4],int *y[]);
+#endif
+
+int x[3][4], *y[3];
+
+main() {
+ int z[3][4];
+ int i, j, *p;
+
+ for (i = 0; i < 3; i++) {
+ for (j = 0; j < 4; j++)
+ x[i][j] = 1000*i + j;
+ y[i] = x[i];
+ }
+ f();
+ for (i = 0; i < 3; i++) {
+ y[i] = p = &z[i][0];
+ for (j = 0; j < 4; j++)
+ p[j] = x[i][j];
+ }
+ g(z, y);
+
+ return 0;
+}
+
+f() {
+ int i, j;
+
+ for (i = 0; i < 3; i++)
+ for (j = 0; j < 4; j++)
+ printf(" %d", x[i][j]);
+ printf("\n");
+ for (i = 0; i < 3; i++)
+ for (j = 0; j < 4; j++)
+ printf(" %d", y[i][j]);
+ printf("\n");
+}
+
+g(x, y)
+int x[][4], *y[];
+{
+ int i, j;
+
+ for (i = 0; i < 3; i++)
+ for (j = 0; j < 4; j++)
+ printf(" %d", x[i][j]);
+ printf("\n");
+ for (i = 0; i < 3; i++)
+ for (j = 0; j < 4; j++)
+ printf(" %d", y[i][j]);
+ printf("\n");
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!!
+*/
+
+#include <stdio.h>
+
+typedef signed int TypA[3];
+typedef struct TypB {
+ TypA Data[2];
+} sTypB;
+sTypB Bs[10];
+TypA * APtr;
+
+int main(int argc, char* argv[])
+{
+ Bs[7].Data[1][2]=11;
+ APtr=&(Bs[7].Data[1]);
+ printf("Hallo Welt! %i = %i \n",Bs[7].Data[1][2], (*APtr)[2] );
+ return 0;
+}
+
+/*
+....gives
+test.c(20): Error: Incompatible pointer types
+for APtr=&(Bs[7].Data[1]);
+
+My experience in C is very limited, but as this works both in MSVC and
+the 8 bit Z80 compiler i originally used, i guess its an bug in CC65.
+
+As a workaround, an typecast via APtr=(TypA*)&(Bs[7].Data[1]);
+seems to work.
+
+greetings,
+ Andreas
+*/
\ No newline at end of file
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!!
+*/
+
+#include <stdio.h>
+
+long a; /* must be static life */
+long b; /* must be static life */
+
+int main(void)
+{
+ a = 0x00112200; /* must be immediate pattern is (1stBYTE == 4thBYTE) */
+ b = a;
+ /* b is 0x11112200 ! */
+
+ printf("b (should be 0x00112200): %08lx\n",b);
+
+ return 0;
+}
+
+/*
+[ command line ]
+ cl65 -c -T -l -O test.c
+
+[ part of test.lst ]
+ 000012r 1 ; b = a;
+ 000012r 1 AD rr rr lda _a+2
+ 000015r 1 85 rr sta sreg
+ 000017r 1 AE rr rr ldx _a+1
+ 00001Ar 1 AD rr rr lda _a
+ 00001Dr 1 8D rr rr sta _b
+ 000020r 1 8E rr rr stx _b+1
+ 000023r 1 A4 rr ldy sreg
+ 000025r 1 8C rr rr sty _b+2
+ 000028r 1 8C rr rr sty _b+3 ; lost 4th BYTE !
+*/
\ No newline at end of file
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!!
+*/
+
+/*
+The following code produces an 'Error: Incompatible pointer types' at
+the last line when compiling with snapshot-2.11.9.20080316 without
+optimizations. If I remove the struct inside f() it compiles fine ?!?
+
+Best, Oliver
+*/
+
+#include <stdio.h>
+
+void f(void){struct{int i;}d;}
+struct{void(*p)(void);}s={f};
+
+int main(void)
+{
+ printf("it works :)\n");
+
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!!
+*/
+
+#include <stdio.h>
+
+/*
+cc65 doesn't compile this, if i use the "-O"-option.
+but it works with "while(!0)"; instead of "for(;;);"
+
+i'm using cl65 V2.12.9 win
+
+----
+#include <stdint.h>
+
+int main(void)
+{
+ static uint8_t x = 0;
+ static uint8_t y = 0;
+
+ for (x = 0; x < 16; ++x)
+ {
+ y = y + 1;
+ }
+ for(;;);
+}
+*/
+
+#include <stdint.h>
+
+int test(void)
+{
+ static uint8_t x = 0;
+ static uint8_t y = 0;
+
+ for (x = 0; x < 16; ++x)
+ {
+ y = y + 1;
+ }
+ for(;;);
+}
+
+int main(void)
+{
+ printf("it works :)\n");
+
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!!
+*/
+
+#include <stdio.h>
+
+/*
+there is a bug in the preprocessor (i think) ... the following works
+(compiles) correctly:
+
+unsigned long fs,fd,a;
+
+unsigned long _func(unsigned long x,unsigned long y)
+{
+ return 0;
+}
+
+int main(void)
+{
+ fs=(_func((fd/a),(_func(2,0x0082c90f))));
+}
+
+now if i wrap _func into a macro like this:
+
+#define func(x,y) _func(x,y)
+
+int main(void)
+{
+ fs=(func((fd/a),(func(2,0x0082c90f))));
+}
+
+i get "Error: `)' expected" on that line. (this is with the snapshot, freshly
+compiled 5 minutes ago)
+*/
+
+unsigned long fs,fd,a;
+
+unsigned long _func1(unsigned long x,unsigned long y)
+{
+ return 0;
+}
+
+int test1(void)
+{
+ fs=(_func1((fd/a),(_func1(2,0x0082c90f))));
+}
+
+#define func(x,y) _func1(x,y)
+
+int test2(void)
+{
+ fs=(func((fd/a),(func(2,0x0082c90f))));
+}
+
+int main(void)
+{
+ printf("it works :)\n");
+
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!!
+*/
+
+#include "common.h"
+
+struct Record {
+ struct Record *PtrComp;
+ int x;
+};
+
+typedef struct Record RecordType;
+typedef RecordType *RecordPtr;
+
+void Proc3(RecordPtr *PtrParOut)
+{
+ /* whatever */
+}
+
+void Proc1(RecordPtr PtrParIn)
+{
+#define NextRecord (*(PtrParIn->PtrComp))
+ Proc3((RecordPtr *)NextRecord.PtrComp);
+ Proc3(&NextRecord.PtrComp);
+ Proc3(&PtrParIn->PtrComp->PtrComp);
+
+#ifdef CAST_STRUCT_PTR
+ Proc3((RecordPtr *) PtrParIn->PtrComp->PtrComp);
+ Proc3((RecordPtr *) (*(PtrParIn->PtrComp)).PtrComp);
+ Proc3((RecordPtr *) NextRecord.PtrComp);
+#else
+ Proc3(PtrParIn->PtrComp->PtrComp);
+ Proc3((*(PtrParIn->PtrComp)).PtrComp);
+ Proc3(NextRecord.PtrComp);
+#endif
+
+#undef NextRecord
+}
+
+int main(void)
+{
+ printf("it works :)\n");
+
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! optimizer bug
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!! Oliver Schmidt
+*/
+
+#include <stdio.h>
+
+/*
+After spending a "little" time I finally succeeded in isolating an
+(maybe THE) optimizer bug causing Contiki to fail.
+
+From my user perspective it is very interesting that the bug shows up
+with compiler option -O but does _not_ show up with -Oi.
+*/
+
+unsigned htons(unsigned val)
+{
+ return (((unsigned) (val)) << 8) | (((unsigned) (val)) >> 8);
+}
+
+int main(void)
+{
+ printf("%x -> %x\n", 0x1234, htons(0x1234) & 0xffff);
+
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! optimizer bug
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!! Oliver Schmidt
+*/
+
+/*
+> I found the problem and fixed it. cc65 treated a label as a statement, but
+> the standard says, that a label is part of a statement. In a loop without
+> curly braces like
+>
+> while (foo < bar)
+> label: ++foo;
+>
+> the following statement is the one that is looped over - and because cc65
+> treated just the label as a statement, it created code that looped forever.
+
+*/
+
+#include <stdio.h>
+
+int foo=0,bar=2;
+
+int main(void)
+{
+ while(foo<bar)
+ label: ++foo;
+
+ printf("foo: %d bar: %d\n",foo,bar);
+
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!! Johan Kotlinski
+*/
+
+#include <stdio.h>
+
+/*
+This produces the compiler error "test.c(9): Error: Assignment to const"
+Shouldn't be an error, should it? baz is const, bar isn't.
+*/
+
+typedef struct {
+ char foo;
+} Bar;
+
+int main() {
+ Bar bar;
+ Bar* const baz = &bar;
+
+ baz->foo = 1;
+
+ printf("it works :)\n");
+
+ return 0;
+}
+
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!! Johan Kotlinski
+*/
+
+#include <stdio.h>
+
+/*
+...gives "test.c(2): Error: Variable `foo' has unknown size" using -Cl.
+Is it really unknown?
+
+cc65 V2.13.0, SVN version: 4384
+*/
+
+int main() {
+ char foo[] = { 0 };
+ printf("it works :)\n");
+
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!! Marc 'BlackJack' Rintsch
+*/
+
+/*
+Compiler is build from cc65-snapshot-2.13.9.20101031 sources.
+
+Expected results and also what I get from this without any optimisations
+are: 48663 and 49218
+
+When I turn on ``-O``: 58096 and 58096. After swapping the two variable
+declaration lines in `calculate_checksum()` the results are correct
+with ``-O``.
+
+But with ``--O --static-locals`` the results are incorrect again (31757
+and 15408). ``--static-locals`` alone works though.
+*/
+
+#include <stdio.h>
+#include <stdint.h>
+
+// uint16_t __fastcall__ calculate_checksum(uint8_t *block);
+uint8_t block[256];
+
+uint16_t calculate_checksum(uint8_t *block)
+{
+ uint16_t i, result = 0xffff;
+ uint8_t j;
+
+ for (i = 0; i < 256; ++i) {
+ result ^= block[i] << 8;
+ for (j = 0; j < 8; ++j) {
+ if (result & (1 << 15)) {
+ result = (result << 1) ^ 0x1021;
+ } else {
+ result <<= 1;
+ }
+ }
+ }
+ return ~result;
+}
+
+int main(void)
+{
+ uint16_t i;
+
+ printf("zeroes: %u\n", calculate_checksum(block));
+ for (i = 0; i < 256; ++i) block[i] = i;
+ printf("0..255: %u\n", calculate_checksum(block));
+
+ return 0;
+}
+
--- /dev/null
+/*
+ !!DESCRIPTION!! mod operator bug
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!! marcas
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(void) {
+ int tmp;
+
+ for (tmp = 0; tmp<=12345; tmp++)
+ if (!(tmp%1000)) printf("%d mod 1000 is %d\n", tmp, tmp%1000);
+
+ return 0;
+}
+
+/*
+results in (vice x64)
+0 mod 1000 is 0
+232 mod 1000 is 0
+1000 mod 1000 is 0
+
+Interesting:
+
+ 1000 = $3E8
+ 232 = $E8
+
+So testing with 999 gives:
+
+0 mod 999 is 0
+231 mod 999 is 0
+999 mod 999 is 0
+
+This seems to be systematic.
+*/
\ No newline at end of file
--- /dev/null
+/*
+ !!DESCRIPTION!! division bug
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!! Stefan Wessels
+*/
+
+/*
+The output from the code below is:
+a / b = 6
+
+Shouldn't that be 0?
+*/
+
+#include <stdio.h>
+#define b 10000
+char a;
+int main()
+{
+ char c;
+
+ a = 100;
+ c = a / b;
+ printf("a / b = %d", c);
+
+ return 0;
+}
\ No newline at end of file
--- /dev/null
+/*
+ !!DESCRIPTION!! linker bug
+ !!ORIGIN!! testsuite
+ !!LICENCE!! public domain
+*/
+
+/*
+with SVN version: 4973M
+
+$ cl65 -v -o test.prg tests/cc65110210.c
+Opened include file `/usr/local/lib/cc65/include/stdio.h'
+Opened include file `/usr/local/lib/cc65/include/stddef.h'
+Opened include file `/usr/local/lib/cc65/include/stdarg.h'
+Opened include file `/usr/local/lib/cc65/include/limits.h'
+0 errors, 0 warnings
+Opened output file `tests/cc65110210.s'
+Wrote output to `tests/cc65110210.s'
+Closed output file `tests/cc65110210.s'
+cl65: Subprocess `ld65' aborted by signal 11
+
+*/
+
+/* #define STANDALONE */
+
+#include <stdio.h>
+#include <limits.h>
+
+#ifdef STANDALONE
+
+#define NO_IMPLICIT_FUNCPTR_CONV
+
+#define OPENTEST()
+#define CLOSETEST()
+
+#else
+
+#endif
+
+#ifdef NO_IMPLICIT_FUNCPTR_CONV
+void (*p1func)(void);
+#else
+void (*p1func)();
+#endif
+
+void func(void)
+{
+ (*p1func)();
+}
+
+int main(void)
+{
+ printf("it works :)\n");
+
+ return (0);
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! unreachable code related bug
+ !!ORIGIN!! Testsuite
+ !!LICENCE!! Public Domain
+*/
+
+/*
+ test2 and test3 will result in an endless loop (SVN version: 4974M)
+*/
+
+#include <stdio.h>
+
+#define OPENTEST()
+#define CLOSETEST()
+
+static char upper[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+int test1(void)
+{
+ int res;
+ unsigned char *p;
+
+ p = upper;
+ res = 0;
+
+ while(*p) {
+ if(*p < 0) {
+ res = 1;
+ }
+ p++;
+ }
+
+ printf("test1:ok\n");
+ return res;
+}
+
+int test2(void)
+{
+ int res;
+ unsigned char *p;
+
+ p = upper;
+ res = 0;
+
+ while(*p) {
+ if(*p++ < 0) {
+ res = 1;
+ }
+ }
+
+ printf("test2:ok\n");
+ return res;
+}
+
+int test3(void)
+{
+ int res;
+ unsigned char *p;
+
+ p = upper;
+ res = 0;
+
+ while(*p) {
+ if(*++p < 0) {
+ res = 1;
+ }
+ }
+
+ printf("test3:ok\n");
+ return res;
+}
+
+int main(int n,char **args)
+{
+ test1();
+ test2();
+ test3();
+
+ printf("it works :)\n");
+
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! print character frequencies
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+/*
+ cf - print character frequencies
+*/
+
+#include "common.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+
+FILE *in;
+
+#define INFILE "cf.in"
+#define GETCHAR() fgetc(in)
+
+#ifndef NO_FLOATS
+float f[0x100];
+#else
+signed f[0x100];
+#endif
+
+#ifdef NO_OLD_FUNC_DECL
+int main(int argc,char **argv)
+#else
+main(argc, argv)
+int argc;
+char *argv[];
+#endif
+{
+ int i, c, nc;
+#ifndef NO_FLOATS
+ float cutoff, atof();
+#else
+ signed cutoff;
+#endif
+
+ in = fopen(INFILE, "rb");
+ if (in == NULL) {
+ return EXIT_FAILURE;
+ }
+
+ if (argc <= 1)
+#ifndef NO_FLOATS
+ cutoff = 0.0;
+#else
+ cutoff = 0;
+#endif
+ else
+#ifndef NO_FLOATS
+ cutoff = atof(argv[1])/100;
+#else
+ cutoff = atoi(argv[1])/100;
+#endif
+ for (i = 0; i < 0x100; )
+ {
+#ifndef NO_FLOATS
+ f[i++] = 0.0;
+#else
+ f[i++] = 0;
+#endif
+ }
+
+ printf("input:\n\n");
+
+ nc = 0;
+ while ((c = GETCHAR()) != -1)
+ {
+/* printf("[%02x]",c); */
+ printf("%c",c);
+ f[c] += 1;
+ nc++;
+ }
+ printf("\n\ncount: %d\n\n",nc);
+
+ /*
+ now try to print a report in a way so that
+ the order is somewhat independent from the
+ target character set
+ */
+
+ printf("a-z char:freq\n\n");
+
+ /* first round ... lowercase characters */
+ for (i = 0; i < 0x100; ++i)
+ {
+ if ((f[i]) && ((f[i]/nc) >= cutoff))
+ {
+ if ((i >= 'a') && (i <= 'z'))
+ {
+ printf("%c", i);
+#ifndef NO_FLOATS
+ printf(":%.1f\n", 100*f[i]/nc);
+#else
+ printf(":%d\n", 100*f[i]/nc);
+#endif
+ f[i]=0;
+ }
+ }
+ }
+
+ printf("A-Z char:freq\n\n");
+
+ /* second round ... uppercase characters */
+ for (i = 0; i < 0x100; ++i)
+ {
+ if ((f[i]) && ((f[i]/nc) >= cutoff))
+ {
+ if ((i >= 'A') && (i <= 'Z'))
+ {
+ printf("%c", i);
+#ifndef NO_FLOATS
+ printf(":%.1f\n", 100*f[i]/nc);
+#else
+ printf(":%d\n", 100*f[i]/nc);
+#endif
+ f[i]=0;
+ }
+ }
+ }
+
+ printf("0-9 char:freq\n\n");
+
+ /* third round ... numbers */
+ for (i = 0; i < 0x100; ++i)
+ {
+ if ((f[i]) && ((f[i]/nc) >= cutoff))
+ {
+ if ((i >= '0') && (i <= '9'))
+ {
+ printf("%c", i);
+#ifndef NO_FLOATS
+ printf(":%.1f\n", 100*f[i]/nc);
+#else
+ printf(":%d\n", 100*f[i]/nc);
+#endif
+ f[i]=0;
+ }
+ }
+ }
+
+ printf("isprint char:freq\n\n");
+
+ /* second last round ... remaining printable characters */
+ for (i = 0; i < 0x100; ++i)
+ {
+ if ((f[i]) && ((f[i]/nc) >= cutoff))
+ {
+ if(isprint(i))
+ {
+ printf("%c", i);
+#ifndef NO_FLOATS
+ printf(":%.1f\n", 100*f[i]/nc);
+#else
+ printf(":%d\n", 100*f[i]/nc);
+#endif
+ f[i]=0;
+ }
+ }
+ }
+
+ printf("rest char:freq\n\n");
+
+ /* last round ... remaining non printable characters */
+ for (i = 0; i < 0x100; ++i)
+ {
+ if ((f[i]) && ((f[i]/nc) >= cutoff))
+ {
+ if(i=='\n')
+ {
+ printf("newline");
+ }
+ else
+ {
+ printf("%03o", i);
+ }
+#ifndef NO_FLOATS
+ printf(":%.1f\n", 100*f[i]/nc);
+#else
+ printf(":%d\n", 100*f[i]/nc);
+#endif
+ }
+ }
+ fclose(in);
+ return 0;
+}
--- /dev/null
+start cf.input >
+The sky above the port was the color of television, tuned
+to a dead channel.
+"It's not like I'm using," Case heard someone say, as he
+shouldered his way through the crowd around the door of the
+Chat. "It's like my body's developed this massive drug deficiency."
+It was a Sprawl voice and a Sprawl joke. The Chatsubo
+was a bar for professional expatriates; you could drink there
+for a week and never hear two words in Japanese.
+Ratz was tending bar, his prosthetic arm jerking monotonously
+as he filled a tray of glasses with draft Kirin. He saw
+Case and smiled, his teeth a web work of East European steel
+and brown decay. Case found a place at the bar, between the
+unlikely tan on one of Lonny Zone's whores and the crisp naval
+uniform of a tall African whose cheekbones were ridged with
+Joe boys," Ratz said, shoving a draft across the bar with his
+good hand. "Maybe some business with you, Case?"
+Case shrugged. The girl to his right giggled and nudged
+< end cf.input
--- /dev/null
+/*
+ !!DESCRIPTION!! check if character constants are translated correctly
+ !!ORIGIN!! cc65 bug report
+ !!LICENCE!! Public Domain
+*/
+
+#include "common.h"
+#include <limits.h>
+#include <ctype.h>
+
+void backslash(unsigned char c)
+{
+ printf("%c : ",c);
+
+ switch (c)
+ {
+ case 'b':
+ c = '\b';
+ case 'f':
+ c = '\f';
+ case 'n':
+ c = '\n';
+ case 'r':
+ c = '\r';
+ case 't':
+ c = '\t';
+ case 'v':
+ #ifndef NO_BACKSLASH_V
+ c = '\v';
+ #else
+ c = 0x0b;
+ #endif
+ }
+
+ if(!isprint(c))
+ {
+ printf("ok.\n");
+ }
+ else
+ {
+ printf("failed.\n");
+ }
+}
+
+void testbackslash(void)
+{
+ backslash('b');
+ backslash('f');
+ backslash('n');
+ backslash('r');
+ backslash('t');
+ backslash('v');
+}
+
+int main(void)
+{
+ testbackslash();
+
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! basic ASCII character test
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!! Groepaz/Hitmen
+*/
+
+#include <stdio.h>
+
+#if 0
+
+/* this kind of line-continuation for strings doesnt work properly for cc65 */
+
+const unsigned char characters[]={
+ /*0123456789abcdef0123456789abcdef*/
+ /* iso646-us control-characters */
+ " " /* 00-1f */
+ /* iso646-us printable characters */
+ " !\"#$%&'()*+,-./" /* 20-2f !"#$%&'()*+,-./ */
+ "0123456789" /* 30-39 0123456789 */
+ ":;<=>?@" /* 3a-40 :;<=>?@ */
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ" /* 41-5a A-Z */
+ "[\\]^_`" /* 5b-60 [\]^_` */
+ "abcdefghijklmnopqrstuvwxyz" /* 61-7a a-z */
+ "{|}~ " /* 7b-7f {|}~ */
+ /* iso8859-15 extended characters */
+};
+
+#endif
+
+const unsigned char characters[]={
+ /*0123456789abcdef0123456789abcdef*/
+ /* iso646-us control-characters */
+ /* 00-1f */
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ /* iso646-us printable characters */
+ /* 20-2f !"#$%&'()*+,-./ */
+ ' ','!','"','#','$','%','&','\'','(',')','*','+',',','-','.','/',
+ /* 30-39 0123456789 */
+ '0','1','2','3','4','5','6','7','8','9',
+ /* 3a-40 :;<=>?@ */
+ ':',';','<','=','>','?','@',
+ /* 41-5a A-Z */
+ 'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
+ /* 5b-60 [\]^_` */
+ '[','\\',']','^','_','`',
+ /* 61-7a a-z */
+ 'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',
+ /* 7b-7f {|}~ */
+ '{','|','}','~',' '
+ /* iso8859-15 extended characters */
+};
+
+void printchars(unsigned char a,unsigned char b){
+ for(b++;a!=b;a++)
+/* printf("%02x ",a); */
+/* printf("%02x ",characters[a]); */
+ printf("%c",characters[a]);
+ printf("\n");
+}
+
+int main(void) {
+ printf("characters:\n\n");
+ printchars(0x61,0x7a);
+ printchars(0x41,0x5a);
+ printf("numbers:\n\n");
+ printchars(0x30,0x39);
+ printf("other:\n\n");
+ printchars(0x20,0x2f);
+ /*printchars(0x3a,0x40);*/
+ printchars(0x3a,0x3f);
+ /*printchars(0x5b,0x60);*/
+ /*printchars(0x7b,0x7f);*/
+ printf("\n\n");
+ printf("slash: '%c'\n",'/');
+ printf("backslash: '%c'\n",'\\');
+ printf("curly braces open: '%c'\n",'{');
+ printf("curly braces close: '%c'\n",'}');
+ printf("square braces open: '%c'\n",'[');
+ printf("square braces close: '%c'\n",']');
+ printf("underscore: '%c'\n",'_');
+ printf("tilde: '%c'\n",'~');
+ printf("pipe: '%c'\n",'|');
+ printf("apostroph: '%c'\n",'\'');
+ printf("single quote '%c'\n",'`');
+ printf("xor '%c'\n",'^');
+ printf("at '%c'\n",'@');
+
+ return 0;
+}
--- /dev/null
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define NO_OLD_FUNC_DECL
+#define NO_TYPELESS_INT
+#define NO_TYPELESS_INT_PTR
+#define MAIN_RETURNS_INT
+#define NO_IMPLICIT_FUNC_PROTOTYPES
+#define NO_FLOATS
+#define NO_WCHAR
+#define NO_EMPTY_FUNC_ARGS
+#define NO_SLOPPY_STRUCT_INIT
+#define NO_FUNCS_TAKE_STRUCTS
+#define NO_FUNCS_RETURN_STRUCTS
+#define CAST_STRUCT_PTR
+#define NO_TYPELESS_STRUCT_PTR
+#define NO_IMPLICIT_FUNCPTR_CONV
+#define SIZEOF_INT_16BIT
+#define SIZEOF_LONG_32BIT
+#define UNSIGNED_CHARS
+#define UNSIGNED_BITFIELDS
--- /dev/null
+/*
+ !!DESCRIPTION!! type conversion
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+#include <stdio.h>
+
+signed char c;
+signed short s;
+signed int i;
+signed long int l;
+unsigned char C;
+unsigned short S;
+unsigned int I;
+unsigned long int L;
+
+#ifdef NO_FLOATS
+signed long f;
+signed long d;
+signed long D;
+#else
+float f;
+double d;
+long double D;
+#endif
+
+void *p;
+void (*P)(void);
+
+void print(void) {
+ #ifdef NO_FLOATS
+ printf("%d %d %d %ld %u %u %u %lu %ld.000000 %ld.000000 %ld.000000\n",c,s,i,l,C,S,I,L,f,d,D);
+ #else
+ printf("%d %d %d %ld %u %u %u %lu %f %f %lf \n",c,s,i,l,C,S,I,L,f,d,D );
+ #endif
+}
+
+main() {
+ c= 1; s=c;i=c;l=c;C=c;S=c;I=c;L=c; f=c;d=c;D=c; print();
+ s= 2; c=s; i=s;l=s;C=s;S=s;I=s;L=s; f=s;d=s;D=s; print();
+ i= 3; c=i;s=i; l=i;C=i;S=i;I=i;L=i; f=i;d=i;D=i; print();
+ l= 4; c=l;s=l;i=l; C=l;S=l;I=l;L=l; f=l;d=l;D=l; print();
+ C= 5; c=C;s=C;i=C;l=C; S=C;I=C;L=C; f=C;d=C;D=C; print();
+ S= 6; c=S;s=S;i=S;l=S;C=S; I=S;L=S; f=S;d=S;D=S; print();
+ I= 7; c=I;s=I;i=I;l=I;C=I;S=I; L=I; f=I;d=I;D=I; print();
+ L= 8; c=L;s=L;i=L;l=L;C=L;S=L;I=S; f=L;d=L;D=L; print();
+ f= 9; c=f;s=f;i=f;l=f;C=f;S=f;I=f;L=f; d=f;D=f; print();
+ d=10; c=d;s=d;i=d;l=d;C=d;S=d;I=d;L=d;f=d; D=d; print();
+ D=11; c=D;s=D;i=D;l=D;C=D;S=D;I=D;L=D;f=D;d=D; print();
+
+ p=0; p=0L; p=0U; p=0UL; p=P;
+ P=0; P=0L; P=0U; P=0UL; P=p;
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Dijkstras Algorithm
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!! Groepaz/Hitmen
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+#define DIJKSTRA_INFINITY (0xffff)
+
+#define DIJKSTRA_FLAG_UNVISITED (0x0)
+/*
+#define DIJKSTRA_FLAG_OPEN (0x1)
+*/
+#define DIJKSTRA_FLAG_CLOSED (0x2)
+
+typedef struct _DIJKSTRA_EDGE {
+ struct _DIJKSTRA_NODE *NEXTNODE;
+ unsigned short DISTANCE;
+} DIJKSTRA_EDGE;
+
+typedef struct _DIJKSTRA_NODE {
+ DIJKSTRA_EDGE *EDGES;
+ unsigned char TAG;
+ unsigned char FLAG;
+ unsigned short MINDIST;
+ struct _DIJKSTRA_NODE *PREVIOUS;
+} DIJKSTRA_NODE;
+
+/* init with graph, startnode, working-array */
+void Dijkstra_Init(const DIJKSTRA_NODE *graph,DIJKSTRA_NODE *start,DIJKSTRA_NODE *nodes);
+
+/* call main algo with working-array */
+void Dijkstra_Search(DIJKSTRA_NODE *nodes);
+
+/* print path, call with working-array, endnode */
+void Dijkstra_Path(DIJKSTRA_NODE *nodes,DIJKSTRA_NODE *end);
+
+/* print table, call with working-array, current node */
+void Dijkstra_Table(DIJKSTRA_NODE *nodes,DIJKSTRA_NODE *current);
+
+/* internally used routines */
+
+unsigned short Dijkstra_Distance(DIJKSTRA_NODE *currnode,DIJKSTRA_NODE *nextnode);
+void Dijkstra_Relax(DIJKSTRA_NODE *currnode,DIJKSTRA_NODE *nextnode);
+DIJKSTRA_NODE *Dijkstra_NextCheapest(DIJKSTRA_NODE *graph);
+unsigned short Dijkstra_CountUnvisited(DIJKSTRA_NODE *graph);
+
+/* define to get printed info as the algorithm proceeds */
+#define DIJKSTRA_PRINTDEBUG
+
+/* the working array */
+DIJKSTRA_NODE mynodes[0x10];
+
+/* test-network data (mypoints and myedges) */
+
+const DIJKSTRA_EDGE myedges_A[]={
+ {&mynodes[1],1},
+ {NULL}
+};
+const DIJKSTRA_EDGE myedges_B[]={
+ {&mynodes[0],1},
+ {&mynodes[2],2},
+ {&mynodes[3],1},
+ {NULL}
+};
+const DIJKSTRA_EDGE myedges_C[]={
+ {&mynodes[1],2},
+ {&mynodes[5],1},
+ {NULL}
+};
+const DIJKSTRA_EDGE myedges_D[]={
+ {&mynodes[1],1},
+ {&mynodes[4],1},
+ {NULL}
+};
+const DIJKSTRA_EDGE myedges_E[]={
+ {&mynodes[6],1},
+ {NULL}
+};
+const DIJKSTRA_EDGE myedges_F[]={
+ {&mynodes[7],1},
+ {NULL}
+};
+const DIJKSTRA_EDGE myedges_G[]={
+ {&mynodes[8],1},
+ {&mynodes[7],4},
+ {NULL}
+};
+const DIJKSTRA_EDGE myedges_H[]={
+ {&mynodes[9],1},
+ {&mynodes[6],4},
+ {NULL}
+};
+const DIJKSTRA_EDGE myedges_I[]={
+ {&mynodes[10],5},
+ {NULL}
+};
+const DIJKSTRA_EDGE myedges_J[]={
+ {&mynodes[10],1},
+ {NULL}
+};
+const DIJKSTRA_EDGE myedges_K[]={
+ {&mynodes[11],1},
+ {NULL}
+};
+const DIJKSTRA_EDGE myedges_L[]={
+ {&mynodes[10],1},
+ {NULL}
+};
+
+const DIJKSTRA_NODE mypoints[]={
+ {(DIJKSTRA_EDGE *)&myedges_A[0],'A'},
+ {(DIJKSTRA_EDGE *)&myedges_B[0],'B'},
+ {(DIJKSTRA_EDGE *)&myedges_C[0],'C'},
+ {(DIJKSTRA_EDGE *)&myedges_D[0],'D'},
+ {(DIJKSTRA_EDGE *)&myedges_E[0],'E'},
+ {(DIJKSTRA_EDGE *)&myedges_F[0],'F'},
+ {(DIJKSTRA_EDGE *)&myedges_G[0],'G'},
+ {(DIJKSTRA_EDGE *)&myedges_H[0],'H'},
+ {(DIJKSTRA_EDGE *)&myedges_I[0],'I'},
+ {(DIJKSTRA_EDGE *)&myedges_J[0],'J'},
+ {(DIJKSTRA_EDGE *)&myedges_K[0],'K'},
+ {(DIJKSTRA_EDGE *)&myedges_L[0],'L'},
+ {NULL}
+};
+
+/*
+ * initialize working-array
+ */
+
+void Dijkstra_Init(const DIJKSTRA_NODE *graph,DIJKSTRA_NODE *start,DIJKSTRA_NODE *nodes) {
+ while(graph->EDGES!=NULL) {
+ nodes->EDGES=graph->EDGES;
+ nodes->TAG=graph->TAG;
+ nodes->FLAG=DIJKSTRA_FLAG_UNVISITED;
+ nodes->MINDIST=DIJKSTRA_INFINITY;
+ nodes->PREVIOUS=NULL;
+
+ graph++;nodes++;
+
+ }
+/*
+ start->FLAG=DIJKSTRA_FLAG_OPEN;
+ start->PREVIOUS=NULL;
+ */
+ start->MINDIST=0;
+}
+
+/*
+ * compute the distance between two Nodes in the Graph
+ */
+
+unsigned short Dijkstra_Distance(DIJKSTRA_NODE *currnode,DIJKSTRA_NODE *nextnode){
+DIJKSTRA_EDGE *edge;
+
+ edge=currnode->EDGES;
+
+ while(edge!=NULL) {
+ if(edge->NEXTNODE == nextnode){
+ return(edge->DISTANCE);
+ }
+
+ edge++;
+
+ }
+
+ return(DIJKSTRA_INFINITY);
+}
+
+/*
+ * 'relax' one node against another
+ */
+
+void Dijkstra_Relax(DIJKSTRA_NODE *currnode,DIJKSTRA_NODE *nextnode){
+unsigned short newdist;
+
+#ifdef DIJKSTRA_PRINTDEBUG
+ printf("relax >%c< to >%c<\n",currnode->TAG,nextnode->TAG);
+#endif
+
+ newdist=currnode->MINDIST+Dijkstra_Distance(currnode,nextnode);
+
+ if((nextnode->MINDIST)>(newdist)){
+ nextnode->MINDIST=newdist;
+ nextnode->PREVIOUS=currnode;
+
+ }
+}
+
+/*
+ * find the yet unprocessed Node with the currently
+ * smallest estimated MINDIST
+ */
+
+DIJKSTRA_NODE *Dijkstra_NextCheapest(DIJKSTRA_NODE *graph){
+unsigned short mindist;
+DIJKSTRA_NODE *node;
+
+ node=NULL;
+ mindist=DIJKSTRA_INFINITY;
+
+ while(graph->EDGES!=NULL) {
+ if(graph->FLAG!=DIJKSTRA_FLAG_CLOSED){
+ if(!(mindist<graph->MINDIST)){
+ mindist=graph->MINDIST;
+ node=graph;
+ }
+ }
+
+ graph++;
+
+ }
+
+#ifdef DIJKSTRA_PRINTDEBUG
+ if(node!=NULL) printf("next cheapest Node: >%c<\n",node->TAG);
+#endif
+
+ return(node);
+}
+
+/*
+ * count number of Nodes that are left for processing
+ */
+
+unsigned short Dijkstra_CountUnvisited(DIJKSTRA_NODE *graph){
+unsigned short num;
+
+ num=0;
+
+ while(graph->EDGES!=NULL) {
+ if(graph->FLAG!=DIJKSTRA_FLAG_CLOSED){
+ num++;
+ }
+
+ graph++;
+
+ }
+
+ return(num);
+}
+
+/*
+ * Dijkstra-Algorithmus main processing
+ */
+
+void Dijkstra_Search(DIJKSTRA_NODE *graph){
+DIJKSTRA_NODE *currnode,*nextnode;
+DIJKSTRA_EDGE *edge;
+
+ currnode=graph;
+
+ while(Dijkstra_CountUnvisited(graph)>0){
+ edge=currnode->EDGES;
+ while(edge->NEXTNODE!=NULL){
+ nextnode=edge->NEXTNODE;
+ if(nextnode->FLAG!=DIJKSTRA_FLAG_CLOSED){
+/*
+ nextnode->FLAG=DIJKSTRA_FLAG_OPEN;
+ */
+ Dijkstra_Relax(currnode,nextnode);
+#ifdef DIJKSTRA_PRINTDEBUG
+ Dijkstra_Table(graph,currnode);
+#endif
+ }
+ edge++;
+ }
+ currnode=Dijkstra_NextCheapest(graph);
+ currnode->FLAG=DIJKSTRA_FLAG_CLOSED;
+ }
+}
+
+/*
+ * print the Path from start Node to one other Node
+ */
+
+void Dijkstra_Path(DIJKSTRA_NODE *graph,DIJKSTRA_NODE *end){
+DIJKSTRA_NODE *currnode,*nextnode;
+
+ printf("Path from >%c< to >%c< : ",end->TAG,graph->TAG);
+
+ currnode=end;
+
+ while(currnode->PREVIOUS!=NULL){
+ printf(">%c< ",currnode->TAG);
+ currnode=currnode->PREVIOUS;
+ }
+
+ printf(">%c<\n",currnode->TAG);
+}
+
+/*
+ * print working-array as a table
+ */
+
+void Dijkstra_Table(DIJKSTRA_NODE *graph,DIJKSTRA_NODE *current){
+DIJKSTRA_NODE *g;
+
+ printf("----------------------\n");
+
+ printf("Node |");
+ g=graph;while(g->EDGES!=NULL) {
+ printf("-->%c<-|",g->TAG);
+ g++;
+ }
+ printf("\n");
+
+ printf("MinDist |");
+ g=graph;while(g->EDGES!=NULL) {
+ printf(" %5u|",g->MINDIST);
+ g++;
+ }
+ printf("\n");
+
+ printf("Flag |");
+ g=graph;while(g->EDGES!=NULL) {
+ switch(g->FLAG){
+/*
+ case DIJKSTRA_FLAG_OPEN:
+ printf("opened|");
+ break;
+ */
+ case DIJKSTRA_FLAG_CLOSED:
+ printf("closed|");
+ break;
+ default:
+ if(g->MINDIST!=DIJKSTRA_INFINITY){
+ printf("opened|");
+ } else {
+ printf("------|");
+ }
+ break;
+ }
+ g++;
+ }
+ printf("\n");
+
+ printf("Previous|");
+ g=graph;while(g->EDGES!=NULL) {
+ if(g->PREVIOUS==NULL)
+ printf("------|");
+ else
+ printf(" (%c) |",g->PREVIOUS->TAG);
+ g++;
+ }
+ printf("\n");
+
+ printf("----------------------\n");
+}
+
+int main(void)
+{
+ /* init with graph, startnode, working-array */
+ Dijkstra_Init(&mypoints[0],&mynodes[0],&mynodes[0]);
+ /* call main algo with working-array */
+ Dijkstra_Search(&mynodes[0]);
+ /* print table, call with working-array, endnode */
+ Dijkstra_Table(&mynodes[0],&mynodes[11]);
+ /* print path, call with working-array, endnode */
+ Dijkstra_Path(&mynodes[0],&mynodes[11]);
+
+ return 0;
+}
--- /dev/null
+/*\r
+ !!DESCRIPTION!! div/mod test\r
+ !!ORIGIN!!\r
+ !!LICENCE!! public domain\r
+*/\r
+\r
+#include <stdio.h>\r
+\r
+void printc(signed char a,signed char b){\r
+signed char x=a/b,y=a%b,z=a*b;\r
+ printf("%3d,%3d is %3d,%3d,%3d\n",a,b,x,y,z);\r
+}\r
+void prints(short a,short b){\r
+short x=a/b,y=a%b,z=a*b;\r
+ printf("%3d,%3d is %3d,%3d,%3d\n",a,b,x,y,z);\r
+}\r
+void printl(long a,long b){\r
+long x=a/b,y=a%b,z=a*b;\r
+ printf("%3ld,%3ld is %3ld,%3ld,%3ld\n",a,b,x,y,z);\r
+}\r
+\r
+int main(void) {\r
+ printl( 3,-2);\r
+ printl(-3,-2);\r
+ printl(-3, 2);\r
+ printl( 3, 2);\r
+ printf("-\n");\r
+ prints( 3,-2);\r
+ prints(-3,-2);\r
+ prints(-3, 2);\r
+ prints( 3, 2);\r
+ printf("-\n");\r
+ printc( 3,-2);\r
+ printc(-3,-2);\r
+ printc(-3, 2);\r
+ printc( 3, 2);\r
+ return 0;
+}\r
--- /dev/null
+/*
+ !!DESCRIPTION!! solves the "towers of hanoi" problem
+ !!ORIGIN!! BYTE UNIX Benchmarks
+ !!LICENCE!! Public Domain
+*/
+
+/*******************************************************************************
+ * The BYTE UNIX Benchmarks - Release 3
+ * Module: hanoi.c SID: 3.3 5/15/91 19:30:20
+ *
+ *******************************************************************************
+ * Bug reports, patches, comments, suggestions should be sent to:
+ *
+ * Ben Smith, Rick Grehan or Tom Yager
+ * ben@bytepb.byte.com rick_g@bytepb.byte.com tyager@bytepb.byte.com
+ *
+ *******************************************************************************
+ * Modification Log:
+ * $Header: hanoi.c,v 3.5 87/08/06 08:11:14 kenj Exp $
+ * August 28, 1990 - Modified timing routines (ty)
+ *
+ ******************************************************************************/
+
+#define VERBOSE
+/*#define USECMDLINE*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+unsigned short iter = 0; /* number of iterations */
+char num[4];
+long cnt;
+
+int disk=5, /* default number of disks */
+ duration=10; /* default time to run test */
+
+void mov(unsigned char n,unsigned char f,unsigned char t)
+{
+char o;
+
+ if(n == 1)
+ {
+ num[f]--;
+ num[t]++;
+ }
+ else
+ {
+ o = (6-(f+t));
+ mov(n-1,f,o);
+ mov(1,f,t);
+ mov(n-1,o,t);
+ }
+
+ #ifdef VERBOSE
+ printf("%2d: %2d %2d %2d %2d\n",
+ (int)iter,(int)num[0],(int)num[1],(int)num[2],(int)num[3]);
+ #endif
+}
+
+int main(int argc,char **argv)
+{
+ #ifdef USECMDLINE
+ if (argc < 2) {
+ printf("Usage: %s [duration] [disks]\n", argv[0]);
+ exit(1);
+ }
+ else
+ {
+ if(argc > 1) duration = atoi(argv[1]);
+ if(argc > 2) disk = atoi(argv[2]);
+ }
+ #endif
+
+ printf("towers of hanoi\ndisks: %d\n\n",disk);
+
+ num[1] = disk;
+
+ #ifdef VERBOSE
+ printf("%2d: %2d %2d %2d %2d\n",
+ (int)iter,(int)num[0],(int)num[1],(int)num[2],(int)num[3]);
+ #endif
+
+ while(num[3]<disk)
+ {
+ mov(disk,1,3);
+ ++iter;
+ }
+
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! if/then, ? operator, compares
+ !!ORIGIN!! cc65 devel list
+ !!LICENCE!! Public Domain
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+void t1a(void)
+{
+ int a = -0x5000;
+
+ printf(a < 0x5000 ? "ok\n" : "error\n");
+}
+
+void t1b(void)
+{
+ int a = -0x5000;
+
+ if(a<0x5000)
+ {
+ printf("ok\n");
+ }
+ else
+ {
+ printf("error\n");
+ }
+}
+
+int main(void)
+{
+ t1a();t1b();
+
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! increment/decrement
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include <stdio.h>
+
+int main(void)
+{
+ printf("disassemble this program to check the generated code.\n");
+ return 0;
+}
+
+memchar() {
+ char x, *p;
+
+ &x, &p;
+ x = *p++;
+ x = *++p;
+ x = *p--;
+ x = *--p;
+}
+
+memint() {
+ int x, *p;
+
+ &x, &p;
+ x = *p++;
+ x = *++p;
+ x = *p--;
+ x = *--p;
+}
+
+regchar() {
+ register char x, *p;
+
+ x = *p++;
+ x = *++p;
+ x = *p--;
+ x = *--p;
+}
+
+regint() {
+ register int x, *p;
+
+ x = *p++;
+ x = *++p;
+ x = *p--;
+ x = *--p;
+}
--- /dev/null
+/*\r
+ !!DESCRIPTION!! variable initialization\r
+ !!ORIGIN!! LCC 4.1 Testsuite\r
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC\r
+*/\r
+\r
+#include "common.h"\r
+/* todo: add back conditional stuff here ! */\r
+\r
+typedef struct { int codes[3]; char name[6]; } Word;\r
+\r
+#ifdef NO_IMPLICIT_FUNC_PROTOTYPES\r
+\r
+#ifdef NO_OLD_FUNC_DECL\r
+f();\r
+void g(Word *p);\r
+h();\r
+#else\r
+f();\r
+g();\r
+h();\r
+#endif\r
+\r
+#endif\r
+\r
+/*\r
+Word words[] = {\r
+ 1, 2, 3,"if",\r
+ { { 4, 5 }, { 'f', 'o', 'r' } },\r
+ 6, 7, 8, {"else"},\r
+ { { 9, 10, 11,}, 'w', 'h', 'i', 'l', 'e', },\r
+ { 0 },\r
+}, *wordlist = words;\r
+*/\r
+\r
+Word words[] = {\r
+ {{1, 2, 3},"if"},\r
+ { { 4, 5 }, { 'f', 'o', 'r' } },\r
+ {{6, 7, 8}, "else"},\r
+ { { 9, 10, 11}, {'w', 'h', 'i', 'l', 'e', }},\r
+ {{ 0 }},\r
+}, *wordlist = words;\r
+\r
+/*int x[][5] = { 1, 2, 3, 4, 0, { 5, 6 }, { 7 } };*/\r
+int x[][5] = { {1, 2, 3, 4, 0 }, { 5, 6 }, { 7 } };\r
+int *y[] = { x[0], x[1], x[2], 0 };\r
+\r
+main()\r
+{\r
+ int i, j;\r
+\r
+ for (i = 0; y[i]; i++) {\r
+ for (j = 0; y[i][j]; j++)\r
+ printf(" %d", y[i][j]);\r
+ printf("\n");\r
+ }\r
+ f();\r
+ g(wordlist);\r
+ return 0;\r
+}\r
+\r
+f() {\r
+ static char *keywords[] = {"if", "for", "else", "while", 0, };\r
+ char **p;\r
+\r
+ for (p = keywords; *p; p++)\r
+ printf("%s\n", *p);\r
+}\r
+\r
+#ifdef NO_OLD_FUNC_DECL\r
+void g(Word *p)\r
+#else\r
+g(p)\r
+Word *p;\r
+#endif\r
+{\r
+ int i;\r
+\r
+ for ( ; p->codes[0]; p++) {\r
+ for (i = 0; i < sizeof p->codes/sizeof(p->codes[0]); i++)\r
+ printf("%d ", p->codes[i]);\r
+ printf("%s\n", p->name);\r
+ }\r
+ h();\r
+}\r
+\r
+h()\r
+{\r
+ int i;\r
+\r
+ for (i = 0; i < sizeof(words)/sizeof(Word); i++)\r
+ printf("%d %d %d %s\n", words[i].codes[0],\r
+ words[i].codes[1], words[i].codes[2],\r
+ &words[i].name[0]);\r
+}\r
--- /dev/null
+/*
+ !!DESCRIPTION!! macro bug test program
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!! Groepaz/Hitmen
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+unsigned long fs=7;
+unsigned long fd=5;
+unsigned long a=3;
+
+unsigned long _func(unsigned long x,unsigned long y)
+{
+ printf("x:%ld y:%ld\n",x,y);
+ return 0;
+}
+
+#define func(x,y) _func(x,y)
+
+int main(void)
+{
+ fs= func( (fd/a) , func(2,0x0082c90f) );
+ printf("fs:%ld\n",fs);
+ fs=_func( (fd/a) , _func(2,0x0082c90f) );
+ printf("fs:%ld\n",fs);
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! mandelbrot test program
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!! Groepaz/Hitmen
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static unsigned short SCREEN_X;
+static unsigned char SCREEN_Y;
+
+#define MAXCOL 8
+
+#define maxiterations 16
+
+#define fpshift (12)
+
+#define tofp(_x) ((_x)<<fpshift)
+#define fromfp(_x) ((_x)>>fpshift)
+#define fpabs(_x) (abs(_x))
+
+#define mulfp(_a,_b) ((((signed long)_a)*(_b))>>fpshift)
+#define divfp(_a,_b) ((((signed long)_a)<<fpshift)/(_b))
+
+unsigned char dither[MAXCOL]={" .*o+0%#"};
+
+void mandelbrot(signed short x1,signed short y1,signed short x2,signed short y2)
+{
+register signed short r,r1,i;
+register unsigned char count;
+register signed short xs,ys,xx,yy;
+register signed short x;
+register unsigned char y;
+
+ /* calc stepwidth */
+ xs=((x2-x1)/(SCREEN_X));
+ ys=((y2-y1)/(SCREEN_Y));
+
+ yy=y1;
+ for(y = 0; y < (SCREEN_Y); ++y)
+ {
+ yy+=ys; xx=x1;
+ for(x = 0; x < (SCREEN_X); ++x)
+ {
+ xx+=xs;
+ /* do iterations */
+ r=0;i=0;
+ for(count=0;(count<maxiterations)&&
+ (fpabs(r)<tofp(2))&&
+ (fpabs(i)<tofp(2))
+ ;++count)
+ {
+ r1 = (mulfp(r,r)-mulfp(i,i))+xx;
+ /* i = (mulfp(mulfp(r,i),tofp(2)))+yy; */
+ i = (((signed long)r*i)>>(fpshift-1))+yy;
+ r=r1;
+ }
+ if(count==maxiterations)
+ {
+ printf(" ");
+ }
+ else
+ {
+ printf("%c",dither[(count%MAXCOL)]);
+ }
+ }
+ printf("\n");
+ }
+}
+
+int main (void)
+{
+ SCREEN_X = 80;
+ SCREEN_Y = 40;
+
+ /* calc mandelbrot set */
+ mandelbrot(tofp(-2),tofp(-2),tofp(2),tofp(2));
+
+ /* Done */
+ return 0;
+}
+
--- /dev/null
+/*
+ !!DESCRIPTION!! minimal Program, checks if the Compiler and testsuite framework works
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!! Groepaz/Hitmen
+*/
+
+#include <stdio.h>
+
+int main(void)
+{
+#if 1
+ printf("it works :)\n");
+#endif
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! OTCC Example (simple K&R Style)
+ !!ORIGIN!! OTCC
+ !!LICENCE!! GPL (?), read COPYING.GPL
+*/
+
+#include "common.h"
+
+/*
+ * Sample OTCC C example. You can uncomment the first line and install
+ * otcc in /usr/local/bin to make otcc scripts !
+ */
+
+/* Any preprocessor directive except #define are ignored. We put this
+ include so that a standard C compiler can compile this code too. */
+#include <stdio.h>
+#include <limits.h>
+
+/* defines are handled, but macro arguments cannot be given. No
+ recursive defines are tolerated */
+#define DEFAULT_BASE 10
+
+#ifdef NO_IMPLICIT_FUNC_PROTOTYPES
+help(char *name);
+#endif
+
+/*
+ * Only old style K&R prototypes are parsed. Only int arguments are
+ * allowed (implicit types).
+ *
+ * By benchmarking the execution time of this function (for example
+ * for fib(35)), you'll notice that OTCC is quite fast because it
+ * generates native i386 machine code.
+ */
+fib(n)
+{
+ printf("[fib(%d)]", n);
+ if (n <= 2)
+ return 1;
+ else
+ return fib(n-1) + fib(n-2);
+}
+
+/* Identifiers are parsed the same way as C: begins with letter or
+ '_', and then letters, '_' or digits */
+long fact(n)
+{
+ /* local variables can be declared. Only 'int' type is supported */
+ int i;
+ long r;
+ r = 1;
+ /* 'while' and 'for' loops are supported */
+ for(i=2;i<=n;i++)
+ r = r * i;
+ return r;
+}
+
+/* Well, we could use printf, but it would be too easy */
+print_num(long n,int b)
+{
+ int tab, p, c;
+ /* Numbers can be entered in decimal, hexadecimal ('0x' prefix) and
+ octal ('0' prefix) */
+ /* more complex programs use malloc */
+ tab = malloc(0x100);
+ p = tab;
+ while (1) {
+ c = n % b;
+ /* Character constants can be used */
+ if (c >= 10)
+ c = c + 'a' - 10;
+ else
+ c = c + '0';
+ *(char *)p = c;
+ p++;
+ n = n / b;
+ /* 'break' is supported */
+ if (n == 0)
+ break;
+ }
+ while (p != tab) {
+ p--;
+ printf("%c", *(char *)p);
+ }
+ free(tab);
+}
+
+/* 'main' takes standard 'argc' and 'argv' parameters */
+mymain(int argc,char **argv)
+{
+ /* no local name space is supported, but local variables ARE
+ supported. As long as you do not use a globally defined
+ variable name as local variable (which is a bad habbit), you
+ won't have any problem */
+ int s, n, f, base;
+
+
+ /* && and || operator have the same semantics as C (left to right
+ evaluation and early exit) */
+ if (argc != 2 && argc != 3) {
+ /* '*' operator is supported with explicit casting to 'int *',
+ 'char *' or 'int (*)()' (function pointer). Of course, 'int'
+ are supposed to be used as pointers too. */
+ s = *(int *)argv;
+ help(s);
+ return 1;
+ }
+ /* Any libc function can be used because OTCC uses dynamic linking */
+ n = atoi(argv[1]);
+ base = DEFAULT_BASE;
+ if (argc >= 3) {
+ base = atoi(argv[2]);
+ if (base < 2 || base > 36) {
+ /* external variables can be used too (here: 'stderr') */
+ fprintf(stdout, "Invalid base\n");
+ return 1;
+ }
+ }
+ printf("fib(%d) =\n", n);
+ print_num(fib(n), base);
+ printf("\n");
+
+ printf("fact(%d) = ", n);
+ if (n > 12) {
+ printf("Overflow");
+ } else {
+ /* why not using a function pointer ? */
+ f = &fact;
+ print_num((*(long (*)())f)(n), base);
+ }
+ printf("\n");
+ return 0;
+}
+
+/* functions can be used before being defined */
+help(char *name)
+{
+ printf("usage: %s n [base]\n", name);
+ printf("Compute fib(n) and fact(n) and output the result in base 'base'\n");
+}
+
+int main(void)
+{
+ char *argv[3];
+ argv[0]="";
+ argv[1]="10"; /* n */
+ argv[2]="8"; /* base */
+ mymain(3, argv);
+ return 0;
+}
\ No newline at end of file
--- /dev/null
+/*
+ !!DESCRIPTION!! a wellknown floating point test
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+#ifdef NO_FLOATS
+
+main()
+{
+ printf("NO_FLOATS\n\r");
+ return 0;
+}
+
+#else
+
+#undef V9
+#define NOPAUSE
+/* A C version of Kahan's Floating Point Test "Paranoia"
+
+ Thos Sumner, UCSF, Feb. 1985
+ David Gay, BTL, Jan. 1986
+
+ This is a rewrite from the Pascal version by
+
+ B. A. Wichmann, 18 Jan. 1985
+
+ (and does NOT exhibit good C programming style).
+
+(C) Apr 19 1983 in BASIC version by:
+ Professor W. M. Kahan,
+ 567 Evans Hall
+ Electrical Engineering & Computer Science Dept.
+ University of California
+ Berkeley, California 94720
+ USA
+
+converted to Pascal by:
+ B. A. Wichmann
+ National Physical Laboratory
+ Teddington Middx
+ TW11 OLW
+ UK
+
+converted to C by:
+
+ David M. Gay and Thos Sumner
+ AT&T Bell Labs Computer Center, Rm. U-76
+ 600 Mountain Avenue University of California
+ Murray Hill, NJ 07974 San Francisco, CA 94143
+ USA USA
+
+with simultaneous corrections to the Pascal source (reflected
+in the Pascal source available over netlib).
+[A couple of bug fixes from dgh = sun!dhough incorporated 31 July 1986.]
+
+Reports of results on various systems from all the versions
+of Paranoia are being collected by Richard Karpinski at the
+same address as Thos Sumner. This includes sample outputs,
+bug reports, and criticisms.
+
+You may copy this program freely if you acknowledge its source.
+Comments on the Pascal version to NPL, please.
+
+The C version catches signals from floating-point exceptions.
+If signal(SIGFPE,...) is unavailable in your environment, you may
+#define NOSIGNAL to comment out the invocations of signal.
+
+This source file is too big for some C compilers, but may be split
+into pieces. Comments containing "SPLIT" suggest convenient places
+for this splitting. At the end of these comments is an "ed script"
+(for the UNIX(tm) editor ed) that will do this splitting.
+
+By #defining Single when you compile this source, you may obtain
+a single-precision C version of Paranoia.
+
+The following is from the introductory commentary from Wichmann's work:
+
+The BASIC program of Kahan is written in Microsoft BASIC using many
+facilities which have no exact analogy in Pascal. The Pascal
+version below cannot therefore be exactly the same. Rather than be
+a minimal transcription of the BASIC program, the Pascal coding
+follows the conventional style of block-structured languages. Hence
+the Pascal version could be useful in producing versions in other
+structured languages.
+
+Rather than use identifiers of minimal length (which therefore have
+little mnemonic significance), the Pascal version uses meaningful
+identifiers as follows [Note: A few changes have been made for C]:
+
+BASIC C BASIC C BASIC C
+
+ A J S StickyBit
+ A1 AInverse J0 NoErrors T
+ B Radix [Failure] T0 Underflow
+ B1 BInverse J1 NoErrors T2 ThirtyTwo
+ B2 RadixD2 [SeriousDefect] T5 OneAndHalf
+ B9 BMinusU2 J2 NoErrors T7 TwentySeven
+ C [Defect] T8 TwoForty
+ C1 CInverse J3 NoErrors U OneUlp
+ D [Flaw] U0 UnderflowThreshold
+ D4 FourD K PageNo U1
+ E0 L Milestone U2
+ E1 M V
+ E2 Exp2 N V0
+ E3 N1 V8
+ E5 MinSqEr O Zero V9
+ E6 SqEr O1 One W
+ E7 MaxSqEr O2 Two X
+ E8 O3 Three X1
+ E9 O4 Four X8
+ F1 MinusOne O5 Five X9 Random1
+ F2 Half O8 Eight Y
+ F3 Third O9 Nine Y1
+ F6 P Precision Y2
+ F9 Q Y9 Random2
+ G1 GMult Q8 Z
+ G2 GDiv Q9 Z0 PseudoZero
+ G3 GAddSub R Z1
+ H R1 RMult Z2
+ H1 HInverse R2 RDiv Z9
+ I R3 RAddSub
+ IO NoTrials R4 RSqrt
+ I3 IEEE R9 Random9
+
+ SqRWrng
+
+All the variables in BASIC are true variables and in consequence,
+the program is more difficult to follow since the "constants" must
+be determined (the glossary is very helpful). The Pascal version
+uses Real constants, but checks are added to ensure that the values
+are correctly converted by the compiler.
+
+The major textual change to the Pascal version apart from the
+identifiersis that named procedures are used, inserting parameters
+wherehelpful. New procedures are also introduced. The
+correspondence is as follows:
+
+BASIC Pascal
+lines
+
+ 90- 140 Pause
+ 170- 250 Instructions
+ 380- 460 Heading
+ 480- 670 Characteristics
+ 690- 870 History
+2940-2950 Random
+3710-3740 NewD
+4040-4080 DoesYequalX
+4090-4110 PrintIfNPositive
+4640-4850 TestPartialUnderflow
+
+=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
+
+Below is an "ed script" that splits para.c into 10 files
+of the form part[1-8].c, subs.c, and msgs.c, plus a header
+file, paranoia.h, that these files require.
+
+r paranoia.c
+$
+?SPLIT
++,$w msgs.c
+ .,$d
+?SPLIT
+ .d
++d
+-,$w subs.c
+-,$d
+?part8
++d
+?include
+ .,$w part8.c
+ .,$d
+-d
+?part7
++d
+?include
+ .,$w part7.c
+ .,$d
+-d
+?part6
++d
+?include
+ .,$w part6.c
+ .,$d
+-d
+?part5
++d
+?include
+ .,$w part5.c
+ .,$d
+-d
+?part4
++d
+?include
+ .,$w part4.c
+ .,$d
+-d
+?part3
++d
+?include
+ .,$w part3.c
+ .,$d
+-d
+?part2
++d
+?include
+ .,$w part2.c
+ .,$d
+?SPLIT
+ .d
+1,/^#include/-1d
+1,$w part1.c
+/Computed constants/,$d
+1,$s/^int/extern &/
+1,$s/^FLOAT/extern &/
+1,$s/^char/extern &/
+1,$s! = .*!;!
+/^Guard/,/^Round/s/^/extern /
+/^jmp_buf/s/^/extern /
+/^Sig_type/s/^/extern /
+s/$/\
+extern void sigfpe();/
+w paranoia.h
+q
+
+*/
+
+#include <stdio.h>
+#ifndef NOSIGNAL
+#include <signal.h>
+#endif
+#include <setjmp.h>
+
+extern double fabs(), floor(), log(), pow(), sqrt();
+
+#ifdef Single
+#define FLOAT float
+#define FABS(x) (float)fabs((double)(x))
+#define FLOOR(x) (float)floor((double)(x))
+#define LOG(x) (float)log((double)(x))
+#define POW(x,y) (float)pow((double)(x),(double)(y))
+#define SQRT(x) (float)sqrt((double)(x))
+#else
+#define FLOAT double
+#define FABS(x) fabs(x)
+#define FLOOR(x) floor(x)
+#define LOG(x) log(x)
+#define POW(x,y) pow(x,y)
+#define SQRT(x) sqrt(x)
+#endif
+
+jmp_buf ovfl_buf;
+typedef void (*Sig_type)();
+Sig_type sigsave;
+
+#define KEYBOARD 0
+
+FLOAT Radix, BInvrse, RadixD2, BMinusU2;
+FLOAT Sign(), Random();
+
+/*Small floating point constants.*/
+FLOAT Zero = 0.0;
+FLOAT Half = 0.5;
+FLOAT One = 1.0;
+FLOAT Two = 2.0;
+FLOAT Three = 3.0;
+FLOAT Four = 4.0;
+FLOAT Five = 5.0;
+FLOAT Eight = 8.0;
+FLOAT Nine = 9.0;
+FLOAT TwentySeven = 27.0;
+FLOAT ThirtyTwo = 32.0;
+FLOAT TwoForty = 240.0;
+FLOAT MinusOne = -1.0;
+FLOAT OneAndHalf = 1.5;
+/*Integer constants*/
+int NoTrials = 20; /*Number of tests for commutativity. */
+#define False 0
+#define True 1
+
+/* Definitions for declared types
+ Guard == (Yes, No);
+ Rounding == (Chopped, Rounded, Other);
+ Message == packed array [1..40] of char;
+ Class == (Flaw, Defect, Serious, Failure);
+ */
+#define Yes 1
+#define No 0
+#define Chopped 2
+#define Rounded 1
+#define Other 0
+#define Flaw 3
+#define Defect 2
+#define Serious 1
+#define Failure 0
+typedef int Guard, Rounding, Class;
+typedef char Message;
+
+/* Declarations of Variables */
+int Indx;
+char ch[8];
+FLOAT AInvrse, A1;
+FLOAT C, CInvrse;
+FLOAT D, FourD;
+FLOAT E0, E1, Exp2, E3, MinSqEr;
+FLOAT SqEr, MaxSqEr, E9;
+FLOAT Third;
+FLOAT F6, F9;
+FLOAT H, HInvrse;
+int I;
+FLOAT StickyBit, J;
+FLOAT MyZero;
+FLOAT Precision;
+FLOAT Q, Q9;
+FLOAT R, Random9;
+FLOAT T, Underflow, S;
+FLOAT OneUlp, UfThold, U1, U2;
+FLOAT V, V0, V9;
+FLOAT W;
+FLOAT X, X1, X2, X8, Random1;
+FLOAT Y, Y1, Y2, Random2;
+FLOAT Z, PseudoZero, Z1, Z2, Z9;
+int ErrCnt[4];
+int fpecount;
+int Milestone;
+int PageNo;
+int M, N, N1;
+Guard GMult, GDiv, GAddSub;
+Rounding RMult, RDiv, RAddSub, RSqrt;
+int Break, Done, NotMonot, Monot, Anomaly, IEEE,
+ SqRWrng, UfNGrad;
+/* Computed constants. */
+/*U1 gap below 1.0, i.e, 1.0-U1 is next number below 1.0 */
+/*U2 gap above 1.0, i.e, 1.0+U2 is next number above 1.0 */
+
+/* floating point exception receiver */
+ void
+sigfpe(i)
+{
+ fpecount++;
+ printf("\n* * * FLOATING-POINT ERROR * * *\n");
+ fflush(stdout);
+ if (sigsave) {
+#ifndef NOSIGNAL
+ signal(SIGFPE, sigsave);
+#endif
+ sigsave = 0;
+ longjmp(ovfl_buf, 1);
+ }
+ abort();
+}
+
+main()
+{
+#ifdef mc
+ char *out;
+ ieee_flags("set", "precision", "double", &out);
+#endif
+ /* First two assignments use integer right-hand sides. */
+ Zero = 0;
+ One = 1;
+ Two = One + One;
+ Three = Two + One;
+ Four = Three + One;
+ Five = Four + One;
+ Eight = Four + Four;
+ Nine = Three * Three;
+ TwentySeven = Nine * Three;
+ ThirtyTwo = Four * Eight;
+ TwoForty = Four * Five * Three * Four;
+ MinusOne = -One;
+ Half = One / Two;
+ OneAndHalf = One + Half;
+ ErrCnt[Failure] = 0;
+ ErrCnt[Serious] = 0;
+ ErrCnt[Defect] = 0;
+ ErrCnt[Flaw] = 0;
+ PageNo = 1;
+ /*=============================================*/
+ Milestone = 0;
+ /*=============================================*/
+#ifndef NOSIGNAL
+ signal(SIGFPE, sigfpe);
+#endif
+ Instructions();
+ Pause();
+ Heading();
+ Pause();
+ Characteristics();
+ Pause();
+ History();
+ Pause();
+ /*=============================================*/
+ Milestone = 7;
+ /*=============================================*/
+ printf("Program is now RUNNING tests on small integers:\n");
+
+ TstCond (Failure, (Zero + Zero == Zero) && (One - One == Zero)
+ && (One > Zero) && (One + One == Two),
+ "0+0 != 0, 1-1 != 0, 1 <= 0, or 1+1 != 2");
+ Z = - Zero;
+ if (Z != 0.0) {
+ ErrCnt[Failure] = ErrCnt[Failure] + 1;
+ printf("Comparison alleges that -0.0 is Non-zero!\n");
+ U1 = 0.001;
+ Radix = 1;
+ TstPtUf();
+ }
+ TstCond (Failure, (Three == Two + One) && (Four == Three + One)
+ && (Four + Two * (- Two) == Zero)
+ && (Four - Three - One == Zero),
+ "3 != 2+1, 4 != 3+1, 4+2*(-2) != 0, or 4-3-1 != 0");
+ TstCond (Failure, (MinusOne == (0 - One))
+ && (MinusOne + One == Zero ) && (One + MinusOne == Zero)
+ && (MinusOne + FABS(One) == Zero)
+ && (MinusOne + MinusOne * MinusOne == Zero),
+ "-1+1 != 0, (-1)+abs(1) != 0, or -1+(-1)*(-1) != 0");
+ TstCond (Failure, Half + MinusOne + Half == Zero,
+ "1/2 + (-1) + 1/2 != 0");
+ /*=============================================*/
+ /*SPLIT
+ part2();
+ part3();
+ part4();
+ part5();
+ part6();
+ part7();
+ part8();
+ }
+#include "paranoia.h"
+part2(){
+*/
+ Milestone = 10;
+ /*=============================================*/
+ TstCond (Failure, (Nine == Three * Three)
+ && (TwentySeven == Nine * Three) && (Eight == Four + Four)
+ && (ThirtyTwo == Eight * Four)
+ && (ThirtyTwo - TwentySeven - Four - One == Zero),
+ "9 != 3*3, 27 != 9*3, 32 != 8*4, or 32-27-4-1 != 0");
+ TstCond (Failure, (Five == Four + One) &&
+ (TwoForty == Four * Five * Three * Four)
+ && (TwoForty / Three - Four * Four * Five == Zero)
+ && ( TwoForty / Four - Five * Three * Four == Zero)
+ && ( TwoForty / Five - Four * Three * Four == Zero),
+ "5 != 4+1, 240/3 != 80, 240/4 != 60, or 240/5 != 48");
+ if (ErrCnt[Failure] == 0) {
+ printf("-1, 0, 1/2, 1, 2, 3, 4, 5, 9, 27, 32 & 240 are O.K.\n");
+ printf("\n");
+ }
+ printf("Searching for Radix and Precision.\n");
+ W = One;
+ do {
+ W = W + W;
+ Y = W + One;
+ Z = Y - W;
+ Y = Z - One;
+ } while (MinusOne + FABS(Y) < Zero);
+ /*.. now W is just big enough that |((W+1)-W)-1| >= 1 ...*/
+ Precision = Zero;
+ Y = One;
+ do {
+ Radix = W + Y;
+ Y = Y + Y;
+ Radix = Radix - W;
+ } while ( Radix == Zero);
+ if (Radix < Two) Radix = One;
+ printf("Radix = %f .\n", Radix);
+ if (Radix != 1) {
+ W = One;
+ do {
+ Precision = Precision + One;
+ W = W * Radix;
+ Y = W + One;
+ } while ((Y - W) == One);
+ }
+ /*... now W == Radix^Precision is barely too big to satisfy (W+1)-W == 1
+ ...*/
+ U1 = One / W;
+ U2 = Radix * U1;
+ printf("Closest relative separation found is U1 = %.7e .\n\n", U1);
+ printf("Recalculating radix and precision\n ");
+
+ /*save old values*/
+ E0 = Radix;
+ E1 = U1;
+ E9 = U2;
+ E3 = Precision;
+
+ X = Four / Three;
+ Third = X - One;
+ F6 = Half - Third;
+ X = F6 + F6;
+ X = FABS(X - Third);
+ if (X < U2) X = U2;
+
+ /*... now X = (unknown no.) ulps of 1+...*/
+ do {
+ U2 = X;
+ Y = Half * U2 + ThirtyTwo * U2 * U2;
+ Y = One + Y;
+ X = Y - One;
+ } while ( ! ((U2 <= X) || (X <= Zero)));
+
+ /*... now U2 == 1 ulp of 1 + ... */
+ X = Two / Three;
+ F6 = X - Half;
+ Third = F6 + F6;
+ X = Third - Half;
+ X = FABS(X + F6);
+ if (X < U1) X = U1;
+
+ /*... now X == (unknown no.) ulps of 1 -... */
+ do {
+ U1 = X;
+ Y = Half * U1 + ThirtyTwo * U1 * U1;
+ Y = Half - Y;
+ X = Half + Y;
+ Y = Half - X;
+ X = Half + Y;
+ } while ( ! ((U1 <= X) || (X <= Zero)));
+ /*... now U1 == 1 ulp of 1 - ... */
+ if (U1 == E1) printf("confirms closest relative separation U1 .\n");
+ else printf("gets better closest relative separation U1 = %.7e .\n", U1);
+ W = One / U1;
+ F9 = (Half - U1) + Half;
+ Radix = FLOOR(0.01 + U2 / U1);
+ if (Radix == E0) printf("Radix confirmed.\n");
+ else printf("MYSTERY: recalculated Radix = %.7e .\n", Radix);
+ TstCond (Defect, Radix <= Eight + Eight,
+ "Radix is too big: roundoff problems");
+ TstCond (Flaw, (Radix == Two) || (Radix == 10)
+ || (Radix == One), "Radix is not as good as 2 or 10");
+ /*=============================================*/
+ Milestone = 20;
+ /*=============================================*/
+ TstCond (Failure, F9 - Half < Half,
+ "(1-U1)-1/2 < 1/2 is FALSE, prog. fails?");
+ X = F9;
+ I = 1;
+ Y = X - Half;
+ Z = Y - Half;
+ TstCond (Failure, (X != One)
+ || (Z == Zero), "Comparison is fuzzy,X=1 but X-1/2-1/2 != 0");
+ X = One + U2;
+ I = 0;
+ /*=============================================*/
+ Milestone = 25;
+ /*=============================================*/
+ /*... BMinusU2 = nextafter(Radix, 0) */
+ BMinusU2 = Radix - One;
+ BMinusU2 = (BMinusU2 - U2) + One;
+ /* Purify Integers */
+ if (Radix != One) {
+ X = - TwoForty * LOG(U1) / LOG(Radix);
+ Y = FLOOR(Half + X);
+ if (FABS(X - Y) * Four < One) X = Y;
+ Precision = X / TwoForty;
+ Y = FLOOR(Half + Precision);
+ if (FABS(Precision - Y) * TwoForty < Half) Precision = Y;
+ }
+ if ((Precision != FLOOR(Precision)) || (Radix == One)) {
+ printf("Precision cannot be characterized by an Integer number\n");
+ printf("of significant digits but, by itself, this is a minor flaw.\n");
+ }
+ if (Radix == One)
+ printf("logarithmic encoding has precision characterized solely by U1.\n");
+ else printf("The number of significant digits of the Radix is %f .\n",
+ Precision);
+ TstCond (Serious, U2 * Nine * Nine * TwoForty < One,
+ "Precision worse than 5 decimal figures ");
+ /*=============================================*/
+ Milestone = 30;
+ /*=============================================*/
+ /* Test for extra-precise subepressions */
+ X = FABS(((Four / Three - One) - One / Four) * Three - One / Four);
+ do {
+ Z2 = X;
+ X = (One + (Half * Z2 + ThirtyTwo * Z2 * Z2)) - One;
+ } while ( ! ((Z2 <= X) || (X <= Zero)));
+ X = Y = Z = FABS((Three / Four - Two / Three) * Three - One / Four);
+ do {
+ Z1 = Z;
+ Z = (One / Two - ((One / Two - (Half * Z1 + ThirtyTwo * Z1 * Z1))
+ + One / Two)) + One / Two;
+ } while ( ! ((Z1 <= Z) || (Z <= Zero)));
+ do {
+ do {
+ Y1 = Y;
+ Y = (Half - ((Half - (Half * Y1 + ThirtyTwo * Y1 * Y1)) + Half
+ )) + Half;
+ } while ( ! ((Y1 <= Y) || (Y <= Zero)));
+ X1 = X;
+ X = ((Half * X1 + ThirtyTwo * X1 * X1) - F9) + F9;
+ } while ( ! ((X1 <= X) || (X <= Zero)));
+ if ((X1 != Y1) || (X1 != Z1)) {
+ BadCond(Serious, "Disagreements among the values X1, Y1, Z1,\n");
+ printf("respectively %.7e, %.7e, %.7e,\n", X1, Y1, Z1);
+ printf("are symptoms of inconsistencies introduced\n");
+ printf("by extra-precise evaluation of arithmetic subexpressions.\n");
+ notify("Possibly some part of this");
+ if ((X1 == U1) || (Y1 == U1) || (Z1 == U1)) printf(
+ "That feature is not tested further by this program.\n") ;
+ }
+ else {
+ if ((Z1 != U1) || (Z2 != U2)) {
+ if ((Z1 >= U1) || (Z2 >= U2)) {
+ BadCond(Failure, "");
+ notify("Precision");
+ printf("\tU1 = %.7e, Z1 - U1 = %.7e\n",U1,Z1-U1);
+ printf("\tU2 = %.7e, Z2 - U2 = %.7e\n",U2,Z2-U2);
+ }
+ else {
+ if ((Z1 <= Zero) || (Z2 <= Zero)) {
+ printf("Because of unusual Radix = %f", Radix);
+ printf(", or exact rational arithmetic a result\n");
+ printf("Z1 = %.7e, or Z2 = %.7e ", Z1, Z2);
+ notify("of an\nextra-precision");
+ }
+ if (Z1 != Z2 || Z1 > Zero) {
+ X = Z1 / U1;
+ Y = Z2 / U2;
+ if (Y > X) X = Y;
+ Q = - LOG(X);
+ printf("Some subexpressions appear to be calculated extra\n");
+ printf("precisely with about %g extra B-digits, i.e.\n",
+ (Q / LOG(Radix)));
+ printf("roughly %g extra significant decimals.\n",
+ Q / LOG(10.));
+ }
+ printf("That feature is not tested further by this program.\n");
+ }
+ }
+ }
+ Pause();
+ /*=============================================*/
+ /*SPLIT
+ }
+#include "paranoia.h"
+part3(){
+*/
+ Milestone = 35;
+ /*=============================================*/
+ if (Radix >= Two) {
+ X = W / (Radix * Radix);
+ Y = X + One;
+ Z = Y - X;
+ T = Z + U2;
+ X = T - Z;
+ TstCond (Failure, X == U2,
+ "Subtraction is not normalized X=Y,X+Z != Y+Z!");
+ if (X == U2) printf(
+ "Subtraction appears to be normalized, as it should be.");
+ }
+ printf("\nChecking for guard digit in *, /, and -.\n");
+ Y = F9 * One;
+ Z = One * F9;
+ X = F9 - Half;
+ Y = (Y - Half) - X;
+ Z = (Z - Half) - X;
+ X = One + U2;
+ T = X * Radix;
+ R = Radix * X;
+ X = T - Radix;
+ X = X - Radix * U2;
+ T = R - Radix;
+ T = T - Radix * U2;
+ X = X * (Radix - One);
+ T = T * (Radix - One);
+ if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T == Zero)) GMult = Yes;
+ else {
+ GMult = No;
+ TstCond (Serious, False,
+ "* lacks a Guard Digit, so 1*X != X");
+ }
+ Z = Radix * U2;
+ X = One + Z;
+ Y = FABS((X + Z) - X * X) - U2;
+ X = One - U2;
+ Z = FABS((X - U2) - X * X) - U1;
+ TstCond (Failure, (Y <= Zero)
+ && (Z <= Zero), "* gets too many final digits wrong.\n");
+ Y = One - U2;
+ X = One + U2;
+ Z = One / Y;
+ Y = Z - X;
+ X = One / Three;
+ Z = Three / Nine;
+ X = X - Z;
+ T = Nine / TwentySeven;
+ Z = Z - T;
+ TstCond(Defect, X == Zero && Y == Zero && Z == Zero,
+ "Division lacks a Guard Digit, so error can exceed 1 ulp\nor 1/3 and 3/9 and 9/27 may disagree");
+ Y = F9 / One;
+ X = F9 - Half;
+ Y = (Y - Half) - X;
+ X = One + U2;
+ T = X / One;
+ X = T - X;
+ if ((X == Zero) && (Y == Zero) && (Z == Zero)) GDiv = Yes;
+ else {
+ GDiv = No;
+ TstCond (Serious, False,
+ "Division lacks a Guard Digit, so X/1 != X");
+ }
+ X = One / (One + U2);
+ Y = X - Half - Half;
+ TstCond (Serious, Y < Zero,
+ "Computed value of 1/1.000..1 >= 1");
+ X = One - U2;
+ Y = One + Radix * U2;
+ Z = X * Radix;
+ T = Y * Radix;
+ R = Z / Radix;
+ StickyBit = T / Radix;
+ X = R - X;
+ Y = StickyBit - Y;
+ TstCond (Failure, X == Zero && Y == Zero,
+ "* and/or / gets too many last digits wrong");
+ Y = One - U1;
+ X = One - F9;
+ Y = One - Y;
+ T = Radix - U2;
+ Z = Radix - BMinusU2;
+ T = Radix - T;
+ if ((X == U1) && (Y == U1) && (Z == U2) && (T == U2)) GAddSub = Yes;
+ else {
+ GAddSub = No;
+ TstCond (Serious, False,
+ "- lacks Guard Digit, so cancellation is obscured");
+ }
+ if (F9 != One && F9 - One >= Zero) {
+ BadCond(Serious, "comparison alleges (1-U1) < 1 although\n");
+ printf(" subtraction yields (1-U1) - 1 = 0 , thereby vitiating\n");
+ printf(" such precautions against division by zero as\n");
+ printf(" ... if (X == 1.0) {.....} else {.../(X-1.0)...}\n");
+ }
+ if (GMult == Yes && GDiv == Yes && GAddSub == Yes) printf(
+ " *, /, and - appear to have guard digits, as they should.\n");
+ /*=============================================*/
+ Milestone = 40;
+ /*=============================================*/
+ Pause();
+ printf("Checking rounding on multiply, divide and add/subtract.\n");
+ RMult = Other;
+ RDiv = Other;
+ RAddSub = Other;
+ RadixD2 = Radix / Two;
+ A1 = Two;
+ Done = False;
+ do {
+ AInvrse = Radix;
+ do {
+ X = AInvrse;
+ AInvrse = AInvrse / A1;
+ } while ( ! (FLOOR(AInvrse) != AInvrse));
+ Done = (X == One) || (A1 > Three);
+ if (! Done) A1 = Nine + One;
+ } while ( ! (Done));
+ if (X == One) A1 = Radix;
+ AInvrse = One / A1;
+ X = A1;
+ Y = AInvrse;
+ Done = False;
+ do {
+ Z = X * Y - Half;
+ TstCond (Failure, Z == Half,
+ "X * (1/X) differs from 1");
+ Done = X == Radix;
+ X = Radix;
+ Y = One / X;
+ } while ( ! (Done));
+ Y2 = One + U2;
+ Y1 = One - U2;
+ X = OneAndHalf - U2;
+ Y = OneAndHalf + U2;
+ Z = (X - U2) * Y2;
+ T = Y * Y1;
+ Z = Z - X;
+ T = T - X;
+ X = X * Y2;
+ Y = (Y + U2) * Y1;
+ X = X - OneAndHalf;
+ Y = Y - OneAndHalf;
+ if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T <= Zero)) {
+ X = (OneAndHalf + U2) * Y2;
+ Y = OneAndHalf - U2 - U2;
+ Z = OneAndHalf + U2 + U2;
+ T = (OneAndHalf - U2) * Y1;
+ X = X - (Z + U2);
+ StickyBit = Y * Y1;
+ S = Z * Y2;
+ T = T - Y;
+ Y = (U2 - Y) + StickyBit;
+ Z = S - (Z + U2 + U2);
+ StickyBit = (Y2 + U2) * Y1;
+ Y1 = Y2 * Y1;
+ StickyBit = StickyBit - Y2;
+ Y1 = Y1 - Half;
+ if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T == Zero)
+ && ( StickyBit == Zero) && (Y1 == Half)) {
+ RMult = Rounded;
+ printf("Multiplication appears to round correctly.\n");
+ }
+ else if ((X + U2 == Zero) && (Y < Zero) && (Z + U2 == Zero)
+ && (T < Zero) && (StickyBit + U2 == Zero)
+ && (Y1 < Half)) {
+ RMult = Chopped;
+ printf("Multiplication appears to chop.\n");
+ }
+ else printf("* is neither chopped nor correctly rounded.\n");
+ if ((RMult == Rounded) && (GMult == No)) notify("Multiplication");
+ }
+ else printf("* is neither chopped nor correctly rounded.\n");
+ /*=============================================*/
+ Milestone = 45;
+ /*=============================================*/
+ Y2 = One + U2;
+ Y1 = One - U2;
+ Z = OneAndHalf + U2 + U2;
+ X = Z / Y2;
+ T = OneAndHalf - U2 - U2;
+ Y = (T - U2) / Y1;
+ Z = (Z + U2) / Y2;
+ X = X - OneAndHalf;
+ Y = Y - T;
+ T = T / Y1;
+ Z = Z - (OneAndHalf + U2);
+ T = (U2 - OneAndHalf) + T;
+ if (! ((X > Zero) || (Y > Zero) || (Z > Zero) || (T > Zero))) {
+ X = OneAndHalf / Y2;
+ Y = OneAndHalf - U2;
+ Z = OneAndHalf + U2;
+ X = X - Y;
+ T = OneAndHalf / Y1;
+ Y = Y / Y1;
+ T = T - (Z + U2);
+ Y = Y - Z;
+ Z = Z / Y2;
+ Y1 = (Y2 + U2) / Y2;
+ Z = Z - OneAndHalf;
+ Y2 = Y1 - Y2;
+ Y1 = (F9 - U1) / F9;
+ if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T == Zero)
+ && (Y2 == Zero) && (Y2 == Zero)
+ && (Y1 - Half == F9 - Half )) {
+ RDiv = Rounded;
+ printf("Division appears to round correctly.\n");
+ if (GDiv == No) notify("Division");
+ }
+ else if ((X < Zero) && (Y < Zero) && (Z < Zero) && (T < Zero)
+ && (Y2 < Zero) && (Y1 - Half < F9 - Half)) {
+ RDiv = Chopped;
+ printf("Division appears to chop.\n");
+ }
+ }
+ if (RDiv == Other) printf("/ is neither chopped nor correctly rounded.\n");
+ BInvrse = One / Radix;
+ TstCond (Failure, (BInvrse * Radix - Half == Half),
+ "Radix * ( 1 / Radix ) differs from 1");
+ /*=============================================*/
+ /*SPLIT
+ }
+#include "paranoia.h"
+part4(){
+*/
+ Milestone = 50;
+ /*=============================================*/
+ TstCond (Failure, ((F9 + U1) - Half == Half)
+ && ((BMinusU2 + U2 ) - One == Radix - One),
+ "Incomplete carry-propagation in Addition");
+ X = One - U1 * U1;
+ Y = One + U2 * (One - U2);
+ Z = F9 - Half;
+ X = (X - Half) - Z;
+ Y = Y - One;
+ if ((X == Zero) && (Y == Zero)) {
+ RAddSub = Chopped;
+ printf("Add/Subtract appears to be chopped.\n");
+ }
+ if (GAddSub == Yes) {
+ X = (Half + U2) * U2;
+ Y = (Half - U2) * U2;
+ X = One + X;
+ Y = One + Y;
+ X = (One + U2) - X;
+ Y = One - Y;
+ if ((X == Zero) && (Y == Zero)) {
+ X = (Half + U2) * U1;
+ Y = (Half - U2) * U1;
+ X = One - X;
+ Y = One - Y;
+ X = F9 - X;
+ Y = One - Y;
+ if ((X == Zero) && (Y == Zero)) {
+ RAddSub = Rounded;
+ printf("Addition/Subtraction appears to round correctly.\n");
+ if (GAddSub == No) notify("Add/Subtract");
+ }
+ else printf("Addition/Subtraction neither rounds nor chops.\n");
+ }
+ else printf("Addition/Subtraction neither rounds nor chops.\n");
+ }
+ else printf("Addition/Subtraction neither rounds nor chops.\n");
+ S = One;
+ X = One + Half * (One + Half);
+ Y = (One + U2) * Half;
+ Z = X - Y;
+ T = Y - X;
+ StickyBit = Z + T;
+ if (StickyBit != Zero) {
+ S = Zero;
+ BadCond(Flaw, "(X - Y) + (Y - X) is non zero!\n");
+ }
+ StickyBit = Zero;
+ if ((GMult == Yes) && (GDiv == Yes) && (GAddSub == Yes)
+ && (RMult == Rounded) && (RDiv == Rounded)
+ && (RAddSub == Rounded) && (FLOOR(RadixD2) == RadixD2)) {
+ printf("Checking for sticky bit.\n");
+ X = (Half + U1) * U2;
+ Y = Half * U2;
+ Z = One + Y;
+ T = One + X;
+ if ((Z - One <= Zero) && (T - One >= U2)) {
+ Z = T + Y;
+ Y = Z - X;
+ if ((Z - T >= U2) && (Y - T == Zero)) {
+ X = (Half + U1) * U1;
+ Y = Half * U1;
+ Z = One - Y;
+ T = One - X;
+ if ((Z - One == Zero) && (T - F9 == Zero)) {
+ Z = (Half - U1) * U1;
+ T = F9 - Z;
+ Q = F9 - Y;
+ if ((T - F9 == Zero) && (F9 - U1 - Q == Zero)) {
+ Z = (One + U2) * OneAndHalf;
+ T = (OneAndHalf + U2) - Z + U2;
+ X = One + Half / Radix;
+ Y = One + Radix * U2;
+ Z = X * Y;
+ if (T == Zero && X + Radix * U2 - Z == Zero) {
+ if (Radix != Two) {
+ X = Two + U2;
+ Y = X / Two;
+ if ((Y - One == Zero)) StickyBit = S;
+ }
+ else StickyBit = S;
+ }
+ }
+ }
+ }
+ }
+ }
+ if (StickyBit == One) printf("Sticky bit apparently used correctly.\n");
+ else printf("Sticky bit used incorrectly or not at all.\n");
+ TstCond (Flaw, !(GMult == No || GDiv == No || GAddSub == No ||
+ RMult == Other || RDiv == Other || RAddSub == Other),
+ "lack(s) of guard digits or failure(s) to correctly round or chop\n(noted above) count as one flaw in the final tally below");
+ /*=============================================*/
+ Milestone = 60;
+ /*=============================================*/
+ printf("\n");
+ printf("Does Multiplication commute? ");
+ printf("Testing on %d random pairs.\n", NoTrials);
+ Random9 = SQRT(3.0);
+ Random1 = Third;
+ I = 1;
+ do {
+ X = Random();
+ Y = Random();
+ Z9 = Y * X;
+ Z = X * Y;
+ Z9 = Z - Z9;
+ I = I + 1;
+ } while ( ! ((I > NoTrials) || (Z9 != Zero)));
+ if (I == NoTrials) {
+ Random1 = One + Half / Three;
+ Random2 = (U2 + U1) + One;
+ Z = Random1 * Random2;
+ Y = Random2 * Random1;
+ Z9 = (One + Half / Three) * ((U2 + U1) + One) - (One + Half /
+ Three) * ((U2 + U1) + One);
+ }
+ if (! ((I == NoTrials) || (Z9 == Zero)))
+ BadCond(Defect, "X * Y == Y * X trial fails.\n");
+ else printf(" No failures found in %d integer pairs.\n", NoTrials);
+ /*=============================================*/
+ Milestone = 70;
+ /*=============================================*/
+ printf("\nRunning test of square root(x).\n");
+ TstCond (Failure, (Zero == SQRT(Zero))
+ && (- Zero == SQRT(- Zero))
+ && (One == SQRT(One)), "Square root of 0.0, -0.0 or 1.0 wrong");
+ MinSqEr = Zero;
+ MaxSqEr = Zero;
+ J = Zero;
+ X = Radix;
+ OneUlp = U2;
+ SqXMinX (Serious);
+ X = BInvrse;
+ OneUlp = BInvrse * U1;
+ SqXMinX (Serious);
+ X = U1;
+ OneUlp = U1 * U1;
+ SqXMinX (Serious);
+ if (J != Zero) Pause();
+ printf("Testing if sqrt(X * X) == X for %d Integers X.\n", NoTrials);
+ J = Zero;
+ X = Two;
+ Y = Radix;
+ if ((Radix != One)) do {
+ X = Y;
+ Y = Radix * Y;
+ } while ( ! ((Y - X >= NoTrials)));
+ OneUlp = X * U2;
+ I = 1;
+ while (I <= NoTrials) {
+ X = X + One;
+ SqXMinX (Defect);
+ if (J > Zero) break;
+ I = I + 1;
+ }
+ printf("Test for sqrt monotonicity.\n");
+ I = - 1;
+ X = BMinusU2;
+ Y = Radix;
+ Z = Radix + Radix * U2;
+ NotMonot = False;
+ Monot = False;
+ while ( ! (NotMonot || Monot)) {
+ I = I + 1;
+ X = SQRT(X);
+ Q = SQRT(Y);
+ Z = SQRT(Z);
+ if ((X > Q) || (Q > Z)) NotMonot = True;
+ else {
+ Q = FLOOR(Q + Half);
+ if ((I > 0) || (Radix == Q * Q)) Monot = True;
+ else if (I > 0) {
+ if (I > 1) Monot = True;
+ else {
+ Y = Y * BInvrse;
+ X = Y - U1;
+ Z = Y + U1;
+ }
+ }
+ else {
+ Y = Q;
+ X = Y - U2;
+ Z = Y + U2;
+ }
+ }
+ }
+ if (Monot) printf("sqrt has passed a test for Monotonicity.\n");
+ else {
+ BadCond(Defect, "");
+ printf("sqrt(X) is non-monotonic for X near %.7e .\n", Y);
+ }
+ /*=============================================*/
+ /*SPLIT
+ }
+#include "paranoia.h"
+part5(){
+*/
+ Milestone = 80;
+ /*=============================================*/
+ MinSqEr = MinSqEr + Half;
+ MaxSqEr = MaxSqEr - Half;
+ Y = (SQRT(One + U2) - One) / U2;
+ SqEr = (Y - One) + U2 / Eight;
+ if (SqEr > MaxSqEr) MaxSqEr = SqEr;
+ SqEr = Y + U2 / Eight;
+ if (SqEr < MinSqEr) MinSqEr = SqEr;
+ Y = ((SQRT(F9) - U2) - (One - U2)) / U1;
+ SqEr = Y + U1 / Eight;
+ if (SqEr > MaxSqEr) MaxSqEr = SqEr;
+ SqEr = (Y + One) + U1 / Eight;
+ if (SqEr < MinSqEr) MinSqEr = SqEr;
+ OneUlp = U2;
+ X = OneUlp;
+ for( Indx = 1; Indx <= 3; ++Indx) {
+ Y = SQRT((X + U1 + X) + F9);
+ Y = ((Y - U2) - ((One - U2) + X)) / OneUlp;
+ Z = ((U1 - X) + F9) * Half * X * X / OneUlp;
+ SqEr = (Y + Half) + Z;
+ if (SqEr < MinSqEr) MinSqEr = SqEr;
+ SqEr = (Y - Half) + Z;
+ if (SqEr > MaxSqEr) MaxSqEr = SqEr;
+ if (((Indx == 1) || (Indx == 3)))
+ X = OneUlp * Sign (X) * FLOOR(Eight / (Nine * SQRT(OneUlp)));
+ else {
+ OneUlp = U1;
+ X = - OneUlp;
+ }
+ }
+ /*=============================================*/
+ Milestone = 85;
+ /*=============================================*/
+ SqRWrng = False;
+ Anomaly = False;
+ RSqrt = Other; /* ~dgh */
+ if (Radix != One) {
+ printf("Testing whether sqrt is rounded or chopped.\n");
+ D = FLOOR(Half + POW(Radix, One + Precision - FLOOR(Precision)));
+ /* ... == Radix^(1 + fract) if (Precision == Integer + fract. */
+ X = D / Radix;
+ Y = D / A1;
+ if ((X != FLOOR(X)) || (Y != FLOOR(Y))) {
+ Anomaly = True;
+ }
+ else {
+ X = Zero;
+ Z2 = X;
+ Y = One;
+ Y2 = Y;
+ Z1 = Radix - One;
+ FourD = Four * D;
+ do {
+ if (Y2 > Z2) {
+ Q = Radix;
+ Y1 = Y;
+ do {
+ X1 = FABS(Q + FLOOR(Half - Q / Y1) * Y1);
+ Q = Y1;
+ Y1 = X1;
+ } while ( ! (X1 <= Zero));
+ if (Q <= One) {
+ Z2 = Y2;
+ Z = Y;
+ }
+ }
+ Y = Y + Two;
+ X = X + Eight;
+ Y2 = Y2 + X;
+ if (Y2 >= FourD) Y2 = Y2 - FourD;
+ } while ( ! (Y >= D));
+ X8 = FourD - Z2;
+ Q = (X8 + Z * Z) / FourD;
+ X8 = X8 / Eight;
+ if (Q != FLOOR(Q)) Anomaly = True;
+ else {
+ Break = False;
+ do {
+ X = Z1 * Z;
+ X = X - FLOOR(X / Radix) * Radix;
+ if (X == One)
+ Break = True;
+ else
+ Z1 = Z1 - One;
+ } while ( ! (Break || (Z1 <= Zero)));
+ if ((Z1 <= Zero) && (! Break)) Anomaly = True;
+ else {
+ if (Z1 > RadixD2) Z1 = Z1 - Radix;
+ do {
+ NewD();
+ } while ( ! (U2 * D >= F9));
+ if (D * Radix - D != W - D) Anomaly = True;
+ else {
+ Z2 = D;
+ I = 0;
+ Y = D + (One + Z) * Half;
+ X = D + Z + Q;
+ SR3750();
+ Y = D + (One - Z) * Half + D;
+ X = D - Z + D;
+ X = X + Q + X;
+ SR3750();
+ NewD();
+ if (D - Z2 != W - Z2) Anomaly = True;
+ else {
+ Y = (D - Z2) + (Z2 + (One - Z) * Half);
+ X = (D - Z2) + (Z2 - Z + Q);
+ SR3750();
+ Y = (One + Z) * Half;
+ X = Q;
+ SR3750();
+ if (I == 0) Anomaly = True;
+ }
+ }
+ }
+ }
+ }
+ if ((I == 0) || Anomaly) {
+ BadCond(Failure, "Anomalous arithmetic with Integer < ");
+ printf("Radix^Precision = %.7e\n", W);
+ printf(" fails test whether sqrt rounds or chops.\n");
+ SqRWrng = True;
+ }
+ }
+ if (! Anomaly) {
+ if (! ((MinSqEr < Zero) || (MaxSqEr > Zero))) {
+ RSqrt = Rounded;
+ printf("Square root appears to be correctly rounded.\n");
+ }
+ else {
+ if ((MaxSqEr + U2 > U2 - Half) || (MinSqEr > Half)
+ || (MinSqEr + Radix < Half)) SqRWrng = True;
+ else {
+ RSqrt = Chopped;
+ printf("Square root appears to be chopped.\n");
+ }
+ }
+ }
+ if (SqRWrng) {
+ printf("Square root is neither chopped nor correctly rounded.\n");
+ printf("Observed errors run from %.7e ", MinSqEr - Half);
+ printf("to %.7e ulps.\n", Half + MaxSqEr);
+ TstCond (Serious, MaxSqEr - MinSqEr < Radix * Radix,
+ "sqrt gets too many last digits wrong");
+ }
+ /*=============================================*/
+ Milestone = 90;
+ /*=============================================*/
+ Pause();
+ printf("Testing powers Z^i for small Integers Z and i.\n");
+ N = 0;
+ /* ... test powers of zero. */
+ I = 0;
+ Z = -Zero;
+ M = 3.0;
+ Break = False;
+ do {
+ X = One;
+ SR3980();
+ if (I <= 10) {
+ I = 1023;
+ SR3980();
+ }
+ if (Z == MinusOne) Break = True;
+ else {
+ Z = MinusOne;
+ PrintIfNPositive();
+ N = 0;
+ /* .. if(-1)^N is invalid, replace MinusOne by One. */
+ I = - 4;
+ }
+ } while ( ! Break);
+ PrintIfNPositive();
+ N1 = N;
+ N = 0;
+ Z = A1;
+ M = FLOOR(Two * LOG(W) / LOG(A1));
+ Break = False;
+ do {
+ X = Z;
+ I = 1;
+ SR3980();
+ if (Z == AInvrse) Break = True;
+ else Z = AInvrse;
+ } while ( ! (Break));
+ /*=============================================*/
+ Milestone = 100;
+ /*=============================================*/
+ /* Powers of Radix have been tested, */
+ /* next try a few primes */
+ M = NoTrials;
+ Z = Three;
+ do {
+ X = Z;
+ I = 1;
+ SR3980();
+ do {
+ Z = Z + Two;
+ } while ( Three * FLOOR(Z / Three) == Z );
+ } while ( Z < Eight * Three );
+ if (N > 0) {
+ printf("Errors like this may invalidate financial calculations\n");
+ printf("\tinvolving interest rates.\n");
+ }
+ PrintIfNPositive();
+ N += N1;
+ if (N == 0) printf("... no discrepancis found.\n");
+ if (N > 0) Pause();
+ else printf("\n");
+ /*=============================================*/
+ /*SPLIT
+ }
+#include "paranoia.h"
+part6(){
+*/
+ Milestone = 110;
+ /*=============================================*/
+ printf("Seeking Underflow thresholds UfThold and E0.\n");
+ D = U1;
+ if (Precision != FLOOR(Precision)) {
+ D = BInvrse;
+ X = Precision;
+ do {
+ D = D * BInvrse;
+ X = X - One;
+ } while ( X > Zero);
+ }
+ Y = One;
+ Z = D;
+ /* ... D is power of 1/Radix < 1. */
+ do {
+ C = Y;
+ Y = Z;
+ Z = Y * Y;
+ } while ((Y > Z) && (Z + Z > Z));
+ Y = C;
+ Z = Y * D;
+ do {
+ C = Y;
+ Y = Z;
+ Z = Y * D;
+ } while ((Y > Z) && (Z + Z > Z));
+ if (Radix < Two) HInvrse = Two;
+ else HInvrse = Radix;
+ H = One / HInvrse;
+ /* ... 1/HInvrse == H == Min(1/Radix, 1/2) */
+ CInvrse = One / C;
+ E0 = C;
+ Z = E0 * H;
+ /* ...1/Radix^(BIG Integer) << 1 << CInvrse == 1/C */
+ do {
+ Y = E0;
+ E0 = Z;
+ Z = E0 * H;
+ } while ((E0 > Z) && (Z + Z > Z));
+ UfThold = E0;
+ E1 = Zero;
+ Q = Zero;
+ E9 = U2;
+ S = One + E9;
+ D = C * S;
+ if (D <= C) {
+ E9 = Radix * U2;
+ S = One + E9;
+ D = C * S;
+ if (D <= C) {
+ BadCond(Failure, "multiplication gets too many last digits wrong.\n");
+ Underflow = E0;
+ Y1 = Zero;
+ PseudoZero = Z;
+ Pause();
+ }
+ }
+ else {
+ Underflow = D;
+ PseudoZero = Underflow * H;
+ UfThold = Zero;
+ do {
+ Y1 = Underflow;
+ Underflow = PseudoZero;
+ if (E1 + E1 <= E1) {
+ Y2 = Underflow * HInvrse;
+ E1 = FABS(Y1 - Y2);
+ Q = Y1;
+ if ((UfThold == Zero) && (Y1 != Y2)) UfThold = Y1;
+ }
+ PseudoZero = PseudoZero * H;
+ } while ((Underflow > PseudoZero)
+ && (PseudoZero + PseudoZero > PseudoZero));
+ }
+ /* Comment line 4530 .. 4560 */
+ if (PseudoZero != Zero) {
+ printf("\n");
+ Z = PseudoZero;
+ /* ... Test PseudoZero for "phoney- zero" violates */
+ /* ... PseudoZero < Underflow or PseudoZero < PseudoZero + PseudoZero
+ ... */
+ if (PseudoZero <= Zero) {
+ BadCond(Failure, "Positive expressions can underflow to an\n");
+ printf("allegedly negative value\n");
+ printf("PseudoZero that prints out as: %g .\n", PseudoZero);
+ X = - PseudoZero;
+ if (X <= Zero) {
+ printf("But -PseudoZero, which should be\n");
+ printf("positive, isn't; it prints out as %g .\n", X);
+ }
+ }
+ else {
+ BadCond(Flaw, "Underflow can stick at an allegedly positive\n");
+ printf("value PseudoZero that prints out as %g .\n", PseudoZero);
+ }
+ TstPtUf();
+ }
+ /*=============================================*/
+ Milestone = 120;
+ /*=============================================*/
+ if (CInvrse * Y > CInvrse * Y1) {
+ S = H * S;
+ E0 = Underflow;
+ }
+ if (! ((E1 == Zero) || (E1 == E0))) {
+ BadCond(Defect, "");
+ if (E1 < E0) {
+ printf("Products underflow at a higher");
+ printf(" threshold than differences.\n");
+ if (PseudoZero == Zero)
+ E0 = E1;
+ }
+ else {
+ printf("Difference underflows at a higher");
+ printf(" threshold than products.\n");
+ }
+ }
+ printf("Smallest strictly positive number found is E0 = %g .\n", E0);
+ Z = E0;
+ TstPtUf();
+ Underflow = E0;
+ if (N == 1) Underflow = Y;
+ I = 4;
+ if (E1 == Zero) I = 3;
+ if (UfThold == Zero) I = I - 2;
+ UfNGrad = True;
+ switch (I) {
+ case 1:
+ UfThold = Underflow;
+ if ((CInvrse * Q) != ((CInvrse * Y) * S)) {
+ UfThold = Y;
+ BadCond(Failure, "Either accuracy deteriorates as numbers\n");
+ printf("approach a threshold = %.17e\n", UfThold);;
+ printf(" coming down from %.17e\n", C);
+ printf(" or else multiplication gets too many last digits wrong.\n");
+ }
+ Pause();
+ break;
+
+ case 2:
+ BadCond(Failure, "Underflow confuses Comparison, which alleges that\n");
+ printf("Q == Y while denying that |Q - Y| == 0; these values\n");
+ printf("print out as Q = %.17e, Y = %.17e .\n", Q, Y2);
+ printf ("|Q - Y| = %.17e .\n" , FABS(Q - Y2));
+ UfThold = Q;
+ break;
+
+ case 3:
+ X = X;
+ break;
+
+ case 4:
+ if ((Q == UfThold) && (E1 == E0)
+ && (FABS( UfThold - E1 / E9) <= E1)) {
+ UfNGrad = False;
+ printf("Underflow is gradual; it incurs Absolute Error =\n");
+ printf("(roundoff in UfThold) < E0.\n");
+ Y = E0 * CInvrse;
+ Y = Y * (OneAndHalf + U2);
+ X = CInvrse * (One + U2);
+ Y = Y / X;
+ IEEE = (Y == E0);
+ }
+ }
+ if (UfNGrad) {
+ printf("\n");
+ sigsave = sigfpe;
+ if (setjmp(ovfl_buf)) {
+ printf("Underflow / UfThold failed!\n");
+ R = H + H;
+ }
+ else R = SQRT(Underflow / UfThold);
+ sigsave = 0;
+ if (R <= H) {
+ Z = R * UfThold;
+ X = Z * (One + R * H * (One + H));
+ }
+ else {
+ Z = UfThold;
+ X = Z * (One + H * H * (One + H));
+ }
+ if (! ((X == Z) || (X - Z != Zero))) {
+ BadCond(Flaw, "");
+ printf("X = %.17e\n\tis not equal to Z = %.17e .\n", X, Z);
+ Z9 = X - Z;
+ printf("yet X - Z yields %.17e .\n", Z9);
+ printf(" Should this NOT signal Underflow, ");
+ printf("this is a SERIOUS DEFECT\nthat causes ");
+ printf("confusion when innocent statements like\n");;
+ printf(" if (X == Z) ... else");
+ printf(" ... (f(X) - f(Z)) / (X - Z) ...\n");
+ printf("encounter Division by Zero although actually\n");
+ sigsave = sigfpe;
+ if (setjmp(ovfl_buf)) printf("X / Z fails!\n");
+ else printf("X / Z = 1 + %g .\n", (X / Z - Half) - Half);
+ sigsave = 0;
+ }
+ }
+ printf("The Underflow threshold is %.17e, %s\n", UfThold,
+ " below which");
+ printf("calculation may suffer larger Relative error than ");
+ printf("merely roundoff.\n");
+ Y2 = U1 * U1;
+ Y = Y2 * Y2;
+ Y2 = Y * U1;
+ if (Y2 <= UfThold) {
+ if (Y > E0) {
+ BadCond(Defect, "");
+ I = 5;
+ }
+ else {
+ BadCond(Serious, "");
+ I = 4;
+ }
+ printf("Range is too narrow; U1^%d Underflows.\n", I);
+ }
+ /*=============================================*/
+ /*SPLIT
+ }
+#include "paranoia.h"
+part7(){
+*/
+ Milestone = 130;
+ /*=============================================*/
+ Y = - FLOOR(Half - TwoForty * LOG(UfThold) / LOG(HInvrse)) / TwoForty;
+ Y2 = Y + Y;
+ printf("Since underflow occurs below the threshold\n");
+ printf("UfThold = (%.17e) ^ (%.17e)\nonly underflow ", HInvrse, Y);
+ printf("should afflict the expression\n\t(%.17e) ^ (%.17e);\n", HInvrse, Y);
+ V9 = POW(HInvrse, Y2);
+ printf("actually calculating yields: %.17e .\n", V9);
+ if (! ((V9 >= Zero) && (V9 <= (Radix + Radix + E9) * UfThold))) {
+ BadCond(Serious, "this is not between 0 and underflow\n");
+ printf(" threshold = %.17e .\n", UfThold);
+ }
+ else if (! (V9 > UfThold * (One + E9)))
+ printf("This computed value is O.K.\n");
+ else {
+ BadCond(Defect, "this is not between 0 and underflow\n");
+ printf(" threshold = %.17e .\n", UfThold);
+ }
+ /*=============================================*/
+ Milestone = 140;
+ /*=============================================*/
+ printf("\n");
+ /* ...calculate Exp2 == exp(2) == 7.389056099... */
+ X = Zero;
+ I = 2;
+ Y = Two * Three;
+ Q = Zero;
+ N = 0;
+ do {
+ Z = X;
+ I = I + 1;
+ Y = Y / (I + I);
+ R = Y + Q;
+ X = Z + R;
+ Q = (Z - X) + R;
+ } while(X > Z);
+ Z = (OneAndHalf + One / Eight) + X / (OneAndHalf * ThirtyTwo);
+ X = Z * Z;
+ Exp2 = X * X;
+ X = F9;
+ Y = X - U1;
+ printf("Testing X^((X + 1) / (X - 1)) vs. exp(2) = %.17e as X -> 1.\n",
+ Exp2);
+ for(I = 1;;) {
+ Z = X - BInvrse;
+ Z = (X + One) / (Z - (One - BInvrse));
+ Q = POW(X, Z) - Exp2;
+ if (FABS(Q) > TwoForty * U2) {
+ N = 1;
+ V9 = (X - BInvrse) - (One - BInvrse);
+ BadCond(Defect, "Calculated");
+ printf(" %.17e for\n", POW(X,Z));
+ printf("\t(1 + (%.17e) ^ (%.17e);\n", V9, Z);
+ printf("\tdiffers from correct value by %.17e .\n", Q);
+ printf("\tThis much error may spoil financial\n");
+ printf("\tcalculations involving tiny interest rates.\n");
+ break;
+ }
+ else {
+ Z = (Y - X) * Two + Y;
+ X = Y;
+ Y = Z;
+ Z = One + (X - F9)*(X - F9);
+ if (Z > One && I < NoTrials) I++;
+ else {
+ if (X > One) {
+ if (N == 0)
+ printf("Accuracy seems adequate.\n");
+ break;
+ }
+ else {
+ X = One + U2;
+ Y = U2 + U2;
+ Y += X;
+ I = 1;
+ }
+ }
+ }
+ }
+ /*=============================================*/
+ Milestone = 150;
+ /*=============================================*/
+ printf("Testing powers Z^Q at four nearly extreme values.\n");
+ N = 0;
+ Z = A1;
+ Q = FLOOR(Half - LOG(C) / LOG(A1));
+ Break = False;
+ do {
+ X = CInvrse;
+ Y = POW(Z, Q);
+ IsYeqX();
+ Q = - Q;
+ X = C;
+ Y = POW(Z, Q);
+ IsYeqX();
+ if (Z < One) Break = True;
+ else Z = AInvrse;
+ } while ( ! (Break));
+ PrintIfNPositive();
+ if (N == 0) printf(" ... no discrepancies found.\n");
+ printf("\n");
+
+ /*=============================================*/
+ Milestone = 160;
+ /*=============================================*/
+ Pause();
+ printf("Searching for Overflow threshold:\n");
+ printf("This may generate an error.\n");
+ Y = - CInvrse;
+ V9 = HInvrse * Y;
+ sigsave = sigfpe;
+ if (setjmp(ovfl_buf)) { I = 0; V9 = Y; goto overflow; }
+ do {
+ V = Y;
+ Y = V9;
+ V9 = HInvrse * Y;
+ } while(V9 < Y);
+ I = 1;
+overflow:
+ sigsave = 0;
+ Z = V9;
+ printf("Can `Z = -Y' overflow?\n");
+ printf("Trying it on Y = %.17e .\n", Y);
+ V9 = - Y;
+ V0 = V9;
+ if (V - Y == V + V0) printf("Seems O.K.\n");
+ else {
+ printf("finds a ");
+ BadCond(Flaw, "-(-Y) differs from Y.\n");
+ }
+ if (Z != Y) {
+ BadCond(Serious, "");
+ printf("overflow past %.17e\n\tshrinks to %.17e .\n", Y, Z);
+ }
+ if (I) {
+ Y = V * (HInvrse * U2 - HInvrse);
+ Z = Y + ((One - HInvrse) * U2) * V;
+ if (Z < V0) Y = Z;
+ if (Y < V0) V = Y;
+ if (V0 - V < V0) V = V0;
+ }
+ else {
+ V = Y * (HInvrse * U2 - HInvrse);
+ V = V + ((One - HInvrse) * U2) * Y;
+ }
+ printf("Overflow threshold is V = %.17e .\n", V);
+ if (I) printf("Overflow saturates at V0 = %.17e .\n", V0);
+ else printf("There is no saturation value because the system traps on overflow.\n");
+ V9 = V * One;
+ printf("No Overflow should be signaled for V * 1 = %.17e\n", V9);
+ V9 = V / One;
+ printf(" nor for V / 1 = %.17e .\n", V9);
+ printf("Any overflow signal separating this * from the one\n");
+ printf("above is a DEFECT.\n");
+ /*=============================================*/
+ Milestone = 170;
+ /*=============================================*/
+ if (!(-V < V && -V0 < V0 && -UfThold < V && UfThold < V)) {
+ BadCond(Failure, "Comparisons involving ");
+ printf("+-%g, +-%g\nand +-%g are confused by Overflow.",
+ V, V0, UfThold);
+ }
+ /*=============================================*/
+ Milestone = 175;
+ /*=============================================*/
+ printf("\n");
+ for(Indx = 1; Indx <= 3; ++Indx) {
+ switch (Indx) {
+ case 1: Z = UfThold; break;
+ case 2: Z = E0; break;
+ case 3: Z = PseudoZero; break;
+ }
+ if (Z != Zero) {
+ V9 = SQRT(Z);
+ Y = V9 * V9;
+ if (Y / (One - Radix * E9) < Z
+ || Y > (One + Radix * E9) * Z) { /* dgh: + E9 --> * E9 */
+ if (V9 > U1) BadCond(Serious, "");
+ else BadCond(Defect, "");
+ printf("Comparison alleges that what prints as Z = %.17e\n", Z);
+ printf(" is too far from sqrt(Z) ^ 2 = %.17e .\n", Y);
+ }
+ }
+ }
+ /*=============================================*/
+ Milestone = 180;
+ /*=============================================*/
+ for(Indx = 1; Indx <= 2; ++Indx) {
+ if (Indx == 1) Z = V;
+ else Z = V0;
+ V9 = SQRT(Z);
+ X = (One - Radix * E9) * V9;
+ V9 = V9 * X;
+ if (((V9 < (One - Two * Radix * E9) * Z) || (V9 > Z))) {
+ Y = V9;
+ if (X < W) BadCond(Serious, "");
+ else BadCond(Defect, "");
+ printf("Comparison alleges that Z = %17e\n", Z);
+ printf(" is too far from sqrt(Z) ^ 2 (%.17e) .\n", Y);
+ }
+ }
+ /*=============================================*/
+ /*SPLIT
+ }
+#include "paranoia.h"
+part8(){
+*/
+ Milestone = 190;
+ /*=============================================*/
+ Pause();
+ X = UfThold * V;
+ Y = Radix * Radix;
+ if (X*Y < One || X > Y) {
+ if (X * Y < U1 || X > Y/U1) BadCond(Defect, "Badly");
+ else BadCond(Flaw, "");
+
+ printf(" unbalanced range; UfThold * V = %.17e\n\t%s\n",
+ X, "is too far from 1.\n");
+ }
+ /*=============================================*/
+ Milestone = 200;
+ /*=============================================*/
+ for (Indx = 1; Indx <= 5; ++Indx) {
+ X = F9;
+ switch (Indx) {
+ case 2: X = One + U2; break;
+ case 3: X = V; break;
+ case 4: X = UfThold; break;
+ case 5: X = Radix;
+ }
+ Y = X;
+ sigsave = sigfpe;
+ if (setjmp(ovfl_buf))
+ printf(" X / X traps when X = %g\n", X);
+ else {
+ V9 = (Y / X - Half) - Half;
+ if (V9 == Zero) continue;
+ if (V9 == - U1 && Indx < 5) BadCond(Flaw, "");
+ else BadCond(Serious, "");
+ printf(" X / X differs from 1 when X = %.17e\n", X);
+ printf(" instead, X / X - 1/2 - 1/2 = %.17e .\n", V9);
+ }
+ sigsave = 0;
+ }
+ /*=============================================*/
+ Milestone = 210;
+ /*=============================================*/
+ MyZero = Zero;
+ printf("\n");
+ printf("What message and/or values does Division by Zero produce?\n") ;
+#ifndef NOPAUSE
+ printf("This can interupt your program. You can ");
+ printf("skip this part if you wish.\n");
+ printf("Do you wish to compute 1 / 0? ");
+ fflush(stdout);
+ read (KEYBOARD, ch, 8);
+ if ((ch[0] == 'Y') || (ch[0] == 'y')) {
+#endif
+ sigsave = sigfpe;
+ printf(" Trying to compute 1 / 0 produces ...");
+ if (!setjmp(ovfl_buf)) printf(" %.7e .\n", One / MyZero);
+ sigsave = 0;
+#ifndef NOPAUSE
+ }
+ else printf("O.K.\n");
+ printf("\nDo you wish to compute 0 / 0? ");
+ fflush(stdout);
+ read (KEYBOARD, ch, 80);
+ if ((ch[0] == 'Y') || (ch[0] == 'y')) {
+#endif
+ sigsave = sigfpe;
+ printf("\n Trying to compute 0 / 0 produces ...");
+ if (!setjmp(ovfl_buf)) printf(" %.7e .\n", Zero / MyZero);
+ sigsave = 0;
+#ifndef NOPAUSE
+ }
+ else printf("O.K.\n");
+#endif
+ /*=============================================*/
+ Milestone = 220;
+ /*=============================================*/
+ Pause();
+ printf("\n");
+ {
+ static char *msg[] = {
+ "FAILUREs encountered =",
+ "SERIOUS DEFECTs discovered =",
+ "DEFECTs discovered =",
+ "FLAWs discovered =" };
+ int i;
+ for(i = 0; i < 4; i++) if (ErrCnt[i])
+ printf("The number of %-29s %d.\n",
+ msg[i], ErrCnt[i]);
+ }
+ printf("\n");
+ if ((ErrCnt[Failure] + ErrCnt[Serious] + ErrCnt[Defect]
+ + ErrCnt[Flaw]) > 0) {
+ if ((ErrCnt[Failure] + ErrCnt[Serious] + ErrCnt[
+ Defect] == 0) && (ErrCnt[Flaw] > 0)) {
+ printf("The arithmetic diagnosed seems ");
+ printf("Satisfactory though flawed.\n");
+ }
+ if ((ErrCnt[Failure] + ErrCnt[Serious] == 0)
+ && ( ErrCnt[Defect] > 0)) {
+ printf("The arithmetic diagnosed may be Acceptable\n");
+ printf("despite inconvenient Defects.\n");
+ }
+ if ((ErrCnt[Failure] + ErrCnt[Serious]) > 0) {
+ printf("The arithmetic diagnosed has ");
+ printf("unacceptable Serious Defects.\n");
+ }
+ if (ErrCnt[Failure] > 0) {
+ printf("Potentially fatal FAILURE may have spoiled this");
+ printf(" program's subsequent diagnoses.\n");
+ }
+ }
+ else {
+ printf("No failures, defects nor flaws have been discovered.\n");
+ if (! ((RMult == Rounded) && (RDiv == Rounded)
+ && (RAddSub == Rounded) && (RSqrt == Rounded)))
+ printf("The arithmetic diagnosed seems Satisfactory.\n");
+ else {
+ if (StickyBit >= One &&
+ (Radix - Two) * (Radix - Nine - One) == Zero) {
+ printf("Rounding appears to conform to ");
+ printf("the proposed IEEE standard P");
+ if ((Radix == Two) &&
+ ((Precision - Four * Three * Two) *
+ ( Precision - TwentySeven -
+ TwentySeven + One) == Zero))
+ printf("754");
+ else printf("854");
+ if (IEEE) printf(".\n");
+ else {
+ printf(",\nexcept for possibly Double Rounding");
+ printf(" during Gradual Underflow.\n");
+ }
+ }
+ printf("The arithmetic diagnosed appears to be Excellent!\n");
+ }
+ }
+ if (fpecount)
+ printf("\nA total of %d floating point exceptions were registered.\n",
+ fpecount);
+ printf("END OF TEST.\n");
+ return 0;
+ }
+
+/*SPLIT subs.c
+#include "paranoia.h"
+*/
+
+/* Sign */
+
+FLOAT Sign (X)
+FLOAT X;
+{ return X >= 0. ? 1.0 : -1.0; }
+
+/* Pause */
+
+Pause()
+{
+#ifndef NOPAUSE
+ char ch[8];
+
+ printf("\nTo continue, press RETURN");
+ fflush(stdout);
+ read(KEYBOARD, ch, 8);
+#endif
+ printf("\nDiagnosis resumes after milestone Number %d", Milestone);
+ printf(" Page: %d\n\n", PageNo);
+ ++Milestone;
+ ++PageNo;
+ }
+
+ /* TstCond */
+
+TstCond (K, Valid, T)
+int K, Valid;
+char *T;
+{ if (! Valid) { BadCond(K,T); printf(".\n"); } }
+
+BadCond(K, T)
+int K;
+char *T;
+{
+ static char *msg[] = { "FAILURE", "SERIOUS DEFECT", "DEFECT", "FLAW" };
+
+ ErrCnt [K] = ErrCnt [K] + 1;
+ printf("%s: %s", msg[K], T);
+ }
+
+/* Random */
+/* Random computes
+ X = (Random1 + Random9)^5
+ Random1 = X - FLOOR(X) + 0.000005 * X;
+ and returns the new value of Random1
+*/
+
+FLOAT Random()
+{
+ FLOAT X, Y;
+
+ X = Random1 + Random9;
+ Y = X * X;
+ Y = Y * Y;
+ X = X * Y;
+ Y = X - FLOOR(X);
+ Random1 = Y + X * 0.000005;
+ return(Random1);
+ }
+
+/* SqXMinX */
+
+SqXMinX (ErrKind)
+int ErrKind;
+{
+ FLOAT XA, XB;
+
+ XB = X * BInvrse;
+ XA = X - XB;
+ SqEr = ((SQRT(X * X) - XB) - XA) / OneUlp;
+ if (SqEr != Zero) {
+ if (SqEr < MinSqEr) MinSqEr = SqEr;
+ if (SqEr > MaxSqEr) MaxSqEr = SqEr;
+ J = J + 1.0;
+ BadCond(ErrKind, "\n");
+ printf("sqrt( %.17e) - %.17e = %.17e\n", X * X, X, OneUlp * SqEr);
+ printf("\tinstead of correct value 0 .\n");
+ }
+ }
+
+/* NewD */
+
+NewD()
+{
+ X = Z1 * Q;
+ X = FLOOR(Half - X / Radix) * Radix + X;
+ Q = (Q - X * Z) / Radix + X * X * (D / Radix);
+ Z = Z - Two * X * D;
+ if (Z <= Zero) {
+ Z = - Z;
+ Z1 = - Z1;
+ }
+ D = Radix * D;
+ }
+
+/* SR3750 */
+
+SR3750()
+{
+ if (! ((X - Radix < Z2 - Radix) || (X - Z2 > W - Z2))) {
+ I = I + 1;
+ X2 = SQRT(X * D);
+ Y2 = (X2 - Z2) - (Y - Z2);
+ X2 = X8 / (Y - Half);
+ X2 = X2 - Half * X2 * X2;
+ SqEr = (Y2 + Half) + (Half - X2);
+ if (SqEr < MinSqEr) MinSqEr = SqEr;
+ SqEr = Y2 - X2;
+ if (SqEr > MaxSqEr) MaxSqEr = SqEr;
+ }
+ }
+
+/* IsYeqX */
+
+IsYeqX()
+{
+ if (Y != X) {
+ if (N <= 0) {
+ if (Z == Zero && Q <= Zero)
+ printf("WARNING: computing\n");
+ else BadCond(Defect, "computing\n");
+ printf("\t(%.17e) ^ (%.17e)\n", Z, Q);
+ printf("\tyielded %.17e;\n", Y);
+ printf("\twhich compared unequal to correct %.17e ;\n",
+ X);
+ printf("\t\tthey differ by %.17e .\n", Y - X);
+ }
+ N = N + 1; /* ... count discrepancies. */
+ }
+ }
+
+/* SR3980 */
+
+SR3980()
+{
+ do {
+ Q = (FLOAT) I;
+ Y = POW(Z, Q);
+ IsYeqX();
+ if (++I > M) break;
+ X = Z * X;
+ } while ( X < W );
+ }
+
+/* PrintIfNPositive */
+
+PrintIfNPositive()
+{
+ if (N > 0) printf("Similar discrepancies have occurred %d times.\n", N);
+ }
+
+/* TstPtUf */
+
+TstPtUf()
+{
+ N = 0;
+ if (Z != Zero) {
+ printf("Since comparison denies Z = 0, evaluating ");
+ printf("(Z + Z) / Z should be safe.\n");
+ sigsave = sigfpe;
+ if (setjmp(ovfl_buf)) goto very_serious;
+ Q9 = (Z + Z) / Z;
+ printf("What the machine gets for (Z + Z) / Z is %.17e .\n",
+ Q9);
+ if (FABS(Q9 - Two) < Radix * U2) {
+ printf("This is O.K., provided Over/Underflow");
+ printf(" has NOT just been signaled.\n");
+ }
+ else {
+ if ((Q9 < One) || (Q9 > Two)) {
+very_serious:
+ N = 1;
+ ErrCnt [Serious] = ErrCnt [Serious] + 1;
+ printf("This is a VERY SERIOUS DEFECT!\n");
+ }
+ else {
+ N = 1;
+ ErrCnt [Defect] = ErrCnt [Defect] + 1;
+ printf("This is a DEFECT!\n");
+ }
+ }
+ sigsave = 0;
+ V9 = Z * One;
+ Random1 = V9;
+ V9 = One * Z;
+ Random2 = V9;
+ V9 = Z / One;
+ if ((Z == Random1) && (Z == Random2) && (Z == V9)) {
+ if (N > 0) Pause();
+ }
+ else {
+ N = 1;
+ BadCond(Defect, "What prints as Z = ");
+ printf("%.17e\n\tcompares different from ", Z);
+ if (Z != Random1) printf("Z * 1 = %.17e ", Random1);
+ if (! ((Z == Random2)
+ || (Random2 == Random1)))
+ printf("1 * Z == %g\n", Random2);
+ if (! (Z == V9)) printf("Z / 1 = %.17e\n", V9);
+ if (Random2 != Random1) {
+ ErrCnt [Defect] = ErrCnt [Defect] + 1;
+ BadCond(Defect, "Multiplication does not commute!\n");
+ printf("\tComparison alleges that 1 * Z = %.17e\n",
+ Random2);
+ printf("\tdiffers from Z * 1 = %.17e\n", Random1);
+ }
+ Pause();
+ }
+ }
+ }
+
+notify(s)
+char *s;
+{
+ printf("%s test appears to be inconsistent...\n", s);
+ printf(" PLEASE NOTIFY KARPINKSI!\n");
+ }
+
+/*SPLIT msgs.c */
+
+/* Instructions */
+
+msglist(s)
+char **s;
+{ while(*s) printf("%s\n", *s++); }
+
+Instructions()
+{
+ static char *instr[] = {
+ "Lest this program stop prematurely, i.e. before displaying\n",
+ " `END OF TEST',\n",
+ "try to persuade the computer NOT to terminate execution when an",
+ "error like Over/Underflow or Division by Zero occurs, but rather",
+ "to persevere with a surrogate value after, perhaps, displaying some",
+ "warning. If persuasion avails naught, don't despair but run this",
+ "program anyway to see how many milestones it passes, and then",
+ "amend it to make further progress.\n",
+ "Answer questions with Y, y, N or n (unless otherwise indicated).\n",
+ 0};
+
+ msglist(instr);
+ }
+
+/* Heading */
+
+Heading()
+{
+ static char *head[] = {
+ "Users are invited to help debug and augment this program so it will",
+ "cope with unanticipated and newly uncovered arithmetic pathologies.\n",
+ "Please send suggestions and interesting results to",
+ "\tRichard Karpinski",
+ "\tComputer Center U-76",
+ "\tUniversity of California",
+ "\tSan Francisco, CA 94143-0704, USA\n",
+ "In doing so, please include the following information:",
+#ifdef Single
+ "\tPrecision:\tsingle;",
+#else
+ "\tPrecision:\tdouble;",
+#endif
+ "\tVersion:\t10 February 1989;",
+ "\tComputer:\n",
+ "\tCompiler:\n",
+ "\tOptimization level:\n",
+ "\tOther relevant compiler options:",
+ 0};
+
+ msglist(head);
+ }
+
+/* Characteristics */
+
+Characteristics()
+{
+ static char *chars[] = {
+ "Running this program should reveal these characteristics:",
+ " Radix = 1, 2, 4, 8, 10, 16, 100, 256 ...",
+ " Precision = number of significant digits carried.",
+ " U2 = Radix/Radix^Precision = One Ulp",
+ "\t(OneUlpnit in the Last Place) of 1.000xxx .",
+ " U1 = 1/Radix^Precision = One Ulp of numbers a little less than 1.0 .",
+ " Adequacy of guard digits for Mult., Div. and Subt.",
+ " Whether arithmetic is chopped, correctly rounded, or something else",
+ "\tfor Mult., Div., Add/Subt. and Sqrt.",
+ " Whether a Sticky Bit used correctly for rounding.",
+ " UnderflowThreshold = an underflow threshold.",
+ " E0 and PseudoZero tell whether underflow is abrupt, gradual, or fuzzy.",
+ " V = an overflow threshold, roughly.",
+ " V0 tells, roughly, whether Infinity is represented.",
+ " Comparisions are checked for consistency with subtraction",
+ "\tand for contamination with pseudo-zeros.",
+ " Sqrt is tested. Y^X is not tested.",
+ " Extra-precise subexpressions are revealed but NOT YET tested.",
+ " Decimal-Binary conversion is NOT YET tested for accuracy.",
+ 0};
+
+ msglist(chars);
+ }
+
+History()
+
+{ /* History */
+ /* Converted from Brian Wichmann's Pascal version to C by Thos Sumner,
+ with further massaging by David M. Gay. */
+
+ static char *hist[] = {
+ "The program attempts to discriminate among",
+ " FLAWs, like lack of a sticky bit,",
+ " Serious DEFECTs, like lack of a guard digit, and",
+ " FAILUREs, like 2+2 == 5 .",
+ "Failures may confound subsequent diagnoses.\n",
+ "The diagnostic capabilities of this program go beyond an earlier",
+ "program called `MACHAR', which can be found at the end of the",
+ "book `Software Manual for the Elementary Functions' (1980) by",
+ "W. J. Cody and W. Waite. Although both programs try to discover",
+ "the Radix, Precision and range (over/underflow thresholds)",
+ "of the arithmetic, this program tries to cope with a wider variety",
+ "of pathologies, and to say how well the arithmetic is implemented.",
+ "\nThe program is based upon a conventional radix representation for",
+ "floating-point numbers, but also allows logarithmic encoding",
+ "as used by certain early WANG machines.\n",
+ "BASIC version of this program (C) 1983 by Prof. W. M. Kahan;",
+ "see source comments for more history.",
+ 0};
+
+ msglist(hist);
+ }
+
+double
+pow(x, y) /* return x ^ y (exponentiation) */
+double x, y;
+{
+ extern double exp(), frexp(), ldexp(), log(), modf();
+ double xy, ye;
+ long i;
+ int ex, ey = 0, flip = 0;
+
+ if (!y) return 1.0;
+
+ if ((y < -1100. || y > 1100.) && x != -1.) return exp(y * log(x));
+
+ if (y < 0.) { y = -y; flip = 1; }
+ y = modf(y, &ye);
+ if (y) xy = exp(y * log(x));
+ else xy = 1.0;
+ /* next several lines assume >= 32 bit integers */
+ x = frexp(x, &ex);
+ if (i = ye) for(;;) {
+ if (i & 1) { xy *= x; ey += ex; }
+ if (!(i >>= 1)) break;
+ x *= x;
+ ex *= 2;
+ if (x < .5) { x *= 2.; ex -= 1; }
+ }
+ if (flip) { xy = 1. / xy; ey = -ey; }
+ return ldexp(xy, ey);
+}
+
+#endif /* NO_FLOATS */
--- /dev/null
+/*\r
+ !!DESCRIPTION!! pointer test\r
+ !!ORIGIN!!\r
+ !!LICENCE!! public domain\r
+*/\r
+\r
+#include "common.h"\r
+#include <stdio.h>\r
+\r
+/*\r
+ check behaviour on incompletely declared arrays\r
+*/\r
+\r
+char i1[];\r
+\r
+void test1(void) {\r
+int a;\r
+\r
+ a=sizeof(i1[0]);\r
+ printf("%04x - ",a);\r
+ if(sizeof(i1[0])==sizeof(char)) {\r
+ /* gcc gives size of element */\r
+ printf("sizeof(i1[0]) gives size of element\n");\r
+ }\r
+ if(sizeof(i1[0])==sizeof(char*)) {\r
+ printf("sizeof(i1[0]) gives size of pointer to element\n");\r
+ }\r
+}\r
+\r
+/*\r
+ check behaviour on string init\r
+*/\r
+\r
+char t1[]="abcde";\r
+char t2[]={"abcde"};\r
+\r
+char *t3="abcde";\r
+char *t4={"abcde"};\r
+\r
+void test2(void) {\r
+char c1,c2,c3,c4;\r
+int i,e=0;\r
+ for(i=0;i<5;i++){\r
+ c1=t1[i];c2=t2[i];c3=t3[i];c4=t4[i];\r
+/* printf("%02x %02x %02x %02x\n",c1,c2,c3,c4); */\r
+ printf("%c %c %c %c\n",c1,c2,c3,c4);\r
+ if(!((c1==c2)&(c1==c3)&(c1==c4))) e=1;\r
+ }\r
+ if(e) printf("test2 failed.\n");\r
+ else printf("test2 ok.\n");\r
+}\r
+\r
+/*\r
+ check behaviour on extern-declarations inside functions\r
+*/\r
+\r
+typedef struct {\r
+ char *name;\r
+ void *func;\r
+} A3;\r
+\r
+#ifdef NO_SLOPPY_STRUCT_INIT\r
+A3 a3[] = {\r
+ { "test3", (void*) NULL },\r
+ { "test3", (void*) NULL },\r
+};\r
+#else\r
+/*gcc warning: missing braces around initializer (near initialization for `a3[0]')\r
+ this type of struct-initialization seems to be kinda common */\r
+A3 a3[] = {\r
+ "test3", (void*) NULL ,\r
+ "test3", (void*) NULL ,\r
+};\r
+#endif\r
+\r
+void test3a(A3 *list, int number){\r
+ printf("%s %d\n",list->name,number);\r
+}\r
+\r
+static void test31(void)\r
+{\r
+ extern A3 a3[];\r
+ test3a(a3, -1);\r
+}\r
+\r
+#if 0\r
+/* this variation compiles and works with cc65, but gives an error with gcc :=P */\r
+static void test32(void)\r
+{\r
+ extern A3 *a3;\r
+ test3a(a3, -1);\r
+}\r
+#endif\r
+\r
+static void test30(void)\r
+{\r
+ test3a(a3, -1);\r
+}\r
+\r
+/*\r
+ todo: add test on function pointers in the form of (*func)(arg) ...\r
+ cc65 seems to have problems here aswell ;/\r
+*/\r
+\r
+int main(void) {\r
+ test1();\r
+ test2();\r
+ test30();\r
+ test31();\r
+/* test32(); */\r
+ return 0;\r
+}\r
--- /dev/null
+/*
+ !!DESCRIPTION!! return values, implicit type conversion on return
+ !!ORIGIN!! cc65 devel list
+ !!LICENCE!! Public Domain
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+unsigned char val_char=0x76;
+unsigned int val_int=0x5678;
+unsigned long val_long=0x12345678;
+
+int test1_int_char(void)
+{
+ return val_char;
+}
+int test1_int_int(void)
+{
+ return val_int;
+}
+
+int test2_int_char(void)
+{
+ return (int)val_char;
+}
+int test2_int_int(void)
+{
+ return (int)val_int;
+}
+
+long test1_long_char(void)
+{
+ return val_char;
+}
+long test1_long_int(void)
+{
+ return val_int;
+}
+long test1_long_long(void)
+{
+ return val_long;
+}
+
+long test2_long_char(void)
+{
+ return (long)val_char;
+}
+long test2_long_int(void)
+{
+ return (long)val_int;
+}
+long test2_long_long(void)
+{
+ return (long)val_long;
+}
+
+#define dotest(_n,_a,_v) \
+ _n=_a; \
+ printf("%04lx %04lx,",(unsigned long)_n,(unsigned long)_v); \
+ if(_n!=_v) printf("failed\n"); \
+ else printf("ok\n")
+
+int main(void)
+{
+int i;
+unsigned long l;
+
+ printf("\nwithout cast:\n");
+
+ printf("return int\n");
+
+ dotest(i,test1_int_char(),0x76);
+ dotest(i,test1_int_int(),0x5678);
+
+ printf("return long\n");
+
+ dotest(l,test1_long_char(),0x76);
+ dotest(l,test1_long_int(),0x5678);
+ dotest(l,test1_long_long(),0x12345678);
+
+ printf("\nwith cast:\n");
+
+ printf("return int\n");
+
+ dotest(i,test2_int_char(),0x76);
+ dotest(i,test2_int_int(),0x5678);
+
+ printf("return long\n");
+
+ dotest(l,test2_long_char(),0x76);
+ dotest(l,test2_long_int(),0x5678);
+ dotest(l,test2_long_long(),0x12345678);
+
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! simple quicksort, tests recursion
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+
+int in[] = {10, 32, -1, 567, 3, 18, 1, -51, 789, 0};
+int *xx;
+
+/* exchange - exchange *x and *y */
+exchange(int *x,int *y) {
+int t;
+
+ printf("exchange(%d,%d)\n", x - xx, y - xx);
+ t = *x; *x = *y; *y = t;
+}
+
+/* partition - partition a[i..j] */
+int partition(int a[], int i, int j) {
+int v, k;
+
+ j++;
+ k = i;
+ v = a[k];
+ while (i < j) {
+ i++; while (a[i] < v) i++;
+ j--; while (a[j] > v) j--;
+ if (i < j) exchange(&a[i], &a[j]);
+ }
+ exchange(&a[k], &a[j]);
+ return j;
+}
+
+/* quick - quicksort a[lb..ub] */
+void quick(int a[], int lb, int ub) {
+ int k;
+
+ if (lb >= ub)
+ return;
+ k = partition(a, lb, ub);
+ quick(a, lb, k - 1);
+ quick(a, k + 1, ub);
+}
+
+/* sort - sort a[0..n-1] into increasing order */
+sort(int a[], int n) {
+ quick(xx = a, 0, --n);
+}
+
+/* putd - output decimal number */
+void putd(int n) {
+ if (n < 0) {
+ putchar('-');
+ n = -n;
+ }
+ if (n/10)
+ putd(n/10);
+ putchar(n%10 + '0');
+}
+
+int main(void) {
+ int i;
+
+ sort(in, (sizeof in)/(sizeof in[0]));
+ for (i = 0; i < (sizeof in)/(sizeof in[0]); i++) {
+ putd(in[i]);
+ putchar('\n');
+ }
+
+ return 0;
+}
+
--- /dev/null
+/*
+ !!DESCRIPTION!! register spilling
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+#include <stdio.h>
+
+int main(void)
+{
+ printf("disassemble this program to check the generated code.\n");
+ return 0;
+}
+
+#ifdef NO_EMPTY_FUNC_ARGS
+ f(i){return i+i;}
+ f2(i){return f(i)+(i?f(i):1);}
+ f3(int i,int *p){
+ register r1=0,r2=0,r3=0,r4=0,r5=0,r6=0,r7=0,r8=0,r9=0,r10=0;
+ *p++=i?f(i):0;
+ }
+#else
+ f(i){i=f()+f();}
+ f2(i){i=f()+(i?f():1);}
+ f3(int i,int *p){
+ register r1=0,r2=0,r3=0,r4=0,r5=0,r6=0,r7=0,r8=0,r9=0,r10=0;
+ *p++=i?f():0;
+ }
+#endif
+
+#ifdef NO_FLOATS
+ signed a[10],b[10];
+#else
+ double a[10],b[10];
+#endif
+
+int i;
+
+f4(){
+register r6=0,r7=0,r8=0,r9=0,r10=0,r11=0;
+ i=a[i]+b[i] && i && a[i]-b[i];
+}
+/* f4 causes parent to spill child on vax when odd double regs are enabled */
+
+int j, k, m, n;
+#ifdef NO_FLOATS
+ signed *A, *B, x;
+#else
+ double *A, *B, x;
+#endif
+
+f5(){
+ x=A[k*m]*A[j*m]+B[k*n]*B[j*n];
+ x=A[k*m]*B[j*n]-B[k*n]*A[j*m];
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! variable argument lists
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+#include <stdarg.h>
+
+#ifndef NO_FUNCS_TAKE_STRUCTS
+struct node
+{
+ int a[4];
+} x =
+{
+#ifdef NO_SLOPPY_STRUCT_INIT
+ {
+#endif
+ 1,2,3,4
+#ifdef NO_SLOPPY_STRUCT_INIT
+ }
+#endif
+};
+#endif
+
+print(char *fmt, ...);
+
+main()
+{
+ print("test 1\n");
+ print("test %s\n", "2");
+ print("test %d%c", 3, '\n');
+ print("%s%s %w%c", "te", "st", 4, '\n');
+ #ifdef NO_FLOATS
+ print("%s%s %f%c", "te", "st", (signed long) 5, '\n');
+ #else
+ print("%s%s %f%c", "te", "st", 5.0, '\n');
+ #endif
+ #ifndef NO_FUNCS_TAKE_STRUCTS
+ print("%b %b %b %b %b %b\n", x, x, x, x, x, x);
+ #endif
+ return 0;
+}
+
+print(char *fmt, ...) {
+ va_list ap;
+ va_start(ap, fmt);
+ for (; *fmt; fmt++)
+ {
+ if (*fmt == '%')
+ switch (*++fmt) {
+ case 'b': {
+ #ifdef NO_FUNCS_TAKE_STRUCTS
+ printf("(1 2 3 4)");
+ #else
+ struct node x =
+ va_arg(
+ ap,
+ struct node
+ );
+ printf("(%d %d %d %d)", x.a[0], x.a[1], x.a[2], x.a[3]);
+ #endif
+ break;
+ }
+ case 'c':
+ /* printf("%c", va_arg(ap, char)); */
+ printf("%c", va_arg(ap, int));
+ break;
+ case 'd':
+ printf("%d", va_arg(ap, int));
+ break;
+ case 'w':
+ /* printf("%x", va_arg(ap, short)); */
+ printf("%x", va_arg(ap, int));
+ break;
+ case 's':
+ printf("%s", va_arg(ap, char *));
+ break;
+ case 'f':
+ #ifdef NO_FLOATS
+ printf("%ld.000000", va_arg(ap, signed long));
+ #else
+ printf("%f", va_arg(ap, double));
+ #endif
+ break;
+ default:
+ printf("%c", *fmt);
+ break;
+ }
+ else
+ printf("%c", *fmt);
+ }
+ va_end(ap);
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!! Groepaz/Hitmen
+*/
+
+/*
+ this test reproduces a bug that prevented the testsuites directory
+ reading stuff for the c64 from working before. the bug appears to
+ only occur when optimizations are enabled. it also disappears if
+ the buffers inside the readdir function are declared static or
+ made global.
+*/
+
+/*#define STANDALONE*/
+
+#ifdef STANDALONE
+
+FILE *outfile=NULL;
+#define OPENTEST() outfile=stdout;
+#define CLOSETEST()
+
+#else
+
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <string.h>
+
+#define XNAME_MAX 16
+
+struct Xdirent
+{
+ char d_name[XNAME_MAX+1];
+ unsigned short d_off;
+ unsigned short d_reclen;
+ unsigned char d_type;
+ unsigned char d_namlen;
+};
+
+typedef struct
+{
+ unsigned char fd;
+ unsigned short off;
+ char name[XNAME_MAX+1];
+} XDIR;
+
+unsigned char b1[4];
+unsigned char b2[0x10]={" \"test\" "};
+
+struct Xdirent *Xreaddir(XDIR *dir)
+{
+unsigned char buffer[0x40];
+unsigned char temp;
+unsigned char i,ii;
+
+static struct Xdirent entry;
+unsigned char fd;
+static unsigned char ch;
+
+ entry.d_off=dir->off;
+
+ /* basic line-link / file-length */
+ memcpy(buffer,b1,4);
+
+ dir->off=dir->off+4;
+ entry.d_reclen=254*(buffer[2]+(buffer[3]<<8));
+
+ /* read file entry */
+ memcpy(buffer,b2,0x10);
+
+ dir->off=dir->off+i;
+
+ printf("Xreaddir: '%s'\n",buffer);
+
+ /* skip until either quote (file) or b (blocks free => end) */
+ i=0;ii=0;
+ while(i==0){
+ temp=buffer[ii];ii++;
+ if(ii>16){
+ /* something went wrong...this shouldnt happen! */
+ return(NULL);
+ }
+ else if(temp=='\"') i++;
+ else if(temp=='b') {
+ /* "blocks free" */
+ return(NULL);
+ }
+ }
+ printf("Xreaddir: '%s'\n",buffer);
+
+ /* process file entry */
+
+ i=0; temp=buffer[ii];ii++;
+ while(temp!='\"'){
+ entry.d_name[i]=temp;
+ i++;
+ temp=buffer[ii];ii++;
+ }
+ entry.d_name[i]=0;
+ entry.d_namlen=i;
+
+ /* set type flag */
+
+ return(&entry);
+}
+
+int main(void)
+{
+char mydirname[XNAME_MAX+1]=".";
+XDIR mydir;
+struct Xdirent *mydirent;
+
+ printf("start\n");
+
+ if((mydirent=Xreaddir(&mydir))==NULL)
+ {
+ printf("NULL\n");
+ }
+ else
+ {
+ printf("=%s\n",mydirent->d_name);
+ }
+ printf("done\n");
+
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! structs
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+typedef struct point { int x,y; } point;
+typedef struct rect { point pt1, pt2; } rect;
+
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
+#ifdef NO_FUNCS_RETURN_STRUCTS
+# ifdef NO_FUNCS_TAKE_STRUCTS
+/* canonicalize rectangle coordinates */
+void canonrect(rect *d,rect *r) {
+ d->pt1.x = min(r->pt1.x, r->pt2.x);
+ d->pt1.y = min(r->pt1.y, r->pt2.y);
+ d->pt2.x = max(r->pt1.x, r->pt2.x);
+ d->pt2.y = max(r->pt1.y, r->pt2.y);
+}
+/* add two points */
+void addpoint(point *p, point *p1, point *p2) {
+ p->x= p1->x + p2->x;
+ p->y= p1->y + p2->y;
+}
+/* make a point from x and y components */
+void makepoint(point *p,int x, int y) {
+ p->x = x;
+ p->y = y;
+}
+/* make a rectangle from two points */
+void makerect(rect *d,point *p1, point *p2) {
+rect r;
+ r.pt1.x = p1->x;
+ r.pt1.y = p1->y;
+ r.pt2.x = p2->x;
+ r.pt2.y = p2->y;
+
+ canonrect(d,&r);
+}
+
+#ifdef NO_SLOPPY_STRUCT_INIT
+struct odd {char a[3]; } y = {{'a', 'b', 0 }};
+#else
+struct odd {char a[3]; } y = {'a', 'b', 0};
+#endif
+
+odd(struct odd *y) {
+ struct odd *x = y;
+ printf("%s\n\r", x->a);
+}
+
+# else /* FUNCS_TAKE_STRUCTS */
+/* canonicalize rectangle coordinates */
+void canonrect(rect *d,rect r) {
+ d->pt1.x = min(r.pt1.x, r.pt2.x);
+ d->pt1.y = min(r.pt1.y, r.pt2.y);
+ d->pt2.x = max(r.pt1.x, r.pt2.x);
+ d->pt2.y = max(r.pt1.y, r.pt2.y);
+}
+/* add two points */
+void addpoint(point *p, point p1, point p2) {
+ p->x= p1.x + p2.x;
+ p->y= p1.y + p2.y;
+}
+/* make a point from x and y components */
+void makepoint(point *p,int x, int y) {
+ p->x = x;
+ p->y = y;
+}
+/* make a rectangle from two points */
+void makerect(rect *d,point p1, point p2) {
+rect r;
+ r.pt1 = p1;
+ r.pt2 = p2;
+
+ canonrect(d,r);
+}
+
+#ifdef NO_SLOPPY_STRUCT_INIT
+struct odd {char a[3]; } y = {{'a', 'b', 0}};
+#else
+struct odd {char a[3]; } y = {'a', 'b', 0};
+#endif
+
+odd(struct odd y) {
+ struct odd x = y;
+ printf("%s\n\r", x.a);
+}
+
+# endif /* FUNCS_TAKE_STRUCTS */
+
+#else /* FUNCS_RETURN_STRUCTS */
+
+/* add two points */
+point addpoint(point p1, point p2) {
+ p1.x += p2.x;
+ p1.y += p2.y;
+ return p1;
+}
+/* canonicalize rectangle coordinates */
+rect canonrect(rect r) {
+ rect temp;
+
+ temp.pt1.x = min(r.pt1.x, r.pt2.x);
+ temp.pt1.y = min(r.pt1.y, r.pt2.y);
+ temp.pt2.x = max(r.pt1.x, r.pt2.x);
+ temp.pt2.y = max(r.pt1.y, r.pt2.y);
+ return temp;
+}
+/* make a point from x and y components */
+point makepoint(int x, int y) {
+ point p;
+
+ p.x = x;
+ p.y = y;
+ return p;
+}
+
+/* make a rectangle from two points */
+rect makerect(point p1, point p2) {
+ rect r;
+
+ r.pt1 = p1;
+ r.pt2 = p2;
+ return canonrect(r);
+}
+
+struct odd {char a[3]; } y =
+{
+#ifdef NO_SLOPPY_STRUCT_INIT
+ {
+#endif
+ 'a', 'b', 0
+#ifdef NO_SLOPPY_STRUCT_INIT
+ }
+#endif
+};
+
+odd(struct odd y)
+{
+ struct odd x
+ = y;
+ printf("%s\n\r", x.a);
+}
+
+#endif
+
+/* is p in r? */
+# ifdef NO_FUNCS_TAKE_STRUCTS
+int ptinrect(point *p, rect *r) {
+ return p->x >= r->pt1.x && p->x < r->pt2.x
+ && p->y >= r->pt1.y && p->y < r->pt2.y;
+}
+#else
+int ptinrect(point p, rect r) {
+ return p.x >= r.pt1.x && p.x < r.pt2.x
+ && p.y >= r.pt1.y && p.y < r.pt2.y;
+}
+#endif
+
+#ifdef NO_FUNCS_RETURN_STRUCTS
+
+#ifdef NO_LOCAL_STRUCT_INIT
+#ifdef NO_SLOPPY_STRUCT_INIT
+point pts[] = { {-1, -1},{ 1, 1},{ 20, 300},{ 500, 400 } };
+#else
+point pts[] = { -1, -1, 1, 1, 20, 300, 500, 400 };
+#endif
+point origin = { 0, 0 };
+point maxpt = { 320, 320 };
+#endif
+
+main() {
+int i;
+point x;
+rect screen;
+#ifndef NO_LOCAL_STRUCT_INIT
+point origin = { 0, 0 };
+point maxpt = { 320, 320 };
+#ifdef NO_SLOPPY_STRUCT_INIT
+point pts[] = { {-1, -1},{ 1, 1},{ 20, 300},{ 500, 400 } };
+#else
+point pts[] = { -1, -1, 1, 1, 20, 300, 500, 400 };
+#endif
+#endif
+
+ makepoint ( &x, -10, -10);
+#ifdef NO_FUNCS_TAKE_STRUCTS
+ addpoint ( &maxpt, &maxpt, &x);
+#else
+ addpoint ( &maxpt, maxpt, x);
+#endif
+ makepoint ( &x, 10, 10);
+
+#ifdef NO_FUNCS_TAKE_STRUCTS
+ addpoint (&origin,&origin, &x);
+ makerect (&screen, &maxpt,&origin);
+#else
+ addpoint (&origin,origin, x);
+ makerect (&screen, maxpt,origin);
+#endif
+
+ for (i = 0; i < sizeof pts/sizeof pts[0]; i++) {
+ makepoint(&x,pts[i].x, pts[i].y);
+ printf("(%d,%d) is ", pts[i].x, x.y);
+#ifdef NO_FUNCS_TAKE_STRUCTS
+ if (ptinrect(&x, &screen) == 0)
+#else
+ if (ptinrect(x, screen) == 0)
+#endif
+ {
+ printf("not ");
+ }
+ printf("within (%d,%d; %d,%d)\n\r", screen.pt1.x, screen.pt1.y,
+ screen.pt2.x, screen.pt2.y);
+ }
+#ifdef NO_FUNCS_TAKE_STRUCTS
+ odd(&y);
+#else
+ odd(y);
+#endif
+
+ return 0;
+}
+
+#else /* FUNCS_RETURN_STRUCTS */
+
+main() {
+int i;
+point x, origin = { 0, 0 }, maxpt = { 320, 320 };
+
+#ifdef NO_SLOPPY_STRUCT_INIT
+point pts[] = { {-1, -1}, {1, 1}, {20, 300}, {500, 400} };
+#else
+point pts[] = { -1, -1, 1, 1, 20, 300, 500, 400 };
+#endif
+
+rect screen =
+ makerect(
+ addpoint(maxpt, makepoint(-10, -10)),
+ addpoint(origin, makepoint(10, 10))
+ );
+
+ test1();
+
+ for (i = 0; i < sizeof pts/sizeof pts[0]; i++) {
+ printf("(%d,%d) is ", pts[i].x,
+ (x = makepoint(pts[i].x, pts[i].y)).y);
+ if (ptinrect(x, screen) == 0)
+ printf("not ");
+ printf("within (%d,%d; %d,%d)\n\r", screen.pt1.x, screen.pt1.y,
+ screen.pt2.x, screen.pt2.y);
+ }
+ odd(y);
+
+ return 0;
+}
+
+#endif /* FUNCS_RETURN_STRUCTS */
--- /dev/null
+/*
+ !!DESCRIPTION!! switch statement
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+#include <limits.h>
+
+#ifdef NO_IMPLICIT_FUNC_PROTOTYPES
+testbig();
+testbackslash();
+backslash(int c);
+f();
+g();
+h();
+limit();
+
+big(
+# ifdef ASSUME_32BIT_UNSIGNED
+ unsigned
+# else
+ unsigned long
+# endif
+x);
+
+#endif
+
+main()
+{
+ testbackslash();
+ f();
+ g();
+ h();
+ testbig(); /* ! broken long int compare (?) */
+ limit(); /* ! broken long int compare (?) */
+
+ return 0;
+}
+
+testbig()
+{
+ #ifdef ASSUME_32BIT_INT
+ int i;
+ #else
+ signed long i;
+ #endif
+ /* 2341234 2341234 2341234 */
+ for (i = 0x1000000; i&0x7000000; i += 0x1000000) {
+/* printf("i = 0x%lx\n", i); */
+ big(i);
+ }
+}
+
+#ifdef NO_LOCAL_STRING_INIT
+/* static char _s[8]={"bfnrtvx"}; */
+ static char _s[8]="bfnrtvx";
+#endif
+
+testbackslash()
+{
+ char *s;
+
+#ifdef NO_STRINGS_IN_FOR
+# ifndef NO_LOCAL_STRING_INIT
+ char _s[8]={"bfnrtvx"};
+# endif
+ for (s=_s; *s; s++) {
+#else
+ for (s = "bfnrtvx"; *s; s++) {
+#endif
+ printf("%c = %c\n", *s, backslash(*s));
+ }
+}
+
+backslash(c)
+{
+ switch (c)
+ {
+ case 'b':
+ return 'b';
+ case 'f':
+ return 'f';
+ case 'n':
+ return 'n';
+ case 'r':
+ return 'r';
+ case 't':
+ return 't';
+ case 'v':
+ return 'v';
+ }
+
+ return 'x';
+}
+
+f() {
+ int i, x = 0, y;
+
+ printf("f:\n");
+ for (i = 0; i <= 20; i++) {
+ y = i;
+ switch (i) {
+ case 1: x = i; break;
+ case 2: x = i; break;
+ case 7: x = i; break;
+ case 8: x = i; break;
+ case 9: x = i; break;
+ case 16: x = i; break;
+ case 17: x = i; break;
+ case 18: x = i; break;
+ case 19: x = i; break;
+ case 20: x = i; break;
+ }
+ printf("x = %d\n", x);
+ }
+}
+
+g() {
+ int i;
+
+ printf("g:\n");
+ for (i = 1; i <= 10; i++)
+ switch (i) {
+ case 1: case 2: printf("1 %d\n", i); break;
+ case 3: case 4: case 5: printf("2 %d\n", i); break;
+ case 6: case 7: case 8: printf("3 %d\n", i);
+ default:
+ printf("d %d\n", i); break;
+ case 1001: case 1002: case 1003: case 1004:
+ printf("5 %d\n", i); break;
+ case 3001: case 3002: case 3003: case 3004:
+ printf("6 %d\n", i); break;
+ }
+}
+
+h()
+{
+ int i, n=0;
+
+ printf("h:\n");
+ for (i = 1; i <= 500; i++)
+ switch (i) {
+ default: n++; continue;
+ case 128: printf("i = %d\n", i); break;
+ case 16: printf("i = %d\n", i); break;
+ case 8: printf("i = %d\n", i); break;
+ case 120: printf("i = %d\n", i); break;
+ case 280: printf("i = %d\n", i); break;
+ case 264: printf("i = %d\n", i); break;
+ case 248: printf("i = %d\n", i); break;
+ case 272: printf("i = %d\n", i); break;
+ case 304: printf("i = %d\n", i); break;
+ case 296: printf("i = %d\n", i); break;
+ case 288: printf("i = %d\n", i); break;
+ case 312: printf("i = %d\n", i); break;
+ }
+ printf("%d defaults\n", n);
+}
+
+#ifdef NO_OLD_FUNC_DECL
+ big(
+#else
+ big(x)
+#endif
+
+# ifdef ASSUME_32BIT_UNSIGNED
+ unsigned
+# else
+ unsigned long
+# endif
+
+#ifdef NO_OLD_FUNC_DECL
+ x) {
+#else
+ x; {
+#endif
+
+/* printf("x = 0x%x\n", x); */
+
+ switch(x&0x6000000){
+ case -1:
+ case -2:
+ case 0x0000000:
+ printf("x = 0x%lx\n", x); break;
+ case 0x2000000:
+ printf("x = 0x%lx\n", x); break;
+ case 0x4000000:
+ printf("x = 0x%lx\n", x); break;
+ default:
+ printf("x = 0x%lx (default)\n", x); break;
+ }
+}
+
+limit() {
+ int i;
+
+ for (i = INT_MIN; i <= INT_MIN+5; i++)
+/* for (i = INT_MIN; i < INT_MIN+6; i++) */
+ switch (i) {
+ case INT_MIN: printf("0\n"); break;
+ case INT_MIN+1: printf("1\n"); break;
+ case INT_MIN+2: printf("2\n"); break;
+ case INT_MIN+3: printf("3\n"); break;
+ case INT_MIN+4: printf("4\n"); break;
+ default: printf("5\n"); break;
+ }
+ for (i = INT_MAX; i >= INT_MAX-5; i--)
+ switch (i) {
+ case INT_MAX: printf("0\n"); break;
+ case INT_MAX-1: printf("1\n"); break;
+ case INT_MAX-2: printf("2\n"); break;
+ case INT_MAX-3: printf("3\n"); break;
+ case INT_MAX-4: printf("4\n"); break;
+ default: printf("5\n"); break;
+ }
+}
--- /dev/null
+/*\r
+ !!DESCRIPTION!! switch test\r
+ !!ORIGIN!!\r
+ !!LICENCE!! public domain\r
+*/\r
+\r
+/*#define STANDALONE*/\r
+\r
+#include <stdio.h>\r
+\r
+void testlimits(int i) {
+ printf("%d:",i);\r
+\r
+ switch(i) {
+ case -1: /* works */\r
+ /* case 0xffff: */ /* 'range error' (-1) */\r
+\r
+ printf("-1\n");\r
+ break;\r
+ /* max int */\r
+\r
+/* case 0x7fff: */ /* works */\r
+ case 32767: /* works */\r
+ /* case 32768: */ /* 'range error' (correct for that one!) */\r
+\r
+ printf("max\n");\r
+ break;\r
+ /* min int */\r
+\r
+ case -32768: /* 'warning. constant is long' */\r
+ /* case 0x8000: */ /* 'range error' */\r
+ /* case -32769: */ /* 'range error' (correct for that one!) */\r
+ printf("min\n");\r
+ break;\r
+ }\r
+ printf("\n");\r
+}\r
+\r
+void testdefault1(unsigned char i) {\r
+/* we want a signed char */\r
+#ifdef REFCC\r
+\r
+#ifdef REFCC_UNSIGNED_CHARS\r
+signed char k;\r
+#else\r
+char k;\r
+#endif\r
+ \r
+#else\r
+ \r
+#ifdef UNSIGNED_CHARS\r
+signed char k;\r
+#else\r
+char k;\r
+#endif\r
+\r
+#endif\r
+\r
+ for(;i<254;) {\r
+ k = i;\r
+ printf(">%d\n",i);i++;\r
+ switch(k) {\r
+ case 1:\r
+ break;\r
+ case 2:\r
+ break;\r
+ case 3:\r
+ break;\r
+ case 4:\r
+ break;\r
+ case 5:\r
+ break;\r
+ case 6:\r
+ break;\r
+ case 7:\r
+ break;\r
+ case 8:\r
+ break;\r
+ case 9:\r
+ break;\r
+ case 10:\r
+ break;\r
+ case 11:\r
+ break;\r
+ case 12:\r
+ break;\r
+ case 13:\r
+ break;\r
+ case 14:\r
+ break;\r
+ case 15:\r
+ break;\r
+ case 17:\r
+ break;\r
+ /* triggers bug ? */\r
+ /* gcc warning: case label value exceeds maximum value for type */\r
+ /* cc65 error: range error */\r
+\r
+ /*\r
+ case 170:\r
+ break;\r
+ */\r
+ case 18:\r
+ break;\r
+ case 19:\r
+ break;\r
+ case 20:\r
+ break;\r
+ case 21:\r
+ break;\r
+ case 22:\r
+ break;\r
+ case 23:\r
+ break;\r
+ case 24:\r
+ switch(k) {\r
+ case 1:\r
+ break;\r
+ case 2:\r
+ break;\r
+ case 3:\r
+ break;\r
+ case 4:\r
+ case 5:\r
+ break;\r
+ case 6:\r
+ case 7:\r
+ break;\r
+ case 8:\r
+ case 9:\r
+ break;\r
+ }\r
+ break;\r
+ case 100:\r
+ break;\r
+ default:\r
+ printf(">>>default\n");\r
+ /* triggers bug if this break; is missing? */\r
+ /* break; */\r
+ }\r
+ }\r
+}\r
+\r
+void testdefault2(unsigned char i) {\r
+/* we want a unsigned char */\r
+#ifdef REFCC\r
+\r
+#ifdef REFCC_UNSIGNED_CHARS\r
+char k;\r
+#else\r
+unsigned char k;\r
+#endif\r
+ \r
+#else\r
+ \r
+#ifdef UNSIGNED_CHARS\r
+char k;\r
+#else\r
+unsigned char k;\r
+#endif\r
+\r
+#endif\r
+\r
+ for(;i<254;) {\r
+ k = i;\r
+ printf(">%d\n",i);i++;\r
+ switch(k) {\r
+ case 1:\r
+ break;\r
+ case 2:\r
+ break;\r
+ case 3:\r
+ break;\r
+ case 4:\r
+ break;\r
+ case 5:\r
+ break;\r
+ case 6:\r
+ break;\r
+ case 7:\r
+ break;\r
+ case 8:\r
+ break;\r
+ case 9:\r
+ break;\r
+ case 10:\r
+ break;\r
+ case 11:\r
+ break;\r
+ case 12:\r
+ break;\r
+ case 13:\r
+ break;\r
+ case 14:\r
+ break;\r
+ case 15:\r
+ break;\r
+ case 17:\r
+ break;\r
+ /* triggers bug ? */\r
+\r
+ case 170:\r
+ break;\r
+ \r
+ case 18:\r
+ break;\r
+ case 19:\r
+ break;\r
+ case 20:\r
+ break;\r
+ case 21:\r
+ break;\r
+ case 22:\r
+ break;\r
+ case 23:\r
+ break;\r
+ case 24:\r
+ switch(k) {\r
+ case 1:\r
+ break;\r
+ case 2:\r
+ break;\r
+ case 3:\r
+ break;\r
+ case 4:\r
+ case 5:\r
+ break;\r
+ case 6:\r
+ case 7:\r
+ break;\r
+ case 8:\r
+ case 9:\r
+ break;\r
+ }\r
+ break;\r
+ case 100:\r
+ break;\r
+ default:\r
+ printf(">>>default\n");\r
+ /* triggers bug if this break; is missing? */\r
+ /* break; */\r
+ }\r
+ }\r
+}
+
+int main(void) {
+ testlimits(32767);\r
+ testlimits(-32768);\r
+ testlimits(-1);\r
+ \r
+ testdefault1(1);\r
+ testdefault1(2);\r
+ testdefault1(3);\r
+ testdefault1(4);\r
+ \r
+ testdefault2(1);\r
+ testdefault2(2);\r
+ testdefault2(3);\r
+ testdefault2(4);\r
+\r
+ return 0;\r
+}\r
--- /dev/null
+/*
+ !!DESCRIPTION!! varargs test\r
+ !!ORIGIN!!\r
+ !!LICENCE!! public domain\r
+*/\r
+\r
+#include <stdlib.h>\r
+#include <stdio.h>\r
+#include <stdarg.h>\r
+\r
+void chk0(char *format,...);\r
+void chk1(int fd,char *format,...);\r
+\r
+#if 0\r
+// old workaround for broken varargs\r
+\r
+void chk0(char *format,...){\r
+ __asm__ ("pha"); // save argument size\r
+ {\r
+//va_list ap;\r
+char *ap;\r
+char *_format;\r
+static char string[0x100];\r
+\r
+// va_start(ap,format);\r
+ __asm__ ("pla"); // restore argument size\r
+ __asm__ ("ldx #$00"); // clear hibyte of AX\r
+ ap=__AX__;\r
+ ap+=(char*)&format;\r
+ // get value of format\r
+ ap-=2;\r
+ _format=*((char**)ap);\r
+\r
+// vsprintf(string,format,ap);\r
+ vsprintf(&string[0],_format,ap);\r
+ printf("format:%s,string:%s\n",_format,string);\r
+// va_end(ap);\r
+\r
+ }\r
+}\r
+\r
+void chk1(int fd,char *format,...){\r
+ __asm__ ("pha"); // save argument size\r
+ {\r
+//va_list ap;\r
+char *ap;\r
+char *_format;\r
+int _fd;\r
+static char string[0x100];\r
+\r
+// va_start(ap,format);\r
+ __asm__ ("pla"); // restore argument size\r
+ __asm__ ("ldx #$00"); // clear hibyte of AX\r
+ ap=__AX__;\r
+ ap+=(char*)&format;\r
+ // get value of fd\r
+ ap-=2;\r
+ _fd=*((int*)ap);\r
+ // get value of format\r
+ ap-=2;\r
+ _format=*((char**)ap);\r
+\r
+// vsprintf(string,format,ap);\r
+ vsprintf(&string[0],_format,ap);\r
+ printf("fd:%d,format:%s,string:%s\n",_fd,_format,string);\r
+// va_end(ap);\r
+\r
+ }\r
+}\r
+\r
+#endif\r
+\r
+void chk0(char *format,...){\r
+va_list ap;\r
+static char string[0x100];\r
+ va_start(ap,format);\r
+ vsprintf(string,format,ap);\r
+ printf("format:%s,string:%s\n",format,string);\r
+ va_end(ap);\r
+}\r
+\r
+void chk1(int fd,char *format,...){\r
+va_list ap;\r
+static char string[0x100];\r
+\r
+ va_start(ap,format);\r
+\r
+ vsprintf(string,format,ap);\r
+ printf("fd:%d,format:%s,string:%s\n",fd,format,string);\r
+ va_end(ap);\r
+}
+
+int main(int argc,char **argv) {\r
+ printf("varargs test\n");\r
+\r
+ printf("\nchk0/0:\n");chk0("chk0 %s","arg0");\r
+ printf("\nchk0/1:\n");chk0("chk0 %s %s","arg0","arg1");\r
+ printf("\nchk0/2:\n");chk0("chk0 %s %s %s","arg0","arg1","arg2");\r
+\r
+ printf("\nchk1/0:\n");chk1(0xfd,"chk1 %s","arg0");\r
+ printf("\nchk1/1:\n");chk1(0xfd,"chk1 %s %s","arg0","arg1");\r
+ printf("\nchk1/2:\n");chk1(0xfd,"chk1 %s %s %s","arg0","arg1","arg2");\r
+\r
+ return 0;
+}\r
--- /dev/null
+/*
+ !!DESCRIPTION!! print word frequencies; uses structures
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#define MAXWORDS 250
+
+FILE *in;
+#define getchar() fgetc(in)
+
+struct node
+{
+ int count; /* frequency count */
+ struct node *left; /* left subtree */
+ struct node *right; /* right subtree */
+ char *word; /* word itself */
+} words[MAXWORDS];
+int next; /* index of next free entry in words */
+
+/*struct node *lookup();*/
+
+#if defined(NO_NEW_PROTOTYPES_FOR_OLD_FUNC_DECL) && !defined(NO_OLD_FUNC_DECL)
+
+#else
+
+int err(char *s);
+int getword(char *buf);
+void tprint(struct node *tree);
+struct node *lookup(char *word, struct node **p);
+
+#endif
+
+int isletter(char c);
+
+/* err - print error message s and die */
+#ifndef NO_OLD_FUNC_DECL
+err(s) char *s; {
+#else
+int err(char *s) {
+#endif
+ printf("? %s\n", s);
+ exit(1);
+}
+
+/* getword - get next input word into buf, return 0 on EOF */
+#ifndef NO_OLD_FUNC_DECL
+int getword(buf) char *buf;
+#else
+int getword(char *buf)
+#endif
+{
+ char *s;
+ int c;
+
+ while (((c = getchar()) != -1) && (isletter(c) == 0))
+ ;
+ for (s = buf; (c = isletter(c)); c = getchar())
+ *s++ = c;
+ *s = 0;
+ if (s > buf)
+ return 1;
+ return 0;
+}
+
+/* isletter - return folded version of c if it is a letter, 0 otherwise */
+int isletter(char c)
+{
+ if ((c >= 'A') && (c <= 'Z')) c += 'a' - 'A';
+ if ((c >= 'a') && (c <= 'z')) return c;
+ return 0;
+}
+
+/* lookup - lookup word in tree; install if necessary */
+#ifndef NO_OLD_FUNC_DECL
+struct node *lookup(word, p)
+char *word; struct node **p;
+#else
+struct node *lookup(char *word, struct node **p)
+#endif
+{
+ int cond;
+/* char *malloc(); */
+
+ if (*p) {
+ cond = strcmp(word, (*p)->word);
+ if (cond < 0)
+ return lookup(word, &(*p)->left);
+ else if (cond > 0)
+ return lookup(word, &(*p)->right);
+ else
+ return *p;
+ }
+ if (next >= MAXWORDS)
+ err("out of node storage");
+ words[next].count = 0;
+ words[next].left = words[next].right = 0;
+ words[next].word = malloc(strlen(word) + 1);
+ if (words[next].word == 0)
+ err("out of word storage");
+ strcpy(words[next].word, word);
+ return *p = &words[next++];
+}
+
+/* tprint - print tree */
+#ifndef NO_OLD_FUNC_DECL
+void tprint(tree) struct node *tree; {
+#else
+void tprint(struct node *tree) {
+#endif
+ if (tree) {
+ tprint(tree->left);
+ printf("%d:%s\n", tree->count, tree->word);
+ tprint(tree->right);
+ }
+}
+
+int main(void)
+{
+ struct node *root;
+ char word[20];
+
+ in = fopen("wf1.in","rb");
+ if (in == NULL) {
+ return EXIT_FAILURE;
+ }
+
+ root = 0;
+ next = 0;
+ while (getword(word))
+ lookup(word, &root)->count++;
+ tprint(root);
+
+ fclose(in);
+ return 0;
+}
--- /dev/null
+The sky above the port was the color of television, tuned
+to a dead channel.
+"It's not like I'm using," Case heard someone say, as he
+shouldered his way through the crowd around the door of the
+Chat. "It's like my body's developed this massive drug deficiency."
+It was a Sprawl voice and a Sprawl joke. The Chatsubo
+was a bar for professional expatriates; you could drink there
+for a week and never hear two words in Japanese.
+Ratz was tending bar, his prosthetic arm jerking monotonously
+as he filled a tray of glasses with draft Kirin. He saw
+Case and smiled, his teeth a web work of East European steel
+and brown decay. Case found a place at the bar, between the
+unlikely tan on one of Lonny Zone's whores and the crisp naval
+uniform of a tall African whose cheekbones were ridged with
+Joe boys," Ratz said, shoving a draft across the bar with his
+good hand. "Maybe some business with you, Case?"
+Case shrugged. The girl to his right giggled and nudged
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+/*#define STANDALONE*/
+
+#include "common.h"
+
+#ifndef YACCDBG
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+/*
+#define LEXDEBUG
+#define YYDEBUG
+*/
+
+#endif
+
+FILE *infile, *outfile;
+#define getchar() fgetc(infile)
+
+/* hack the original tables to work with both petscii and ascii */
+#define CHARSETHACK
+
+# define ID 257
+# define CON 258
+# define UNARYMINUS 259
+#define yyclearin yychar = -1
+#define yyerrok yyerrflag = 0
+extern int yychar;
+extern short yyerrflag;
+#ifndef YYMAXDEPTH
+/*#define YYMAXDEPTH 150*/
+#define YYMAXDEPTH 50
+#endif
+#ifndef YYSTYPE
+#define YYSTYPE int
+#endif
+YYSTYPE yylval, yyval;
+# define YYERRCODE 256
+
+# define U(x) x
+# define NLSTATE yyprevious=YYNEWLINE
+# define BEGIN yybgin = yysvec + 1 +
+# define INITIAL 0
+# define YYLERR yysvec
+# define YYSTATE (yyestate-yysvec-1)
+# define YYOPTIM 1
+# define YYLMAX 200
+# define output(c) (void)putc(c,yyout)
+
+/* # define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar) */
+# define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getchar())==('\n')?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
+
+# define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
+# define yymore() (yymorfg=1)
+# define ECHO fprintf(yyout, "%s",yytext)
+# define REJECT { nstr = yyreject(); goto yyfussy;}
+int yyleng; extern char yytext[];
+int yymorfg;
+extern char *yysptr, yysbuf[];
+int yytchar;
+
+#define yyin infile
+#define yyout outfile
+
+extern int yylineno;
+struct yysvf
+{
+ struct yywork *yystoff;
+ struct yysvf *yyother;
+ int *yystops;
+};
+struct yysvf *yyestate;
+extern struct yysvf yysvec[], *yybgin;
+
+/*# define YYNEWLINE 10 */
+# define YYNEWLINE ('\n')
+
+#ifdef NO_IMPLICIT_FUNC_PROTOTYPES
+yylook();
+int yywrap();
+yyparse();
+yyerror(char *s);
+yyunput(int c);
+yyoutput(int c);
+yyinput();
+yyback(int *p,int m);
+#endif
+
+#ifdef YYDEBUG
+void printchar(char *name,int ch)
+{
+ if((ch==YYNEWLINE))
+ {
+ fprintf(yyout," %s=YYNEWLINE\n",name);
+ }
+ else if((ch<0)||(ch>0xf0)||(!isprint(ch)))
+ {
+ fprintf(yyout," %s=%04x\n",name,ch &0xffff);
+ }
+ else
+ {
+ fprintf(yyout," %s='%c'\n",name,ch);
+ }
+}
+#endif
+
+yylex()
+{
+int nstr;
+extern int yyprevious;
+
+#ifdef YYDEBUG
+ fprintf(yyout,"yylex()\n");
+#endif
+
+ while((nstr = yylook()) >= 0)
+ {
+#ifdef YYDEBUG
+ fprintf(yyout,"yylex: nstr=%d\n",nstr);
+#endif
+yyfussy:
+ switch(nstr)
+ {
+ case 0:
+ if(yywrap()) return(0);
+ break;
+ case 1:
+ return ID;
+ break;
+ case 2:
+ return CON;
+ break;
+ case 3:
+ ;
+ break;
+ case 4:
+ return yytext[0];
+ break;
+ case -1:
+ break;
+ default:
+ fprintf(yyout,"yylex: bad switch yylook %d\n",nstr);
+ }
+
+ }
+
+#ifdef YYDEBUG
+ fprintf(yyout,"yylex: return 0\n");
+#endif
+ return(0);
+}
+/* end of yylex */
+
+int yyvstop[] =
+{
+ 0,4,0,3,4,0,2,4,0,1,4,0,2,0,1,0,0
+};
+
+# define YYTYPE char
+struct yywork
+{
+ YYTYPE verify, advance;
+} yycrank[] =
+{
+ {0,0}, {0,0}, {1,3}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {1,4}, {1,3},
+ {0,0}, {0,0}, {0,0}, {0,0},
+
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+
+ {0,0}, {1,5}, {5,7}, {5,7},
+ {5,7}, {5,7}, {5,7}, {5,7},
+ {5,7}, {5,7}, {5,7}, {5,7},
+ {0,0}, {0,0}, {0,0}, {0,0},
+/* 0x40 */
+ {0,0}, {0,0}, {1,6}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {0,0}, {0,0}, {0,0},
+
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {0,0}, {0,0},
+
+ {0,0}, {0,0}, {6,8}, {0,0},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+/* 0x80 */
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {0,0}, {0,0},
+
+#ifdef CHARSETHACK
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+
+/* 0xc0 */
+ {0,0}, {0,0}, {1,6}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {0,0}, {0,0}, {0,0},
+#endif
+ {0,0}
+};
+
+/*
+struct yysvf
+{
+ struct yywork *yystoff;
+ struct yysvf *yyother;
+ int *yystops;
+};
+*/
+struct yysvf yysvec[] =
+{
+ {0, 0, 0},
+ {yycrank+-1, 0, 0},
+ {yycrank+0, yysvec+1, 0},
+ {yycrank+0, 0, yyvstop+1},
+ {yycrank+0, 0, yyvstop+3},
+ {yycrank+2, 0, yyvstop+6},
+ {yycrank+19, 0, yyvstop+9},
+ {yycrank+0, yysvec+5, yyvstop+12},
+ {yycrank+0, yysvec+6, yyvstop+14},
+ {0, 0, 0}
+};
+ /* 0x8d */
+/* struct yywork *yytop = yycrank+141; */
+ /* 0xff */
+struct yywork *yytop = yycrank+255;
+
+struct yysvf *yybgin = yysvec+1;
+
+/*
+ WARNING: this table contains one entry per character
+ in the execution character set and must match it.
+*/
+char yymatch[] =
+{
+ 00 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
+#ifdef CHARSETHACK
+ 01 ,011 ,012 ,01 ,01 ,012 ,01 ,01 ,
+#else
+ 01 ,011 ,012 ,01 ,01 ,01 ,01 ,01 ,
+#endif
+ 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
+ 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
+
+ 011 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
+ 01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
+
+ '0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
+ '0' ,'0' ,01 ,01 ,01 ,01 ,01 ,01 ,
+
+/* 0x40 (ascii) @A... (petscii) @a... */
+ 01 ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
+ 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
+
+ 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
+ 'A' ,'A' ,'A' ,01 ,01 ,01 ,01 ,'A' ,
+
+/* 0x60 (ascii) @a... */
+ 01 ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
+ 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
+
+ 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
+ 'A' ,'A' ,'A' ,01 ,01 ,01 ,01 ,01 ,
+
+#ifdef CHARSETHACK
+/* 0x80 */
+ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
+ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
+ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
+ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
+
+/* 0xc0 (petcii) @A... */
+ 01 ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
+ 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
+
+ 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
+ 'A' ,'A' ,'A' ,01 ,01 ,01 ,01 ,01 ,
+
+ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
+ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
+ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
+#endif
+ 0
+};
+char yyextra[] =
+{
+ 0,0,0,0,0,0,0,0,0
+};
+
+/* ncform 4.1 83/08/11 */
+
+int yylineno =1;
+# define YYU(x) x
+# define NLSTATE yyprevious=YYNEWLINE
+char yytext[YYLMAX];
+struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
+char yysbuf[YYLMAX];
+char *yysptr = yysbuf;
+int *yyfnd;
+extern struct yysvf *yyestate;
+int yyprevious = YYNEWLINE;
+
+unsigned char testbreak=0;
+
+yylook()
+{
+ register struct yysvf *yystate, **lsp;
+ register struct yywork *yyt;
+ struct yysvf *yyz;
+ int yych;
+ struct yywork *yyr;
+/*
+# ifdef LEXDEBUG
+ int debug;
+# endif
+*/
+
+ char *yylastch;
+
+ /* start off machines */
+
+/*
+# ifdef LEXDEBUG
+ debug = 1;
+# else
+ debug = 0;
+# endif
+*/
+
+# ifdef LEXDEBUG
+#define debug 1
+# else
+#define debug 0
+#endif
+
+#ifdef YYDEBUG
+ fprintf(yyout,"yylook()\n");
+# endif
+
+ if (!yymorfg)
+ yylastch = yytext;
+ else
+ {
+ yymorfg=0;
+ yylastch = yytext+yyleng;
+ }
+
+#ifdef YYDEBUG
+ fprintf(yyout,"yylook: yymorfg=%d\n",yymorfg);
+# endif
+
+ for(;;)
+ {
+#ifdef YYDEBUG
+ fprintf(yyout,"yylook: (outer loop)");
+ printchar("yyprevious",yyprevious);
+# endif
+ lsp = yylstate;
+ yyestate = yystate = yybgin;
+ if (yyprevious==YYNEWLINE) yystate++;
+
+ testbreak=0;
+
+ for (;;)
+ {
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: (inner loop) state %d\n",yystate-yysvec-1);
+# endif
+ if(testbreak==5)
+ {
+ fprintf(yyout,"yylook: error, aborted after 5 loops\n");
+ exit(0);
+ }
+ testbreak++;
+
+ yyt = yystate->yystoff;
+
+/* fprintf(yyout,"yylook: yyt offs: %02x\n",yyt-yycrank); */
+
+
+ if(yyt == yycrank)
+ { /* may not be any transitions */
+ yyz = yystate->yyother;
+ if(yyz == 0)break;
+ if(yyz->yystoff == yycrank)break;
+ }
+ *yylastch++ = yych = input();
+
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: input ");
+ printchar("yych",yych);
+# endif
+
+ tryagain:
+
+# ifdef LEXDEBUG
+/* fprintf(yyout,"yylook: yych=%02x yymatch[yych]=%02x\n",yych,yymatch[yych]); */
+ fprintf(yyout,"yylook: tryagain\n");
+# endif
+ yyr = yyt;
+
+/* fprintf(yyout,"yylook: yyr offs: %02x\n",yyr-yycrank); */
+
+ if ( yyt > yycrank)
+ {
+ yyt = yyr + yych;
+ if (yyt <= yytop && yyt->verify+yysvec == yystate)
+ {
+ if(yyt->advance+yysvec == YYLERR) /* error transitions */
+ {
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: unput (1) ");
+ printchar("*yylastch",*yylastch);
+# endif
+ unput(*--yylastch);
+ break;
+ }
+ *lsp++ = yystate = yyt->advance+yysvec;
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: continue (1)\n");
+# endif
+ goto contin;
+ }
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: ( yyt > yycrank)\n");
+# endif
+ }
+# ifdef YYOPTIM
+ else if(yyt < yycrank) /* r < yycrank */
+ {
+ yyt = yyr = yycrank+(yycrank-yyt);
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: compressed state\n");
+# endif
+ yyt = yyt + yych;
+ if(yyt <= yytop && yyt->verify+yysvec == yystate)
+ {
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: (1)\n");
+# endif
+ if(yyt->advance+yysvec == YYLERR) /* error transitions */
+ {
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: unput (2) ");
+ printchar("*yylastch",*yylastch);
+# endif
+ unput(*--yylastch);
+ break;
+ }
+ *lsp++ = yystate = yyt->advance+yysvec;
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: continue (2)\n");
+# endif
+ goto contin;
+
+ }
+# ifdef LEXDEBUG
+/*
+ fprintf(yyout,"yylook: yych=%02x yymatch[yych]=%02x\n",yych,yymatch[yych]);
+ fprintf(yyout,"yylook: yyt offs: %02x\n",yyt-yycrank);
+ fprintf(yyout,"yylook: yyr offs: %02x\n",yyr-yycrank);
+*/
+# endif
+ yyt = yyr + YYU(yymatch[yych]);
+# ifdef LEXDEBUG
+/*
+ fprintf(yyout,"yylook: yyt offs: %02x <= yytop offs: %02x\n",yyt-yycrank,yytop-yycrank);
+ fprintf(yyout,"yylook: yyt->verify=%04x yysvec=%04x (yyt->verify+yysvec)=%04x == yystate=%04x\n",yyt->verify,yysvec,(yyt->verify+yysvec),yystate);
+*/
+ fprintf(yyout,"yylook: try fall back character\n");
+# endif
+ if(yyt <= yytop && yyt->verify+yysvec == yystate)
+ {
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: (2a)\n");
+# endif
+
+ if(yyt->advance+yysvec == YYLERR) /* error transition */
+ {
+# ifdef LEXDEBUG
+/* cc65 compiles this ?! fprintf(yyout,"yylook: unput (3) ",); */
+ fprintf(yyout,"yylook: unput (3) ");
+ printchar("*yylastch",*yylastch);
+# endif
+ unput(*--yylastch);
+ break;
+ }
+ *lsp++ = yystate = yyt->advance+yysvec;
+# ifdef LEXDEBUG
+/* fprintf(yyout,"yylook: yyt offs: %02x yyt->advance=%d\n",yyt-yycrank,yyt->advance); */
+ fprintf(yyout,"yylook: continue (3)\n");
+# endif
+ goto contin;
+
+ }
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: (2)\n");
+# endif
+ }
+ if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank)
+ {
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: fall back to state %d\n",yystate-yysvec-1);
+# endif
+ goto tryagain;
+ }
+# endif
+ else
+ {
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: unput (4) ");
+ printchar("*yylastch",*yylastch);
+# endif
+ unput(*--yylastch);
+ break;
+ }
+ contin:
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: contin state=%d\n",yystate-yysvec-1);
+# endif
+ ;
+ }
+
+# ifdef LEXDEBUG
+ if((*(lsp-1)-yysvec-1)<0)
+ {
+ fprintf(yyout,"yylook: stopped (end)\n");
+ }
+ else
+ {
+ fprintf(yyout,"yylook: stopped at %d with\n",*(lsp-1)-yysvec-1);
+ }
+# endif
+ while (lsp-- > yylstate)
+ {
+ *yylastch-- = 0;
+ if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0)
+ {
+ yyolsp = lsp;
+ if(yyextra[*yyfnd]) /* must backup */
+ {
+ while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate)
+ {
+ lsp--;
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: unput (5) ");
+ printchar("*yylastch",*yylastch);
+# endif
+ unput(*yylastch--);
+ }
+ }
+ yyprevious = YYU(*yylastch);
+ yylsp = lsp;
+ yyleng = yylastch-yytext+1;
+ yytext[yyleng] = 0;
+# ifdef LEXDEBUG
+ fprintf(yyout,"\nyylook: match action %d\n",*yyfnd);
+ fprintf(yyout,"yylook: done loops: %d\n",testbreak);
+# endif
+ return(*yyfnd++);
+ }
+ unput(*yylastch);
+ }
+ if (yytext[0] == 0 /* && feof(yyin) */)
+ {
+ yysptr=yysbuf;
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: done loops: %d\n",testbreak);
+# endif
+ return(0);
+ }
+ yyprevious = yytext[0] = input();
+
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: input ");
+ printchar("yyprevious",yyprevious);
+# endif
+
+ if (yyprevious>0)
+ output(yyprevious);
+ yylastch=yytext;
+# ifdef LEXDEBUG
+/* if(debug)putchar('\n'); */
+# endif
+ }
+
+# ifdef LEXDEBUG
+ fprintf(yyout,"yylook: done loops: %d\n",testbreak);
+ fprintf(yyout,"yylook: return <void>\n");
+# endif
+}
+
+
+yyback(p, m)
+ int *p;
+{
+ if (p==0) return(0);
+ while (*p)
+ {
+ if (*p++ == m)
+ {
+ return(1);
+ }
+ }
+ return(0);
+}
+ /* the following are only used in the lex library */
+yyinput()
+{
+ int out=input();
+
+#ifdef YYDEBUG
+ fprintf(yyout,"yylook: input ");
+ printchar("out",out);
+#endif
+ return(out);
+}
+yyoutput(c)
+ int c;
+{
+ output(c);
+}
+yyunput(c)
+ int c;
+{
+ unput(c);
+}
+
+main()
+{
+ printf("main start\n");
+ infile = fopen("yacc.in","rb");
+ if (infile == NULL) {
+ return EXIT_FAILURE;
+ }
+ outfile = stdout;
+ yyparse();
+ fclose(infile);
+ printf("main end\n");
+ return 0;
+}
+
+/* yyerror - issue error message */
+yyerror(s)
+char *s;
+{
+ printf("[%s]\n", s);
+}
+short yyexca[] =
+{
+-1, 1,
+ 0, -1,
+ -2, 0,
+};
+
+# define YYNPROD 15
+# define YYLAST 249
+
+short yyact[]=
+{
+ 12, 2, 9, 8, 17, 11, 25, 17, 15, 18,
+ 16, 10, 18, 17, 15, 7, 16, 13, 18, 5,
+ 3, 1, 0, 19, 20, 0, 0, 21, 22, 23,
+ 24, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 6, 14, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 4, 6
+};
+short yypact[]=
+{
+-1000, -9,-1000, 5, -7, -59,-1000,-1000,-1000, -40,
+ -29, -40, -40,-1000,-1000, -40, -40, -40, -40, -38,
+ -35, -38, -38,-1000,-1000,-1000
+};
+short yypgo[]=
+{
+ 0, 21, 20, 17, 11
+};
+short yyr1[]=
+{
+ 0, 1, 1, 1, 1, 2, 4, 4, 4, 4,
+ 4, 4, 4, 4, 3
+};
+short yyr2[]=
+{
+ 0, 0, 2, 3, 3, 3, 3, 3, 3, 3,
+ 2, 3, 1, 1, 1
+};
+short yychk[]=
+{
+-1000, -1, 10, -2, 256, -3, 257, 10, 10, 61,
+ -4, 45, 40, -3, 258, 43, 45, 42, 47, -4,
+ -4, -4, -4, -4, -4, 41
+};
+short yydef[]=
+{
+ 1, -2, 2, 0, 0, 0, 14, 3, 4, 0,
+ 5, 0, 0, 12, 13, 0, 0, 0, 0, 10,
+ 0, 6, 7, 8, 9, 11
+};
+
+# define YYFLAG -1000
+# define YYERROR goto yyerrlab
+# define YYACCEPT return(0)
+# define YYABORT return(1)
+
+/* parser for yacc output */
+
+#ifdef YYDEBUG
+int yydebug = 1; /* 1 for debugging */
+#else
+int yydebug = 0; /* 1 for debugging */
+#endif
+YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
+int yychar = -1; /* current input token number */
+int yynerrs = 0; /* number of errors */
+short yyerrflag = 0; /* error recovery flag */
+
+yyparse()
+{
+ short yys[YYMAXDEPTH];
+ short yyj, yym;
+ register YYSTYPE *yypvt;
+ register short yystate, *yyps, yyn;
+ register YYSTYPE *yypv;
+ register short *yyxi;
+
+ yystate = 0;
+ yychar = -1;
+ yynerrs = 0;
+ yyerrflag = 0;
+ yyps= &yys[-1];
+ yypv= &yyv[-1];
+
+ yystack: /* put a state and value onto the stack */
+#ifdef YYDEBUG
+ printf("yyparse: yystack\n");
+#endif
+
+#ifdef YYDEBUG
+ printf("yyparse: yystate=%d, ", yystate);
+ printchar("yychar",yychar);
+#endif
+ if( ++yyps> &yys[YYMAXDEPTH] )
+ {
+ yyerror( "yyparse: yacc stack overflow" );
+ return(1);
+ }
+ *yyps = yystate;
+ ++yypv;
+ *yypv = yyval;
+
+ yynewstate:
+#ifdef YYDEBUG
+ printf("yyparse: yynewstate\n");
+#endif
+
+ yyn = yypact[yystate];
+
+ if( yyn<= YYFLAG ) goto yydefault; /* simple state */
+
+#ifdef YYDEBUG
+ printf("yyparse: yynewstate (1)\n");
+#endif
+
+ if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
+
+#ifdef YYDEBUG
+
+ printf("yyparse: yynewstate yyn=%d ",yyn);
+ printchar("yychar",yychar);
+#endif
+
+ if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
+
+#ifdef YYDEBUG
+ printf("yyparse: yynewstate (2)\n");
+#endif
+
+ if( yychk[ yyn=yyact[ yyn ] ] == yychar ) /* valid shift */
+ {
+ yychar = -1;
+ yyval = yylval;
+ yystate = yyn;
+
+#ifdef YYDEBUG
+ printf("yyparse: yynewstate (3)\n");
+#endif
+
+ if( yyerrflag > 0 ) --yyerrflag;
+ goto yystack;
+ }
+
+ yydefault:
+#ifdef YYDEBUG
+ printf("yyparse: yydefault yystate=%d\n",yystate);
+#endif
+ /* default state action */
+
+ if( (yyn=yydef[yystate]) == -2 )
+ {
+ if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
+ /* look through exception table */
+
+ for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
+
+ while( *(yyxi+=2) >= 0 )
+ {
+ if( *yyxi == yychar ) break;
+ }
+ if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */
+ }
+
+#ifdef YYDEBUG
+ printf("yyparse: yyn=%d yyerrflag=%d\n",yyn,yyerrflag);
+#endif
+
+ if( yyn == 0 ) /* error */
+ {
+ /* error ... attempt to resume parsing */
+
+ switch( yyerrflag ){
+ case 0: /* brand new error */
+
+ yyerror( "yyparse: syntax error" );
+ yyerrlab:
+ ++yynerrs;
+
+ case 1:
+ case 2: /* incompletely recovered error ... try again */
+
+ yyerrflag = 3;
+
+ /* find a state where "error" is a legal shift action */
+
+ while ( yyps >= yys ) {
+ yyn = yypact[*yyps] + YYERRCODE;
+ if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
+ yystate = yyact[yyn]; /* simulate a shift of "error" */
+ goto yystack;
+ }
+ yyn = yypact[*yyps];
+
+ /* the current yyps has no shift onn "error", pop stack */
+
+#ifdef YYDEBUG
+ printf("yyparse: error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
+#endif
+ --yyps;
+ --yypv;
+ }
+
+ /* there is no state on the stack with an error shift ... abort */
+
+ yyabort:
+ return(1);
+
+ case 3: /* no shift yet; clobber input char */
+
+#ifdef YYDEBUG
+ printf("yyparse: error recovery discards char ");
+ printchar("yychar",yychar);
+#endif
+
+ if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
+ yychar = -1;
+ goto yynewstate; /* try again in the same state */
+
+ }
+
+ }
+
+ /* reduction by production yyn */
+
+#ifdef YYDEBUG
+ printf("yyparse: reduce %d\n",yyn);
+#endif
+ yyps -= yyr2[yyn];
+ yypvt = yypv;
+ yypv -= yyr2[yyn];
+ yyval = yypv[1];
+ yym=yyn;
+ /* consult goto table to find next state */
+ yyn = yyr1[yyn];
+ yyj = yypgo[yyn] + *yyps + 1;
+ if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
+
+ switch(yym)
+ {
+ case 4:
+ {
+ yyerrok;
+ }
+ break;
+ case 5:
+ {
+ printf("[STORE]\n");
+ }
+ break;
+ case 6:
+ {
+ printf("[ADD]\n");
+ }
+ break;
+ case 7:
+ {
+ printf("[NEG]\n[ADD]\n");
+ }
+ break;
+ case 8:
+ {
+ printf("[MUL]\n");
+ }
+ break;
+ case 9:
+ {
+ printf("[DIV]\n");
+ }
+ break;
+ case 10:
+ {
+ printf("[NEG]\n");
+ }
+ break;
+ case 12:
+ {
+ printf("[LOAD]\n");
+ }
+ break;
+ case 13:
+ {
+ printf("[PUSH %s]\n", yytext);
+ }
+ break;
+ case 14:
+ {
+ printf("[%s]\n", yytext);
+ }
+ break;
+ }
+
+ goto yystack; /* stack new state and value */
+}
+
+int yywrap()
+{
+ return 1;
+}
--- /dev/null
+x=(e+1)*3/(3+7)
+
+
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!! Groepaz/Hitmen
+*/
+
+#include <stdio.h>
+
+# define YYTYPE char
+struct yywork
+{
+ YYTYPE verify, advance;
+} yycrank[] =
+{
+ {0,0}, {0,0}, {1,3}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {1,4}, {1,3},
+ {0,0}, {0,0}, {0,0}, {0,0},
+
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+
+ {0,0}, {1,5}, {5,7}, {5,7},
+ {5,7}, {5,7}, {5,7}, {5,7},
+ {5,7}, {5,7}, {5,7}, {5,7},
+ {0,0}, {0,0}, {0,0}, {0,0},
+/* 0x40 */
+ {0,0}, {0,0}, {1,6}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {0,0}, {0,0}, {0,0},
+
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {0,0}, {0,0},
+
+ {0,0}, {0,0}, {6,8}, {0,0},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+/* 0x80 */
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {0,0}, {0,0},
+
+#ifdef CHARSETHACK
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+ {0,0}, {0,0}, {0,0}, {0,0},
+
+/* 0xc0 */
+ {0,0}, {0,0}, {1,6}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {6,8}, {6,8}, {6,8},
+ {6,8}, {0,0}, {0,0}, {0,0},
+#endif
+ {0,0}
+};
+
+struct yywork *yytop = yycrank+255;
+
+int yyvstop[] =
+{
+ 0,4,0,3,4,0,2,4,0,1,4,0,2,0,1,0,0
+};
+
+struct yysvf
+{
+ struct yywork *yystoff;
+ struct yysvf *yyother;
+ int *yystops;
+};
+
+struct yysvf yysvec[] =
+{
+ {0, 0, 0},
+ {yycrank+-1, 0, 0},
+ {yycrank+0, yysvec+1, 0},
+ {yycrank+0, 0, yyvstop+1},
+ {yycrank+0, 0, yyvstop+3},
+ {yycrank+2, 0, yyvstop+6},
+ {yycrank+19, 0, yyvstop+9},
+ {yycrank+0, yysvec+5, yyvstop+12},
+ {yycrank+0, yysvec+6, yyvstop+14},
+ {0, 0, 0}
+};
+
+#if 0
+# define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):GETCHAR())==('\n')?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
+// *yylastch++ = yych = input();
+void subtest1(void)
+{
+ *yylastch++ = yych = input();
+}
+#endif
+
+// do some bogus operation to destroy all registers etc
+static int bog=1234;
+#if 0
+void bogus(void)
+{
+ bog*=0x1234;
+}
+#else
+#define bogus() bog+=0x1234
+#endif
+
+#if 1
+// yyt = yyt + yych;
+void subtest2(void)
+{
+ register struct yywork *yyt;
+ int yych;
+
+ yyt=yycrank;
+ yych=10;
+
+ bogus();
+ yyt = yyt + yych;
+
+ printf("yyt: %d %d\n",yyt->verify,yyt->advance);
+}
+#endif
+
+#if 1
+// if(yyt <= yytop && yyt->verify+yysvec == yystate)
+void subtest3(void)
+{
+ register struct yywork *yyt;
+ register struct yysvf *yystate;
+
+ yyt=yycrank;
+ yystate=yysvec;
+
+ bogus();
+ if(yyt <= yytop && yyt->verify+yysvec == yystate)
+ {
+ printf("if ok %d %d\n",yyt->verify,yyt->advance);
+ }
+ else
+ {
+ printf("if not ok %d %d\n",yyt->verify,yyt->advance);
+ }
+}
+#endif
+
+short yyr2[]=
+{
+ 0, 0, 2, 3, 3, 3, 3, 3, 3, 3,
+ 2, 3, 1, 1, 1
+};
+
+// yyps -= yyr2[yyn];
+void subtest4(void)
+{
+ register short *yyps, yyn;
+
+ yyps=0x8004;
+ yyn=0;
+
+ while(yyn<14)
+ {
+ bogus();
+ yyps -= yyr2[yyn];
+
+ yyn++;
+ }
+ printf("yyps: %04x\n",yyps);
+}
+
+#if 1
+
+int yylookret=10;
+yylook()
+{
+ yylookret--;
+ return yylookret;
+}
+
+// while((nstr = yylook()) >= 0)
+void subtest5(void)
+{
+ int nstr;
+
+ bogus();
+ while((nstr = yylook()) >= 0)
+ {
+ printf("nstr: %04x\n",nstr);
+ bogus();
+ }
+}
+#endif
+
+int main(void)
+{
+// subtest1();
+ subtest2();
+ subtest3();
+ subtest4();
+ subtest5();
+
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! verbose/debug version of yacc.c (if one fails and the other does not you most likely have a stack related problem)
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+/*#define STANDALONE*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#define INFILE "yaccdbg.in"
+
+#define LEXDEBUG
+#define YYDEBUG
+
+#define YACCDBG
+#include "yacc.c"
--- /dev/null
+
+# makefile for the regression tests that return an error code on failure
+
+ifneq ($(shell echo),)
+ CMD_EXE := 1
+endif
+
+CC65FLAGS := -t sim6502
+SIM65FLAGS := -x 200000000
+
+CL65 := $(if $(wildcard ../../bin/cl65*),../../bin/cl65,cl65)
+SIM65 := $(if $(wildcard ../../bin/sim65*),../../bin/sim65,sim65)
+
+ifdef CMD_EXE
+RM := del /f
+else
+RM := rm -f
+endif
+
+WORKDIR := ../../testwrk
+
+.PHONY: all clean
+
+SOURCES := $(wildcard *.c)
+TESTS := $(foreach option,. .o. .os. .osi. .osir. .oi. .oir. .or.,$(SOURCES:%.c=$(WORKDIR)/%$(option)prg))
+
+all: $(TESTS)
+
+$(WORKDIR)/%.prg: %.c
+ $(CL65) $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@
+
+$(WORKDIR)/%.o.prg: %.c
+ $(CL65) -O $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@
+
+$(WORKDIR)/%.os.prg: %.c
+ $(CL65) -Os $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@
+
+$(WORKDIR)/%.osi.prg: %.c
+ $(CL65) -Osi $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@
+
+$(WORKDIR)/%.osir.prg: %.c
+ $(CL65) -Osir $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@
+
+$(WORKDIR)/%.oi.prg: %.c
+ $(CL65) -Oi $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@
+
+$(WORKDIR)/%.oir.prg: %.c
+ $(CL65) -Oir $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@
+
+$(WORKDIR)/%.or.prg: %.c
+ $(CL65) -Or $(CC65FLAGS) $< -o $@
+ $(SIM65) $(SIM65FLAGS) $@
+
+clean:
+ @$(RM) $(TESTS)
+ @$(RM) $(SOURCES:.c=.o)
--- /dev/null
+/*
+ !!DESCRIPTION!! Addition tests
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+unsigned char *acharP = 0;
+
+void done()
+{
+ dummy++;
+}
+
+void add_lit2uchar(void)
+{
+ achar0 = achar0 + 5;
+
+ if(achar0 != 5)
+ failures++;
+
+ achar0 += 10;
+
+ if(achar0 != 15)
+ failures++;
+
+ achar0 = achar0 +1; /*Should be an increment */
+ if(achar0 != 16)
+ failures++;
+
+ for(achar1 = 0; achar1 < 100; achar1++)
+ achar0 += 2;
+
+ if(achar0 != 216)
+ failures++;
+}
+
+void add_uchar2uchar(void)
+{
+ achar1 = achar1 + achar0;
+
+ if(achar1 != 16)
+ failures++;
+
+ for(achar2 = 0; achar2<7; achar2++)
+ achar1 += achar0;
+
+ if(achar1 != 128)
+ failures++;
+}
+
+/* assumes
+ achar0 = 0
+ achar1 = 32
+ achar2, achar3 can be anything.
+*/
+void add_uchar2uchar2(void)
+{
+ achar0++;
+ achar0 = achar0 + 1;
+ achar0 = achar0 + 2;
+ achar0 = achar0 + 3;
+ if(achar0 != 7)
+ failures++;
+
+ achar1 += achar0;
+ if(achar1 != 39)
+ failures++;
+
+ achar2 = achar1 + achar0;
+ if(achar2 != 46)
+ failures++;
+
+ achar3 = achar2 + achar1 + achar0;
+ if(achar3 != 92)
+ failures++;
+}
+
+#ifdef SUPPORT_BIT_TYPES
+void add_bits(void)
+{
+ bit1 = bit0;
+
+ bit0 = 1;
+
+ if(bit1 != 0)
+ failures++;
+
+ bit1 = bit1+bit0;
+ if(bit1 != 1)
+ failures++;
+
+#ifdef SUPPORT_BIT_ARITHMETIC
+ bit2 = bit1+bit3;
+ if(!bit2)
+ failures++;
+
+ bit3 = bit4+bit5+bit6+bit7+bit0;
+ if(!bit3)
+ failures++;
+#endif
+}
+
+/* add_bit2uchar(void) - assumes bit0 = 1, achar0 = 7 */
+
+void add_bit2uchar(void)
+{
+ achar0 += bit0;
+
+ if(achar0 != 8)
+ failures++;
+
+ if(achar0 == bit0)
+ failures++;
+}
+
+void add_bit2uint(void)
+{
+ if(aint0 != bit11)
+ failures++;
+
+ aint0 += bit0;
+ if(aint0!=1)
+ failures++;
+}
+#endif
+
+int main(void)
+{
+ add_lit2uchar();
+
+ achar0=16;
+ achar1=0;
+ add_uchar2uchar();
+
+ achar0 = 0;
+ achar1 = 32;
+ add_uchar2uchar2();
+
+#ifdef SUPPORT_BIT_TYPES
+ add_bits();
+
+ add_bit2uchar();
+ add_bit2uint();
+#endif
+
+ success = failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Addition tests - mostly int's
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SIZEOF_INT_16BIT
+#if defined(__LINUX__) || defined(LINUX)
+unsigned short aint0 = 0;
+unsigned short aint1 = 0;
+unsigned short aint2 = 0;
+unsigned short aint3 = 0;
+
+#else
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned int aint2 = 0;
+unsigned int aint3 = 0;
+
+#endif
+
+#else
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned int aint2 = 0;
+unsigned int aint3 = 0;
+
+#endif
+
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+unsigned char *acharP = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+void done()
+{
+ dummy++;
+}
+
+void add_lit2uint(void)
+{
+ aint0 = aint0 + 5;
+
+ if(aint0 != 5)
+ failures++;
+
+ aint0 += 10;
+
+ if(aint0 != 15)
+ failures++;
+
+ aint0 = aint0 +1; /* Should be an increment */
+ if(aint0 != 16)
+ failures++;
+
+ for(aint1 = 0; aint1 < 100; aint1++)
+ aint0 += 2;
+
+ if(aint0 != 216)
+ failures++;
+}
+
+void add_uint2uint (void)
+{
+ aint1 = aint1 + aint0;
+
+ if(aint1 != 16)
+ failures++;
+
+ for(aint2 = 0; aint2<7; aint2++)
+ aint1 += aint0;
+
+ if(aint1 != 128)
+ failures++;
+}
+
+/* assumes
+ aint0 = 0
+ aint1 = 32
+ aint2, aint3 can be anything.
+*/
+void add_uint2uint2(void)
+{
+ aint0++;
+ aint0 = aint0 + 1;
+ aint0 = aint0 + 2;
+ aint0 = aint0 + 3;
+ if(aint0 != 7)
+ failures++;
+
+ aint1 += aint0;
+ if(aint1 != 0x27)
+ failures++;
+
+ aint2 = aint1 + aint0;
+ if(aint2 != 0x2e)
+ failures++;
+
+ aint3 = aint2 + aint1 + aint0;
+ if(aint3 != 0x5c)
+ failures++;
+
+ aint3 += 0xa0;
+ if(aint3 != 0xfc)
+ failures++;
+
+ aint3 += aint0;
+ if(aint3 != 0x103)
+ failures++;
+
+ aint1 += 0xffc0;
+ if(aint1 != 0xffe7)
+ failures++;
+
+ aint3 = aint2 + aint1 + aint0;
+ if(aint3 != 0x1c)
+ failures++;
+}
+
+#ifdef SUPPORT_BIT_TYPES
+void add_bits(void)
+{
+ bit1 = bit0;
+
+ bit0 = 1;
+
+ if(bit1 != 0)
+ failures++;
+
+ bit1 = bit1+bit0;
+ if(bit1 != 1)
+ failures++;
+
+ bit2 = bit1+bit3;
+ if(!bit2)
+ failures++;
+
+ bit3 = bit4+bit5+bit6+bit7+bit0;
+ if(!bit3)
+ failures++;
+}
+
+/* add_bit2uchar(void) - assumes bit0 = 1, aint0 = 7 */
+
+void add_bit2uchar(void)
+{
+ achar0 += bit0;
+
+ if(achar0 != 8)
+ failures++;
+
+ if(achar0 == bit0)
+ failures++;
+}
+
+void add_bit2uint(void)
+{
+ if(aint0 != bit11)
+ failures++;
+
+ aint0 += bit0;
+ if(aint0!=1)
+ failures++;
+}
+#endif
+
+/***********************************/
+
+void addlits(void)
+{
+ aint0 += 0x0001;
+
+ if(aint0 != 1)
+ failures++;
+
+ aint0 += 0x00;
+
+ if(aint0 != 1)
+ failures++;
+
+ aint0 += 0x00fe;
+ if(aint0 != 0x00ff)
+ failures++;
+
+ aint0 += 0x0001;
+
+ if(aint0 != 0x0100)
+ failures++;
+
+ aint0++;
+ if(aint0 != 0x0101)
+ failures++;
+
+ aint0 += 0x00ff;
+ if(aint0 != 0x0200)
+ failures++;
+
+ aint0 += 0x00a0;
+ if(aint0 != 0x02a0)
+ failures++;
+
+ aint0 += 0x0061;
+ if(aint0 != 0x0301)
+ failures++;
+
+ aint0 += 0x0100;
+ if(aint0 != 0x0401)
+ failures++;
+
+ aint0 += 0x0101;
+ if(aint0 != 0x0502)
+ failures++;
+
+ aint0 += 0x00fd;
+ if(aint0 != 0x05ff)
+ failures++;
+
+ aint0 += 0x0101;
+ if(aint0 != 0x0700)
+ failures++;
+
+ aint0 += 0x01ff;
+ if(aint0 != 0x08ff)
+ failures++;
+
+ aint0 += 0x01ff;
+ if(aint0 != 0x0afe)
+ failures++;
+
+ aint0 += 0xff02;
+ if(aint0 != 0x0a00)
+ failures++;
+
+ aint0 += 0xffff;
+ if(aint0 != 0x09ff)
+ failures++;
+
+ aint0 += 0xff01;
+ if(aint0 != 0x0900)
+ failures++;
+
+ aint0 += 0xff00;
+ if(aint0 != 0x0800)
+ failures++;
+
+ aint0 += 0xff01;
+ if(aint0 != 0x0701)
+ failures++;
+
+ aint0 += 0x0300;
+ if(aint0 != 0x0a01)
+ failures++;
+
+ aint0 += 0x03ff;
+ if(aint0 != 0x0e00)
+ failures++;
+
+ aint0 += 0x0301;
+ if(aint0 != 0x1101)
+ failures++;
+
+ aint0 += 0x03fe;
+ if(aint0 != 0x14ff)
+ failures++;
+
+ aint0 += 0x0301;
+ if(aint0 != 0x1800)
+ failures++;
+}
+
+int main(void)
+{
+ add_lit2uint();
+
+ aint0=16;
+ aint1=0;
+ add_uint2uint();
+
+ aint0 = 0;
+ aint1 = 32;
+ aint2 = 0;
+ add_uint2uint2();
+
+#ifdef SUPPORT_BIT_TYPES
+ add_bits();
+
+ achar0 = 7;
+ add_bit2uchar();
+
+ aint0 = 0;
+ bit0 = 1;
+ add_bit2uint();
+#endif
+
+ aint0 = 0;
+ addlits();
+
+ success = failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Addition tests - mostly int's
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include "common.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+unsigned char failures=0;
+
+char char0 = 0;
+char char1 = 0;
+char char2 = 0;
+
+/*
+ this test assumes:
+ sizeof(char) == 1
+ sizeof(int) == 2
+ sizeof(long) == 4
+*/
+
+#ifdef REFERENCE
+
+/*
+ make sure the reference output uses types with
+ proper size
+*/
+
+#include <stdint.h>
+
+#ifdef SIZEOF_INT_16BIT
+int16_t int0 = 0;
+int16_t int1 = 0;
+#else
+int32_t int0 = 0;
+int32_t int1 = 0;
+#endif
+int32_t long0 = 0;
+int32_t long1 = 0;
+uint32_t ulong0 = 0;
+uint32_t ulong1 = 0;
+
+#else
+
+int int0 = 0;
+int int1 = 0;
+long long0 = 0;
+long long1 = 0;
+unsigned long ulong0 = 0;
+unsigned long ulong1 = 0;
+
+#endif
+
+#ifdef SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+void done(char *name)
+{
+ printf("%s done - failures: %d\n", name, failures);
+
+ if(failures)
+ exit(failures);
+}
+
+void add_char2char(void)
+{
+ if(char0 != 4)
+ failures++;
+ if(char1 != 5)
+ failures++;
+
+ char0 = char0 + char1;
+
+ if(char0 != 9)
+ failures++;
+
+ char0 += 127;
+
+#if (!defined(REFCC) && defined(UNSIGNED_CHARS)) || (defined(REFCC) && defined(REFCC_UNSIGNED_CHARS))
+ if(char0 < 0)
+ failures++;
+
+ if(char0 != (127+9))
+ failures++;
+#else
+ if(char0 > 0)
+ failures++;
+
+ if(char0 != -0x78)
+ failures++;
+#endif
+
+ done("add_char2char");
+}
+
+void add_compound_char(void)
+{
+ char0 = char1+5;
+
+ if(char0 != 9)
+ failures++;
+
+ if((char0+char1) != 13)
+ failures++;
+
+ done("add_compound_char");
+}
+
+void add_int2int(void)
+{
+ if(int0 != 4)
+ failures++;
+ if(int1 != 5)
+ failures++;
+
+ int0 += int1;
+ if(int0 != 9)
+ failures++;
+
+ int0 += 0x7fff;
+ if(int0 != -0x7ff8)
+ failures++;
+
+ done("add_int2int");
+}
+
+void add_compound_int(void)
+{
+ int0 = int1+5;
+
+ if(int0 != 9)
+ failures++;
+
+ if((int0+int1) != 13)
+ failures++;
+
+ done("add_compound_int");
+}
+
+void add_lit2long(void)
+{
+ if(long0 != 0)
+ failures++;
+
+ long0++;
+
+ if(long0 != 1)
+ failures++;
+
+ long0 = long0 + 0xff;
+
+ if(long0 != 0x100)
+ failures++;
+
+ long0 = long0 + 0x100;
+ if(long0 != 0x200)
+ failures++;
+
+ long0 = long0 + 0xfe00;
+ if(long0 != 0x10000)
+ failures++;
+
+ long0 = long0 + 0xff0000;
+ if(long0 != 0x1000000)
+ failures++;
+
+ long0 = long0 + 0x7e000000;
+ if(long0 != 0x7f000000)
+ failures++;
+
+ /* wrap around zero */
+ long0 = long0 + 0x2000000;
+ if(long0 != -0x7f000000)
+ failures++;
+
+ long0 = long0 + 0x7f000000;
+ if(long0 != 0)
+ failures++;
+
+ done("add_lit2long");
+}
+
+void add_lit2ulong(void)
+{
+ if(ulong0 != 0)
+ failures++;
+
+ ulong0++;
+
+ if(ulong0 != 1)
+ failures++;
+
+ ulong0 = ulong0 + 0xff;
+
+ if(ulong0 != 0x100)
+ failures++;
+
+ ulong0 = ulong0 + 0x100;
+ if(ulong0 != 0x200)
+ failures++;
+
+ ulong0 = ulong0 + 0xfe00;
+ if(ulong0 != 0x10000)
+ failures++;
+
+ ulong0 = ulong0 + 0xff0000;
+ if(ulong0 != 0x1000000)
+ failures++;
+
+ ulong0 = ulong0 + 0x7e000000;
+ if(ulong0 != 0x7f000000)
+ failures++;
+
+ ulong0 = ulong0 + 0x2000000;
+ if(ulong0 != 0x81000000)
+ failures++;
+
+ /* wrap around zero */
+ ulong0 = ulong0 + 0x7f000000;
+ if(ulong0)
+ failures++;
+
+ done("add_lit2ulong");
+}
+
+int main(void)
+{
+ char0=4;
+ char1 = char0 + 1;
+ add_char2char();
+
+ char1=4;
+ add_compound_char();
+
+ int0 = 4;
+ int1 = int0 + 1;
+ add_int2int();
+
+ int1=4;
+ add_compound_int();
+
+ add_lit2long();
+ add_lit2ulong();
+
+ /* if not exit() */
+ return 0;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+int int0 = 0;
+int int1 = 0;
+char char0 = 0;
+char char1 = 0;
+long long0 = 0;
+long long1 = 0;
+unsigned long ulong0 = 0;
+unsigned long ulong1 = 0;
+#define NULL 0
+char *cP0=NULL;
+char *cP1=NULL;
+int *iP0=NULL;
+int *iP1=NULL;
+
+void
+done ()
+{
+ dummy++;
+}
+
+/* pointer to char arithmetic */
+
+void pc_add(void)
+{
+ if(*cP1)
+ failures++;
+
+ *cP1 += 1;
+ if(*cP1 != 1)
+ failures++;
+
+ if(char0 != 1)
+ failures++;
+
+ char0++;
+
+ if(*cP1 != 2)
+ failures++;
+
+ char1 = char0 + *cP1;
+
+ if(char1 != 4)
+ failures++;
+}
+
+/* pointer to integer arithmetic */
+void pi_add(void)
+{
+ if(*iP0)
+ failures++;
+
+ *iP0 += 1;
+
+ if(*iP0 != 1)
+ failures++;
+
+ if(int0 != 1)
+ failures++;
+
+ int1 = int0 + *iP0;
+ if(int1 != 2)
+ failures++;
+}
+
+int main(void)
+{
+ cP1 = &char0;
+ pc_add();
+
+ iP0 = &int0;
+ pi_add();
+
+ success = failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+unsigned long ulong0 = 0;
+
+void done()
+{
+ dummy++;
+}
+
+/* uchar0 = 0xff; */
+void and_lit2uchar(void)
+{
+ if(uchar0 != 0xff)
+ failures++;
+
+ uchar0 &= 0x7f;
+
+ if(uchar0 != 0x7f)
+ failures++;
+
+ uchar0 &= 0x3f;
+
+ if(uchar0 != 0x3f)
+ failures++;
+
+ uchar0 &= 0xdf;
+
+ if(uchar0 != 0x1f)
+ failures++;
+}
+
+void and_lit2uint(void)
+{
+ if(uint0 != 0xffff)
+ failures++;
+
+ uint0 &= 0x7fff;
+
+ if(uint0 != 0x7fff)
+ failures++;
+
+ uint0 &= 0x3fff;
+
+ if(uint0 != 0x3fff)
+ failures++;
+
+ uint0 &= 0xdfff;
+
+ if(uint0 != 0x1fff)
+ failures++;
+
+ uint0 &= 0xff7f;
+
+ if(uint0 != 0x1f7f)
+ failures++;
+
+ uint0 &= 0x0f0f;
+
+ if(uint0 != 0x0f0f)
+ failures++;
+
+ uint0 &= 0xfefe;
+
+ if(uint0 != 0x0e0e)
+ failures++;
+
+ uint0 &= 0xf0f0;
+
+ if(uint0 != 0)
+ failures++;
+}
+
+void and_lit2ulong(void)
+{
+ if(ulong0 != 0xffffffff)
+ failures++;
+
+ ulong0 &= 0x7fffffff;
+
+ if(ulong0 != 0x7fffffff)
+ failures++;
+
+ ulong0 &= 0xff00ffff;
+
+ if(ulong0 != 0x7f00ffff)
+ failures++;
+
+ ulong0 &= 0xfeff00ff;
+
+ if(ulong0 != 0x7e0000ff)
+ failures++;
+}
+
+/*-----------*/
+void and_uchar2uchar(void)
+{
+ uchar0 &= uchar1;
+
+ if(uchar0 != 0x0f)
+ failures++;
+
+ uchar1 &= 0xf7;
+
+ uchar0 = uchar1 & 0xfe;
+
+ if(uchar0 != 0x06)
+ failures++;
+}
+
+int main(void)
+{
+ uchar0 = 0xff;
+ and_lit2uchar();
+
+ uint0 = 0xffff;
+ and_lit2uint();
+
+ ulong0 = 0xffffffff;
+ and_lit2ulong();
+
+ uchar0 = 0xff;
+ uchar1 = 0x0f;
+ and_uchar2uchar();
+
+ success = failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+unsigned long ulong0 = 0;
+
+void done()
+{
+ dummy++;
+}
+
+/* uchar0 = 0x13; */
+void and_compound1(void)
+{
+ uchar0 = (uchar0 + 1) & 0x0f;
+ if(uchar0 != 4)
+ failures++;
+}
+
+/* uchar1 = 0x42; */
+void and_compound2(void)
+{
+ uchar0 = (uchar1 + 1) & 0x0f;
+ if(uchar0 != 3)
+ failures++;
+
+ if(uchar1 != 0x42)
+ failures++;
+}
+
+/* uchar0 = 0x13; */
+void or_compound1(void)
+{
+ uchar0 = (uchar0 + 0xe) | 0x0f;
+ if(uchar0 != 0x2f)
+ failures++;
+}
+
+/* uchar1 = 0x47; */
+void or_compound2(void)
+{
+ uchar0 = (uchar1 + 0xf) | 0x0f;
+ if(uchar0 != 0x5f)
+ failures++;
+
+ if(uchar1 != 0x47)
+ failures++;
+}
+
+/* uchar0 = 0x13; */
+void xor_compound1(void)
+{
+ uchar0 = (uchar0 + 1) ^ 0x0f;
+ if(uchar0 != 0x1b)
+ failures++;
+}
+
+/* uchar1 = 0x47; */
+void xor_compound2(void)
+{
+ uchar0 = (uchar1 + 0xf) ^ 0x0f;
+ if(uchar0 != 0x59)
+ failures++;
+
+ if(uchar1 != 0x47)
+ failures++;
+}
+
+/* uchar0 = 0x13; */
+void neg_compound1(void)
+{
+ uchar0 = ~(uchar0 + 1);
+ if(uchar0 != 0xeb)
+ failures++;
+}
+
+int main(void)
+{
+ uchar0 = 0x13;
+ and_compound1();
+
+ uchar1 = 0x42;
+ and_compound2();
+
+ uchar0 = 0x13;
+ or_compound1();
+
+ uchar1 = 0x47;
+ or_compound2();
+
+ uchar0 = 0x13;
+ xor_compound1();
+
+ uchar1 = 0x47;
+ xor_compound2();
+
+ uchar0 = 0x13;
+ neg_compound1();
+
+ success = failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! A small test for atoi. Assumes twos complement
+ !!ORIGIN!!
+ !!LICENCE!!
+ !!AUTHOR!!
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+static unsigned int Failures = 0;
+
+static void CheckAtoi (const char* Str, int Val)
+{
+ int Res = atoi (Str);
+ if (Res != Val) {
+ printf ("atoi error in \"%s\":\n"
+ " result = %d, should be %d\n", Str, Res, Val);
+ ++Failures;
+ }
+}
+
+int main (void)
+{
+ CheckAtoi ("\t +0A", 0);
+ CheckAtoi ("\t -0.123", 0);
+ CheckAtoi (" -32 ", -32);
+ CheckAtoi (" +32 ", 32);
+ CheckAtoi ("0377", 377);
+ CheckAtoi (" 0377 ", 377);
+ CheckAtoi (" +0377 ", 377);
+ CheckAtoi (" -0377 ", -377);
+ CheckAtoi ("0x7FFF", 0);
+ CheckAtoi (" +0x7FFF", 0);
+ CheckAtoi (" -0x7FFF", 0);
+ printf ("Failures: %u\n", Failures);
+
+ return Failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void done()
+{
+ dummy++;
+}
+
+void bool_or1(void)
+{
+ if( (achar0 >0) || (achar1 >0 ))
+ failures++;
+}
+
+void bool_or2(void)
+{
+ if( achar0 || achar1)
+ failures++;
+}
+
+void bool_test1(void)
+{
+ if( (achar0==0) || achar1)
+ failures++;
+}
+
+void bool_test2(void)
+{
+ if( (achar0==0) || aint0)
+ failures++;
+}
+
+void bool_and1(void)
+{
+ if( achar0 && achar1)
+ failures++;
+}
+
+void bin_or1(void)
+{
+ char t;
+
+ t = achar0 | achar1;
+ if(t)
+ failures++;
+}
+
+void bin_xor1(void)
+{
+ if(achar0 ^ achar1)
+ failures++;
+}
+
+void bool_test3(void)
+{
+ if((achar0 == 0x42) || (achar1 == 42))
+ failures++;
+}
+
+void bool_or_lit1(void)
+{
+ achar0 |= 0x0f;
+
+ if(achar0 > 0x10)
+ failures++;
+
+ if( (achar0 | 0x10) > 0xf0)
+ failures++;
+}
+
+void bool_and_lit1(void)
+{
+ achar0 &= 0xf0;
+
+ if(achar0 > 0x10)
+ failures++;
+
+ if( (achar0 & 0x10) > 0xf0)
+ failures++;
+
+ achar0 &= 0xef;
+}
+
+int main(void)
+{
+ bool_or1();
+ bool_or2();
+ bool_and1();
+ bin_or1();
+ bin_xor1();
+
+ achar0++;
+ bool_and1();
+ bool_test1();
+ bool_test2();
+ bool_test3();
+
+ achar0--; achar1++;
+ bool_and1();
+
+ achar0=0;
+ achar1=0;
+
+ bool_or_lit1();
+ bool_and_lit1();
+
+ success = failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Compound comparisons
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+bit bit1 = 0;
+#endif
+unsigned int ui0 = 0;
+unsigned int ui1 = 0;
+unsigned char uc0 = 0;
+unsigned char uc1 = 0;
+unsigned long uL0 = 0;
+unsigned long uL1 = 0;
+
+void done()
+{
+ dummy++;
+}
+
+void compound_compare_uc(void)
+{
+ failures += (uc0 != uc1);
+}
+
+void compound_compare_ui(void)
+{
+ failures += (ui0 != ui1);
+}
+
+void compound_compare_ul(void)
+{
+ failures += (uL0 != uL1);
+}
+
+void compound_compare_uc_lit(void)
+{
+ failures += (uc0 != 0xff);
+ failures += (uc0 != 0xff);
+ failures += (uc0 == 0);
+}
+
+int main(void)
+{
+ compound_compare_uc();
+ compound_compare_ui();
+ compound_compare_ul();
+
+ uc0 = 0xff;
+ compound_compare_uc_lit();
+
+ success = failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+
+unsigned char call3 (void);
+
+void
+done ()
+{
+ dummy++;
+}
+
+void
+call1 (unsigned char uc0)
+{
+ if (uc0)
+ failures++;
+}
+
+void
+call2 (unsigned int ui0)
+{
+ if (ui0)
+ failures++;
+}
+
+unsigned char
+call3 (void)
+{
+ if (uchar0)
+ failures++;
+
+ return (failures);
+}
+
+unsigned int
+call4 (void)
+{
+ unsigned int i = 0;
+
+ if (uint0)
+ i++;
+
+ return (i);
+}
+
+unsigned int
+call5 (unsigned int k)
+{
+ if (k)
+ failures++;
+
+ return (k);
+}
+
+unsigned char
+call6a(unsigned char uc)
+{
+ if(uc>uchar1)
+ return 1;
+ else
+ return 0;
+}
+
+unsigned char
+call6(unsigned char uc)
+{
+ return(call6a(uc));
+}
+
+unsigned int
+call7a(unsigned int ui)
+{
+ if(ui)
+ return 1;
+ else
+ return 0;
+}
+
+unsigned int
+call7(unsigned int ui)
+{
+ return(call7a(ui));
+}
+
+unsigned char
+call8(unsigned char uc1,unsigned char uc2)
+{
+ return uc1+uc2;
+}
+
+void call9(unsigned int ui1, unsigned int ui2)
+{
+ if(ui1 != 0x1234)
+ failures++;
+ if(ui2 != 0x5678)
+ failures++;
+}
+
+int
+main (void)
+{
+ call1 (uchar0);
+ call2 (uint0);
+ uchar1 = call3 ();
+ uint1 = call4 ();
+ if (uint1)
+ failures++;
+
+ uint1 = call5 (uint0);
+ if (uint1)
+ failures++;
+
+ if(call6(uchar0))
+ failures++;
+
+ if(call7(0))
+ failures++;
+
+ if(!call7(1))
+ failures++;
+
+ if(!call7(0xff00))
+ failures++;
+
+ uchar0=4;
+ uchar1=3;
+ uchar0 = call8(uchar0,uchar1);
+
+ if(uchar0 != 7)
+ failures++;
+
+ call9(0x1234,0x5678);
+
+ success = failures;
+ done ();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! bit field bug
+ !!ORIGIN!! testsuite
+ !!LICENCE!! Public Domain
+ !!AUTHOR!! Johan Kotlinski
+*/
+
+#include <stdio.h>
+#include <assert.h>
+
+struct {
+ int foo : 7;
+ int bar : 4;
+} baz = { 0, 2 };
+
+int main() {
+ char bar = baz.bar;
+
+ assert(2 == bar);
+
+ printf("it works :)\n");
+
+ /* if not assert() */
+ return 0;
+}
+
+/* Assert fails. (SVN rev 4381) */
\ No newline at end of file
--- /dev/null
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define NO_OLD_FUNC_DECL
+#define NO_TYPELESS_INT
+#define NO_TYPELESS_INT_PTR
+#define MAIN_RETURNS_INT
+#define NO_IMPLICIT_FUNC_PROTOTYPES
+#define NO_FLOATS
+#define NO_WCHAR
+#define NO_EMPTY_FUNC_ARGS
+#define NO_SLOPPY_STRUCT_INIT
+#define NO_FUNCS_TAKE_STRUCTS
+#define NO_FUNCS_RETURN_STRUCTS
+#define CAST_STRUCT_PTR
+#define NO_TYPELESS_STRUCT_PTR
+#define NO_IMPLICIT_FUNCPTR_CONV
+#define SIZEOF_INT_16BIT
+#define SIZEOF_LONG_32BIT
+#define UNSIGNED_CHARS
+#define UNSIGNED_BITFIELDS
--- /dev/null
+/*
+ !!DESCRIPTION!! test compare
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+/*
+ compare.c
+*/
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+bit bit1 = 0;
+#endif
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+
+char schar0 = 0;
+char schar1 = 0;
+
+void
+done ()
+{
+ dummy++;
+}
+
+/* achar0 should be zero */
+
+void
+compare_char_to_lits1 (void)
+{
+ if (achar0)
+ failures++;
+
+ if (achar0 == 1)
+ failures++;
+
+ if (achar0 == 7)
+ failures++;
+
+ if (achar0 != 0)
+ failures++;
+}
+
+/* achar0 should be `5' */
+void
+compare_char_to_lits2 (void)
+{
+ if (!achar0)
+ failures++;
+
+ if (achar0 == 1)
+ failures++;
+
+ if (achar0 == 7)
+ failures++;
+
+ if (achar0 != 5)
+ failures++;
+}
+
+/* achar0 should equal achar1 */
+void
+compare_char_to_char1 (void)
+{
+ if (achar0 != achar1)
+ failures++;
+
+ if (schar0 != schar1)
+ failures++;
+}
+
+/* achar0 should be different than achar1 */
+void
+compare_char_to_char2 (void)
+{
+ if (achar0 == achar1)
+ failures++;
+}
+
+/* aint0 should be zero */
+
+void
+compare_int_to_lits1 (void)
+{
+ if (aint0)
+ failures++;
+
+ if (aint0 == 1)
+ failures++;
+
+ if (aint0 == 7)
+ failures++;
+
+ if (aint0 != 0)
+ failures++;
+}
+
+/* aint0 should be `5' */
+void
+compare_int_to_lits2 (void)
+{
+ if (!aint0)
+ failures++;
+
+ if (aint0 == 1)
+ failures++;
+
+ if (aint0 == 7)
+ failures++;
+
+ if (aint0 != 5)
+ failures++;
+}
+
+/* aint0 should be `0x1234' */
+void
+compare_int_to_lits3 (void)
+{
+ if (!aint0)
+ failures++;
+
+ if (aint0 == 1)
+ failures++;
+
+ if (aint0 == 7)
+ failures++;
+
+ if (aint0 != 0x1234)
+ failures++;
+}
+
+/* aint0 should equal aint1 */
+void
+compare_int_to_int1 (void)
+{
+ if (aint0 != aint1)
+ failures++;
+}
+
+/* aint0 should be different than aint1 */
+void
+compare_int_to_int2 (void)
+{
+ if (aint0 == aint1)
+ failures++;
+}
+
+int
+main (void)
+{
+ compare_char_to_lits1 ();
+ compare_char_to_char1 ();
+ achar0 = 5;
+ compare_char_to_lits2 ();
+ compare_char_to_char2 ();
+
+ compare_int_to_lits1 ();
+ aint0 = 5;
+ compare_int_to_lits2 ();
+ aint0 = 0x1234;
+ compare_int_to_lits3 ();
+ compare_int_to_int2 ();
+ aint0 = 0;
+ compare_int_to_int1 ();
+
+ success = failures;
+ done ();
+
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Signed comparisons of the form: (variable>=LIT)
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+/* This regression test exercises all of the boundary
+ conditions in literal less than comparisons. There
+ are numerous opportunities to optimize these comparison
+ and each one has an astonishing capability of failing
+ a boundary condition.
+*/
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+unsigned char result = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+int int0 = 0;
+int int1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+signed char char0 = 0;
+signed char char1 = 0;
+char long0 = 0;
+char long1 = 0;
+
+/* *** NOTE *** This particular test takes quite a while to run
+ * ~ 10,000,000 instruction cycles. (2.5 seconds on a 20Mhz PIC).
+ * The WDT will reset the CPU if it's enabled. So disable it...
+*/
+
+void
+done ()
+{
+ dummy++;
+}
+
+void c_char_gte_lit1(unsigned char expected_result)
+{
+ result = 0;
+
+ if(char0 >= -0x7f)
+ result |= 1;
+
+ if(char0 >= -1)
+ result |= 2;
+
+ if(char0 >= 0)
+ result |= 4;
+
+ if(char0 >= 1)
+ result |= 8;
+
+ if(char0 >= 0x7e)
+ result |= 0x10;
+
+ if(char0 >= 0x7f)
+ result |= 0x20;
+
+ if(result != expected_result)
+ {
+/* LOG_ERROR(1); */
+ printf("c_char_gte_lit1: char %02x - result %02x expected: %02x\n",char0,result,expected_result);
+ failures++;
+ }
+
+/* printf("char %02x - %02x failures: %d\n",char0,expected_result,failures); */
+}
+
+void char_compare(void)
+{
+ char0 = 0x7f;
+ c_char_gte_lit1(0x3f);
+
+ char0 = 0x7e;
+ c_char_gte_lit1(0x1f);
+
+ char0 = 0x40;
+ c_char_gte_lit1(0x0f);
+
+ char0 = 0x2;
+ c_char_gte_lit1(0x0f);
+
+ char0 = 0x1;
+ c_char_gte_lit1(0x0f);
+
+ char0 = 0;
+ c_char_gte_lit1(0x07);
+
+ char0 = -1;
+ c_char_gte_lit1(0x03);
+
+ char0 = -2;
+ c_char_gte_lit1(0x01);
+
+ char0 = -0x40;
+ c_char_gte_lit1(0x01);
+
+ char0 = -0x7e;
+ c_char_gte_lit1(0x01);
+
+ char0 = -0x7f;
+ c_char_gte_lit1(0x01);
+
+ char0 = 0x80;
+ c_char_gte_lit1(0x00);
+
+ /* Now test entire range */
+
+ for(char0=1; char0 != 0x7e; char0++)
+ c_char_gte_lit1(0x0f);
+
+ for(char0=-0x7f; char0 != -1; char0++)
+ c_char_gte_lit1(0x01);
+}
+
+void c_int_gte_lit1(unsigned char expected_result)
+{
+ result = 0;
+
+ if(int0 >= 0)
+ result |= 1;
+
+ if(int0 >= 1)
+ result |= 2;
+
+ if(int0 >= 0xff)
+ result |= 4;
+
+ if(int0 >= 0x100)
+ result |= 8;
+
+ if(int0 >= 0x0101)
+ result |= 0x10;
+
+ if(int0 >= 0x01ff)
+ result |= 0x20;
+
+ if(int0 >= 0x0200)
+ result |= 0x40;
+
+ if(int0 >= 0x0201)
+ result |= 0x80;
+
+ if(result != expected_result)
+ failures=1;
+}
+
+void int_compare1(void)
+{
+ int0 = -1;
+ c_int_gte_lit1(0x00);
+
+ int0 = 0;
+ c_int_gte_lit1(0x01);
+
+ int0 = 1;
+ c_int_gte_lit1(0x03);
+
+ int0 = 2;
+ c_int_gte_lit1(0x03);
+
+ int0 = 0xfe;
+ c_int_gte_lit1(0x03);
+
+ int0 = 0xff;
+ c_int_gte_lit1(0x07);
+
+ int0 = 0x100;
+ c_int_gte_lit1(0x0f);
+
+ int0 = 0x101;
+ c_int_gte_lit1(0x1f);
+
+ int0 = 0x102;
+ c_int_gte_lit1(0x1f);
+
+ int0 = 0x1fe;
+ c_int_gte_lit1(0x1f);
+
+ int0 = 0x1ff;
+ c_int_gte_lit1(0x3f);
+
+ int0 = 0x200;
+ c_int_gte_lit1(0x7f);
+
+ int0 = 0x201;
+ c_int_gte_lit1(0xff);
+
+ int0 = 0x7f00;
+ c_int_gte_lit1(0xff);
+
+ /* now check contiguous ranges */
+
+ for(int0 = -0x7fff; int0 != -1; int0++)
+ c_int_gte_lit1(0x00);
+
+ for(int0 = 1; int0 != 0xff; int0++)
+ c_int_gte_lit1(0x03);
+
+ for(int0 = 0x201; int0 != 0x7fff; int0++)
+ c_int_gte_lit1(0xff);
+}
+
+void c_int_gte_lit2(unsigned char expected_result)
+{
+ result = 0;
+
+ if(int0 >= -0x7fff)
+ result |= 1;
+
+ if(int0 >= -0x7f00)
+ result |= 2;
+
+ if(int0 >= -0x7eff)
+ result |= 4;
+
+ if(int0 >= -0x7e00)
+ result |= 8;
+
+ if(int0 >= -0x0101)
+ result |= 0x10;
+
+ if(int0 >= -0x0100)
+ result |= 0x20;
+
+ if(int0 >= -0xff)
+ result |= 0x40;
+
+ if(int0 >= -1)
+ result |= 0x80;
+
+ if(result != expected_result)
+ failures=1;
+}
+
+void int_compare2(void)
+{
+ int0 = -0x7fff;
+ c_int_gte_lit2(0x01);
+
+ int0 = -0x7f00;
+ c_int_gte_lit2(0x03);
+
+ int0 = -0x7eff;
+ c_int_gte_lit2(0x07);
+
+ int0 = -0x7e00;
+ c_int_gte_lit2(0x0f);
+
+ int0 = -0x7dff;
+ c_int_gte_lit2(0x0f);
+
+ int0 = -0x4567;
+ c_int_gte_lit2(0x0f);
+
+ int0 = -0x200;
+ c_int_gte_lit2(0x0f);
+
+ int0 = -0x102;
+ c_int_gte_lit2(0x0f);
+
+ int0 = -0x101;
+ c_int_gte_lit2(0x1f);
+
+ int0 = -0x100;
+ c_int_gte_lit2(0x3f);
+
+ int0 = -0xff;
+ c_int_gte_lit2(0x7f);
+
+ int0 = -0x02;
+ c_int_gte_lit2(0x7f);
+
+ int0 = -0x01;
+ c_int_gte_lit2(0xff);
+
+ int0 = 0;
+ c_int_gte_lit2(0xff);
+
+ int0 = 1;
+ c_int_gte_lit2(0xff);
+
+ int0 = 0x7fff;
+ c_int_gte_lit2(0xff);
+
+ /* now check contiguous ranges */
+
+ for(int0 = -0x7fff; int0 != -0x7f00; int0++)
+ c_int_gte_lit2(0x01);
+
+ for(int0 = -0x7e00; int0 != -0x101; int0++)
+ c_int_gte_lit2(0x0f);
+
+ for(int0 = -1; int0 != 0x7fff; int0++)
+ c_int_gte_lit2(0xff);
+}
+
+int
+main (void)
+{
+ char_compare();
+ printf("failures: %d\n",failures);
+ int_compare1();
+ printf("failures: %d\n",failures);
+ int_compare2();
+
+ success = failures;
+ done ();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void
+done ()
+{
+ dummy++;
+}
+
+void
+char_lt_char (void)
+{
+ if (achar0 < achar1)
+ failures++;
+}
+
+void
+char_gt_char (void)
+{
+ if (achar1 > achar0)
+ failures++;
+}
+
+void
+char_lte_char (void)
+{
+ if (achar0 <= achar1)
+ failures++;
+}
+
+void
+char_gte_char (void)
+{
+ if (achar1 >= achar0)
+ failures++;
+}
+
+void
+char_lt_lit (void)
+{
+ if (achar1 < 0x10)
+ failures++;
+}
+
+void
+char_gt_lit (void)
+{
+ if (achar1 > 0x10)
+ failures++;
+}
+
+void
+char_lte_lit (void)
+{
+ if (achar1 <= 0x0f)
+ failures++;
+}
+
+void
+char_gte_lit (void)
+{
+ if (achar1 >= 0x11)
+ failures++;
+}
+
+/* now repeat test using negative logic */
+void
+char_lt_char_else (void)
+{
+ if (achar0 >= achar1)
+ dummy++;
+ else
+ failures++;
+}
+
+void
+char_gt_char_else (void)
+{
+ if (achar1 <= achar0)
+ dummy++;
+ else
+ failures++;
+}
+
+void
+char_lte_char_else (void)
+{
+ if (achar0 > achar1)
+ dummy++;
+ else
+ failures++;
+}
+
+void
+char_gte_char_else (void)
+{
+ if (achar1 < achar0)
+ dummy++;
+ else
+ failures++;
+}
+
+void
+char_lt_lit_else (void)
+{
+ if (achar1 >= 0x10)
+ dummy++;
+ else
+ failures++;
+}
+
+void
+char_gt_lit_else (void)
+{
+ if (achar1 <= 0x10)
+ dummy++;
+ else
+ failures++;
+}
+
+void
+char_lte_lit_else (void)
+{
+ if (achar1 > 0x0f)
+ dummy++;
+ else
+ failures++;
+}
+
+void
+char_gte_lit_else (void)
+{
+ if (achar1 < 0x11)
+ dummy++;
+ else
+ failures++;
+}
+
+/* ints */
+
+void
+int_lt_int (void)
+{
+ if (aint0 < aint1)
+ failures++;
+}
+
+void
+int_gt_int (void)
+{
+ if (aint1 > aint0)
+ failures++;
+}
+
+void
+int_lte_int (void)
+{
+ if (aint0 <= aint1)
+ failures++;
+}
+
+void
+int_gte_int (void)
+{
+ if (aint1 >= aint0)
+ failures++;
+}
+
+void
+int_lt_lit (void)
+{
+ if (aint1 < 0x10)
+ failures++;
+}
+
+void
+int_gt_lit (void)
+{
+ if (aint1 > 0x10)
+ failures++;
+}
+
+void
+int_lte_lit (void)
+{
+ if (aint1 <= 0x0f)
+ failures++;
+}
+
+void
+int_gte_lit (void)
+{
+ if (aint1 >= 0x11)
+ failures++;
+}
+
+/* now repeat int comparisons using negative logic */
+
+void
+int_lt_int_else (void)
+{
+ if (aint0 >= aint1)
+ dummy++;
+ else
+ failures++;
+}
+
+void
+int_gt_int_else (void)
+{
+ if (aint1 <= aint0)
+ dummy++;
+ else
+ failures++;
+}
+
+void
+int_lte_int_else (void)
+{
+ if (aint0 > aint1)
+ dummy++;
+ else
+ failures++;
+}
+
+void
+int_gte_int_else (void)
+{
+ if (aint1 < aint0)
+ dummy++;
+ else
+ failures++;
+}
+
+void
+int_lt_lit_else (void)
+{
+ if (aint1 >= 0x10)
+ dummy++;
+ else
+ failures++;
+}
+
+void
+int_gt_lit_else (void)
+{
+ if (aint1 <= 0x10)
+ dummy++;
+ else
+ failures++;
+}
+
+void
+int_lte_lit_else (void)
+{
+ if (aint1 > 0x0f)
+ dummy++;
+ else
+ failures++;
+}
+
+void
+int_gte_lit_else (void)
+{
+ if (aint1 < 0x11)
+ dummy++;
+ else
+ failures++;
+}
+
+int
+main (void)
+{
+ char_lt_char ();
+ char_gt_char ();
+
+ achar0++;
+ char_lt_char ();
+ char_gt_char ();
+ char_gte_char ();
+ char_lte_char ();
+
+ achar1 = 0x10;
+ char_lt_lit ();
+ char_gt_lit ();
+ char_lte_lit ();
+ char_gte_lit ();
+
+ achar0 = 0;
+ achar1 = 0;
+
+ char_lt_char_else ();
+ char_gt_char_else ();
+
+ achar0++;
+ char_lt_char_else ();
+ char_gt_char_else ();
+ char_gte_char_else ();
+ char_lte_char_else ();
+
+ achar1 = 0x10;
+ char_lt_lit_else ();
+ char_gt_lit_else ();
+ char_lte_lit_else ();
+ char_gte_lit_else ();
+
+ int_lt_int ();
+ int_gt_int ();
+
+ aint0++;
+ int_lt_int ();
+ int_gt_int ();
+ int_gte_int ();
+ int_lte_int ();
+
+ aint1 = 0x10;
+ int_lt_lit ();
+ int_gt_lit ();
+ int_lte_lit ();
+ int_gte_lit ();
+
+ aint0=0;
+ aint1=0;
+ int_lt_int_else ();
+ int_gt_int_else ();
+
+ aint0++;
+ int_lt_int_else ();
+ int_gt_int_else ();
+ int_gte_int_else ();
+ int_lte_int_else ();
+
+ aint1 = 0x10;
+ int_lt_lit_else ();
+ int_gt_lit_else ();
+ int_lte_lit_else ();
+ int_gte_lit_else ();
+
+ success = failures;
+ done ();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! regression testing program for comparing literals to variables
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+/*
+ compare3.c
+*/
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void
+done ()
+{
+ dummy++;
+}
+
+/* compare to 0
+ assumes
+ achar0 == 0
+ achar1 != 0
+ aint0 == 0
+ aint1 != 0
+*/
+void c_0(void)
+{
+ if(achar0 != 0)
+ failures++;
+
+ if(achar0)
+ failures++;
+
+ if(achar1 == 0)
+ failures++;
+
+ if(!achar1)
+ failures++;
+
+ if(aint0 != 0)
+ failures++;
+
+ if(aint0)
+ failures++;
+
+ if(aint1 == 0)
+ failures++;
+
+ if(!aint1)
+ failures++;
+}
+
+/* compare to 1
+ assumes
+ achar0 != 1
+ achar1 == 1
+ aint0 != 1
+ aint1 == 1
+*/
+void c_1(void)
+{
+ if(achar0 == 1)
+ failures++;
+
+ if(achar1 != 1)
+ failures++;
+
+ if(aint0 == 1)
+ failures++;
+
+ if(aint1 != 1)
+ failures++;
+}
+
+/* compare to 2
+ assumes
+ achar0 == 2
+ aint0 == 2
+*/
+void c_2(void)
+{
+ if(achar0 != 2)
+ failures++;
+
+ if(aint0 != 2)
+ failures++;
+}
+
+/* compare to 0xff
+ assumes
+ achar0 == 0xff
+ aint0 == 0xff
+*/
+void c_ff(void)
+{
+ if(achar0 != 0xff)
+ failures++;
+
+ if(aint0 != 0xff)
+ failures++;
+
+ if(aint0 == 0xfe)
+ failures++;
+
+ if(aint0 == 0xff00)
+ failures++;
+}
+
+/* compare to 0x00a5
+ assumes
+ achar0 == 0xa5
+ aint0 == 0x00a5
+*/
+void c_a5(void)
+{
+ if(achar0 != 0xa5)
+ failures++;
+
+ if(aint0 != 0xa5)
+ failures++;
+
+ if(aint0 == 0xa4)
+ failures++;
+
+ if(aint0 == 0xa500)
+ failures++;
+}
+
+/* compare to 0xa500
+ assumes
+ achar0 == 0xa5
+ aint0 == 0xa500
+*/
+void c_a500(void)
+{
+ if(achar0 == 0xa500)
+ failures++;
+
+ if(aint0 != 0xa500)
+ failures++;
+
+ if(aint0 == 0xa400)
+ failures++;
+
+ if(aint0 == 0x00a5)
+ failures++;
+}
+
+/* compare to 0xabcd
+ assumes
+ achar0 == 0xa5
+ aint0 == 0xabcd
+*/
+void c_abcd(void)
+{
+ if(achar0 == 0xabcd)
+ failures++;
+
+ if(aint0 != 0xabcd)
+ failures++;
+
+ if(aint0 == 0xab00)
+ failures++;
+
+ if(aint0 == 0x00cd)
+ failures++;
+
+ if(aint0 == 0x05cd)
+ failures++;
+
+ if(aint0 == 0xab05)
+ failures++;
+
+ if(aint0 == 0xab01)
+ failures++;
+
+ if(aint0 == 0x01cd)
+ failures++;
+
+ /*
+ if(aint0 == 0x1234abcd)
+ failures++;
+ */
+}
+
+/* assumes achar1 == 0 */
+void c_ifelse1(void)
+{
+ if(achar0)
+ achar0 = achar1;
+ else
+ achar0 = 0;
+
+ if(achar0)
+ failures++;
+}
+
+int
+main (void)
+{
+ aint1 = 1;
+ achar1 = 1;
+ c_0();
+ c_1();
+
+ aint0 = 2;
+ achar0 = 2;
+ c_2();
+
+ aint0 = 0xff;
+ achar0 = 0xff;
+ c_ff();
+
+ aint0 = 0xa5;
+ achar0 = 0xa5;
+ c_a5();
+
+ aint0 = 0xabcd;
+ c_abcd();
+
+ achar0 = 0;
+ achar1 = 0;
+ c_ifelse1();
+
+ achar0 = 1;
+ c_ifelse1();
+
+ success = failures;
+ done ();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! regression testing program for comparing signed chars and ints
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+/*
+ compare4.c
+*/
+
+/*#define COMPARE_OUT_OF_RANGE 1*/
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+#ifdef SIZEOF_INT_16BIT
+#if defined(__LINUX__) || defined(LINUX)
+short int0 = 0;
+short int1 = 0;
+
+#else
+int int0 = 0;
+int int1 = 0;
+
+#endif
+
+#else
+int int0 = 0;
+int int1 = 0;
+
+#endif
+
+signed char char0 = 0;
+signed char char1 = 0;
+
+void
+done ()
+{
+ dummy++;
+}
+
+/* compare to 0
+ assumes
+ char0 == 0
+ char1 != 0
+ int0 == 0
+ int1 != 0
+*/
+void c_0(void)
+{
+ if(char0 != 0)
+ failures++;
+
+ if(char0)
+ failures++;
+
+ if(char1 == 0)
+ failures++;
+
+ if(!char1)
+ failures++;
+
+ if(int0 != 0)
+ failures++;
+
+ if(int0)
+ failures++;
+
+ if(int1 == 0)
+ failures++;
+
+ if(!int1)
+ failures++;
+
+ if(char0>0)
+ failures++;
+
+ if(int0>0)
+ failures++;
+
+ if(char0<0)
+ failures++;
+
+ if(int0<0)
+ failures++;
+}
+
+/* compare to 1
+ assumes
+ char0 != 1
+ char1 == 1
+ int0 != 1
+ int1 == 1
+*/
+void c_1(void)
+{
+ if(char0 == 1)
+ failures++;
+
+ if(char1 != 1)
+ failures++;
+
+ if(int0 == 1)
+ failures++;
+
+ if(int1 != 1)
+ failures++;
+
+ if(char0 < 0)
+ failures++;
+
+ if(int0 < 0)
+ failures++;
+}
+
+/* compare to 2
+ assumes
+ achar0 == 2
+ aint0 == 2
+*/
+void c_2(void)
+{
+ if(char0 != 2)
+ failures++;
+
+ if(int0 != 2)
+ failures++;
+}
+
+/* compare to 0xff
+ assumes
+ achar0 == 0xff
+ aint0 == 0xff
+*/
+void c_ff(void)
+{
+ if((unsigned char)char0 != 0xff)
+ failures++;
+
+ if((unsigned short)int0 != 0xff)
+ failures++;
+
+ if((unsigned short)int0 == 0xfe)
+ failures++;
+
+ if((unsigned short)int0 == 0xff00)
+ failures++;
+}
+
+/* compare to 0x00a5
+ assumes
+ char0 == 0xa5
+ int0 == 0x00a5
+*/
+void c_a5(void)
+{
+ if((unsigned char)char0 != 0xa5)
+ failures++;
+
+ if((unsigned short)int0 != 0xa5)
+ failures++;
+
+ if((unsigned short)int0 == 0xa4)
+ failures++;
+
+ if((unsigned short)int0 == 0xa500)
+ failures++;
+}
+
+/* compare to 0xa500
+ assumes
+ char0 == 0xa5
+ int0 == 0xa500
+*/
+void c_a500(void)
+{
+#ifdef COMPARE_OUT_OF_RANGE
+ if(char0 == 0xa500)
+ failures++;
+#endif
+
+ if((unsigned short)int0 != 0xa500)
+ failures++;
+
+ if(int0 != 0x44)
+ int0 = 0x28;
+
+ if((unsigned short)int0 == 0xa400)
+ failures++;
+
+ if(int0 == 0x00a5)
+ failures++;
+}
+
+/* compare to 0xabcd
+ assumes
+ char0 == 0xa5
+ int0 == 0xabcd
+*/
+void c_abcd(void)
+{
+#ifdef COMPARE_OUT_OF_RANGE
+ if(char0 == 0xabcd)
+ failures++;
+#endif
+/*
+ if(int0 != 0xabcd)
+ failures++;
+*/
+ if((unsigned short)int0 == 0xab00)
+ failures++;
+
+ if(int0 == 0x00cd)
+ failures++;
+
+ if(int0 == 0x05cd)
+ failures++;
+
+ if((unsigned short)int0 == 0xab05)
+ failures++;
+
+ if((unsigned short)int0 == 0xab01)
+ failures++;
+
+ if(int0 == 0x01cd)
+ failures++;
+
+ if(int0 > 0)
+ failures++;
+
+#ifdef COMPARE_OUT_OF_RANGE
+ if(int0 == 0x1234abcd)
+ failures++;
+#endif
+}
+
+/* assumes char1 == 0 */
+void c_ifelse1(void)
+{
+ if(char0)
+ char0 = char1;
+ else
+ char0 = 0;
+
+ if(char0)
+ failures++;
+}
+
+/* assumes char0 = -1
+ assumes int0 = -1
+*/
+void c_minus1(void)
+{
+ if(char0 != -1)
+ failures++;
+
+ printf("%d\n",failures);
+
+ if(int0 != -1)
+ failures++;
+
+ printf("%d\n",failures);
+
+ if(char0 != int0)
+ failures++;
+
+ printf("%d\n",failures);
+
+ if(char0>0)
+ failures++;
+
+ printf("%d\n",failures);
+
+ if(int0>0)
+ failures++;
+
+ printf("%d\n",failures);
+}
+
+void c_c0gtc1(void)
+{
+ if(char0 < char1)
+ failures++;
+
+ printf("%d\n",failures);
+}
+
+int main(void)
+{
+ int1 = 1;
+ char1 = 1;
+ c_0();
+ printf("failures: %d\n",failures);
+ c_1();
+ printf("failures: %d\n",failures);
+
+ int0 = 2;
+ char0 = 2;
+ c_2();
+ printf("failures: %d\n",failures);
+
+ int0 = 0xff;
+ char0 = 0xff;
+ c_ff();
+ printf("failures: %d\n",failures);
+
+ int0 = 0xa5;
+ char0 = 0xa5;
+ c_a5();
+ printf("failures: %d\n",failures);
+
+ int0 = 0xabcd;
+ /*c_abcd();*/
+
+ char0 = 0;
+ char1 = 0;
+ c_ifelse1();
+ printf("failures: %d\n",failures);
+
+ char0 = 1;
+ c_ifelse1();
+ printf("failures: %d\n",failures);
+
+ char0 = -1;
+ int0 = -1;
+ c_minus1();
+ printf("failures: %d\n",failures);
+
+ char0 = 5;
+ char1 = 3;
+ c_c0gtc1();
+ printf("failures: %d\n",failures);
+
+ char1 = -3;
+ c_c0gtc1();
+
+ success = failures;
+ done ();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! regression testing program for comparing longs
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+/*
+ compare5.c
+*/
+
+#define COMPARE_OUT_OF_RANGE 1
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+int int0 = 0;
+int int1 = 0;
+char char0 = 0;
+char char1 = 0;
+long long0 = 0;
+long long1 = 0;
+unsigned long ulong0 = 0;
+unsigned long ulong1 = 0;
+
+void
+done ()
+{
+ dummy++;
+}
+
+/* compare to 0
+ assumes
+ long0 == 0
+ ulong0 == 0
+*/
+void c_0(void)
+{
+ if(long0 != 0)
+ failures++;
+
+ if(long0 > 0)
+ failures++;
+
+ if(ulong0 != 0)
+ failures++;
+
+ if(ulong0 > 0)
+ failures++;
+}
+
+/* compare to 1
+ assumes
+ long1 == 1
+ ulong1 == 1
+*/
+void c_1(void)
+{
+ if(long0 == 1)
+ failures++;
+
+ if(long1 != 1)
+ failures++;
+
+ if(ulong0 == 1)
+ failures++;
+
+ if(ulong1 != 1)
+ failures++;
+
+ if(long1 < 0)
+ failures++;
+
+ if(long1 < 1)
+ failures++;
+
+ if(ulong1 < 1)
+ failures++;
+
+ if(long1 > 1)
+ failures++;
+
+ if(ulong1 > 1)
+ failures++;
+}
+
+/* compare to 2
+ assumes
+ long0 == 2
+ ulong0 == 2
+*/
+void c_2(void)
+{
+ if(long0 != 2)
+ failures++;
+
+ if(ulong0 != 2)
+ failures++;
+
+ if(long1 == 2)
+ failures++;
+
+ if(ulong1 == 2)
+ failures++;
+}
+
+/* compare to 0xff
+ assumes
+ achar0 == 0xff
+ aint0 == 0xff
+*/
+void c_ff(void)
+{
+ if(long0 != 0xff)
+ failures++;
+
+ if(ulong0 != 0xff)
+ failures++;
+
+ if(long1 == 0xff)
+ failures++;
+
+ if(ulong1 == 0xff)
+ failures++;
+}
+
+/* compare to 0x200
+ assumes
+ achar0 == 0x200
+ aint0 == 0x200
+*/
+void c_200(void)
+{
+ if(long0 != 0x200)
+ failures++;
+
+ if(ulong0 != 0x200)
+ failures++;
+
+ if(long1 == 0x200)
+ failures++;
+
+ if(ulong1 == 0x200)
+ failures++;
+}
+
+/* compare to 0x20000
+ assumes
+ long0 == 0x20000
+ ulong0 == 0x20000
+ long1 != 0x20000
+ ulong1 != 0x20000
+*/
+void c_20000(void)
+{
+ if(long0 != 0x20000)
+ failures++;
+
+ if(ulong0 != 0x20000)
+ failures++;
+
+ if(long1 == 0x20000)
+ failures++;
+
+ if(ulong1 == 0x20000)
+ failures++;
+
+ if(long0 <= 0x10000)
+ failures++;
+
+ if(long0 < 0x10000)
+ failures++;
+
+/* if(long0 < 0x12345)
+ failures++;
+*/
+ if(long0 == 0)
+ failures++;
+}
+
+/* compare to 0x00a5
+ assumes
+ char0 == 0xa5
+ int0 == 0x00a5
+*/
+void c_a5(void)
+{
+ if(char0 != 0xa5)
+ failures++;
+
+ if(int0 != 0xa5)
+ failures++;
+
+ if(int0 == 0xa4)
+ failures++;
+
+ if(int0 == 0xa500)
+ failures++;
+}
+
+/* compare to 0xa500
+ assumes
+ char0 == 0xa5
+ int0 == 0xa500
+*/
+void c_a500(void)
+{
+#ifdef COMPARE_OUT_OF_RANGE
+ if(char0 == 0xa500)
+ failures++;
+#endif
+
+ if(int0 != 0xa500)
+ failures++;
+
+ if(int0 == 0xa400)
+ failures++;
+
+ if(int0 == 0x00a5)
+ failures++;
+}
+
+/* compare to 0xabcd
+ assumes
+ char0 == 0xa5
+ int0 == 0xabcd
+*/
+void c_abcd(void)
+{
+#ifdef COMPARE_OUT_OF_RANGE
+ if(char0 == 0xabcd)
+ failures++;
+#endif
+
+ if(int0 != 0xabcd)
+ failures++;
+
+ if(int0 == 0xab00)
+ failures++;
+
+ if(int0 == 0x00cd)
+ failures++;
+
+ if(int0 == 0x05cd)
+ failures++;
+
+ if(int0 == 0xab05)
+ failures++;
+
+ if(int0 == 0xab01)
+ failures++;
+
+ if(int0 == 0x01cd)
+ failures++;
+
+ if(int0 > 0)
+ failures++;
+
+#ifdef COMPARE_OUT_OF_RANGE
+ if(int0 == 0x1234abcd)
+ failures++;
+#endif
+}
+
+/* assumes char1 == 0 */
+void c_ifelse1(void)
+{
+ if(char0)
+ char0 = char1;
+ else
+ char0 = 0;
+
+ if(char0)
+ failures++;
+}
+
+/*
+ assumes long0 = -1
+ assumes long1 = 1
+*/
+void c_minus1(void)
+{
+ printf("long0:%ld long1:%ld\n",long0,long1);
+
+ printf("(long0 != -1)\n");
+ if(long0 != -1)
+ {
+ failures++;
+ }
+ printf("(long0 > 0)\n");
+ if(long0 > 0)
+ {
+ failures++;
+ }
+ printf("(long1 < 0)\n");
+ if(long1 < 0)
+ {
+ failures++;
+ }
+/*
+ if(long1 < 2)
+ failures++;
+*/
+}
+
+/* assumes
+ long0 = long1 = ulong0 = ulong1 == 0
+*/
+void c_long2long_eq(void)
+{
+ if(long0 != long1)
+ failures++;
+
+ if(ulong0 != ulong1)
+ failures++;
+
+ if(long0 != ulong1)
+ failures++;
+
+ if(long0 > long1)
+ failures++;
+
+ if(long0 < long1)
+ failures++;
+
+ if(long0 > ulong0)
+ failures++;
+
+ if(long0 < ulong0)
+ failures++;
+}
+
+/* assumes
+ long0 = ulong0 == 0
+ long1 = ulong1 == 1
+*/
+void c_long2long_neq(void)
+{
+ if(long0 == long1)
+ failures++;
+
+ if(ulong0 == ulong1)
+ failures++;
+
+ if(long1 != ulong1)
+ failures++;
+
+ if(long1 < long0)
+ failures++;
+
+ if(long1 <= long0)
+ failures++;
+
+ if(ulong1 < ulong0)
+ failures++;
+
+ if(ulong1 <= ulong0)
+ failures++;
+}
+
+/* long0=-100;
+ long1=-1000;
+*/
+void
+c_long2neglit(void)
+{
+ if(long0>0)
+ failures++;
+ if(long1>0)
+ failures++;
+
+ if(long1 > long0)
+ failures++;
+
+ if(long1 > 100)
+ failures++;
+
+ if(long0 > -50)
+ failures++;
+
+ if(long1 < -5000)
+ failures++;
+}
+
+int
+main (void)
+{
+ c_0();
+ printf("c_0: %d\n",failures);
+
+ c_long2long_eq();
+ printf("c_long2long_eq: %d\n",failures);
+
+ long1 = 1;
+ ulong1 = 1;
+ c_1();
+ printf("c_1: %d\n",failures);
+ c_long2long_neq();
+ printf("c_long2long_neq: %d\n",failures);
+
+ long0 = 2;
+ ulong0 = 2;
+ c_2();
+ printf("c_2: %d\n",failures);
+
+ long0 = 0xff;
+ ulong0 = 0xff;
+ c_ff();
+ printf("c_ff: %d\n",failures);
+
+ long0 = 0x200;
+ ulong0 = 0x200;
+ c_200();
+ printf("c_200: %d\n",failures);
+
+ long0 = 0x20000;
+ ulong0 = 0x20000;
+ c_20000();
+ printf("c_20000: %d\n",failures);
+
+ long0 = -1;
+ c_minus1();
+ printf("c_minus1: %d\n",failures);
+
+ long0=-100;
+ long1=-1000;
+ c_long2neglit();
+ printf("c_long2neglit: %d\n",failures);
+
+ success = failures;
+ done ();
+
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Compound comparisons
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+int int0 = 0;
+int int1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+char char0 = 0;
+char char1 = 0;
+char long0 = 0;
+char long1 = 0;
+
+void
+done ()
+{
+ dummy++;
+}
+
+void c_char(void)
+{
+ if(char0 || char1)
+ failures++;
+
+ if(char0 && char1)
+ failures++;
+
+ if(char0 > char1)
+ failures++;
+
+ if((char0+1) < char1)
+ failures++;
+
+ if((char0+5) >= (char1+9))
+ failures++;
+
+ char0++;
+
+ if(char0 && char1)
+ failures++;
+
+ if(char0 != (char1+1) )
+ failures++;
+
+ if(!char0)
+ failures++;
+
+ if(char1 || !char0)
+ failures++;
+
+ if((char0 >5 ) && (char0 < 10))
+ failures++;
+
+ char0 +=5; /* char0 = 6 now */
+
+ if(!((char0 >5 ) && (char0 < 10)))
+ failures++;
+}
+
+void c_int(void)
+{
+ if(int0 || int1)
+ failures++;
+
+ if(int0 && int1)
+ failures++;
+
+ if(int0 > int1)
+ failures++;
+
+ if((int0+1) < int1)
+ failures++;
+
+ if((int0+5) >= (int1+9))
+ failures++;
+
+ int0++;
+
+ if(int0 && int1)
+ failures++;
+
+ if(int0 != (int1+1) )
+ failures++;
+
+ if(!int0)
+ failures++;
+
+ if(int1 || !int0)
+ failures++;
+
+ if((int0 >5 ) && (int0 < 10))
+ failures++;
+
+ int0 +=5; /* int0 = 6 now */
+
+ if(!((int0 >5 ) && (int0 < 10)))
+ failures++;
+}
+
+void c_long(void)
+{
+ if(long0 || long1)
+ failures++;
+
+ if(long0 && long1)
+ failures++;
+
+ if(long0 > long1)
+ failures++;
+
+ if((long0+1) < long1)
+ failures++;
+
+ if((long0+5) >= (long1+9))
+ failures++;
+
+ long0++;
+
+ if(long0 && long1)
+ failures++;
+
+ if(long0 != (long1+1) )
+ failures++;
+
+ if(!long0)
+ failures++;
+
+ if(long1 || !long0)
+ failures++;
+
+ if((long0 >5 ) && (long0 < 10))
+ failures++;
+
+ long0 +=5; /* long0 = 6 now */
+
+ if(!((long0 >5 ) && (long0 < 10)))
+ failures++;
+}
+
+void c_uminus(void)
+{
+ int1 = -int0;
+ if(int1 < 0)
+ failures++;
+}
+
+int
+main (void)
+{
+ c_char();
+ c_int();
+ c_long();
+
+ int0 = -1;
+ c_uminus();
+ if(int1 != 1)
+ failures++;
+
+ success = failures;
+ done ();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Signed comparisons of the form: (variable<LIT)
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+/* This regression test exercises all of the boundary
+ conditions in literal less than comparisons. There
+ are numerous opportunities to optimize these comparison
+ and each one has an astonishing capability of failing
+ a boundary condition.
+*/
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+unsigned char result = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+int int0 = 0;
+int int1 = 0;
+signed char char0 = 0;
+signed char char1 = 0;
+char long0 = 0;
+char long1 = 0;
+
+/* *** NOTE *** This particular test takes quite a while to run
+ * ~ 10,000,000 instruction cycles. (2.5 seconds on a 20Mhz PIC).
+ * The WDT will reset the CPU if it's enabled. So disable it...
+*/
+
+void
+done ()
+{
+ dummy++;
+}
+
+void c_char_lt_lit1(unsigned char expected_result)
+{
+ result = 0;
+
+ if(char0 < -0x7f)
+ result |= 1;
+
+ if(char0 < -1)
+ result |= 2;
+
+ if(char0 < 0)
+ result |= 4;
+
+ if(char0 < 1)
+ result |= 8;
+
+ if(char0 < 0x7f)
+ result |= 0x10;
+
+ if(result != expected_result)
+ failures++;
+}
+
+void char_compare(void)
+{
+ char0 = 0x7f;
+ c_char_lt_lit1(0);
+
+/* return; */
+
+ char0 = 0x7e;
+ c_char_lt_lit1(0x10);
+
+ char0 = 0x40;
+ c_char_lt_lit1(0x10);
+
+ char0 = 0x2;
+ c_char_lt_lit1(0x10);
+
+ char0 = 0x1;
+ c_char_lt_lit1(0x10);
+
+ char0 = 0;
+ c_char_lt_lit1(0x18);
+
+ char0 = -1;
+ c_char_lt_lit1(0x1c);
+
+ char0 = -2;
+ c_char_lt_lit1(0x1e);
+
+ char0 = -0x40;
+ c_char_lt_lit1(0x1e);
+
+ char0 = -0x7e;
+ c_char_lt_lit1(0x1e);
+
+ char0 = -0x7f;
+ c_char_lt_lit1(0x1e);
+
+ char0 = 0x80;
+ c_char_lt_lit1(0x1f);
+
+ /* Now test entire range */
+
+ for(char0=1; char0 != 0x7f; char0++)
+ c_char_lt_lit1(0x10);
+
+ for(char0=-0x7f; char0 != -1; char0++)
+ c_char_lt_lit1(0x1e);
+}
+
+void c_int_lt_lit1(unsigned char expected_result)
+{
+ result = 0;
+
+ if(int0 < 0)
+ result |= 1;
+
+ if(int0 < 1)
+ result |= 2;
+
+ if(int0 < 0xff)
+ result |= 4;
+
+ if(int0 < 0x100)
+ result |= 8;
+
+ if(int0 < 0x0101)
+ result |= 0x10;
+
+ if(int0 < 0x01ff)
+ result |= 0x20;
+
+ if(int0 < 0x0200)
+ result |= 0x40;
+
+ if(int0 < 0x0201)
+ result |= 0x80;
+
+ if(result != expected_result)
+ failures=1;
+}
+
+void int_compare1(void)
+{
+ int0 = -1;
+ c_int_lt_lit1(0xff);
+
+ int0 = 0;
+ c_int_lt_lit1(0xfe);
+
+ int0 = 1;
+ c_int_lt_lit1(0xfc);
+
+ int0 = 2;
+ c_int_lt_lit1(0xfc);
+
+ int0 = 0xfe;
+ c_int_lt_lit1(0xfc);
+
+ int0 = 0xff;
+ c_int_lt_lit1(0xf8);
+
+ int0 = 0x100;
+ c_int_lt_lit1(0xf0);
+
+ int0 = 0x101;
+ c_int_lt_lit1(0xe0);
+
+ int0 = 0x1fe;
+ c_int_lt_lit1(0xe0);
+
+ int0 = 0x1ff;
+ c_int_lt_lit1(0xc0);
+
+ int0 = 0x200;
+ c_int_lt_lit1(0x80);
+
+ int0 = 0x201;
+ c_int_lt_lit1(0x0);
+
+ int0 = 0x7f00;
+ c_int_lt_lit1(0x0);
+
+ /* now check contiguous ranges */
+
+ for(int0 = -0x7fff; int0 != -1; int0++)
+ c_int_lt_lit1(0xff);
+
+ for(int0 = 1; int0 != 0xff; int0++)
+ c_int_lt_lit1(0xfc);
+
+ for(int0 = 0x201; int0 != 0x7fff; int0++)
+ c_int_lt_lit1(0);
+}
+
+void c_int_lt_lit2(unsigned char expected_result)
+{
+ result = 0;
+
+ if(int0 < -0x7fff)
+ result |= 1;
+
+ if(int0 < -0x7f00)
+ result |= 2;
+
+ if(int0 < -0x7eff)
+ result |= 4;
+
+ if(int0 < -0x7e00)
+ result |= 8;
+
+ if(int0 < -0x0101)
+ result |= 0x10;
+
+ if(int0 < -0x0100)
+ result |= 0x20;
+
+ if(int0 < -0xff)
+ result |= 0x40;
+
+ if(int0 < -1)
+ result |= 0x80;
+
+ if(result != expected_result)
+ failures=1;
+}
+
+void int_compare2(void)
+{
+ int0 = -0x7fff;
+ c_int_lt_lit2(0xfe);
+
+ int0 = -0x7f00;
+ c_int_lt_lit2(0xfc);
+
+ int0 = -0x7eff;
+ c_int_lt_lit2(0xf8);
+
+ int0 = -0x7e00;
+ c_int_lt_lit2(0xf0);
+
+ int0 = -0x4567;
+ c_int_lt_lit2(0xf0);
+
+ int0 = -0x200;
+ c_int_lt_lit2(0xf0);
+
+ int0 = -0x102;
+ c_int_lt_lit2(0xf0);
+
+ int0 = -0x101;
+ c_int_lt_lit2(0xe0);
+
+ int0 = -0x100;
+ c_int_lt_lit2(0xc0);
+
+ int0 = -0xff;
+ c_int_lt_lit2(0x80);
+
+ int0 = -0x02;
+ c_int_lt_lit2(0x80);
+
+ int0 = -0x01;
+ c_int_lt_lit2(0x00);
+
+ int0 = 0;
+ c_int_lt_lit2(0x00);
+
+ int0 = 1;
+ c_int_lt_lit2(0x00);
+
+ int0 = 0x7fff;
+ c_int_lt_lit2(0x00);
+
+ /* now check contiguous ranges */
+ int0 = -0x7f01;
+ c_int_lt_lit2(0xfe);
+
+ for(int0 = -0x7ffe; int0 != -0x7f01; int0++)
+ c_int_lt_lit2(0xfe);
+
+ for(int0 = -0x7e00; int0 != -0x101; int0++)
+ c_int_lt_lit2(0xf0);
+
+ for(int0 = -1; int0 != 0x7fff; int0++)
+ c_int_lt_lit2(0);
+}
+
+int
+main (void)
+{
+ char_compare();
+ printf("failures: %d\n",failures);
+
+ int_compare1();
+ printf("failures: %d\n",failures);
+ int_compare2();
+
+ success = failures;
+ done ();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Signed comparisons of the form: (variable>LIT)
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+/* This regression test exercises all of the boundary
+ conditions in literal less than comparisons. There
+ are numerous opportunities to optimize these comparison
+ and each one has an astonishing capability of failing
+ a boundary condition.
+*/
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+unsigned char result = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+int int0 = 0;
+int int1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+signed char char0 = 0;
+signed char char1 = 0;
+char long0 = 0;
+char long1 = 0;
+
+/* *** NOTE *** This particular test takes quite a while to run
+ * ~ 10,000,000 instruction cycles. (2.5 seconds on a 20Mhz PIC).
+ * The WDT will reset the CPU if it's enabled. So disable it...
+*/
+
+void
+done ()
+{
+ dummy++;
+}
+
+void c_char_gt_lit1(unsigned char expected_result)
+{
+ result = 0;
+
+ if(char0 > -0x7f)
+ result |= 1;
+
+ if(char0 > -1)
+ result |= 2;
+
+ if(char0 > 0)
+ result |= 4;
+
+ if(char0 > 1)
+ result |= 8;
+
+ if(char0 > 0x7e)
+ result |= 0x10;
+
+ if(char0 > 0x7f)
+ result |= 0x20;
+
+ if(result != expected_result)
+ failures++;
+}
+
+void char_compare(void)
+{
+ char0 = 0x7f;
+ c_char_gt_lit1(0x1f);
+
+ char0 = 0x7e;
+ c_char_gt_lit1(0x0f);
+
+ char0 = 0x40;
+ c_char_gt_lit1(0x0f);
+
+ char0 = 0x2;
+ c_char_gt_lit1(0x0f);
+
+ char0 = 0x1;
+ c_char_gt_lit1(0x07);
+
+ char0 = 0;
+ c_char_gt_lit1(0x03);
+
+ char0 = -1;
+ c_char_gt_lit1(0x01);
+
+ char0 = -2;
+ c_char_gt_lit1(0x01);
+
+ char0 = -0x40;
+ c_char_gt_lit1(0x01);
+
+ char0 = -0x7e;
+ c_char_gt_lit1(0x01);
+
+ char0 = -0x7f;
+ c_char_gt_lit1(0x00);
+
+ char0 = 0x80;
+ c_char_gt_lit1(0x00);
+
+ /* Now test entire range */
+
+ for(char0=2; char0 != 0x7f; char0++)
+ c_char_gt_lit1(0x0f);
+
+ for(char0=-0x7e; char0 != -1; char0++)
+ c_char_gt_lit1(0x01);
+}
+
+void c_int_gt_lit1(unsigned char expected_result)
+{
+ result = 0;
+
+ if(int0 > 0)
+ result |= 1;
+
+ if(int0 > 1)
+ result |= 2;
+
+ if(int0 > 0xff)
+ result |= 4;
+
+ if(int0 > 0x100)
+ result |= 8;
+
+ if(int0 > 0x0101)
+ result |= 0x10;
+
+ if(int0 > 0x01ff)
+ result |= 0x20;
+
+ if(int0 > 0x0200)
+ result |= 0x40;
+
+ if(int0 > 0x0201)
+ result |= 0x80;
+
+ if(result != expected_result)
+ failures=1;
+}
+
+void int_compare1(void)
+{
+ int0 = -1;
+ c_int_gt_lit1(0x00);
+
+ int0 = 0;
+ c_int_gt_lit1(0x00);
+
+ int0 = 1;
+ c_int_gt_lit1(0x01);
+
+ int0 = 2;
+ c_int_gt_lit1(0x03);
+
+ int0 = 0xfe;
+ c_int_gt_lit1(0x03);
+
+ int0 = 0xff;
+ c_int_gt_lit1(0x03);
+
+ int0 = 0x100;
+ c_int_gt_lit1(0x07);
+
+ int0 = 0x101;
+ c_int_gt_lit1(0x0f);
+
+ int0 = 0x102;
+ c_int_gt_lit1(0x1f);
+
+ int0 = 0x1fe;
+ c_int_gt_lit1(0x1f);
+
+ int0 = 0x1ff;
+ c_int_gt_lit1(0x1f);
+
+ int0 = 0x200;
+ c_int_gt_lit1(0x3f);
+
+ int0 = 0x201;
+ c_int_gt_lit1(0x7f);
+
+ int0 = 0x7f00;
+ c_int_gt_lit1(0xff);
+
+ /* now check contiguous ranges */
+
+ for(int0 = -0x7fff; int0 != -1; int0++)
+ c_int_gt_lit1(0x00);
+
+ for(int0 = 2; int0 != 0xff; int0++)
+ c_int_gt_lit1(0x03);
+
+ for(int0 = 0x202; int0 != 0x7fff; int0++)
+ c_int_gt_lit1(0xff);
+}
+
+void c_int_gt_lit2(unsigned char expected_result)
+{
+ result = 0;
+
+ if(int0 > -0x7fff)
+ result |= 1;
+
+ if(int0 > -0x7f00)
+ result |= 2;
+
+ if(int0 > -0x7eff)
+ result |= 4;
+
+ if(int0 > -0x7e00)
+ result |= 8;
+
+ if(int0 > -0x0101)
+ result |= 0x10;
+
+ if(int0 > -0x0100)
+ result |= 0x20;
+
+ if(int0 > -0xff)
+ result |= 0x40;
+
+ if(int0 > -1)
+ result |= 0x80;
+
+ if(result != expected_result)
+ failures=1;
+}
+
+void int_compare2(void)
+{
+ int0 = -0x7fff;
+ c_int_gt_lit2(0x00);
+
+ int0 = -0x7f00;
+ c_int_gt_lit2(0x01);
+
+ int0 = -0x7eff;
+ c_int_gt_lit2(0x03);
+
+ int0 = -0x7e00;
+ c_int_gt_lit2(0x07);
+
+ int0 = -0x7dff;
+ c_int_gt_lit2(0x0f);
+
+ int0 = -0x4567;
+ c_int_gt_lit2(0x0f);
+
+ int0 = -0x200;
+ c_int_gt_lit2(0x0f);
+
+ int0 = -0x102;
+ c_int_gt_lit2(0x0f);
+
+ int0 = -0x101;
+ c_int_gt_lit2(0x0f);
+
+ int0 = -0x100;
+ c_int_gt_lit2(0x1f);
+
+ int0 = -0xff;
+ c_int_gt_lit2(0x3f);
+
+ int0 = -0x02;
+ c_int_gt_lit2(0x7f);
+
+ int0 = -0x01;
+ c_int_gt_lit2(0x7f);
+
+ int0 = 0;
+ c_int_gt_lit2(0xff);
+
+ int0 = 1;
+ c_int_gt_lit2(0xff);
+
+ int0 = 0x7fff;
+ c_int_gt_lit2(0xff);
+
+ /* now check contiguous ranges */
+
+ for(int0 = -0x7ffe; int0 != -0x7f01; int0++)
+ c_int_gt_lit2(0x01);
+
+ for(int0 = -0x7dff; int0 != -0x101; int0++)
+ c_int_gt_lit2(0x0f);
+
+ for(int0 = 0; int0 != 0x7fff; int0++)
+ c_int_gt_lit2(0xff);
+}
+
+int
+main (void)
+{
+ char_compare();
+ int_compare1();
+ int_compare2();
+
+ success = failures;
+ done ();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Signed comparisons of the form: (variable<=LIT)
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+/*
+ This regression test exercises all of the boundary
+ conditions in literal less than or equal comparisons. There
+ are numerous opportunities to optimize these comparison
+ and each one has an astonishing capability of failing
+ a boundary condition.
+*/
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+unsigned char result = 0;
+
+int int0 = 0;
+int int1 = 0;
+signed char char0 = 0;
+signed char char1 = 0;
+
+/* *** NOTE *** This particular test takes quite a while to run
+ * ~ 10,000,000 instruction cycles. (2.5 seconds on a 20Mhz PIC).
+ * The WDT will reset the CPU if it's enabled. So disable it...
+*/
+
+void
+done ()
+{
+ dummy++;
+}
+
+void c_char_lte_lit1(unsigned char expected_result)
+{
+ result = 0;
+
+ if(char0 <= -0x7f)
+ result |= 1;
+
+ if(char0 <= -1)
+ result |= 2;
+
+ if(char0 <= 0)
+ result |= 4;
+
+ if(char0 <= 1)
+ result |= 8;
+
+ if(char0 <= 0x7f)
+ result |= 0x10;
+
+ if(result != expected_result)
+ failures++;
+}
+
+void char_compare(void)
+{
+ char0 = 0x7f;
+ c_char_lte_lit1(0x10);
+
+ char0 = 0x7e;
+ c_char_lte_lit1(0x10);
+
+ char0 = 0x40;
+ c_char_lte_lit1(0x10);
+
+ char0 = 0x2;
+ c_char_lte_lit1(0x10);
+
+ char0 = 0x1;
+ c_char_lte_lit1(0x18);
+
+ char0 = 0;
+ c_char_lte_lit1(0x1c);
+
+ char0 = -1;
+ c_char_lte_lit1(0x1e);
+
+ char0 = -2;
+ c_char_lte_lit1(0x1e);
+
+ char0 = -0x40;
+ c_char_lte_lit1(0x1e);
+
+ char0 = -0x7e;
+ c_char_lte_lit1(0x1e);
+
+ char0 = -0x7f;
+ c_char_lte_lit1(0x1f);
+
+ char0 = 0x80;
+ /* c_char_lte_lit1(0x1f); */
+
+ /* Now test entire range */
+
+ for(char0=2; char0 != 0x7f; char0++)
+ c_char_lte_lit1(0x10);
+
+ for(char0=-0x7e; char0 != 0; char0++)
+ c_char_lte_lit1(0x1e);
+}
+
+void c_int_lte_lit1(unsigned char expected_result)
+{
+ result = 0;
+
+ if(int0 <= 0)
+ result |= 1;
+
+ if(int0 <= 1)
+ result |= 2;
+
+ if(int0 <= 0xff)
+ result |= 4;
+
+ if(int0 <= 0x100)
+ result |= 8;
+
+ if(int0 <= 0x0101)
+ result |= 0x10;
+
+ if(int0 <= 0x01ff)
+ result |= 0x20;
+
+ if(int0 <= 0x0200)
+ result |= 0x40;
+
+ if(int0 <= 0x0201)
+ result |= 0x80;
+
+ if(result != expected_result)
+ failures=1;
+}
+
+void int_compare1(void)
+{
+ int0 = -1;
+ c_int_lte_lit1(0xff);
+
+ int0 = 0;
+ c_int_lte_lit1(0xff);
+
+ int0 = 1;
+ c_int_lte_lit1(0xfe);
+
+ int0 = 2;
+ c_int_lte_lit1(0xfc);
+
+ int0 = 0xfe;
+ c_int_lte_lit1(0xfc);
+
+ int0 = 0xff;
+ c_int_lte_lit1(0xfc);
+
+ int0 = 0x100;
+ c_int_lte_lit1(0xf8);
+
+ int0 = 0x101;
+ c_int_lte_lit1(0xf0);
+
+ int0 = 0x1fe;
+ c_int_lte_lit1(0xe0);
+
+ int0 = 0x1ff;
+ c_int_lte_lit1(0xe0);
+
+ int0 = 0x200;
+ c_int_lte_lit1(0xc0);
+
+ int0 = 0x201;
+ c_int_lte_lit1(0x80);
+
+ int0 = 0x7f00;
+ c_int_lte_lit1(0x0);
+
+ /* now check contiguous ranges */
+
+ for(int0 = -0x7fff; int0 != 1; int0++)
+ c_int_lte_lit1(0xff);
+
+ for(int0 = 2; int0 != 0xff; int0++)
+ c_int_lte_lit1(0xfc);
+
+ for(int0 = 0x202; int0 != 0x7fff; int0++)
+ c_int_lte_lit1(0);
+}
+
+void c_int_lte_lit2(unsigned char expected_result)
+{
+ result = 0;
+
+ if(int0 <= -0x7fff)
+ result |= 1;
+
+ if(int0 <= -0x7f00)
+ result |= 2;
+
+ if(int0 <= -0x7eff)
+ result |= 4;
+
+ if(int0 <= -0x7e00)
+ result |= 8;
+
+ if(int0 <= -0x0101)
+ result |= 0x10;
+
+ if(int0 <= -0x0100)
+ result |= 0x20;
+
+ if(int0 <= -0xff)
+ result |= 0x40;
+
+ if(int0 <= -1)
+ result |= 0x80;
+
+ if(result != expected_result)
+ failures=1;
+}
+
+void int_compare2(void)
+{
+ int0 = -0x7fff;
+ c_int_lte_lit2(0xff);
+
+ int0 = -0x7f00;
+ c_int_lte_lit2(0xfe);
+
+ int0 = -0x7eff;
+ c_int_lte_lit2(0xfc);
+
+ int0 = -0x7e00;
+ c_int_lte_lit2(0xf8);
+
+ int0 = -0x4567;
+ c_int_lte_lit2(0xf0);
+
+ int0 = -0x200;
+ c_int_lte_lit2(0xf0);
+
+ int0 = -0x102;
+ c_int_lte_lit2(0xf0);
+
+ int0 = -0x101;
+ c_int_lte_lit2(0xf0);
+
+ int0 = -0x100;
+ c_int_lte_lit2(0xe0);
+
+ int0 = -0xff;
+ c_int_lte_lit2(0xc0);
+
+ int0 = -0x02;
+ c_int_lte_lit2(0x80);
+
+ int0 = -0x01;
+ c_int_lte_lit2(0x80);
+
+ int0 = 0;
+ c_int_lte_lit2(0x00);
+
+ int0 = 1;
+ c_int_lte_lit2(0x00);
+
+ int0 = 0x7fff;
+ c_int_lte_lit2(0x00);
+
+ /* now check contiguous ranges */
+
+ for(int0 = -0x7ffe; int0 != -0x7f00; int0++)
+ c_int_lte_lit2(0xfe);
+
+ for(int0 = -0x7dff; int0 != -0x101; int0++)
+ c_int_lte_lit2(0xf0);
+
+ for(int0 = 0; int0 != 0x7fff; int0++)
+ c_int_lte_lit2(0);
+}
+
+int
+main (void)
+{
+ char_compare();
+ int_compare1();
+ int_compare2();
+
+ success = failures;
+ done ();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 2.2: identifiers (names)
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+/*
+ 2.2 Identifiers (Names)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+s22(pd0)
+struct defs *pd0;
+{
+#else
+int s22(struct defs *pd0)
+{
+#endif
+
+ int a234, a;
+ int _, _234, A, rc;
+
+ static char s22er[] = "s22,er%d\n";
+ static char qs22[8] = "s22 ";
+
+ char *ps, *pt;
+ /* Initialize */
+
+ rc = 0;
+ ps = qs22;
+ pt = pd0 -> rfs;
+ while (*pt++ = *ps++);
+
+ /* An identifier is a sequence of letters and digits;
+ the first character must be a letter. The under-
+ score _ counts as a letter. */
+
+ a=1;
+ _=2;
+ _234=3;
+ a234=4;
+ if(a+_+_234+a234 != 10) {
+ rc = rc+1;
+ if(pd0->flgd != 0) printf(s22er,1);
+ }
+
+ /* Upper and lower case letters are different. */
+
+ A = 2;
+ if (A == a) {
+ rc = rc+4;
+ if (pd0->flgd != 0) printf(s22er,4);
+ }
+
+ return(rc);
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#define cq_sections 1
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s22(pd0);
+ }
+}
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 2.41: integer constants, 2.42: explizit long constants
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+/*
+ 2.4.1 Integer constants
+ 2.4.2 Explicit long constants
+*/
+
+/* Calculate 2**n by multiplying, not shifting */
+#ifndef NO_OLD_FUNC_DECL
+long pow2(n)
+long n;
+{
+#else
+long pow2(long n) {
+#endif
+ long s;
+ s = 1;
+ while(n--) s = s*2;
+ return s;
+}
+
+ long d[39], o[39], x[39];
+
+#ifndef NO_OLD_FUNC_DECL
+s241(pd0)
+struct defs *pd0;
+{
+#else
+int s241(struct defs *pd0) {
+#endif
+
+/* long pow2(); */
+ static char s241er[] = "s241,er%d\n";
+ static char qs241[8] = "s241 ";
+ char *ps, *pt;
+ int rc, j, lrc;
+ static long g[39] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,6,0,8,0,12,0,16,0,18,0,20,0,24,
+ 0,28,0,30,0,32,0,36};
+/* long d[39], o[39], x[39]; */
+
+ rc = 0;
+ lrc = 0;
+ ps = qs241;
+ pt = pd0 -> rfs;
+ while (*pt++ = *ps++);
+
+ /* An integer constant consisting of a sequence of digits is
+ taken to be octal if it begins with 0 (digit zero), decimal
+ otherwise. */
+
+ if ( 8 != 010
+ || 16 != 020
+ || 24 != 030
+ || 32 != 040
+ || 40 != 050
+ || 48 != 060
+ || 56 != 070
+ || 64 != 0100
+ || 72 != 0110
+ || 80 != 0120
+ || 9 != 0011
+ || 17 != 0021
+ || 25 != 0031
+ || 33 != 0041
+ || 41 != 0051
+ || 49 != 0061
+ || 57 != 0071
+ || 65 != 0101
+ || 73 != 0111
+ || 81 != 0121 ){
+ rc = rc+1;
+ if( pd0->flgd != 0 ) printf(s241er,1);
+ }
+
+ /* A sequence of digits preceded by 0x or 0X (digit zero)
+ is taken to be a hexadecimal integer. The hexadecimal
+ digits include a or A through f or F with values 10
+ through 15. */
+
+ if ( 0x00abcdef != 0xabcdef
+ || 0xabcdef != 0Xabcdef || 0Xabcdef != 0XAbcdef
+ || 0XAbcdef != 0XABcdef || 0XABcdef != 0XABCdef
+ || 0XABCdef != 0XABCDef || 0XABCDef != 0XABCDEf
+ || 0XABCDEf != 0XABCDEF || 0xABCDEF != 11259375 ){
+ rc = rc+2;
+ if( pd0->flgd != 0 ) printf(s241er,2);
+ }
+
+ /* A decimal constant whose value exceeds the largest signed
+ machine integer is taken to be long; an octal or hex con-
+ stant which exceeds the largest unsigned machine integer
+ is likewise taken to be long. */
+#if defined(REFERENCE) && defined(REFCC_SIZEOF_LONG_64BIT)
+/*#warning "sizeof(long)!=4, skipping test"*/
+#else
+ if ( sizeof 010000000000 != sizeof(long) /* 2**30 */
+ || sizeof 1073741824 != sizeof(long) /* ditto */
+ || sizeof 0x40000000 != sizeof(long) ){ /* " */
+
+ rc = rc+4;
+ if( pd0->flgd != 0 ) printf(s241er,4);
+ }
+#endif
+ /* A decimal, octal, or hexadecimal constant immediately followed
+ by l (letter ell) or L is a long constant. */
+
+ if ( sizeof 67l != sizeof(long)
+ || sizeof 67L != sizeof(long)
+ || sizeof 067l != sizeof(long)
+ || sizeof 067L != sizeof(long)
+ || sizeof 0X67l != sizeof(long)
+ || sizeof 0x67L != sizeof(long) ){
+ rc = rc+8;
+ if( pd0 -> flgd != 0 ) printf(s241er,8);
+ }
+
+ /* Finally, we test to see that decimal (d), octal (o),
+ and hexadecimal (x) constants representing the same values
+ agree among themselves, and with computed values, at spec-
+ ified points over an appropriate range. The points select-
+ ed here are those with the greatest potential for caus-
+ ing trouble, i.e., zero, 1-16, and values of 2**n and
+ 2**n - 1 where n is some multiple of 4 or 6. Unfortunately,
+ just what happens when a value is too big to fit in a
+ long is undefined; however, it would be nice if what
+ happened were at least consistent... */
+
+ for ( j=0; j<17; j++ ) g[j] = j;
+ for ( j=18; j<39; ) {
+ g[j] = pow2(g[j]);
+ g[j-1] = g[j] - 1;
+ j = j+2;
+ }
+
+ d[0] = 0; o[0] = 00; x[0] = 0x0;
+ d[1] = 1; o[1] = 01; x[1] = 0x1;
+ d[2] = 2; o[2] = 02; x[2] = 0x2;
+ d[3] = 3; o[3] = 03; x[3] = 0x3;
+ d[4] = 4; o[4] = 04; x[4] = 0x4;
+ d[5] = 5; o[5] = 05; x[5] = 0x5;
+ d[6] = 6; o[6] = 06; x[6] = 0x6;
+ d[7] = 7; o[7] = 07; x[7] = 0x7;
+ d[8] = 8; o[8] = 010; x[8] = 0x8;
+ d[9] = 9; o[9] = 011; x[9] = 0x9;
+ d[10] = 10; o[10] = 012; x[10] = 0xa;
+ d[11] = 11; o[11] = 013; x[11] = 0xb;
+ d[12] = 12; o[12] = 014; x[12] = 0xc;
+ d[13] = 13; o[13] = 015; x[13] = 0xd;
+ d[14] = 14; o[14] = 016; x[14] = 0xe;
+ d[15] = 15; o[15] = 017; x[15] = 0xf;
+ d[16] = 16; o[16] = 020; x[16] = 0x10;
+ d[17] = 63; o[17] = 077; x[17] = 0x3f;
+ d[18] = 64; o[18] = 0100; x[18] = 0x40;
+ d[19] = 255; o[19] = 0377; x[19] = 0xff;
+ d[20] = 256; o[20] = 0400; x[20] = 0x100;
+ d[21] = 4095; o[21] = 07777; x[21] = 0xfff;
+ d[22] = 4096; o[22] = 010000; x[22] = 0x1000;
+ d[23] = 65535; o[23] = 0177777; x[23] = 0xffff;
+ d[24] = 65536; o[24] = 0200000; x[24] = 0x10000;
+ d[25] = 262143; o[25] = 0777777; x[25] = 0x3ffff;
+ d[26] = 262144; o[26] = 01000000; x[26] = 0x40000;
+ d[27] = 1048575; o[27] = 03777777; x[27] = 0xfffff;
+ d[28] = 1048576; o[28] = 04000000; x[28] = 0x100000;
+ d[29] = 16777215; o[29] = 077777777; x[29] = 0xffffff;
+ d[30] = 16777216; o[30] = 0100000000; x[30] = 0x1000000;
+ d[31] = 268435455; o[31] = 01777777777; x[31] = 0xfffffff;
+ d[32] = 268435456; o[32] = 02000000000; x[32] = 0x10000000;
+ d[33] = 1073741823; o[33] = 07777777777; x[33] = 0x3fffffff;
+ d[34] = 1073741824; o[34] = 010000000000; x[34] = 0x40000000;
+ d[35] = 4294967295; o[35] = 037777777777; x[35] = 0xffffffff;
+ d[36] = 4294967296; o[36] = 040000000000; x[36] = 0x100000000;
+ d[37] = 68719476735; o[37] = 0777777777777; x[37] = 0xfffffffff;
+ d[38] = 68719476736; o[38] = 01000000000000; x[38] = 0x1000000000;
+
+ /* WHEW! */
+
+ for (j=0; j<39; j++){
+ if ( g[j] != d[j]
+ || d[j] != o[j]
+ || o[j] != x[j]) {
+ if( pd0 -> flgm != 0 ) {
+/* printf(s241er,16); save in case opinions change... */
+ printf("Decimal and octal/hex constants sometimes give\n");
+ printf(" different results when assigned to longs.\n");
+ }
+/* lrc = 1; save... */
+ }
+ }
+
+ if (lrc != 0) rc =16;
+
+ return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#define cq_sections 1
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s241(pd0);
+ }
+}
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 2.43: character constants
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+/*********************************************************************************************
+ 2.4.3 Character constants
+**********************************************************************************************/
+
+#ifndef NO_OLD_FUNC_DECL
+zerofill(x)
+char *x;
+{
+#else
+void zerofill(char *x) {
+#endif
+ int j;
+
+ for (j=0; j<256; j++) *x++ = 0;
+}
+
+#ifndef NO_OLD_FUNC_DECL
+sumof(x)
+char *x;
+{
+#else
+int sumof(char *x) {
+#endif
+ char *p;
+ int total, j;
+
+ p = x;
+ total = 0;
+
+ for(j=0; j<256; j++) total = total+ *p++;
+ return total;
+}
+
+char chars[256];
+
+#ifndef NO_OLD_FUNC_DECL
+s243(pd0)
+struct defs *pd0;
+{
+#else
+int s243(struct defs *pd0) {
+#endif
+ static char s243er[] = "s243,er%d\n";
+ static char qs243[8] = "s243 ";
+ char *ps, *pt;
+ int rc;
+/* char chars[256]; */
+
+ rc = 0;
+ ps = qs243;
+ pt = pd0->rfs;
+ while(*pt++ = *ps++);
+
+ /* One of the problems that arises when testing character constants
+ is that of definition: What, exactly, is the character set?
+ In order to guarantee a certain amount of machine independence,
+ the character set we will use here is the set of characters writ-
+ able as escape sequences in C, plus those characters used in writ-
+ ing C programs, i.e.,
+
+ letters:
+ ABCDEFGHIJKLMNOPQRSTUVWXYZ 26
+ abcdefghijklmnopqrstuvwxyz 26
+ numbers:
+ 0123456789 10
+ special characters:
+ ~!"#%&()_=-^|{}[]+;*:<>,.?/ 27
+ extra special characters:
+ newline \n
+ horizontal tab \t
+ backspace \b
+ carriage return \r
+ form feed \f
+ backslash \\
+ single quote \' 7
+ blank & NUL 2
+ ---
+ 98
+
+ Any specific implementation of C may of course support additional
+ characters. */
+
+ /* Since the value of a character constant is the numerical value
+ of the character in the machine's character set, there should
+ be a one-to-one correspondence between characters and values. */
+
+ zerofill(chars);
+
+ chars['a'] = 1; chars['A'] = 1; chars['~'] = 1; chars['0'] = 1;
+ chars['b'] = 1; chars['B'] = 1; chars['!'] = 1; chars['1'] = 1;
+ chars['c'] = 1; chars['C'] = 1; chars['"'] = 1; chars['2'] = 1;
+ chars['d'] = 1; chars['D'] = 1; chars['#'] = 1; chars['3'] = 1;
+ chars['e'] = 1; chars['E'] = 1; chars['%'] = 1; chars['4'] = 1;
+ chars['f'] = 1; chars['F'] = 1; chars['&'] = 1; chars['5'] = 1;
+ chars['g'] = 1; chars['G'] = 1; chars['('] = 1; chars['6'] = 1;
+ chars['h'] = 1; chars['H'] = 1; chars[')'] = 1; chars['7'] = 1;
+ chars['i'] = 1; chars['I'] = 1; chars['_'] = 1; chars['8'] = 1;
+ chars['j'] = 1; chars['J'] = 1; chars['='] = 1; chars['9'] = 1;
+ chars['k'] = 1; chars['K'] = 1; chars['-'] = 1;
+ chars['l'] = 1; chars['L'] = 1; chars['^'] = 1;
+ chars['m'] = 1; chars['M'] = 1; chars['|'] = 1; chars['\n'] = 1;
+ chars['n'] = 1; chars['N'] = 1; chars['\t'] = 1;
+ chars['o'] = 1; chars['O'] = 1; chars['{'] = 1; chars['\b'] = 1;
+ chars['p'] = 1; chars['P'] = 1; chars['}'] = 1; chars['\r'] = 1;
+ chars['q'] = 1; chars['Q'] = 1; chars['['] = 1; chars['\f'] = 1;
+ chars['r'] = 1; chars['R'] = 1; chars[']'] = 1;
+ chars['s'] = 1; chars['S'] = 1; chars['+'] = 1; chars['\\'] = 1;
+ chars['t'] = 1; chars['T'] = 1; chars[';'] = 1; chars['\''] = 1;
+ chars['u'] = 1; chars['U'] = 1; chars['*'] = 1;
+ chars['v'] = 1; chars['V'] = 1; chars[':'] = 1; chars['\0'] = 1;
+ chars['w'] = 1; chars['W'] = 1; chars['<'] = 1; chars[' '] = 1;
+ chars['x'] = 1; chars['X'] = 1; chars['>'] = 1;
+ chars['y'] = 1; chars['Y'] = 1; chars[','] = 1;
+ chars['z'] = 1; chars['Z'] = 1; chars['.'] = 1;
+ chars['?'] = 1;
+ chars['/'] = 1;
+
+ if(sumof(chars) != 98){
+ rc = rc+1;
+ if(pd0->flgd != 0) printf(s243er,1);
+ }
+
+ #ifndef NO_BACKSLASH_CHARCODE
+
+ /* Finally, the escape \ddd consists of the backslash followed
+ by 1, 2, or 3 octal digits which are taken to specify the
+ desired character. */
+
+/*
+ this test is non portable and inaccurate, we replace it
+ by a more failproof version
+
+ if(
+ '\0' != 0 ||
+ '\01' != 1 ||
+ '\02' != 2 ||
+ '\03' != 3 ||
+ '\04' != 4 ||
+ '\05' != 5 ||
+ '\06' != 6 ||
+ '\07' != 7 ||
+ '\10' != 8 ||
+ '\17' != 15 ||
+ '\20' != 16 ||
+ '\77' != 63 ||
+ '\100' != 64 ||
+ '\177' != 127
+ )
+*/
+ if(
+ ('0' != '\60') ||
+ ('9' != '\71') ||
+ ('A' != '\101') ||
+ ('Z' != '\132') ||
+ ('a' != '\141') ||
+ ('z' != '\172')
+ )
+
+ {
+ rc = rc+8;
+ if(pd0->flgd != 0)
+ {
+ printf(s243er,8);
+ }
+ }
+
+ #endif
+
+ return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#define cq_sections 1
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s243(pd0);
+ }
+}
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 2.44: floating point constants
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+#ifndef NO_OLD_FUNC_DECL
+s244(pd0)
+struct defs *pd0;
+{
+#else
+s244(struct defs *pd0) {
+#endif
+
+ #ifndef NO_FLOATS
+ double a[8];
+
+ int rc, lrc, j;
+ static char s244er[] = "s244,er%d\n";
+ static char qs244[8] = "s244 ";
+ char *ps, *pt;
+
+ ps = qs244;
+ pt = pd0->rfs;
+ while(*pt++ = *ps++);
+ rc = 0;
+ lrc = 0;
+
+ /* Unfortunately, there's not a lot we can do with floating constants.
+ We can check to see that the various representations can be com-
+ piled, that the conversion is such that they yield the same hard-
+ ware representations in all cases, and that all representations
+ thus checked are double precision. */
+
+ a[0] = .1250E+04;
+ a[1] = 1.250E3;
+ a[2] = 12.50E02;
+ a[3] = 125.0e+1;
+ a[4] = 1250e00;
+ a[5] = 12500.e-01;
+ a[6] = 125000e-2;
+ a[7] = 1250.;
+
+ lrc = 0;
+ for (j=0; j<7; j++) if(a[j] != a[j+1]) lrc = 1;
+
+ if(lrc != 0) {
+ if(pd0->flgd != 0) printf(s244er,1);
+ rc = rc+1;
+ }
+
+ if ( (sizeof .1250E+04 ) != sizeof(double)
+ || (sizeof 1.250E3 ) != sizeof(double)
+ || (sizeof 12.50E02 ) != sizeof(double)
+ || (sizeof 1.250e+1 ) != sizeof(double)
+ || (sizeof 1250e00 ) != sizeof(double)
+ || (sizeof 12500.e-01) != sizeof(double)
+ || (sizeof 125000e-2 ) != sizeof(double)
+ || (sizeof 1250. ) != sizeof(double)){
+ if(pd0->flgd != 0) printf(s244er,2);
+ rc = rc+2;
+ }
+
+ return rc;
+
+ #else
+
+ return 0;
+
+ #endif
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#define cq_sections 1
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s244(pd0);
+ }
+}
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 2.5: strings
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+#ifndef NO_OLD_FUNC_DECL
+s25(pd0)
+struct defs *pd0;
+{
+#else
+int s25(struct defs *pd0) {
+#endif
+ char *s, *s2;
+ int rc, lrc, j;
+ static char s25er[] = "s25,er%d\n";
+ static char qs25[8] = "s25 ";
+ char *ps, *pt;
+
+ ps = qs25;
+ pt = pd0->rfs;
+ while(*pt++ = *ps++);
+ rc = 0;
+
+ /* A string is a sequence of characters surrounded by double
+ quotes, as in "...". */
+
+ s = "...";
+
+ /* A string has type "array of characters" and storage class
+ static and is initialized with the given characters. */
+
+ if ( s[0] != s[1] || s[1] != s[2]
+ || s[2] != '.' ) {
+ rc = rc+1;
+ if(pd0->flgd != 0) printf(s25er,1);
+ }
+
+ /* The compiler places a null byte \0 at the end of each string
+ so the program which scans the string can find its end. */
+
+ if( s[3] != '\0' ){
+ rc = rc+4;
+ if(pd0->flgd != 0) printf(s25er,4);
+ }
+
+ /* In a string, the double quote character " must be preceded
+ by a \. */
+
+ if( ".\"."[1] != '"' ){
+ rc = rc+8;
+ if(pd0->flgd != 0) printf(s25er,8);
+ }
+
+ /* In addition, the same escapes described for character constants
+ may be used. */
+
+ s = "\n\t\b\r\f\\\'";
+
+ if( s[0] != '\n'
+ || s[1] != '\t'
+ || s[2] != '\b'
+ || s[3] != '\r'
+ || s[4] != '\f'
+ || s[5] != '\\'
+ || s[6] != '\'' ){
+ rc = rc+16;
+ if( pd0->flgd != 0) printf(s25er,16);
+ }
+
+ /* Finally, a \ and an immediately following newline are ignored */
+
+ s2 = "queep!";
+ s = "queep!";
+
+ lrc = 0;
+ for (j=0; j<sizeof "queep!"; j++) if(s[j] != s2[j]) lrc = 1;
+ if (lrc != 0){
+ rc = rc+32;
+ if(pd0->flgd != 0) printf(s25er,32);
+ }
+ return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#define cq_sections 1
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s25(pd0);
+ }
+}
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 2.6: Hardware Characteristics
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+#ifndef CQ26_INCLUDED
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+#endif
+
+/*
+ section s26, which pokes around at the hardware
+ trying to figure out the characteristics of the machine that
+ it is running on, saves information that is subsequently
+ used by sections s626, s72, and s757. If this program is
+ to be broken up into smallish pieces, say for running on
+ a microcomputer, take care to see that s26 is called before
+ calling any of the latter three sections.
+*/
+
+/*
+ 2.6 Hardware Characteristics
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+s26(pd0)
+struct defs *pd0;
+{
+#else
+s26(struct defs *pd0) {
+#endif
+ static char qs26[8] = "s26 ";
+ char *ps, *pt;
+ char c0, c1;
+ #ifndef NO_FLOATS
+ float temp, one, delta;
+ double tempd, oned;
+ #endif
+ static char s[] = "%3d bits in %ss.\n";
+ static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
+
+ ps = qs26;
+ pt = pd0->rfs;
+
+ while(*pt++ = *ps++);
+
+ /* Here, we shake the machinery a little to see what falls
+ out. First, we find out how many bits are in a char. */
+
+ pd0->cbits = 0;
+ c0 = 0;
+ c1 = 1;
+
+ while(c0 != c1) {
+ c1 = c1<<1;
+ pd0->cbits = pd0->cbits+1;
+ }
+ /* That information lets us determine the size of everything else. */
+
+ pd0->ibits = pd0->cbits * sizeof(int);
+ pd0->sbits = pd0->cbits * sizeof(short);
+ pd0->lbits = pd0->cbits * sizeof(long);
+ pd0->ubits = pd0->cbits * sizeof(unsigned);
+ #ifndef NO_FLOATS
+ pd0->fbits = pd0->cbits * sizeof(float);
+ pd0->dbits = pd0->cbits * sizeof(double);
+ #endif
+
+ /* We have now almost reconstructed the table in section 2.6, the
+ exception being the range of the floating point hardware.
+ Now there are just so many ways to conjure up a floating point
+ representation system that it's damned near impossible to guess
+ what's going on by writing a program to interpret bit patterns.
+ Further, the information isn't all that useful, if we consider
+ the fact that machines that won't handle numbers between 10**30
+ and 10**-30 are very hard to find, and that people playing with
+ numbers outside that range have a lot more to worry about than
+ just the capacity of the characteristic.
+
+ A much more useful measure is the precision, which can be ex-
+ pressed in terms of the smallest number that can be added to
+ 1. without loss of significance. We calculate that here, for
+ float and double. */
+
+#ifndef NO_FLOATS
+ one = 1.;
+ delta = 1.;
+ temp = 0.;
+ while(temp != one) {
+ temp = one+delta;
+ delta = delta/2.;
+ }
+ pd0->fprec = delta * 4.;
+ oned = 1.;
+ delta = 1.;
+ tempd = 0.;
+ while(tempd != oned) {
+ tempd = oned+delta;
+ delta = delta/2.;
+ }
+ pd0->dprec = delta * 4.;
+#endif
+
+ /* Now, if anyone's interested, we publish the results. */
+
+#ifndef CQ26_INCLUDED
+ if(pd0->flgm != 0) {
+ printf(s,pd0->cbits,"char");
+ printf(s,pd0->ibits,"int");
+ printf(s,pd0->sbits,"short");
+ printf(s,pd0->lbits,"long");
+ printf(s,pd0->ubits,"unsigned");
+ printf(s,pd0->fbits,"float");
+ printf(s,pd0->dbits,"double");
+ #ifndef NO_FLOATS
+ printf(s2,pd0->fprec,"float");
+ printf(s2,pd0->dprec,"double");
+ #else
+ printf("NO_FLOATS\n");
+ #endif
+ }
+#endif
+ /* Since we are only exploring and perhaps reporting, but not
+ testing any features, we cannot return an error code. */
+
+ return 0;
+}
+
+#ifndef CQ26_INCLUDED
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s26(pd0);
+ }
+}
+
+#define cq_sections 1
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
+#endif
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 4: what's in a name?
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+#define CQ26_INCLUDED
+/*
+ section s26, which pokes around at the hardware
+ trying to figure out the characteristics of the machine that
+ it is running on, saves information that is subsequently
+ used by sections s626, s72, and s757. If this program is
+ to be broken up into smallish pieces, say for running on
+ a microcomputer, take care to see that s26 is called before
+ calling any of the latter three sections.
+*/
+
+/*
+ 2.6 Hardware Characteristics
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+s26(pd0)
+struct defs *pd0;
+{
+#else
+s26(struct defs *pd0) {
+#endif
+ static char qs26[8] = "s26 ";
+ char *ps, *pt;
+ char c0, c1;
+ #ifndef NO_FLOATS
+ float temp, one, delta;
+ double tempd, oned;
+ #endif
+ static char s[] = "%3d bits in %ss.\n";
+ static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
+
+ ps = qs26;
+ pt = pd0->rfs;
+
+ while(*pt++ = *ps++);
+
+ /* Here, we shake the machinery a little to see what falls
+ out. First, we find out how many bits are in a char. */
+
+ pd0->cbits = 0;
+ c0 = 0;
+ c1 = 1;
+
+ while(c0 != c1) {
+ c1 = c1<<1;
+ pd0->cbits = pd0->cbits+1;
+ }
+ /* That information lets us determine the size of everything else. */
+
+ pd0->ibits = pd0->cbits * sizeof(int);
+ pd0->sbits = pd0->cbits * sizeof(short);
+ pd0->lbits = pd0->cbits * sizeof(long);
+ pd0->ubits = pd0->cbits * sizeof(unsigned);
+ #ifndef NO_FLOATS
+ pd0->fbits = pd0->cbits * sizeof(float);
+ pd0->dbits = pd0->cbits * sizeof(double);
+ #endif
+
+ /* We have now almost reconstructed the table in section 2.6, the
+ exception being the range of the floating point hardware.
+ Now there are just so many ways to conjure up a floating point
+ representation system that it's damned near impossible to guess
+ what's going on by writing a program to interpret bit patterns.
+ Further, the information isn't all that useful, if we consider
+ the fact that machines that won't handle numbers between 10**30
+ and 10**-30 are very hard to find, and that people playing with
+ numbers outside that range have a lot more to worry about than
+ just the capacity of the characteristic.
+
+ A much more useful measure is the precision, which can be ex-
+ pressed in terms of the smallest number that can be added to
+ 1. without loss of significance. We calculate that here, for
+ float and double. */
+
+#ifndef NO_FLOATS
+ one = 1.;
+ delta = 1.;
+ temp = 0.;
+ while(temp != one) {
+ temp = one+delta;
+ delta = delta/2.;
+ }
+ pd0->fprec = delta * 4.;
+ oned = 1.;
+ delta = 1.;
+ tempd = 0.;
+ while(tempd != oned) {
+ tempd = oned+delta;
+ delta = delta/2.;
+ }
+ pd0->dprec = delta * 4.;
+#endif
+
+ /* Now, if anyone's interested, we publish the results. */
+
+#ifndef CQ26_INCLUDED
+ if(pd0->flgm != 0) {
+ printf(s,pd0->cbits,"char");
+ printf(s,pd0->ibits,"int");
+ printf(s,pd0->sbits,"short");
+ printf(s,pd0->lbits,"long");
+ printf(s,pd0->ubits,"unsigned");
+ printf(s,pd0->fbits,"float");
+ printf(s,pd0->dbits,"double");
+ #ifndef NO_FLOATS
+ printf(s2,pd0->fprec,"float");
+ printf(s2,pd0->dprec,"double");
+ #else
+ printf("NO_FLOATS\n");
+ #endif
+ }
+#endif
+ /* Since we are only exploring and perhaps reporting, but not
+ testing any features, we cannot return an error code. */
+
+ return 0;
+}
+
+int extvar;
+
+#ifdef NO_IMPLICIT_FUNC_PROTOTYPES
+int s4(struct defs *pd0);
+int svtest(int n);
+zero();
+testev();
+setev();
+#endif
+
+#ifndef NO_OLD_FUNC_DECL
+s4(pd0) /* 4. What's in a name? */
+struct defs *pd0;
+{
+#else
+int s4(struct defs *pd0) {
+#endif
+ static char s4er[] = "s4,er%d\n";
+ static char qs4[8] = "s4 ";
+ char *ps, *pt;
+ int j, rc;
+
+ short sint; /* short integer, for size test */
+ int pint; /* plain */
+ long lint; /* long */
+ unsigned target;
+ unsigned int mask;
+
+ rc = 0;
+ ps = qs4;
+ pt = pd0->rfs;
+
+ while(*pt++ = *ps++);
+
+/* There are four declarable storage classes: automatic,
+static, external, and register. Automatic variables have
+been dealt with extensively thus far, and will not be specif-
+ically treated in this section. Register variables are treated
+in section s81.
+
+ Static variables are local to a block, but retain their
+values upon reentry to a block, even after control has left
+the block. */
+
+ for (j=0; j<3; j++)
+ if(svtest(j) != zero()){
+ rc = 1;
+ if(pd0->flgd != 0) printf(s4er,1);
+ }
+ ;
+
+/* External variables exist and retain their values throughout
+the execution of the entire program, and may be used for comm-
+unication between functions, even separately compiled functions.
+ */
+
+ setev();
+ if(testev() != 0){
+ rc=rc+2;
+ if(pd0->flgd != 0) printf(s4er,2);
+ }
+/*
+ Characters have been tested elsewhere (in s243).
+
+ Up to three sizes of integer, declared short int, int, and
+long int, are available. Longer integers provide no less storage
+than shorter ones, but implementation may make either short
+integers, or long integers, or both, equivalent to plain
+integers.
+ */
+
+ if(sizeof lint < sizeof pint || sizeof pint < sizeof sint){
+ rc = rc+4;
+ if(pd0->flgd != 0) printf(s4er,4);
+ }
+
+/* Unsigned integers, declared unsigned, obey the laws of
+arithmetic modulo 2**n, where n is the number of bits in the
+implementation */
+
+ target = ~0U;
+ mask = 1;
+ printf("sizeof target: %08x pd0->cbits: %08x\n", sizeof target, pd0->cbits);
+ printf("mask: %08x target: %08x\n", mask, target);
+
+ for(j=0; j<(sizeof target)*pd0->cbits; j++){
+ mask = mask⌖
+ target = target>>1;
+ printf("mask: %08x target: %08x\n", mask, target);
+ }
+
+ if(mask != 1 || target != 0){
+ rc = rc+8;
+ if(pd0->flgd != 0) printf(s4er,8);
+ }
+
+ return rc;
+}
+
+#ifndef NO_OLD_FUNC_DECL
+svtest(n)
+int n;
+{
+#else
+int svtest(int n) {
+#endif
+
+ static k;
+ int rc;
+ switch (n) {
+ case 0: k = 1978;
+ rc = 0;
+ break;
+
+ case 1: if(k != 1978) rc = 1;
+ else{
+ k = 1929;
+ rc = 0;
+ }
+ break;
+
+ case 2: if(k != 1929) rc = 1;
+ else rc = 0;
+ break;
+ }
+ return rc;
+}
+zero(){ /* Returns a value of zero, possibly */
+ static k; /* with side effects, as it's called */
+ int rc; /* alternately with svtest, above, */
+ k = 2; /* and has the same internal storage */
+ rc = 0; /* requirements. */
+ return rc;
+}
+testev(){
+ if(extvar != 1066) return 1;
+ else return 0;
+}
+
+/* Sets an external variable. Used */
+/* by s4, and should be compiled */
+/* separately from s4. */
+
+setev(){
+#ifndef NO_SLOPPY_EXTERN
+ extern int extvar;
+#endif
+ extvar = 1066;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s26(pd0);
+ case 1: return s4(pd0);
+ }
+}
+
+#define cq_sections 2
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 6.1: characters and integers
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+/*#include "cq26.c"*/ /* hardware check */
+
+int extvar;
+
+#ifndef NO_OLD_FUNC_DECL
+s61(pd0) /* Characters and integers */
+struct defs *pd0;
+{
+#else
+int s61(struct defs *pd0){
+#endif
+ static char s61er[] = "s61,er%d\n";
+ static char s61ok[] = "s61,ok%d\n";
+ static char qs61[8] = "s61 ";
+ short from, shortint;
+ long int to, longint;
+ int rc, lrc;
+ int j;
+ char fromc, charint;
+ char *wd, *pc[6];
+
+ static char upper_alpha[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ static char lower_alpha[] = "abcdefghijklmnopqrstuvwxyz";
+ static char numbers[] = "0123456789";
+ static char special_characters[] = "~!\"#%&()_=-^|{}[]+;*:<>,.?/";
+ static char extra_special_characters[] = "\n\t\b\r\f\\\'";
+ static char blank_and_NUL[] = " \0";
+
+ char *ps, *pt;
+ ps = qs61;
+ pt = pd0->rfs;
+ rc = 0;
+
+ printf(s61ok,0);
+
+ while (*pt++ = *ps++);
+
+/* A character or a short integer may be used wherever
+an integer may be used. In all cases, the value is converted
+to integer. This principle is extensively used throughout this
+program, and will not be explicitly tested here. */
+
+/* Conversion of a shorter integer to a longer always
+involves sign extension. */
+
+ from = -19;
+ to = from;
+
+ if(to != -19){
+ rc = rc+1;
+ if(pd0->flgd != 0) printf(s61er,1);
+ }
+ else if(pd0->flgd != 0) printf(s61ok,1);
+
+/* It is guaranteed that a member of the standard char-
+acter set is nonnegative. */
+
+ pc[0] = upper_alpha;
+ pc[1] = lower_alpha;
+ pc[2] = numbers;
+ pc[3] = special_characters;
+ pc[4] = extra_special_characters;
+ pc[5] = blank_and_NUL;
+
+ lrc = 0;
+ for (j=0; j<6; j++)
+ while(*pc[j]) if(*pc[j]++ < 0) lrc =1;
+
+ if(lrc != 0){
+ rc=rc+2;
+ if(pd0->flgd != 0) printf(s61er,2);
+ }
+ else if(pd0->flgd != 0) printf(s61ok,2);
+
+/* When a longer integer is converted to a shorter or
+to a char, it is truncated on the left; excess bits are
+simply discarded. */
+
+ longint = 1048579; /* =2**20+3 */
+ shortint = longint;
+ charint = longint;
+
+ if((shortint != longint && shortint != 3) ||
+ (charint != longint && charint != 3)) {
+ rc = rc+8;
+ if(pd0->flgd != 0) printf(s61er,8);
+ }
+ else if(pd0->flgd != 0) printf(s61ok,8);
+
+ return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ /*case 0: return s26(pd0);*/
+ case 0: return s61(pd0);
+ }
+}
+
+#define cq_sections 1
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 6.2: Float and double, 6.3 Floating and integral, 6.4 Pointers and integers, 6.5 Unsigned, 6.6 Arithmetic conversions
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+#define CQ26_INCLUDED
+/*
+ section s26, which pokes around at the hardware
+ trying to figure out the characteristics of the machine that
+ it is running on, saves information that is subsequently
+ used by sections s626, s72, and s757. If this program is
+ to be broken up into smallish pieces, say for running on
+ a microcomputer, take care to see that s26 is called before
+ calling any of the latter three sections.
+*/
+
+/*
+ 2.6 Hardware Characteristics
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+s26(pd0)
+struct defs *pd0;
+{
+#else
+s26(struct defs *pd0) {
+#endif
+ static char qs26[8] = "s26 ";
+ char *ps, *pt;
+ char c0, c1;
+ #ifndef NO_FLOATS
+ float temp, one, delta;
+ double tempd, oned;
+ #endif
+ static char s[] = "%3d bits in %ss.\n";
+ static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
+
+ ps = qs26;
+ pt = pd0->rfs;
+
+ while(*pt++ = *ps++);
+
+ /* Here, we shake the machinery a little to see what falls
+ out. First, we find out how many bits are in a char. */
+
+ pd0->cbits = 0;
+ c0 = 0;
+ c1 = 1;
+
+ while(c0 != c1) {
+ c1 = c1<<1;
+ pd0->cbits = pd0->cbits+1;
+ }
+ /* That information lets us determine the size of everything else. */
+
+ pd0->ibits = pd0->cbits * sizeof(int);
+ pd0->sbits = pd0->cbits * sizeof(short);
+ pd0->lbits = pd0->cbits * sizeof(long);
+ pd0->ubits = pd0->cbits * sizeof(unsigned);
+ #ifndef NO_FLOATS
+ pd0->fbits = pd0->cbits * sizeof(float);
+ pd0->dbits = pd0->cbits * sizeof(double);
+ #endif
+
+ /* We have now almost reconstructed the table in section 2.6, the
+ exception being the range of the floating point hardware.
+ Now there are just so many ways to conjure up a floating point
+ representation system that it's damned near impossible to guess
+ what's going on by writing a program to interpret bit patterns.
+ Further, the information isn't all that useful, if we consider
+ the fact that machines that won't handle numbers between 10**30
+ and 10**-30 are very hard to find, and that people playing with
+ numbers outside that range have a lot more to worry about than
+ just the capacity of the characteristic.
+
+ A much more useful measure is the precision, which can be ex-
+ pressed in terms of the smallest number that can be added to
+ 1. without loss of significance. We calculate that here, for
+ float and double. */
+
+#ifndef NO_FLOATS
+ one = 1.;
+ delta = 1.;
+ temp = 0.;
+ while(temp != one) {
+ temp = one+delta;
+ delta = delta/2.;
+ }
+ pd0->fprec = delta * 4.;
+ oned = 1.;
+ delta = 1.;
+ tempd = 0.;
+ while(tempd != oned) {
+ tempd = oned+delta;
+ delta = delta/2.;
+ }
+ pd0->dprec = delta * 4.;
+#endif
+
+ /* Now, if anyone's interested, we publish the results. */
+
+#ifndef CQ26_INCLUDED
+ if(pd0->flgm != 0) {
+ printf(s,pd0->cbits,"char");
+ printf(s,pd0->ibits,"int");
+ printf(s,pd0->sbits,"short");
+ printf(s,pd0->lbits,"long");
+ printf(s,pd0->ubits,"unsigned");
+ printf(s,pd0->fbits,"float");
+ printf(s,pd0->dbits,"double");
+ #ifndef NO_FLOATS
+ printf(s2,pd0->fprec,"float");
+ printf(s2,pd0->dprec,"double");
+ #else
+ printf("NO_FLOATS\n");
+ #endif
+ }
+#endif
+ /* Since we are only exploring and perhaps reporting, but not
+ testing any features, we cannot return an error code. */
+
+ return 0;
+}
+
+int extvar;
+
+#ifndef NO_OLD_FUNC_DECL
+s626(pd0) /* 6.2 Float and double */
+ /* 6.3 Floating and integral */
+ /* 6.4 Pointers and integers */
+ /* 6.5 Unsigned */
+ /* 6.6 Arithmetic conversions */
+struct defs *pd0;
+{
+#else
+int s626(struct defs *pd0){
+#endif
+ static char s626er[] = "s626,er%d\n";
+ static char qs626[8] = "s626 ";
+ int rc;
+ char *ps, *pt;
+ #ifndef NO_FLOATS
+ float eps, f1, f2, f3, f4, f;
+ #endif
+ long lint1, lint2, l, ls;
+ char c, t[28], t0;
+ short s;
+ int is, i, j;
+ unsigned u, us;
+ #ifndef NO_FLOATS
+ double d, ds;
+ #endif
+ ps = qs626;
+ pt = pd0->rfs;
+ rc = 0;
+ while (*pt++ = *ps++);
+
+ #ifndef NO_FLOATS
+
+ /* Conversions of integral values to floating type are
+ well-behaved. */
+
+ f1 = 1.;
+ lint1 = 1.;
+ lint2 = 1.;
+
+ for(j=0;j<pd0->lbits-2;j++){
+ f1 = f1*2;
+ lint2 = (lint2<<1)|lint1;
+ }
+ f2 = lint2;
+ f1 = (f1-f2)/f1;
+ if(f1>2.*pd0->fprec){
+ rc = rc+2;
+ if(pd0->flgd != 0) printf(s626er,2);
+ }
+
+ /* Pointer-integer combinations are discussed in s74,
+ "Additive operators". The unsigned-int combination
+ appears below. */
+
+ c = 125;
+ s = 125;
+ i = 125; is = 15625;
+ u = 125; us = 15625;
+ l = 125; ls = 15625;
+ f = 125.;
+ d = 125.; ds = 15625.;
+
+ for(j=0;j<28;j++) t[j] = 0;
+
+ if(c*c != is) t[ 0] = 1;
+ if(s*c != is) t[ 1] = 1;
+ if(s*s != is) t[ 2] = 1;
+ if(i*c != is) t[ 3] = 1;
+ if(i*s != is) t[ 4] = 1;
+ if(i*i != is) t[ 5] = 1;
+ if(u*c != us) t[ 6] = 1;
+ if(u*s != us) t[ 7] = 1;
+ if(u*i != us) t[ 8] = 1;
+ if(u*u != us) t[ 9] = 1;
+ if(l*c != ls) t[10] = 1;
+ if(l*s != ls) t[11] = 1;
+ if(l*i != ls) t[12] = 1;
+ if(l*u != us) t[13] = 1;
+ if(l*l != ls) t[14] = 1;
+ if(f*c != ds) t[15] = 1;
+ if(f*s != ds) t[16] = 1;
+ if(f*i != ds) t[17] = 1;
+ if(f*u != ds) t[18] = 1;
+ if(f*l != ds) t[19] = 1;
+ if(f*f != ds) t[20] = 1;
+ if(d*c != ds) t[21] = 1;
+ if(d*s != ds) t[22] = 1;
+ if(d*i != ds) t[23] = 1;
+ if(d*u != ds) t[24] = 1;
+ if(d*l != ds) t[25] = 1;
+ if(d*f != ds) t[26] = 1;
+ if(d*d != ds) t[27] = 1;
+
+ t0 = 0;
+ for(j=0; j<28; j++) t0 = t0+t[j];
+
+ if(t0 != 0){
+ rc = rc+4;
+ if(pd0->flgd != 0){
+ printf(s626er,4);
+ printf(" key=");
+ for(j=0;j<28;j++) printf("%d",t[j]);
+ printf("\n");
+ }
+ }
+
+ #endif
+
+ /* When an unsigned integer is converted to long,
+ the value of the result is the same numerically
+ as that of the unsigned integer. */
+
+ l = (unsigned)0100000;
+ if((long)l > (unsigned)0100000){
+ rc = rc+8;
+ if(pd0->flgd != 0) printf(s626er,8);
+ }
+
+ return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s26(pd0);
+ case 1: return s626(pd0);
+ }
+}
+
+#define cq_sections 2
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 7.1: primary expressions
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+/*include "cq26.c"*/ /* hardware check */
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+int extvar;
+
+#ifndef NO_OLD_FUNC_DECL
+s71(pd0) /* 7.1 Primary expressions */
+struct defs *pd0;
+{
+#else
+int s71(struct defs *pd0){
+#endif
+ static char s71er[] = "s71,er%d\n";
+ static char qs71[8] = "s71 ";
+ int rc;
+ char *ps, *pt;
+ static char q = 'q';
+#ifndef NO_SLOPPY_EXTERN
+ int x[10], McCarthy(), clobber(), a, b, *p;
+#else
+ int x[10], a, b, *p;
+#endif
+ ps = qs71;
+ pt = pd0->rfs;
+ rc = 0;
+ while (*pt++ = *ps++);
+
+/* Testing of expressions and operators is quite complicated,
+ because (a) problems are apt to surface in queer combinations
+ of operators and operands, rather than in isolation,
+ and (b) the number of expressions needed to provoke a case
+ of improper behaviour may be quite large. Hence, we take the
+ following approach: for this section, and for subsequent
+ sections through 7.15, we will check the primitive operations
+ in isolation, thus verifying that the primitives work,
+ after a fashion. The job of testing combinations, we will
+ leave to a separate, machine-generated program, to be included
+ in the C test package at some later date.
+ */
+
+/* A string is a primary expression. The identifier points to
+ the first character of a string.
+ */
+
+ if(*"queep" != q){
+ rc = rc+1;
+ if(pd0->flgd != 0) printf(s71er,1);
+ }
+/* A parenthesized expression is a primary expression whose
+ type and value are the same as those of the unadorned
+ expression.
+ */
+ if((2+3) != 2+3) {
+ rc = rc+2;
+ if(pd0->flgd != 0) printf(s71er,2);
+ }
+
+/* A primary expression followed by an expression in square
+ brackets is a primary expression. The intuitive meaning is
+ that of a subscript. The expression E1[E2] is identical
+ (by definition) to *((E1)+(E2)).
+ */
+
+ x[5] = 1942;
+ if(x[5] != 1942 || x[5] != *((x)+(5))){
+ rc = rc+4;
+ if(pd0->flgd != 0) printf(s71er,4);
+ }
+
+/* If the various flavors of function calls didn't work, we
+ would never have gotten this far; however, we do need to
+ show that functions can be recursive...
+ */
+
+ if ( McCarthy(-5) != 91){
+ rc = rc+8;
+ if(pd0->flgd != 0) printf(s71er,8);
+ }
+
+/* and that argument passing is strictly by value. */
+
+ a = 2;
+ b = 3;
+ p = &b;
+
+ clobber(a,p);
+
+ if(a != 2 || b != 2){
+ rc = rc+16;
+ if(pd0->flgd != 0) printf(s71er,16);
+ }
+
+/* Finally, structures and unions are addressed thusly: */
+
+ #ifndef NO_FLOATS
+
+ if(pd0->dprec != (*pd0).dprec){
+ rc = rc+32;
+ if(pd0->flgd != 0) printf(s71er,32);
+ }
+
+ #endif
+
+ return rc;
+}
+#ifndef NO_OLD_FUNC_DECL
+McCarthy(x)
+int x;
+{
+#else
+int McCarthy(int x){
+#endif
+ if(x>100) return x-10;
+ else return McCarthy( McCarthy(x+11));
+}
+
+#ifndef NO_OLD_FUNC_DECL
+clobber(x,y)
+int x,*y;
+#else
+int clobber(int x,int *y)
+#endif
+
+/*
+#ifndef NO_OLD_FUNC_DECL
+clobber(x,y)
+int x,
+#ifdef NO_TYPELESS_INT_PTR
+int
+#endif
+*y;
+{
+#else
+int clobber(int x,
+#ifdef NO_TYPELESS_INT_PTR
+int
+#endif
+*y
+){
+#endif
+*/
+
+{
+ x = 3;
+ *y = 2;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ /*case 0: return s26(pd0);*/
+ case 0: return s71(pd0);
+ }
+}
+
+#define cq_sections 1
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 7.14: assignment operators
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+#ifndef NO_OLD_FUNC_DECL
+s714(pd0) /* 7.14 Assignment operators */
+struct defs *pd0;
+{
+#else
+int s714(struct defs *pd0){
+#endif
+ static char f[] = "Local error %d.\n";
+ static char s714er[] = "s714,er%d\n";
+ static char qs714[8] = "s714 ";
+ register int prlc, lrc;
+ int rc;
+ char cl, cr;
+ short sl, sr;
+ int il, ir;
+ long ll, lr;
+ unsigned ul, ur;
+ #ifndef NO_FLOATS
+ float fl, fr;
+ double dl, dr;
+ #else
+ signed fl, fr;
+ signed dl, dr;
+ #endif
+ char *ps, *pt;
+ ps = qs714;
+ pt = pd0->rfs;
+ rc = 0;
+ lrc = 0;
+ prlc = pd0->flgl;
+ while (*pt++ = *ps++);
+
+ /* This section tests the assignment operators.
+
+ It is an exhaustive test of all assignment statements
+ of the form:
+
+ vl op vr
+
+ where vl and vr are variables from the set
+ {char,short,int,long,unsigned,float,double} and op is
+ one of the assignment operators. There are 395 such
+ statements.
+
+ The initial values for the variables have been chosen
+ so that both the initial values and the results will
+ "fit" in just about any implementation, and that the re-
+ sults will be such that they test for the proper form-
+ ation of composite operators, rather than checking for
+ the valid operation of those operators' components.
+ For example, in checking >>=, we want to verify that
+ a right shift and a move take place, rather than
+ whether or not there may be some peculiarities about
+ the right shift. Such tests have been made previously,
+ and to repeat them here would be to throw out a red
+ herring.
+
+ The table below lists the operators, assignment targets,
+ initial values for left and right operands, and the
+ expected values of the results.
+
+ = += -= *= /= %= >>= <<= &= ^= |=
+char 2 7 3 10 2 1 1 20 8 6 14
+short 2 7 3 10 2 1 1 20 8 6 14
+int 2 7 3 10 2 1 1 20 8 6 14
+long 2 7 3 10 2 1 1 20 8 6 14
+unsigned 2 7 3 10 2 1 1 20 8 6 14
+float 2 7 3 10 2.5 | |
+double 2 7 3 10 2.5 | |
+ | |
+initial (5,2) | (5,2) | (12,10)
+
+ The following machine-generated program reflects the
+ tests described in the table.
+ */
+
+ cl = 5; cr = 2;
+ cl = cr;
+ if(cl != 2){
+ lrc = 1;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; sr = 2;
+ cl = sr;
+ if(cl != 2){
+ lrc = 2;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ir = 2;
+ cl = ir;
+ if(cl != 2){
+ lrc = 3;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; lr = 2;
+ cl = lr;
+ if(cl != 2){
+ lrc = 4;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ur = 2;
+ cl = ur;
+ if(cl != 2){
+ lrc = 5;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; fr = 2;
+ cl = fr;
+ if(cl != 2){
+ lrc = 6;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; dr = 2;
+ cl = dr;
+ if(cl != 2){
+ lrc = 7;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; cr = 2;
+ sl = cr;
+ if(sl != 2){
+ lrc = 8;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; sr = 2;
+ sl = sr;
+ if(sl != 2){
+ lrc = 9;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ir = 2;
+ sl = ir;
+ if(sl != 2){
+ lrc = 10;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; lr = 2;
+ sl = lr;
+ if(sl != 2){
+ lrc = 11;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ur = 2;
+ sl = ur;
+ if(sl != 2){
+ lrc = 12;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; fr = 2;
+ sl = fr;
+ if(sl != 2){
+ lrc = 13;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; dr = 2;
+ sl = dr;
+ if(sl != 2){
+ lrc = 14;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; cr = 2;
+ il = cr;
+ if(il != 2){
+ lrc = 15;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; sr = 2;
+ il = sr;
+ if(il != 2){
+ lrc = 16;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ir = 2;
+ il = ir;
+ if(il != 2){
+ lrc = 17;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; lr = 2;
+ il = lr;
+ if(il != 2){
+ lrc = 18;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ur = 2;
+ il = ur;
+ if(il != 2){
+ lrc = 19;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; fr = 2;
+ il = fr;
+ if(il != 2){
+ lrc = 20;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; dr = 2;
+ il = dr;
+ if(il != 2){
+ lrc = 21;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; cr = 2;
+ ll = cr;
+ if(ll != 2){
+ lrc = 22;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; sr = 2;
+ ll = sr;
+ if(ll != 2){
+ lrc = 23;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ir = 2;
+ ll = ir;
+ if(ll != 2){
+ lrc = 24;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; lr = 2;
+ ll = lr;
+ if(ll != 2){
+ lrc = 25;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ur = 2;
+ ll = ur;
+ if(ll != 2){
+ lrc = 26;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; fr = 2;
+ ll = fr;
+ if(ll != 2){
+ lrc = 27;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; dr = 2;
+ ll = dr;
+ if(ll != 2){
+ lrc = 28;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; cr = 2;
+ ul = cr;
+ if(ul != 2){
+ lrc = 29;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; sr = 2;
+ ul = sr;
+ if(ul != 2){
+ lrc = 30;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ir = 2;
+ ul = ir;
+ if(ul != 2){
+ lrc = 31;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; lr = 2;
+ ul = lr;
+ if(ul != 2){
+ lrc = 32;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ur = 2;
+ ul = ur;
+ if(ul != 2){
+ lrc = 33;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; fr = 2;
+ ul = fr;
+ if(ul != 2){
+ lrc = 34;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; dr = 2;
+ ul = dr;
+ if(ul != 2){
+ lrc = 35;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; cr = 2;
+ fl = cr;
+ if(fl != 2){
+ lrc = 36;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; sr = 2;
+ fl = sr;
+ if(fl != 2){
+ lrc = 37;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ir = 2;
+ fl = ir;
+ if(fl != 2){
+ lrc = 38;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; lr = 2;
+ fl = lr;
+ if(fl != 2){
+ lrc = 39;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ur = 2;
+ fl = ur;
+ if(fl != 2){
+ lrc = 40;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; fr = 2;
+ fl = fr;
+ if(fl != 2){
+ lrc = 41;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; dr = 2;
+ fl = dr;
+ if(fl != 2){
+ lrc = 42;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; cr = 2;
+ dl = cr;
+ if(dl != 2){
+ lrc = 43;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; sr = 2;
+ dl = sr;
+ if(dl != 2){
+ lrc = 44;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ir = 2;
+ dl = ir;
+ if(dl != 2){
+ lrc = 45;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; lr = 2;
+ dl = lr;
+ if(dl != 2){
+ lrc = 46;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ur = 2;
+ dl = ur;
+ if(dl != 2){
+ lrc = 47;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; fr = 2;
+ dl = fr;
+ if(dl != 2){
+ lrc = 48;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; dr = 2;
+ dl = dr;
+ if(dl != 2){
+ lrc = 49;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; cr = 2;
+ cl += cr;
+ if(cl != 7){
+ lrc = 50;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; sr = 2;
+ cl += sr;
+ if(cl != 7){
+ lrc = 51;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ir = 2;
+ cl += ir;
+ if(cl != 7){
+ lrc = 52;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; lr = 2;
+ cl += lr;
+ if(cl != 7){
+ lrc = 53;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ur = 2;
+ cl += ur;
+ if(cl != 7){
+ lrc = 54;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; fr = 2;
+ cl += fr;
+ if(cl != 7){
+ lrc = 55;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; dr = 2;
+ cl += dr;
+ if(cl != 7){
+ lrc = 56;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; cr = 2;
+ sl += cr;
+ if(sl != 7){
+ lrc = 57;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; sr = 2;
+ sl += sr;
+ if(sl != 7){
+ lrc = 58;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ir = 2;
+ sl += ir;
+ if(sl != 7){
+ lrc = 59;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; lr = 2;
+ sl += lr;
+ if(sl != 7){
+ lrc = 60;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ur = 2;
+ sl += ur;
+ if(sl != 7){
+ lrc = 61;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; fr = 2;
+ sl += fr;
+ if(sl != 7){
+ lrc = 62;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; dr = 2;
+ sl += dr;
+ if(sl != 7){
+ lrc = 63;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; cr = 2;
+ il += cr;
+ if(il != 7){
+ lrc = 64;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; sr = 2;
+ il += sr;
+ if(il != 7){
+ lrc = 65;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ir = 2;
+ il += ir;
+ if(il != 7){
+ lrc = 66;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; lr = 2;
+ il += lr;
+ if(il != 7){
+ lrc = 67;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ur = 2;
+ il += ur;
+ if(il != 7){
+ lrc = 68;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; fr = 2;
+ il += fr;
+ if(il != 7){
+ lrc = 69;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; dr = 2;
+ il += dr;
+ if(il != 7){
+ lrc = 70;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; cr = 2;
+ ll += cr;
+ if(ll != 7){
+ lrc = 71;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; sr = 2;
+ ll += sr;
+ if(ll != 7){
+ lrc = 72;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ir = 2;
+ ll += ir;
+ if(ll != 7){
+ lrc = 73;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; lr = 2;
+ ll += lr;
+ if(ll != 7){
+ lrc = 74;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ur = 2;
+ ll += ur;
+ if(ll != 7){
+ lrc = 75;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; fr = 2;
+ ll += fr;
+ if(ll != 7){
+ lrc = 76;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; dr = 2;
+ ll += dr;
+ if(ll != 7){
+ lrc = 77;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; cr = 2;
+ ul += cr;
+ if(ul != 7){
+ lrc = 78;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; sr = 2;
+ ul += sr;
+ if(ul != 7){
+ lrc = 79;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ir = 2;
+ ul += ir;
+ if(ul != 7){
+ lrc = 80;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; lr = 2;
+ ul += lr;
+ if(ul != 7){
+ lrc = 81;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ur = 2;
+ ul += ur;
+ if(ul != 7){
+ lrc = 82;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; fr = 2;
+ ul += fr;
+ if(ul != 7){
+ lrc = 83;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; dr = 2;
+ ul += dr;
+ if(ul != 7){
+ lrc = 84;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; cr = 2;
+ fl += cr;
+ if(fl != 7){
+ lrc = 85;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; sr = 2;
+ fl += sr;
+ if(fl != 7){
+ lrc = 86;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ir = 2;
+ fl += ir;
+ if(fl != 7){
+ lrc = 87;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; lr = 2;
+ fl += lr;
+ if(fl != 7){
+ lrc = 88;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ur = 2;
+ fl += ur;
+ if(fl != 7){
+ lrc = 89;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; fr = 2;
+ fl += fr;
+ if(fl != 7){
+ lrc = 90;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; dr = 2;
+ fl += dr;
+ if(fl != 7){
+ lrc = 91;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; cr = 2;
+ dl += cr;
+ if(dl != 7){
+ lrc = 92;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; sr = 2;
+ dl += sr;
+ if(dl != 7){
+ lrc = 93;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ir = 2;
+ dl += ir;
+ if(dl != 7){
+ lrc = 94;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; lr = 2;
+ dl += lr;
+ if(dl != 7){
+ lrc = 95;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ur = 2;
+ dl += ur;
+ if(dl != 7){
+ lrc = 96;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; fr = 2;
+ dl += fr;
+ if(dl != 7){
+ lrc = 97;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; dr = 2;
+ dl += dr;
+ if(dl != 7){
+ lrc = 98;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; cr = 2;
+ cl -= cr;
+ if(cl != 3){
+ lrc = 99;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; sr = 2;
+ cl -= sr;
+ if(cl != 3){
+ lrc = 100;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ir = 2;
+ cl -= ir;
+ if(cl != 3){
+ lrc = 101;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; lr = 2;
+ cl -= lr;
+ if(cl != 3){
+ lrc = 102;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ur = 2;
+ cl -= ur;
+ if(cl != 3){
+ lrc = 103;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; fr = 2;
+ cl -= fr;
+ if(cl != 3){
+ lrc = 104;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; dr = 2;
+ cl -= dr;
+ if(cl != 3){
+ lrc = 105;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; cr = 2;
+ sl -= cr;
+ if(sl != 3){
+ lrc = 106;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; sr = 2;
+ sl -= sr;
+ if(sl != 3){
+ lrc = 107;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ir = 2;
+ sl -= ir;
+ if(sl != 3){
+ lrc = 108;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; lr = 2;
+ sl -= lr;
+ if(sl != 3){
+ lrc = 109;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ur = 2;
+ sl -= ur;
+ if(sl != 3){
+ lrc = 110;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; fr = 2;
+ sl -= fr;
+ if(sl != 3){
+ lrc = 111;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; dr = 2;
+ sl -= dr;
+ if(sl != 3){
+ lrc = 112;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; cr = 2;
+ il -= cr;
+ if(il != 3){
+ lrc = 113;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; sr = 2;
+ il -= sr;
+ if(il != 3){
+ lrc = 114;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ir = 2;
+ il -= ir;
+ if(il != 3){
+ lrc = 115;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; lr = 2;
+ il -= lr;
+ if(il != 3){
+ lrc = 116;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ur = 2;
+ il -= ur;
+ if(il != 3){
+ lrc = 117;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; fr = 2;
+ il -= fr;
+ if(il != 3){
+ lrc = 118;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; dr = 2;
+ il -= dr;
+ if(il != 3){
+ lrc = 119;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; cr = 2;
+ ll -= cr;
+ if(ll != 3){
+ lrc = 120;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; sr = 2;
+ ll -= sr;
+ if(ll != 3){
+ lrc = 121;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ir = 2;
+ ll -= ir;
+ if(ll != 3){
+ lrc = 122;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; lr = 2;
+ ll -= lr;
+ if(ll != 3){
+ lrc = 123;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ur = 2;
+ ll -= ur;
+ if(ll != 3){
+ lrc = 124;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; fr = 2;
+ ll -= fr;
+ if(ll != 3){
+ lrc = 125;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; dr = 2;
+ ll -= dr;
+ if(ll != 3){
+ lrc = 126;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; cr = 2;
+ ul -= cr;
+ if(ul != 3){
+ lrc = 127;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; sr = 2;
+ ul -= sr;
+ if(ul != 3){
+ lrc = 128;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ir = 2;
+ ul -= ir;
+ if(ul != 3){
+ lrc = 129;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; lr = 2;
+ ul -= lr;
+ if(ul != 3){
+ lrc = 130;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ur = 2;
+ ul -= ur;
+ if(ul != 3){
+ lrc = 131;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; fr = 2;
+ ul -= fr;
+ if(ul != 3){
+ lrc = 132;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; dr = 2;
+ ul -= dr;
+ if(ul != 3){
+ lrc = 133;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; cr = 2;
+ fl -= cr;
+ if(fl != 3){
+ lrc = 134;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; sr = 2;
+ fl -= sr;
+ if(fl != 3){
+ lrc = 135;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ir = 2;
+ fl -= ir;
+ if(fl != 3){
+ lrc = 136;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; lr = 2;
+ fl -= lr;
+ if(fl != 3){
+ lrc = 137;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ur = 2;
+ fl -= ur;
+ if(fl != 3){
+ lrc = 138;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; fr = 2;
+ fl -= fr;
+ if(fl != 3){
+ lrc = 139;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; dr = 2;
+ fl -= dr;
+ if(fl != 3){
+ lrc = 140;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; cr = 2;
+ dl -= cr;
+ if(dl != 3){
+ lrc = 141;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; sr = 2;
+ dl -= sr;
+ if(dl != 3){
+ lrc = 142;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ir = 2;
+ dl -= ir;
+ if(dl != 3){
+ lrc = 143;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; lr = 2;
+ dl -= lr;
+ if(dl != 3){
+ lrc = 144;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ur = 2;
+ dl -= ur;
+ if(dl != 3){
+ lrc = 145;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; fr = 2;
+ dl -= fr;
+ if(dl != 3){
+ lrc = 146;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; dr = 2;
+ dl -= dr;
+ if(dl != 3){
+ lrc = 147;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; cr = 2;
+ cl *= cr;
+ if(cl != 10){
+ lrc = 148;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; sr = 2;
+ cl *= sr;
+ if(cl != 10){
+ lrc = 149;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ir = 2;
+ cl *= ir;
+ if(cl != 10){
+ lrc = 150;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; lr = 2;
+ cl *= lr;
+ if(cl != 10){
+ lrc = 151;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ur = 2;
+ cl *= ur;
+ if(cl != 10){
+ lrc = 152;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; fr = 2;
+ cl *= fr;
+ if(cl != 10){
+ lrc = 153;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; dr = 2;
+ cl *= dr;
+ if(cl != 10){
+ lrc = 154;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; cr = 2;
+ sl *= cr;
+ if(sl != 10){
+ lrc = 155;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; sr = 2;
+ sl *= sr;
+ if(sl != 10){
+ lrc = 156;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ir = 2;
+ sl *= ir;
+ if(sl != 10){
+ lrc = 157;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; lr = 2;
+ sl *= lr;
+ if(sl != 10){
+ lrc = 158;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ur = 2;
+ sl *= ur;
+ if(sl != 10){
+ lrc = 159;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; fr = 2;
+ sl *= fr;
+ if(sl != 10){
+ lrc = 160;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; dr = 2;
+ sl *= dr;
+ if(sl != 10){
+ lrc = 161;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; cr = 2;
+ il *= cr;
+ if(il != 10){
+ lrc = 162;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; sr = 2;
+ il *= sr;
+ if(il != 10){
+ lrc = 163;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ir = 2;
+ il *= ir;
+ if(il != 10){
+ lrc = 164;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; lr = 2;
+ il *= lr;
+ if(il != 10){
+ lrc = 165;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ur = 2;
+ il *= ur;
+ if(il != 10){
+ lrc = 166;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; fr = 2;
+ il *= fr;
+ if(il != 10){
+ lrc = 167;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; dr = 2;
+ il *= dr;
+ if(il != 10){
+ lrc = 168;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; cr = 2;
+ ll *= cr;
+ if(ll != 10){
+ lrc = 169;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; sr = 2;
+ ll *= sr;
+ if(ll != 10){
+ lrc = 170;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ir = 2;
+ ll *= ir;
+ if(ll != 10){
+ lrc = 171;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; lr = 2;
+ ll *= lr;
+ if(ll != 10){
+ lrc = 172;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ur = 2;
+ ll *= ur;
+ if(ll != 10){
+ lrc = 173;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; fr = 2;
+ ll *= fr;
+ if(ll != 10){
+ lrc = 174;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; dr = 2;
+ ll *= dr;
+ if(ll != 10){
+ lrc = 175;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; cr = 2;
+ ul *= cr;
+ if(ul != 10){
+ lrc = 176;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; sr = 2;
+ ul *= sr;
+ if(ul != 10){
+ lrc = 177;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ir = 2;
+ ul *= ir;
+ if(ul != 10){
+ lrc = 178;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; lr = 2;
+ ul *= lr;
+ if(ul != 10){
+ lrc = 179;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ur = 2;
+ ul *= ur;
+ if(ul != 10){
+ lrc = 180;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; fr = 2;
+ ul *= fr;
+ if(ul != 10){
+ lrc = 181;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; dr = 2;
+ ul *= dr;
+ if(ul != 10){
+ lrc = 182;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; cr = 2;
+ fl *= cr;
+ if(fl != 10){
+ lrc = 183;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; sr = 2;
+ fl *= sr;
+ if(fl != 10){
+ lrc = 184;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ir = 2;
+ fl *= ir;
+ if(fl != 10){
+ lrc = 185;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; lr = 2;
+ fl *= lr;
+ if(fl != 10){
+ lrc = 186;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ur = 2;
+ fl *= ur;
+ if(fl != 10){
+ lrc = 187;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; fr = 2;
+ fl *= fr;
+ if(fl != 10){
+ lrc = 188;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; dr = 2;
+ fl *= dr;
+ if(fl != 10){
+ lrc = 189;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; cr = 2;
+ dl *= cr;
+ if(dl != 10){
+ lrc = 190;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; sr = 2;
+ dl *= sr;
+ if(dl != 10){
+ lrc = 191;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ir = 2;
+ dl *= ir;
+ if(dl != 10){
+ lrc = 192;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; lr = 2;
+ dl *= lr;
+ if(dl != 10){
+ lrc = 193;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ur = 2;
+ dl *= ur;
+ if(dl != 10){
+ lrc = 194;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; fr = 2;
+ dl *= fr;
+ if(dl != 10){
+ lrc = 195;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; dr = 2;
+ dl *= dr;
+ if(dl != 10){
+ lrc = 196;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; cr = 2;
+ cl /= cr;
+ if(cl != 2){
+ lrc = 197;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; sr = 2;
+ cl /= sr;
+ if(cl != 2){
+ lrc = 198;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ir = 2;
+ cl /= ir;
+ if(cl != 2){
+ lrc = 199;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; lr = 2;
+ cl /= lr;
+ if(cl != 2){
+ lrc = 200;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ur = 2;
+ cl /= ur;
+ if(cl != 2){
+ lrc = 201;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; fr = 2;
+ cl /= fr;
+ if(cl != 2){
+ lrc = 202;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; dr = 2;
+ cl /= dr;
+ if(cl != 2){
+ lrc = 203;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; cr = 2;
+ sl /= cr;
+ if(sl != 2){
+ lrc = 204;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; sr = 2;
+ sl /= sr;
+ if(sl != 2){
+ lrc = 205;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ir = 2;
+ sl /= ir;
+ if(sl != 2){
+ lrc = 206;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; lr = 2;
+ sl /= lr;
+ if(sl != 2){
+ lrc = 207;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ur = 2;
+ sl /= ur;
+ if(sl != 2){
+ lrc = 208;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; fr = 2;
+ sl /= fr;
+ if(sl != 2){
+ lrc = 209;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; dr = 2;
+ sl /= dr;
+ if(sl != 2){
+ lrc = 210;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; cr = 2;
+ il /= cr;
+ if(il != 2){
+ lrc = 211;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; sr = 2;
+ il /= sr;
+ if(il != 2){
+ lrc = 212;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ir = 2;
+ il /= ir;
+ if(il != 2){
+ lrc = 213;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; lr = 2;
+ il /= lr;
+ if(il != 2){
+ lrc = 214;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ur = 2;
+ il /= ur;
+ if(il != 2){
+ lrc = 215;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; fr = 2;
+ il /= fr;
+ if(il != 2){
+ lrc = 216;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; dr = 2;
+ il /= dr;
+ if(il != 2){
+ lrc = 217;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; cr = 2;
+ ll /= cr;
+ if(ll != 2){
+ lrc = 218;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; sr = 2;
+ ll /= sr;
+ if(ll != 2){
+ lrc = 219;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ir = 2;
+ ll /= ir;
+ if(ll != 2){
+ lrc = 220;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; lr = 2;
+ ll /= lr;
+ if(ll != 2){
+ lrc = 221;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ur = 2;
+ ll /= ur;
+ if(ll != 2){
+ lrc = 222;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; fr = 2;
+ ll /= fr;
+ if(ll != 2){
+ lrc = 223;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; dr = 2;
+ ll /= dr;
+ if(ll != 2){
+ lrc = 224;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; cr = 2;
+ ul /= cr;
+ if(ul != 2){
+ lrc = 225;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; sr = 2;
+ ul /= sr;
+ if(ul != 2){
+ lrc = 226;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ir = 2;
+ ul /= ir;
+ if(ul != 2){
+ lrc = 227;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; lr = 2;
+ ul /= lr;
+ if(ul != 2){
+ lrc = 228;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ur = 2;
+ ul /= ur;
+ if(ul != 2){
+ lrc = 229;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; fr = 2;
+ ul /= fr;
+ if(ul != 2){
+ lrc = 230;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; dr = 2;
+ ul /= dr;
+ if(ul != 2){
+ lrc = 231;
+ if(prlc) printf(f,lrc);
+ }
+
+ #ifdef NO_FLOATS
+ fl = 5; cr = 2;
+ fl /= cr;
+ if(fl != 2){
+ lrc = 232;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; sr = 2;
+ fl /= sr;
+ if(fl != 2){
+ lrc = 233;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ir = 2;
+ fl /= ir;
+ if(fl != 2){
+ lrc = 234;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; lr = 2;
+ fl /= lr;
+ if(fl != 2){
+ lrc = 235;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ur = 2;
+ fl /= ur;
+ if(fl != 2){
+ lrc = 236;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; fr = 2;
+ fl /= fr;
+ if(fl != 2){
+ lrc = 237;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; dr = 2;
+ fl /= dr;
+ if(fl != 2){
+ lrc = 238;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; cr = 2;
+ dl /= cr;
+ if(dl != 2){
+ lrc = 239;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; sr = 2;
+ dl /= sr;
+ if(dl != 2){
+ lrc = 240;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ir = 2;
+ dl /= ir;
+ if(dl != 2){
+ lrc = 241;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; lr = 2;
+ dl /= lr;
+ if(dl != 2){
+ lrc = 242;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ur = 2;
+ dl /= ur;
+ if(dl != 2){
+ lrc = 243;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; fr = 2;
+ dl /= fr;
+ if(dl != 2){
+ lrc = 244;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; dr = 2;
+ dl /= dr;
+ if(dl != 2){
+ lrc = 245;
+ if(prlc) printf(f,lrc);
+ }
+ #else
+ fl = 5; cr = 2;
+ fl /= cr;
+ if(fl != 2.5){
+ lrc = 232;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; sr = 2;
+ fl /= sr;
+ if(fl != 2.5){
+ lrc = 233;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ir = 2;
+ fl /= ir;
+ if(fl != 2.5){
+ lrc = 234;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; lr = 2;
+ fl /= lr;
+ if(fl != 2.5){
+ lrc = 235;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; ur = 2;
+ fl /= ur;
+ if(fl != 2.5){
+ lrc = 236;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; fr = 2;
+ fl /= fr;
+ if(fl != 2.5){
+ lrc = 237;
+ if(prlc) printf(f,lrc);
+ }
+ fl = 5; dr = 2;
+ fl /= dr;
+ if(fl != 2.5){
+ lrc = 238;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; cr = 2;
+ dl /= cr;
+ if(dl != 2.5){
+ lrc = 239;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; sr = 2;
+ dl /= sr;
+ if(dl != 2.5){
+ lrc = 240;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ir = 2;
+ dl /= ir;
+ if(dl != 2.5){
+ lrc = 241;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; lr = 2;
+ dl /= lr;
+ if(dl != 2.5){
+ lrc = 242;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; ur = 2;
+ dl /= ur;
+ if(dl != 2.5){
+ lrc = 243;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; fr = 2;
+ dl /= fr;
+ if(dl != 2.5){
+ lrc = 244;
+ if(prlc) printf(f,lrc);
+ }
+ dl = 5; dr = 2;
+ dl /= dr;
+ if(dl != 2.5){
+ lrc = 245;
+ if(prlc) printf(f,lrc);
+ }
+ #endif
+ cl = 5; cr = 2;
+ cl %= cr;
+ if(cl != 1){
+ lrc = 246;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; sr = 2;
+ cl %= sr;
+ if(cl != 1){
+ lrc = 247;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ir = 2;
+ cl %= ir;
+ if(cl != 1){
+ lrc = 248;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; lr = 2;
+ cl %= lr;
+ if(cl != 1){
+ lrc = 249;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ur = 2;
+ cl %= ur;
+ if(cl != 1){
+ lrc = 250;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; cr = 2;
+ sl %= cr;
+ if(sl != 1){
+ lrc = 251;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; sr = 2;
+ sl %= sr;
+ if(sl != 1){
+ lrc = 252;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ir = 2;
+ sl %= ir;
+ if(sl != 1){
+ lrc = 253;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; lr = 2;
+ sl %= lr;
+ if(sl != 1){
+ lrc = 254;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ur = 2;
+ sl %= ur;
+ if(sl != 1){
+ lrc = 255;
+ if(prlc) printf(f,lrc);
+ }
+
+ if(lrc != 0) {
+ rc = 1;
+ if(pd0->flgd != 0) printf(s714er,1);
+ }
+ return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s714(pd0);
+ }
+}
+
+#define cq_sections 1
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 9: Statements
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+#ifndef NO_OLD_FUNC_DECL
+s714(pd0) /* 7.14 Assignment operators */
+struct defs *pd0;
+{
+#else
+int s714(struct defs *pd0){
+#endif
+ static char f[] = "Local error %d.\n";
+ static char s714er[] = "s714,er%d\n";
+ static char qs714[8] = "s714 ";
+ register int prlc, lrc;
+ int rc;
+ char cl, cr;
+ short sl, sr;
+ int il, ir;
+ long ll, lr;
+ unsigned ul, ur;
+ #ifndef NO_FLOATS
+ float fl, fr;
+ double dl, dr;
+ #else
+ signed fl, fr;
+ signed dl, dr;
+ #endif
+ char *ps, *pt;
+ ps = qs714;
+ pt = pd0->rfs;
+ rc = 0;
+ lrc = 0;
+ prlc = pd0->flgl;
+ while (*pt++ = *ps++);
+
+ /* This section tests the assignment operators.
+
+ It is an exhaustive test of all assignment statements
+ of the form:
+
+ vl op vr
+
+ where vl and vr are variables from the set
+ {char,short,int,long,unsigned,float,double} and op is
+ one of the assignment operators. There are 395 such
+ statements.
+
+ The initial values for the variables have been chosen
+ so that both the initial values and the results will
+ "fit" in just about any implementation, and that the re-
+ sults will be such that they test for the proper form-
+ ation of composite operators, rather than checking for
+ the valid operation of those operators' components.
+ For example, in checking >>=, we want to verify that
+ a right shift and a move take place, rather than
+ whether or not there may be some peculiarities about
+ the right shift. Such tests have been made previously,
+ and to repeat them here would be to throw out a red
+ herring.
+
+ The table below lists the operators, assignment targets,
+ initial values for left and right operands, and the
+ expected values of the results.
+
+ = += -= *= /= %= >>= <<= &= ^= |=
+char 2 7 3 10 2 1 1 20 8 6 14
+short 2 7 3 10 2 1 1 20 8 6 14
+int 2 7 3 10 2 1 1 20 8 6 14
+long 2 7 3 10 2 1 1 20 8 6 14
+unsigned 2 7 3 10 2 1 1 20 8 6 14
+float 2 7 3 10 2.5 | |
+double 2 7 3 10 2.5 | |
+ | |
+initial (5,2) | (5,2) | (12,10)
+
+ The following machine-generated program reflects the
+ tests described in the table.
+ */
+
+ il = 5; cr = 2;
+ il %= cr;
+ if(il != 1){
+ lrc = 256;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; sr = 2;
+ il %= sr;
+ if(il != 1){
+ lrc = 257;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ir = 2;
+ il %= ir;
+ if(il != 1){
+ lrc = 258;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; lr = 2;
+ il %= lr;
+ if(il != 1){
+ lrc = 259;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ur = 2;
+ il %= ur;
+ if(il != 1){
+ lrc = 260;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; cr = 2;
+ ll %= cr;
+ if(ll != 1){
+ lrc = 261;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; sr = 2;
+ ll %= sr;
+ if(ll != 1){
+ lrc = 262;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ir = 2;
+ ll %= ir;
+ if(ll != 1){
+ lrc = 263;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; lr = 2;
+ ll %= lr;
+ if(ll != 1){
+ lrc = 264;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ur = 2;
+ ll %= ur;
+ if(ll != 1){
+ lrc = 265;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; cr = 2;
+ ul %= cr;
+ if(ul != 1){
+ lrc = 266;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; sr = 2;
+ ul %= sr;
+ if(ul != 1){
+ lrc = 267;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ir = 2;
+ ul %= ir;
+ if(ul != 1){
+ lrc = 268;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; lr = 2;
+ ul %= lr;
+ if(ul != 1){
+ lrc = 269;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ur = 2;
+ ul %= ur;
+ if(ul != 1){
+ lrc = 270;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; cr = 2;
+ cl >>= cr;
+ if(cl != 1){
+ lrc = 271;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; sr = 2;
+ cl >>= sr;
+ if(cl != 1){
+ lrc = 272;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ir = 2;
+ cl >>= ir;
+ if(cl != 1){
+ lrc = 273;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; lr = 2;
+ cl >>= lr;
+ if(cl != 1){
+ lrc = 274;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ur = 2;
+ cl >>= ur;
+ if(cl != 1){
+ lrc = 275;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; cr = 2;
+ sl >>= cr;
+ if(sl != 1){
+ lrc = 276;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; sr = 2;
+ sl >>= sr;
+ if(sl != 1){
+ lrc = 277;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ir = 2;
+ sl >>= ir;
+ if(sl != 1){
+ lrc = 278;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; lr = 2;
+ sl >>= lr;
+ if(sl != 1){
+ lrc = 279;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ur = 2;
+ sl >>= ur;
+ if(sl != 1){
+ lrc = 280;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; cr = 2;
+ il >>= cr;
+ if(il != 1){
+ lrc = 281;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; sr = 2;
+ il >>= sr;
+ if(il != 1){
+ lrc = 282;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ir = 2;
+ il >>= ir;
+ if(il != 1){
+ lrc = 283;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; lr = 2;
+ il >>= lr;
+ if(il != 1){
+ lrc = 284;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ur = 2;
+ il >>= ur;
+ if(il != 1){
+ lrc = 285;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; cr = 2;
+ ll >>= cr;
+ if(ll != 1){
+ lrc = 286;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; sr = 2;
+ ll >>= sr;
+ if(ll != 1){
+ lrc = 287;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ir = 2;
+ ll >>= ir;
+ if(ll != 1){
+ lrc = 288;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; lr = 2;
+ ll >>= lr;
+ if(ll != 1){
+ lrc = 289;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ur = 2;
+ ll >>= ur;
+ if(ll != 1){
+ lrc = 290;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; cr = 2;
+ ul >>= cr;
+ if(ul != 1){
+ lrc = 291;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; sr = 2;
+ ul >>= sr;
+ if(ul != 1){
+ lrc = 292;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ir = 2;
+ ul >>= ir;
+ if(ul != 1){
+ lrc = 293;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; lr = 2;
+ ul >>= lr;
+ if(ul != 1){
+ lrc = 294;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ur = 2;
+ ul >>= ur;
+ if(ul != 1){
+ lrc = 295;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; cr = 2;
+ cl <<= cr;
+ if(cl != 20){
+ lrc = 296;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; sr = 2;
+ cl <<= sr;
+ if(cl != 20){
+ lrc = 297;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ir = 2;
+ cl <<= ir;
+ if(cl != 20){
+ lrc = 298;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; lr = 2;
+ cl <<= lr;
+ if(cl != 20){
+ lrc = 299;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 5; ur = 2;
+ cl <<= ur;
+ if(cl != 20){
+ lrc = 300;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; cr = 2;
+ sl <<= cr;
+ if(sl != 20){
+ lrc = 301;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; sr = 2;
+ sl <<= sr;
+ if(sl != 20){
+ lrc = 302;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ir = 2;
+ sl <<= ir;
+ if(sl != 20){
+ lrc = 303;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; lr = 2;
+ sl <<= lr;
+ if(sl != 20){
+ lrc = 304;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 5; ur = 2;
+ sl <<= ur;
+ if(sl != 20){
+ lrc = 305;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; cr = 2;
+ il <<= cr;
+ if(il != 20){
+ lrc = 306;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; sr = 2;
+ il <<= sr;
+ if(il != 20){
+ lrc = 307;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ir = 2;
+ il <<= ir;
+ if(il != 20){
+ lrc = 308;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; lr = 2;
+ il <<= lr;
+ if(il != 20){
+ lrc = 309;
+ if(prlc) printf(f,lrc);
+ }
+ il = 5; ur = 2;
+ il <<= ur;
+ if(il != 20){
+ lrc = 310;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; cr = 2;
+ ll <<= cr;
+ if(ll != 20){
+ lrc = 311;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; sr = 2;
+ ll <<= sr;
+ if(ll != 20){
+ lrc = 312;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ir = 2;
+ ll <<= ir;
+ if(ll != 20){
+ lrc = 313;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; lr = 2;
+ ll <<= lr;
+ if(ll != 20){
+ lrc = 314;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 5; ur = 2;
+ ll <<= ur;
+ if(ll != 20){
+ lrc = 315;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; cr = 2;
+ ul <<= cr;
+ if(ul != 20){
+ lrc = 316;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; sr = 2;
+ ul <<= sr;
+ if(ul != 20){
+ lrc = 317;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ir = 2;
+ ul <<= ir;
+ if(ul != 20){
+ lrc = 318;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; lr = 2;
+ ul <<= lr;
+ if(ul != 20){
+ lrc = 319;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 5; ur = 2;
+ ul <<= ur;
+ if(ul != 20){
+ lrc = 320;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 12; cr = 10;
+ cl &= cr;
+ if(cl != 8){
+ lrc = 321;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 12; sr = 10;
+ cl &= sr;
+ if(cl != 8){
+ lrc = 322;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 12; ir = 10;
+ cl &= ir;
+ if(cl != 8){
+ lrc = 323;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 12; lr = 10;
+ cl &= lr;
+ if(cl != 8){
+ lrc = 324;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 12; ur = 10;
+ cl &= ur;
+ if(cl != 8){
+ lrc = 325;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 12; cr = 10;
+ sl &= cr;
+ if(sl != 8){
+ lrc = 326;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 12; sr = 10;
+ sl &= sr;
+ if(sl != 8){
+ lrc = 327;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 12; ir = 10;
+ sl &= ir;
+ if(sl != 8){
+ lrc = 328;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 12; lr = 10;
+ sl &= lr;
+ if(sl != 8){
+ lrc = 329;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 12; ur = 10;
+ sl &= ur;
+ if(sl != 8){
+ lrc = 330;
+ if(prlc) printf(f,lrc);
+ }
+ il = 12; cr = 10;
+ il &= cr;
+ if(il != 8){
+ lrc = 331;
+ if(prlc) printf(f,lrc);
+ }
+ il = 12; sr = 10;
+ il &= sr;
+ if(il != 8){
+ lrc = 332;
+ if(prlc) printf(f,lrc);
+ }
+ il = 12; ir = 10;
+ il &= ir;
+ if(il != 8){
+ lrc = 333;
+ if(prlc) printf(f,lrc);
+ }
+ il = 12; lr = 10;
+ il &= lr;
+ if(il != 8){
+ lrc = 334;
+ if(prlc) printf(f,lrc);
+ }
+ il = 12; ur = 10;
+ il &= ur;
+ if(il != 8){
+ lrc = 335;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 12; cr = 10;
+ ll &= cr;
+ if(ll != 8){
+ lrc = 336;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 12; sr = 10;
+ ll &= sr;
+ if(ll != 8){
+ lrc = 337;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 12; ir = 10;
+ ll &= ir;
+ if(ll != 8){
+ lrc = 338;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 12; lr = 10;
+ ll &= lr;
+ if(ll != 8){
+ lrc = 339;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 12; ur = 10;
+ ll &= ur;
+ if(ll != 8){
+ lrc = 340;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 12; cr = 10;
+ ul &= cr;
+ if(ul != 8){
+ lrc = 341;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 12; sr = 10;
+ ul &= sr;
+ if(ul != 8){
+ lrc = 342;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 12; ir = 10;
+ ul &= ir;
+ if(ul != 8){
+ lrc = 343;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 12; lr = 10;
+ ul &= lr;
+ if(ul != 8){
+ lrc = 344;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 12; ur = 10;
+ ul &= ur;
+ if(ul != 8){
+ lrc = 345;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 12; cr = 10;
+ cl ^= cr;
+ if(cl != 6){
+ lrc = 346;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 12; sr = 10;
+ cl ^= sr;
+ if(cl != 6){
+ lrc = 347;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 12; ir = 10;
+ cl ^= ir;
+ if(cl != 6){
+ lrc = 348;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 12; lr = 10;
+ cl ^= lr;
+ if(cl != 6){
+ lrc = 349;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 12; ur = 10;
+ cl ^= ur;
+ if(cl != 6){
+ lrc = 350;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 12; cr = 10;
+ sl ^= cr;
+ if(sl != 6){
+ lrc = 351;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 12; sr = 10;
+ sl ^= sr;
+ if(sl != 6){
+ lrc = 352;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 12; ir = 10;
+ sl ^= ir;
+ if(sl != 6){
+ lrc = 353;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 12; lr = 10;
+ sl ^= lr;
+ if(sl != 6){
+ lrc = 354;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 12; ur = 10;
+ sl ^= ur;
+ if(sl != 6){
+ lrc = 355;
+ if(prlc) printf(f,lrc);
+ }
+ il = 12; cr = 10;
+ il ^= cr;
+ if(il != 6){
+ lrc = 356;
+ if(prlc) printf(f,lrc);
+ }
+ il = 12; sr = 10;
+ il ^= sr;
+ if(il != 6){
+ lrc = 357;
+ if(prlc) printf(f,lrc);
+ }
+ il = 12; ir = 10;
+ il ^= ir;
+ if(il != 6){
+ lrc = 358;
+ if(prlc) printf(f,lrc);
+ }
+ il = 12; lr = 10;
+ il ^= lr;
+ if(il != 6){
+ lrc = 359;
+ if(prlc) printf(f,lrc);
+ }
+ il = 12; ur = 10;
+ il ^= ur;
+ if(il != 6){
+ lrc = 360;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 12; cr = 10;
+ ll ^= cr;
+ if(ll != 6){
+ lrc = 361;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 12; sr = 10;
+ ll ^= sr;
+ if(ll != 6){
+ lrc = 362;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 12; ir = 10;
+ ll ^= ir;
+ if(ll != 6){
+ lrc = 363;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 12; lr = 10;
+ ll ^= lr;
+ if(ll != 6){
+ lrc = 364;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 12; ur = 10;
+ ll ^= ur;
+ if(ll != 6){
+ lrc = 365;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 12; cr = 10;
+ ul ^= cr;
+ if(ul != 6){
+ lrc = 366;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 12; sr = 10;
+ ul ^= sr;
+ if(ul != 6){
+ lrc = 367;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 12; ir = 10;
+ ul ^= ir;
+ if(ul != 6){
+ lrc = 368;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 12; lr = 10;
+ ul ^= lr;
+ if(ul != 6){
+ lrc = 369;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 12; ur = 10;
+ ul ^= ur;
+ if(ul != 6){
+ lrc = 370;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 12; cr = 10;
+ cl |= cr;
+ if(cl != 14){
+ lrc = 371;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 12; sr = 10;
+ cl |= sr;
+ if(cl != 14){
+ lrc = 372;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 12; ir = 10;
+ cl |= ir;
+ if(cl != 14){
+ lrc = 373;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 12; lr = 10;
+ cl |= lr;
+ if(cl != 14){
+ lrc = 374;
+ if(prlc) printf(f,lrc);
+ }
+ cl = 12; ur = 10;
+ cl |= ur;
+ if(cl != 14){
+ lrc = 375;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 12; cr = 10;
+ sl |= cr;
+ if(sl != 14){
+ lrc = 376;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 12; sr = 10;
+ sl |= sr;
+ if(sl != 14){
+ lrc = 377;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 12; ir = 10;
+ sl |= ir;
+ if(sl != 14){
+ lrc = 378;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 12; lr = 10;
+ sl |= lr;
+ if(sl != 14){
+ lrc = 379;
+ if(prlc) printf(f,lrc);
+ }
+ sl = 12; ur = 10;
+ sl |= ur;
+ if(sl != 14){
+ lrc = 380;
+ if(prlc) printf(f,lrc);
+ }
+ il = 12; cr = 10;
+ il |= cr;
+ if(il != 14){
+ lrc = 381;
+ if(prlc) printf(f,lrc);
+ }
+ il = 12; sr = 10;
+ il |= sr;
+ if(il != 14){
+ lrc = 382;
+ if(prlc) printf(f,lrc);
+ }
+ il = 12; ir = 10;
+ il |= ir;
+ if(il != 14){
+ lrc = 383;
+ if(prlc) printf(f,lrc);
+ }
+ il = 12; lr = 10;
+ il |= lr;
+ if(il != 14){
+ lrc = 384;
+ if(prlc) printf(f,lrc);
+ }
+ il = 12; ur = 10;
+ il |= ur;
+ if(il != 14){
+ lrc = 385;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 12; cr = 10;
+ ll |= cr;
+ if(ll != 14){
+ lrc = 386;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 12; sr = 10;
+ ll |= sr;
+ if(ll != 14){
+ lrc = 387;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 12; ir = 10;
+ ll |= ir;
+ if(ll != 14){
+ lrc = 388;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 12; lr = 10;
+ ll |= lr;
+ if(ll != 14){
+ lrc = 389;
+ if(prlc) printf(f,lrc);
+ }
+ ll = 12; ur = 10;
+ ll |= ur;
+ if(ll != 14){
+ lrc = 390;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 12; cr = 10;
+ ul |= cr;
+ if(ul != 14){
+ lrc = 391;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 12; sr = 10;
+ ul |= sr;
+ if(ul != 14){
+ lrc = 392;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 12; ir = 10;
+ ul |= ir;
+ if(ul != 14){
+ lrc = 393;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 12; lr = 10;
+ ul |= lr;
+ if(ul != 14){
+ lrc = 394;
+ if(prlc) printf(f,lrc);
+ }
+ ul = 12; ur = 10;
+ ul |= ur;
+ if(ul != 14){
+ lrc = 395;
+ if(prlc) printf(f,lrc);
+ }
+ if(lrc != 0) {
+ rc = 1;
+ if(pd0->flgd != 0) printf(s714er,1);
+ }
+ return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s714(pd0);
+ }
+}
+
+#define cq_sections 1
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 7.15: Comma operator
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+/*#include "cq26.c"*/ /* hardware check */
+#ifdef NO_IMPLICIT_FUNC_PROTOTYPES
+s715f(int x,int y,int z);
+#endif
+
+#ifndef NO_OLD_FUNC_DECL
+s715(pd0) /* 7.15 Comma operator */
+struct defs *pd0;
+{
+#else
+int s715(struct defs *pd0) {
+#endif
+ static char s715er[] = "s715,er%d\n";
+ static char qs715[8] = "s715 ";
+ int rc;
+ char *ps, *pt;
+ int a, t, c, i;
+ a = c = 0;
+ ps = qs715;
+ pt = pd0->rfs;
+ rc = 0;
+ while (*pt++ = *ps++);
+
+ /* A pair of expressions separated by a comma is
+ evaluated left to right and the value of the left
+ expression is discarded.
+ */
+ i = 1;
+ if( i++,i++,i++,i++,++i != 6 ){
+ if(pd0->flgd != 0) printf(s715er,1);
+ rc = rc+1;
+ }
+
+ /* In contexts where the comma is given a special mean-
+ ing, for example in a list of actual arguments to
+ functions (sic) and lists of initializers, the comma
+ operator as described in this section can only appear
+ in parentheses; for example
+
+ f( a, (t=3, t+2), c)
+
+ has three arguments, the second of which has the
+ value 5.
+ */
+
+ if(s715f(a, (t=3, t+2), c) != 5){
+ if(pd0->flgd != 0) printf(s715er,2);
+ rc = rc+2;
+ }
+ return rc;
+}
+s715f(x,y,z)
+int x, y, z;
+{
+ return y;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ /*case 0: return s26(pd0);*/
+ case 0: return s715(pd0);
+ }
+}
+
+#define cq_sections 1
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 7.2: Unary Operators
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+#define CQ26_INCLUDED
+/*
+ section s26, which pokes around at the hardware
+ trying to figure out the characteristics of the machine that
+ it is running on, saves information that is subsequently
+ used by sections s626, s72, and s757. If this program is
+ to be broken up into smallish pieces, say for running on
+ a microcomputer, take care to see that s26 is called before
+ calling any of the latter three sections.
+*/
+
+/*
+ 2.6 Hardware Characteristics
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+s26(pd0)
+struct defs *pd0;
+{
+#else
+s26(struct defs *pd0) {
+#endif
+ static char qs26[8] = "s26 ";
+ char *ps, *pt;
+ char c0, c1;
+ #ifndef NO_FLOATS
+ float temp, one, delta;
+ double tempd, oned;
+ #endif
+ static char s[] = "%3d bits in %ss.\n";
+ static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
+
+ ps = qs26;
+ pt = pd0->rfs;
+
+ while(*pt++ = *ps++);
+
+ /* Here, we shake the machinery a little to see what falls
+ out. First, we find out how many bits are in a char. */
+
+ pd0->cbits = 0;
+ c0 = 0;
+ c1 = 1;
+
+ while(c0 != c1) {
+ c1 = c1<<1;
+ pd0->cbits = pd0->cbits+1;
+ }
+ /* That information lets us determine the size of everything else. */
+
+ pd0->ibits = pd0->cbits * sizeof(int);
+ pd0->sbits = pd0->cbits * sizeof(short);
+ pd0->lbits = pd0->cbits * sizeof(long);
+ pd0->ubits = pd0->cbits * sizeof(unsigned);
+ #ifndef NO_FLOATS
+ pd0->fbits = pd0->cbits * sizeof(float);
+ pd0->dbits = pd0->cbits * sizeof(double);
+ #endif
+
+ /* We have now almost reconstructed the table in section 2.6, the
+ exception being the range of the floating point hardware.
+ Now there are just so many ways to conjure up a floating point
+ representation system that it's damned near impossible to guess
+ what's going on by writing a program to interpret bit patterns.
+ Further, the information isn't all that useful, if we consider
+ the fact that machines that won't handle numbers between 10**30
+ and 10**-30 are very hard to find, and that people playing with
+ numbers outside that range have a lot more to worry about than
+ just the capacity of the characteristic.
+
+ A much more useful measure is the precision, which can be ex-
+ pressed in terms of the smallest number that can be added to
+ 1. without loss of significance. We calculate that here, for
+ float and double. */
+
+#ifndef NO_FLOATS
+ one = 1.;
+ delta = 1.;
+ temp = 0.;
+ while(temp != one) {
+ temp = one+delta;
+ delta = delta/2.;
+ }
+ pd0->fprec = delta * 4.;
+ oned = 1.;
+ delta = 1.;
+ tempd = 0.;
+ while(tempd != oned) {
+ tempd = oned+delta;
+ delta = delta/2.;
+ }
+ pd0->dprec = delta * 4.;
+#endif
+
+ /* Now, if anyone's interested, we publish the results. */
+
+#ifndef CQ26_INCLUDED
+ if(pd0->flgm != 0) {
+ printf(s,pd0->cbits,"char");
+ printf(s,pd0->ibits,"int");
+ printf(s,pd0->sbits,"short");
+ printf(s,pd0->lbits,"long");
+ printf(s,pd0->ubits,"unsigned");
+ printf(s,pd0->fbits,"float");
+ printf(s,pd0->dbits,"double");
+ #ifndef NO_FLOATS
+ printf(s2,pd0->fprec,"float");
+ printf(s2,pd0->dprec,"double");
+ #else
+ printf("NO_FLOATS\n");
+ #endif
+ }
+#endif
+ /* Since we are only exploring and perhaps reporting, but not
+ testing any features, we cannot return an error code. */
+
+ return 0;
+}
+
+#ifndef NO_OLD_FUNC_DECL
+s72(pd0) /* 7.2 Unary operators */
+struct defs *pd0;
+{
+#else
+int s72(struct defs *pd0){
+#endif
+ static char s72er[] = "s72,er%d\n";
+ static char qs72[8] = "s72 ";
+ int rc;
+ char *ps, *pt;
+ int k, j, i, lrc;
+ char c;
+ short s;
+ long l;
+ unsigned u;
+
+ #ifndef NO_FLOATS
+ double d;
+ float f;
+ #else
+ signed d;
+ signed f;
+ #endif
+
+ ps = qs72;
+ pt = pd0->rfs;
+ rc = 0;
+ while (*pt++ = *ps++);
+
+ /* The *, denoting indirection, and the &, denoting a
+ pointer, are duals of each other, and ought to behave as
+ such... */
+
+ k = 2;
+ if(*&*&k != 2){
+ rc = rc+1;
+ printf(s72er,1);
+ }
+
+ /* The unary minus has the conventional meaning. */
+
+ if(k+(-k) != 0){
+ rc = rc+2;
+ printf(s72er,2);
+ }
+
+ /* The negation operator (!) has been thoroughly checked out,
+ perhaps more thoroughly than any of the others. The ~ oper-
+ ator gets us a ones complement. */
+
+ k = 0;
+ for(j=0;j<pd0->ibits;j++) k = (k<<1)|1;
+ if(~k != 0){
+ rc = rc+4;
+ printf(s72er,4);
+ }
+
+ /* Now we look at the ++ and -- operators, which can be
+ used in either prefix or suffix form. With side
+ effects they're loaded. */
+
+ k = 5;
+
+ if( ++k != 6 || --k != 5
+ || k++ != 5 || k-- != 6
+ || k != 5 ){
+ rc = rc+8;
+ printf(s72er,8);
+ }
+
+ /* An expression preceded by the parenthesised name of a
+ data type causes conversion of the value of the expression
+ to the named type. This construction is called a cast.
+ Here, we check to see that all of the possible casts and
+ their simple combinations are accepted by the compiler,
+ and that they all produce a correct result for this sample
+ of size one. */
+
+ c = 26; l = 26;
+ s = 26; u = 26;
+ i = 26;
+ #ifndef NO_FLOATS
+ f = 26.;
+ d = 26.;
+ #else
+ f = 26;
+ d = 26;
+ #endif
+
+ lrc = 0;
+
+ if( (char)s != 26 || (char)i != 26
+ || (char)l != 26 || (char)u != 26
+ || (char)f != 26 || (char)d != 26 ) lrc = lrc+1;
+
+ if( (short)c != 26 || (short)i != 26
+ || (short)l != 26 || (short)u != 26
+ || (short)f != 26 || (short)d != 26) lrc = lrc+2;
+
+ if( (int)c != 26 || (int)s != 26
+ || (int)l != 26 || (int)u != 26
+ || (int)f != 26 || (int)d != 26 ) lrc = lrc+4;
+
+ if( (long)c != 26 || (long)s != 26
+ || (long)i != 26 || (long)u != 26
+ || (long)f != 26 || (long)d != 26 ) lrc = lrc+8;
+
+ if( (unsigned)c != 26 || (unsigned)s != 26
+ || (unsigned)i != 26 || (unsigned)l != 26
+ || (unsigned)f != 26 || (unsigned)d != 26 ) lrc = lrc+16;
+
+ #ifndef NO_FLOATS
+ if( (float)c != 26. || (float)s != 26.
+ || (float)i != 26. || (float)l != 26.
+ || (float)u != 26. || (float)d != 26. ) lrc = lrc+32;
+
+ if( (double)c != 26. || (double)s != 26.
+ || (double)i != 26. || (double)l != 26.
+ || (double)u != 26. || (double)f != 26. ) lrc = lrc+64;
+ #endif
+
+ if(lrc != 0){
+ rc = rc+16;
+ printf(s72er,16);
+ }
+
+ /* The sizeof operator has been tested previously. */
+
+ return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s26(pd0);
+ case 1: return s72(pd0);
+ }
+}
+
+#define cq_sections 2
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 7.5: Shift operators, 7.6 Relational operators, 7.7 Equality operator
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+#define CQ26_INCLUDED
+/*
+ section s26, which pokes around at the hardware
+ trying to figure out the characteristics of the machine that
+ it is running on, saves information that is subsequently
+ used by sections s626, s72, and s757. If this program is
+ to be broken up into smallish pieces, say for running on
+ a microcomputer, take care to see that s26 is called before
+ calling any of the latter three sections.
+*/
+
+/*
+ 2.6 Hardware Characteristics
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+s26(pd0)
+struct defs *pd0;
+{
+#else
+s26(struct defs *pd0) {
+#endif
+ static char qs26[8] = "s26 ";
+ char *ps, *pt;
+ char c0, c1;
+ #ifndef NO_FLOATS
+ float temp, one, delta;
+ double tempd, oned;
+ #endif
+ static char s[] = "%3d bits in %ss.\n";
+ static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
+
+ ps = qs26;
+ pt = pd0->rfs;
+
+ while(*pt++ = *ps++);
+
+ /* Here, we shake the machinery a little to see what falls
+ out. First, we find out how many bits are in a char. */
+
+ pd0->cbits = 0;
+ c0 = 0;
+ c1 = 1;
+
+ while(c0 != c1) {
+ c1 = c1<<1;
+ pd0->cbits = pd0->cbits+1;
+ }
+ /* That information lets us determine the size of everything else. */
+
+ pd0->ibits = pd0->cbits * sizeof(int);
+ pd0->sbits = pd0->cbits * sizeof(short);
+ pd0->lbits = pd0->cbits * sizeof(long);
+ pd0->ubits = pd0->cbits * sizeof(unsigned);
+ #ifndef NO_FLOATS
+ pd0->fbits = pd0->cbits * sizeof(float);
+ pd0->dbits = pd0->cbits * sizeof(double);
+ #endif
+
+ /* We have now almost reconstructed the table in section 2.6, the
+ exception being the range of the floating point hardware.
+ Now there are just so many ways to conjure up a floating point
+ representation system that it's damned near impossible to guess
+ what's going on by writing a program to interpret bit patterns.
+ Further, the information isn't all that useful, if we consider
+ the fact that machines that won't handle numbers between 10**30
+ and 10**-30 are very hard to find, and that people playing with
+ numbers outside that range have a lot more to worry about than
+ just the capacity of the characteristic.
+
+ A much more useful measure is the precision, which can be ex-
+ pressed in terms of the smallest number that can be added to
+ 1. without loss of significance. We calculate that here, for
+ float and double. */
+
+#ifndef NO_FLOATS
+ one = 1.;
+ delta = 1.;
+ temp = 0.;
+ while(temp != one) {
+ temp = one+delta;
+ delta = delta/2.;
+ }
+ pd0->fprec = delta * 4.;
+ oned = 1.;
+ delta = 1.;
+ tempd = 0.;
+ while(tempd != oned) {
+ tempd = oned+delta;
+ delta = delta/2.;
+ }
+ pd0->dprec = delta * 4.;
+#endif
+
+ /* Now, if anyone's interested, we publish the results. */
+
+#ifndef CQ26_INCLUDED
+ if(pd0->flgm != 0) {
+ printf(s,pd0->cbits,"char");
+ printf(s,pd0->ibits,"int");
+ printf(s,pd0->sbits,"short");
+ printf(s,pd0->lbits,"long");
+ printf(s,pd0->ubits,"unsigned");
+ printf(s,pd0->fbits,"float");
+ printf(s,pd0->dbits,"double");
+ #ifndef NO_FLOATS
+ printf(s2,pd0->fprec,"float");
+ printf(s2,pd0->dprec,"double");
+ #else
+ printf("NO_FLOATS\n");
+ #endif
+ }
+#endif
+ /* Since we are only exploring and perhaps reporting, but not
+ testing any features, we cannot return an error code. */
+
+ return 0;
+}
+
+#ifndef NO_OLD_FUNC_DECL
+s757(pd0) /* 7.5 Shift operators */
+ /* 7.6 Relational operators */
+ /* 7.7 Equality operator */
+struct defs *pd0;
+{
+#else
+int s757(struct defs *pd0){
+#endif
+ static char s757er[] = "s757,er%d\n";
+ static char qs757[8] = "s757 ";
+ int rc;
+ char *ps, *pt;
+ int t,lrc,k,j,a,b,c,d,x[16],*p;
+ unsigned rs, ls, rt, lt;
+ ps = qs757;
+ pt = pd0->rfs;
+ rc = 0;
+ while (*pt++ = *ps++);
+
+ /* The shift operators << and >> group left-to-right.
+ */
+
+ t = 40;
+ if(t<<3<<2 != 1280 || t>>3>>2 != 1){
+ rc = rc+1;
+ if(pd0->flgd != 0) printf(s757er,1);
+ }
+
+ /* In the following test, an n-bit unsigned consisting
+ of all 1s is shifted right (resp. left) k bits, 0<=k<n.
+ We expect to find k 0s followed by n-k 1s (resp. n-k 1s
+ followed by k 0s). If not, we complain.
+ */
+
+ lrc = 0;
+ for(k=0; k<pd0->ubits; k++){
+ rs = 1;
+ ls = rs<<(pd0->ubits-1);
+
+ rt = 0;
+ lt = ~rt>>k;
+ rt = ~rt<<k;
+
+ for(j=0; j<pd0->ubits;j++){
+ if((j<k) != ((rs&rt) == 0) || (j<k) != ((ls<) == 0)) lrc = 1;
+ rs = rs<<1;
+ ls = ls>>1;
+ }
+ }
+
+ if(lrc != 0){
+ rc = rc+2;
+ if(pd0->flgd != 0) printf(s757er,2);
+ }
+
+ /* The relational operators group left-to-right, but this
+ fact is not very useful; a<b<c does not mean what it
+ seems to...
+ */
+
+ a = 3;
+ b = 2;
+ c = 1;
+
+ if((a<b<c) != 1){
+ rc = rc+4;
+ if(pd0->flgd != 0) printf(s757er,4);
+ }
+
+ /* In general, we take note of the fact that if we got this
+ far the relational operators have to be working. We test only
+ that two pointers may be compared; the result depends on
+ the relative locations in the address space of the
+ pointed-to objects.
+ */
+ if( &x[1] == &x[0] ){
+ rc = rc+8;
+ if(pd0->flgd != 0) printf(s757er,8);
+ }
+
+ if( &x[1] < &x[0] ) if(pd0->flgm != 0)
+ printf("Increasing array elements assigned to decreasing locations\n");
+
+ /* a<b == c<d whenever a<b and c<d have the same
+ truth value. */
+
+ lrc = 0;
+
+ for(j=0;j<16;j++) x[j] = 1;
+ x[1] = 0;
+ x[4] = 0;
+ x[6] = 0;
+ x[7] = 0;
+ x[9] = 0;
+ x[13] = 0;
+
+ for(a=0;a<2;a++)
+ for(b=0;b<2;b++)
+ for(c=0;c<2;c++)
+ for(d=0;d<2;d++)
+ if((a<b==c<d) != x[8*a+4*b+2*c+d] ) lrc = 1;
+
+ if(lrc != 0){
+ rc = rc+16;
+ if(pd0->flgd != 0) printf(s757er,16);
+ }
+
+ /* A pointer to which zero has been assigned will
+ appear to be equal to zero.
+ */
+
+ p = 0;
+
+ if(p != 0){
+ rc = rc+32;
+ if(pd0->flgd != 0) printf(s757er,32);
+ }
+
+ return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s26(pd0);
+ case 1: return s757(pd0);
+ }
+}
+
+#define cq_sections 2
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 7.8: Bitwise AND operator, 7.9 Bitwise OR operator, 7.10 Bitwise exclusive OR operator, 7.11 Logical AND operator, 7.12 Logical OR operator, 7.13 Conditional operator
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+#ifndef NO_OLD_FUNC_DECL
+s7813(pd0) /* 7.8 Bitwise AND operator
+ 7.9 Bitwise OR operator
+ 7.10 Bitwise exclusive OR operator
+ 7.11 Logical AND operator
+ 7.12 Logical OR operator
+ 7.13 Conditional operator */
+struct defs *pd0;
+{
+#else
+int s7813(struct defs *pd0){
+#endif
+ register int prlc, lrc;
+ int i, j, r, zero, one;
+ static char fl[] = "Local error %d.\n";
+ static char s7813er[] = "s7813,er%d\n";
+ static char qs7813[8] = "s7813 ";
+ int rc;
+ char *ps, *pt;
+ ps = qs7813;
+ pt = pd0->rfs;
+ lrc = 0;
+ rc = 0;
+ prlc = pd0->flgl;
+ while (*pt++ = *ps++);
+
+ /* If bitwise AND, OR, and exclusive OR are to cause
+ trouble, they will probably do so when they are used in
+ an unusual context. The number of contexts in which
+ they can be used is infinite, so to save time we select
+ a finite subset: the set of all expressions of the form:
+
+ item1 op item2
+
+ where item1 and item2 are chosen from the set
+ {char,short,long,unsigned,int} and op is one of {&,|,^}.
+ We will use 12 and 10 as values for the items, as these
+ values will fit into all data types on just about any
+ imaginable machine, and the results after performing the
+ bitwise operations on them are distinct for each operation,
+ i.e.,
+
+ 12 | 10 -> 1100 | 1010 -> 1110 -> 14
+ 12 ^ 10 -> 1100 ^ 1010 -> 0110 -> 6
+ 12 & 10 -> 1100 & 1010 -> 1000 -> 8
+
+ There are 75 such combinations:
+ */
+
+ if(((char)12 & (char)10) != 8) {lrc = 1;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 | (char)10) != 14) {lrc = 2;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 ^ (char)10) != 6) {lrc = 3;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 & (short)10) != 8) {lrc = 4;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 | (short)10) != 14) {lrc = 5;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 ^ (short)10) != 6) {lrc = 6;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 & (long)10) != 8) {lrc = 7;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 | (long)10) != 14) {lrc = 8;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 ^ (long)10) != 6) {lrc = 9;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 & (unsigned)10) != 8) {lrc = 10;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 | (unsigned)10) != 14) {lrc = 11;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 ^ (unsigned)10) != 6) {lrc = 12;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 & (int)10) != 8) {lrc = 13;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 | (int)10) != 14) {lrc = 14;
+ if(prlc) printf(fl,lrc);}
+ if(((char)12 ^ (int)10) != 6) {lrc = 15;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 & (char)10) != 8) {lrc = 16;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 | (char)10) != 14) {lrc = 17;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 ^ (char)10) != 6) {lrc = 18;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 & (short)10) != 8) {lrc = 16;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 | (short)10) != 14) {lrc = 20;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 ^ (short)10) != 6) {lrc = 21;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 & (long)10) != 8) {lrc = 22;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 | (long)10) != 14) {lrc = 23;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 ^ (long)10) != 6) {lrc = 24;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 & (unsigned)10) != 8) {lrc = 25;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 | (unsigned)10) != 14) {lrc = 26;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 ^ (unsigned)10) != 6) {lrc = 27;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 & (int)10) != 8) {lrc = 28;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 | (int)10) != 14) {lrc = 26;
+ if(prlc) printf(fl,lrc);}
+ if(((short)12 ^ (int)10) != 6) {lrc = 30;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 & (char)10) != 8) {lrc = 31;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 | (char)10) != 14) {lrc = 32;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 ^ (char)10) != 6) {lrc = 33;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 & (short)10) != 8) {lrc = 34;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 | (short)10) != 14) {lrc = 35;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 ^ (short)10) != 6) {lrc = 36;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 & (long)10) != 8) {lrc = 37;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 | (long)10) != 14) {lrc = 38;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 ^ (long)10) != 6) {lrc = 39;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 & (unsigned)10) != 8) {lrc = 40;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 | (unsigned)10) != 14) {lrc = 41;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 ^ (unsigned)10) != 6) {lrc = 42;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 & (int)10) != 8) {lrc = 43;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 | (int)10) != 14) {lrc = 44;
+ if(prlc) printf(fl,lrc);}
+ if(((long)12 ^ (int)10) != 6) {lrc = 45;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 & (char)10) != 8) {lrc = 46;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 | (char)10) != 14) {lrc = 47;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 ^ (char)10) != 6) {lrc = 48;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 & (short)10) != 8) {lrc = 49;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 | (short)10) != 14) {lrc = 50;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 ^ (short)10) != 6) {lrc = 51;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 & (long)10) != 8) {lrc = 52;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 | (long)10) != 14) {lrc = 53;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 ^ (long)10) != 6) {lrc = 54;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 & (unsigned)10) != 8) {lrc = 55;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 | (unsigned)10) != 14) {lrc = 56;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 ^ (unsigned)10) != 6) {lrc = 57;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 & (int)10) != 8) {lrc = 58;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 | (int)10) != 14) {lrc = 56;
+ if(prlc) printf(fl,lrc);}
+ if(((unsigned)12 ^ (int)10) != 6) {lrc = 60;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 & (char)10) != 8) {lrc = 61;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 | (char)10) != 14) {lrc = 62;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 ^ (char)10) != 6) {lrc = 63;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 & (short)10) != 8) {lrc = 64;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 | (short)10) != 14) {lrc = 65;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 ^ (short)10) != 6) {lrc = 66;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 & (long)10) != 8) {lrc = 67;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 | (long)10) != 14) {lrc = 68;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 ^ (long)10) != 6) {lrc = 69;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 & (unsigned)10) != 8) {lrc = 70;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 | (unsigned)10) != 14) {lrc = 71;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 ^ (unsigned)10) != 6) {lrc = 72;
+ if(prlc) printf(fl,lrc);}
+ if(((int)12 & (int)10) != 8) {lrc = 73; if(prlc) printf(fl,lrc);}
+ if(((int)12 | (int)10) != 14) {lrc = 74; if(prlc) printf(fl,lrc);}
+ if(((int)12 ^ (int)10) != 6) {lrc = 75; if(prlc) printf(fl,lrc);}
+
+ if(lrc != 0){
+ if(pd0->flgd != 0) printf(s7813er,1);
+ rc = rc+1;
+ }
+
+ /* The && operator groups left to right. It returns 1
+ if both of the operands are nonzero; 0 otherwise.
+ It guarantees left to right evaluation; moreover, the
+ second operand is not evaluated if the value of the
+ first operand is 0.
+ */
+
+ lrc = 0;
+ i = j = 0;
+
+ r = i++ && j++;
+ if(i!=1) {lrc = 1; if(prlc) printf(fl,lrc);}
+ if(j!=0) {lrc = 2; if(prlc) printf(fl,lrc);}
+ if(r!=0) {lrc = 3; if(prlc) printf(fl,lrc);}
+ r = i && j++;
+ if(i!=1) {lrc = 4; if(prlc) printf(fl,lrc);}
+ if(j!=1) {lrc = 5; if(prlc) printf(fl,lrc);}
+ if(r!=0) {lrc = 6; if(prlc) printf(fl,lrc);}
+ r = i-- && j;
+ if(i!=0) {lrc = 7; if(prlc) printf(fl,lrc);}
+ if(j!=1) {lrc = 8; if(prlc) printf(fl,lrc);}
+ if(r!=1) {lrc = 9; if(prlc) printf(fl,lrc);}
+ r = i && j--;
+ if(i!=0) {lrc = 10; if(prlc) printf(fl,lrc);}
+ if(j!=1) {lrc = 11; if(prlc) printf(fl,lrc);}
+ if(r!=0) {lrc = 12; if(prlc) printf(fl,lrc);}
+
+ if(lrc!=0){
+ if(pd0->flgd != 0) printf(s7813er,2);
+ rc = rc+2;
+ }
+
+ /* The || operator groups left to right. It returns 1
+ if either of its operands is nonzero; 0 otherwise. It
+ guarantees left to right evaluation; moreover, the second
+ operand is not evaluated if the value of the first
+ operand is nonzero.
+ */
+
+ lrc = 0;
+ i = j = 0;
+ r = i++ || j;
+ if(i!=1) {lrc = 1; if(prlc) printf(fl,lrc);}
+ if(j!=0) {lrc = 2; if(prlc) printf(fl,lrc);}
+ if(r!=0) {lrc = 3; if(prlc) printf(fl,lrc);}
+ r = j++ || i;
+ if(i!=1) {lrc = 4; if(prlc) printf(fl,lrc);}
+ if(j!=1) {lrc = 5; if(prlc) printf(fl,lrc);}
+ if(r!=1) {lrc = 6; if(prlc) printf(fl,lrc);}
+ r = i-- || j--;
+ if(i!=0) {lrc = 7; if(prlc) printf(fl,lrc);}
+ if(j!=1) {lrc = 8; if(prlc) printf(fl,lrc);}
+ if(r!=1) {lrc = 9; if(prlc) printf(fl,lrc);}
+ r = i || j--;
+ if(i!=0) {lrc = 10; if(prlc) printf(fl,lrc);}
+ if(j!=0) {lrc = 11; if(prlc) printf(fl,lrc);}
+ if(r!=1) {lrc = 12; if(prlc) printf(fl,lrc);}
+
+ if(lrc!=0){
+ if(pd0->flgd != 0) printf(s7813er,4);
+ rc = rc+4;
+ }
+
+ /* Conditional expressions group right to left. */
+
+ i = j = 0;
+ zero = 0;
+ one = 1;
+ r = one?zero:one?i++:j++;
+ if(r!=0 || i!=0 || j!=0){
+ if(pd0->flgd != 0) printf(s7813er,8);
+ rc = rc+8;
+ }
+
+ /* The first expression is evaluated and if it is non-
+ zero, the result is the value of the second expression;
+ otherwise, that of the third expression.
+ */
+
+ if((one?zero:1) != 0 || (zero?1:zero) != 0){
+ if(pd0->flgd != 0) printf(s7813er,16);
+ rc = rc+16;
+ }
+ return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s7813(pd0);
+ }
+}
+
+#define cq_sections 1
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 8.1: storage class specifiers
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+#ifdef NO_IMPLICIT_FUNC_PROTOTYPES
+regc();
+regp();
+regi();
+#endif
+
+#ifndef NO_OLD_FUNC_DECL
+s81(pd0) /* 8.1 Storage Class Specifiers */
+struct defs *pd0;
+#else
+int s81(struct defs *pd0)
+#endif
+{
+ static char s81er[] = "s81,er%d\n";
+ static char qs81[8] = "s81 ";
+ char *ps, *pt;
+ int k, rc, j, crc, prc, irc;
+ register char rchar;
+ char nrchar;
+ register int *rptr;
+ int *nrptr;
+ register int rint;
+ int nrint;
+ static char badtest[] = "Register count for %s is unreliable.\n";
+ static char goodtest[] = "%d registers assigned to %s variables.\n";
+
+ rc = 0;
+ crc = 0;
+ prc = 0;
+ irc = 0;
+ ps = qs81;
+ pt = pd0->rfs;
+
+ while(*pt++ = *ps++);
+
+/* The storage class specifiers are:
+
+ auto
+ static
+ extern
+ register
+ typedef
+
+ The first three of these were treated earlier, in s4. The last
+ will be checked in s88. "Register" remains.
+
+ There are three flavors of register, viz., char, int and pointer.
+ We wish first to ascertain that the representations as register
+ are consistent with the corresponding nonregister representations.
+ */
+
+ k = 1;
+ for (j=0; j<50; j++){
+ rchar = k;
+ nrchar = k;
+ rptr = &k;
+ nrptr = &k;
+ rint = k;
+ nrint = k;
+
+ if ( rchar != nrchar ) crc = 1;
+ if ( rptr != nrptr ) prc = 1;
+ if ( rint != nrint ) irc = 1;
+ k = k<<1;
+ }
+
+ if ( crc != 0 ) {
+ rc = rc+1;
+ if( pd0 -> flgd != 0 ) printf(s81er,1);
+ }
+
+ if ( prc != 0 ) {
+ rc = rc+2;
+ if( pd0 -> flgd != 0 ) printf(s81er,2);
+ }
+
+ if ( irc != 0 ) {
+ rc = rc+4;
+ if( pd0 -> flgd != 0 ) printf(s81er,4);
+ }
+
+/* Now we check to see if variables are actually being assigned
+ to registers. */
+
+ k = regc();
+ if ( pd0->flgm != 0 ) {
+ if ( k < 0 ) printf(badtest,"char");
+ else printf(goodtest,k,"char");
+ }
+
+ k = regp();
+ if ( pd0->flgm != 0 ) {
+ if ( k<0 ) printf(badtest,"pointer");
+ else printf(goodtest,k,"pointer");
+ }
+
+ k = regi();
+ if ( pd0->flgm != 0 ) {
+ if ( k<0 ) printf(badtest,"int");
+ else printf(goodtest,k,"int");
+ }
+
+ return rc;
+}
+regc() { /* char to register assignment */
+/* Testing a variable whose storage class has been spec-
+ified as "register" is somewhat tricky, but it can be done in a
+fairly reliable fashion by taking advantage of our knowledge of the
+ways in which compilers operate. If we declare a collection of vari-
+ables of the same storage class, we would expect that, when storage
+for these variables is actually allocated, the variables will be
+bunched together and ordered according to one of the following
+criteria:
+
+ (a) the order in which they were defined.
+ (b) the order in which they are used.
+ (c) alphabetically.
+ (d) the order in which they appear in the compiler's
+ symbol table.
+ (e) some other way.
+
+ Hence, if we define a sequence of variables in close alpha-
+betical order, and use them in the same order in which we define
+them, we would expect the differences between the addresses of
+successive variables to be constant, except in case (d) where the
+symbol table is a hash table, or in case (e). If a subsequence in
+the middle of this sequence is selected, and for this subsequence,
+every other variable is specified to be "register", and address
+differences are taken between adjacent nonregister variables, we would
+still expect to find constant differences if the "register" vari-
+ables were actually assigned to registers, and some other diff-
+erences if they were not. Specifically, if we had N variables
+specified as "register" of which the first n were actually ass-
+igned to registers, we would expect the sequence of differences
+to consist of a number of occurrences of some number, followed by
+N-n occurrences of some other number, followed by several occurr-
+ences of the first number. If we get a sequence like this, we can
+determine, by simple subtraction, how many (if any) variables are
+being assigned to registers. If we get some other sequence, we know
+that the test is invalid. */
+
+ char r00;
+ char r01;
+ char r02;
+ char r03;
+ register char r04;
+ char r05;
+ register char r06;
+ char r07;
+ register char r08;
+ char r09;
+ register char r10;
+ char r11;
+ register char r12;
+ char r13;
+ register char r14;
+ char r15;
+ register char r16;
+ char r17;
+ register char r18;
+ char r19;
+ register char r20;
+ char r21;
+ register char r22;
+ char r23;
+ register char r24;
+ char r25;
+ register char r26;
+ char r27;
+ register char r28;
+ char r29;
+ register char r30;
+ char r31;
+ register char r32;
+ char r33;
+ register char r34;
+ char r35;
+ char r36;
+ char r37;
+ char r38;
+
+ int s, n1, n2, nr, j, d[22];
+ r00 = 0;
+ r01 = 1;
+ r02 = 2;
+ r03 = 3;
+ r04 = 4;
+ r05 = 5;
+ r06 = 6;
+ r07 = 7;
+ r08 = 8;
+ r09 = 9;
+ r10 = 10;
+ r11 = 11;
+ r12 = 12;
+ r13 = 13;
+ r14 = 14;
+ r15 = 15;
+ r16 = 16;
+ r17 = 17;
+ r18 = 18;
+ r19 = 19;
+ r20 = 20;
+ r21 = 21;
+ r22 = 22;
+ r23 = 23;
+ r24 = 24;
+ r25 = 25;
+ r26 = 26;
+ r27 = 27;
+ r28 = 28;
+ r29 = 29;
+ r30 = 30;
+ r31 = 31;
+ r32 = 32;
+ r33 = 33;
+ r34 = 34;
+ r35 = 35;
+ r36 = 36;
+ r37 = 37;
+ r38 = 38;
+
+ d[0] = &r01 - &r00;
+ d[1] = &r02 - &r01;
+ d[2] = &r03 - &r02;
+ d[3] = &r05 - &r03;
+ d[4] = &r07 - &r05;
+ d[5] = &r09 - &r07;
+ d[6] = &r11 - &r09;
+ d[7] = &r13 - &r11;
+ d[8] = &r15 - &r13;
+ d[9] = &r17 - &r15;
+ d[10] = &r19 - &r17;
+ d[11] = &r21 - &r19;
+ d[12] = &r23 - &r21;
+ d[13] = &r25 - &r23;
+ d[14] = &r27 - &r25;
+ d[15] = &r29 - &r27;
+ d[16] = &r31 - &r29;
+ d[17] = &r33 - &r31;
+ d[18] = &r35 - &r33;
+ d[19] = &r36 - &r35;
+ d[20] = &r37 - &r36;
+ d[21] = &r38 - &r37;
+
+/* The following FSM analyzes the string of differences. It accepts
+strings of the form a+b+a+ and returns 16 minus the number of bs,
+which is the number of variables that actually got into registers.
+Otherwise it signals rejection by returning -1., indicating that the
+test is unreliable. */
+
+ n1 = d[0];
+ s = 1;
+
+ for (j=0; j<22; j++)
+ switch (s) {
+ case 1: if (d[j] != n1) {
+ n2 = d[j];
+ s = 2;
+ nr = 1;
+ }
+ break;
+ case 2: if (d[j] == n1) {
+ s = 3;
+ break;
+ }
+ if (d[j] == n2) {
+ nr = nr+1;
+ break;
+ }
+ s = 4;
+ break;
+ case 3: if (d[j] != n1) s = 4;
+ break;
+ }
+ ;
+
+ if (s == 3) return 16-nr;
+ else return -1;
+}
+regi() { /* int to register assignment */
+/* Testing a variable whose storage class has been spec-
+ified as "register" is somewhat tricky, but it can be done in a
+fairly reliable fashion by taking advantage of our knowledge of the
+ways in which compilers operate. If we declare a collection of vari-
+ables of the same storage class, we would expect that, when storage
+for these variables is actually allocated, the variables will be
+bunched together and ordered according to one of the following
+criteria:
+
+ (a) the order in which they were defined.
+ (b) the order in which they are used.
+ (c) alphabetically.
+ (d) the order in which they appear in the compiler's
+ symbol table.
+ (e) some other way.
+
+ Hence, if we define a sequence of variables in close alpha-
+betical order, and use them in the same order in which we define
+them, we would expect the differences between the addresses of
+successive variables to be constant, except in case (d) where the
+symbol table is a hash table, or in case (e). If a subsequence in
+the middle of this sequence is selected, and for this subsequence,
+every other variable is specified to be "register", and address
+differences are taken between adjacent nonregister variables, we would
+still expect to find constant differences if the "register" vari-
+ables were actually assigned to registers, and some other diff-
+erences if they were not. Specifically, if we had N variables
+specified as "register" of which the first n were actually ass-
+igned to registers, we would expect the sequence of differences
+to consist of a number of occurrences of some number, followed by
+N-n occurrences of some other number, followed by several occurr-
+ences of the first number. If we get a sequence like this, we can
+determine, by simple subtraction, how many (if any) variables are
+being assigned to registers. If we get some other sequence, we know
+that the test is invalid. */
+
+ int r00;
+ int r01;
+ int r02;
+ int r03;
+ register int r04;
+ int r05;
+ register int r06;
+ int r07;
+ register int r08;
+ int r09;
+ register int r10;
+ int r11;
+ register int r12;
+ int r13;
+ register int r14;
+ int r15;
+ register int r16;
+ int r17;
+ register int r18;
+ int r19;
+ register int r20;
+ int r21;
+ register int r22;
+ int r23;
+ register int r24;
+ int r25;
+ register int r26;
+ int r27;
+ register int r28;
+ int r29;
+ register int r30;
+ int r31;
+ register int r32;
+ int r33;
+ register int r34;
+ int r35;
+ int r36;
+ int r37;
+ int r38;
+
+ int s, n1, n2, nr, j, d[22];
+
+ r00 = 0;
+ r01 = 1;
+ r02 = 2;
+ r03 = 3;
+ r04 = 4;
+ r05 = 5;
+ r06 = 6;
+ r07 = 7;
+ r08 = 8;
+ r09 = 9;
+ r10 = 10;
+ r11 = 11;
+ r12 = 12;
+ r13 = 13;
+ r14 = 14;
+ r15 = 15;
+ r16 = 16;
+ r17 = 17;
+ r18 = 18;
+ r19 = 19;
+ r20 = 20;
+ r21 = 21;
+ r22 = 22;
+ r23 = 23;
+ r24 = 24;
+ r25 = 25;
+ r26 = 26;
+ r27 = 27;
+ r28 = 28;
+ r29 = 29;
+ r30 = 30;
+ r31 = 31;
+ r32 = 32;
+ r33 = 33;
+ r34 = 34;
+ r35 = 35;
+ r36 = 36;
+ r37 = 37;
+ r38 = 38;
+
+ d[0] = &r01 - &r00;
+ d[1] = &r02 - &r01;
+ d[2] = &r03 - &r02;
+ d[3] = &r05 - &r03;
+ d[4] = &r07 - &r05;
+ d[5] = &r09 - &r07;
+ d[6] = &r11 - &r09;
+ d[7] = &r13 - &r11;
+ d[8] = &r15 - &r13;
+ d[9] = &r17 - &r15;
+ d[10] = &r19 - &r17;
+ d[11] = &r21 - &r19;
+ d[12] = &r23 - &r21;
+ d[13] = &r25 - &r23;
+ d[14] = &r27 - &r25;
+ d[15] = &r29 - &r27;
+ d[16] = &r31 - &r29;
+ d[17] = &r33 - &r31;
+ d[18] = &r35 - &r33;
+ d[19] = &r36 - &r35;
+ d[20] = &r37 - &r36;
+ d[21] = &r38 - &r37;
+
+/* The following FSM analyzes the string of differences. It accepts
+strings of the form a+b+a+ and returns 16 minus the number of bs,
+which is the number of variables that actually got into registers.
+Otherwise it signals rejection by returning -1., indicating that the
+test is unreliable. */
+
+ n1 = d[0];
+ s = 1;
+
+ for (j=0; j<22; j++)
+ switch (s) {
+ case 1: if (d[j] != n1) {
+ n2 = d[j];
+ s = 2;
+ nr = 1;
+ }
+ break;
+ case 2: if (d[j] == n1) {
+ s = 3;
+ break;
+ }
+ if (d[j] == n2) {
+ nr = nr+1;
+ break;
+ }
+ s = 4;
+ break;
+ case 3: if (d[j] != n1) s = 4;
+ break;
+ }
+ ;
+
+ if (s == 3) return 16-nr;
+ else return -1;
+}
+regp() { /* pointer to register assignment */
+/* Testing a variable whose storage class has been spec-
+ified as "register" is somewhat tricky, but it can be done in a
+fairly reliable fashion by taking advantage of our knowledge of the
+ways in which compilers operate. If we declare a collection of vari-
+ables of the same storage class, we would expect that, when storage
+for these variables is actually allocated, the variables will be
+bunched together and ordered according to one of the following
+criteria:
+
+ (a) the order in which they were defined.
+ (b) the order in which they are used.
+ (c) alphabetically.
+ (d) the order in which they appear in the compiler's
+ symbol table.
+ (e) some other way.
+
+ Hence, if we define a sequence of variables in close alpha-
+betical order, and use them in the same order in which we define
+them, we would expect the differences between the addresses of
+successive variables to be constant, except in case (d) where the
+symbol table is a hash table, or in case (e). If a subsequence in
+the middle of this sequence is selected, and for this subsequence,
+every other variable is specified to be "register", and address
+differences are taken between adjacent nonregister variables, we would
+still expect to find constant differences if the "register" vari-
+ables were actually assigned to registers, and some other diff-
+erences if they were not. Specifically, if we had N variables
+specified as "register" of which the first n were actually ass-
+igned to registers, we would expect the sequence of differences
+to consist of a number of occurrences of some number, followed by
+N-n occurrences of some other number, followed by several occurr-
+ences of the first number. If we get a sequence like this, we can
+determine, by simple subtraction, how many (if any) variables are
+being assigned to registers. If we get some other sequence, we know
+that the test is invalid. */
+
+ int *r00;
+ int *r01;
+ int *r02;
+ int *r03;
+ register int *r04;
+ int *r05;
+ register int *r06;
+ int *r07;
+ register int *r08;
+ int *r09;
+ register int *r10;
+ int *r11;
+ register int *r12;
+ int *r13;
+ register int *r14;
+ int *r15;
+ register int *r16;
+ int *r17;
+ register int *r18;
+ int *r19;
+ register int *r20;
+ int *r21;
+ register int *r22;
+ int *r23;
+ register int *r24;
+ int *r25;
+ register int *r26;
+ int *r27;
+ register int *r28;
+ int *r29;
+ register int *r30;
+ int *r31;
+ register int *r32;
+ int *r33;
+ register int *r34;
+ int *r35;
+ int *r36;
+ int *r37;
+ int *r38;
+
+ int s, n1, n2, nr, j, d[22];
+
+ r00 = (int *)&r00;
+ r01 = (int *)&r01;
+ r02 = (int *)&r02;
+ r03 = (int *)&r03;
+ r04 = (int *)&r05;
+ r05 = (int *)&r05;
+ r06 = (int *)&r07;
+ r07 = (int *)&r07;
+ r08 = (int *)&r09;
+ r09 = (int *)&r09;
+ r10 = (int *)&r11;
+ r11 = (int *)&r11;
+ r12 = (int *)&r13;
+ r13 = (int *)&r13;
+ r14 = (int *)&r15;
+ r15 = (int *)&r15;
+ r16 = (int *)&r17;
+ r17 = (int *)&r17;
+ r18 = (int *)&r19;
+ r19 = (int *)&r19;
+ r20 = (int *)&r21;
+ r21 = (int *)&r21;
+ r22 = (int *)&r23;
+ r23 = (int *)&r23;
+ r24 = (int *)&r25;
+ r25 = (int *)&r25;
+ r26 = (int *)&r27;
+ r27 = (int *)&r27;
+ r28 = (int *)&r29;
+ r29 = (int *)&r29;
+ r30 = (int *)&r31;
+ r31 = (int *)&r31;
+ r32 = (int *)&r33;
+ r33 = (int *)&r33;
+ r34 = (int *)&r35;
+ r35 = (int *)&r35;
+ r36 = (int *)&r36;
+ r37 = (int *)&r37;
+ r38 = (int *)&r38;
+
+ d[0] = &r01 - &r00;
+ d[1] = &r02 - &r01;
+ d[2] = &r03 - &r02;
+ d[3] = &r05 - &r03;
+ d[4] = &r07 - &r05;
+ d[5] = &r09 - &r07;
+ d[6] = &r11 - &r09;
+ d[7] = &r13 - &r11;
+ d[8] = &r15 - &r13;
+ d[9] = &r17 - &r15;
+ d[10] = &r19 - &r17;
+ d[11] = &r21 - &r19;
+ d[12] = &r23 - &r21;
+ d[13] = &r25 - &r23;
+ d[14] = &r27 - &r25;
+ d[15] = &r29 - &r27;
+ d[16] = &r31 - &r29;
+ d[17] = &r33 - &r31;
+ d[18] = &r35 - &r33;
+ d[19] = &r36 - &r35;
+ d[20] = &r37 - &r36;
+ d[21] = &r38 - &r37;
+
+/* The following FSM analyzes the string of differences. It accepts
+strings of the form a+b+a+ and returns 16 minus the number of bs,
+which is the number of variables that actually got into registers.
+Otherwise it signals rejection by returning -1., indicating that the
+test is unreliable. */
+
+ n1 = d[0];
+ s = 1;
+ for (j=0; j<22; j++)
+ switch (s) {
+ case 1: if (d[j] != n1) {
+ n2 = d[j];
+ s = 2;
+ nr = 1;
+ }
+ break;
+ case 2: if (d[j] == n1) {
+ s = 3;
+ break;
+ }
+ if (d[j] == n2) {
+ nr = nr+1;
+ break;
+ }
+ s = 4;
+ break;
+ case 3: if (d[j] != n1) s = 4;
+ break;
+ }
+ ;
+
+ if (s == 3) return 16-nr;
+ else return -1;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s81(pd0);
+ }
+}
+
+#define cq_sections 1
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 8.4: meaning of declarators
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+#ifdef NO_SLOPPY_EXTERN
+ int *fip(int x);
+ int array(int a[],int size,int start);
+ int glork(int x);
+#endif
+
+#ifndef NO_OLD_FUNC_DECL
+s84(pd0) /* 8.4 Meaning of declarators */
+struct defs *pd0;
+{
+#else
+int s84(struct defs *pd0){
+#endif
+#ifndef NO_SLOPPY_EXTERN
+ int *ip, i, *fip(), (*pfi)(), j, k, array(), glork();
+#else
+ int *ip, i, j, k,(*pfi)();
+/*
+ extern int
+ *fip(),
+ array(),
+ glork();
+ int *fip(int x);
+ int array(int a[],int size,int start);
+*/
+#endif
+ static int x3d[3][5][7];
+ #ifndef NO_FLOATS
+ float fa[17], *afp[17], sum;
+ #else
+ signed fa[17], *afp[17], sum;
+ #endif
+ static char s84er[] = "s84,er%d\n";
+ static char qs84[8] = "s84 ";
+ int rc;
+ char *ps, *pt;
+ ps = qs84;
+ pt = pd0->rfs;
+ rc = 0;
+ while (*pt++ = *ps++);
+
+ /* The more common varieties of declarators have al-
+ ready been touched upon, some more than others. It
+ is useful to compare *fip() and (*pfi)().
+ */
+
+ ip = fip(3);
+ if(*ip != 3){
+ if(pd0->flgd != 0) printf(s84er,1);
+ rc = rc+1;
+ }
+
+ /* kludges */
+ #if defined(FORCE_POINTERS) | defined(NO_OLD_FUNC_DECL)
+ if(glork(4) != 4){
+ if(pd0->flgd != 0) printf(s84er,2);
+ rc = rc+2;
+ }
+ #else
+ pfi = glork;
+ if((*pfi)(4) != 4){
+ if(pd0->flgd != 0) printf(s84er,2);
+ rc = rc+2;
+ }
+ #endif
+
+ /* Float fa[17] declares an array of floating point
+ numbers, and *afp[17] declares an array of pointers
+ to floats.
+ */
+
+ for(j=0; j<17; j++){
+ fa[j] = j;
+ afp[j] = &fa[j];
+ }
+
+ #ifndef NO_FLOATS
+ sum = 0.;
+ #else
+ sum = 0;
+ #endif
+ for(j=0; j<17; j++) sum += *afp[j];
+ if(sum != 136){
+ if(pd0->flgd != 0) printf(s84er,4);
+ rc = rc+4;
+ }
+
+ /* static int x3d[3][5][7] declares a static three
+ dimensional array of integers, with rank 3x5x7.
+ In complete detail, x3d is an array of three items;
+ each item is an array of five arrays, and each of
+ the latter arrays is an array of seven integers.
+ Any of the expressions x3d, x3d[i], x3d[i][j],
+ and x3d[i][j][k] may reasonably appear in an express-
+ ion. The first three have type "array"; the last has
+ type int.
+ */
+
+ for (i=0; i<3; i++)
+ for (j=0; j<5; j++)
+ for (k=0; k<7; k++)
+ x3d[i][j][k] = i*35+j*7+k;
+
+ i = 1; j = 2; k = 3;
+
+ /* kludges */
+ #if defined(FORCE_POINTERS) | defined(NO_OLD_FUNC_DECL)
+ if( array((int*)x3d,105,0)
+ +array((int*)x3d[i],35,35)
+ #else
+ if( array(x3d,105,0)
+ +array(x3d[i],35,35)
+ #endif
+ +array(x3d[i][j],7,49)
+ + x3d[i][j][k]-52){
+ if(pd0->flgd != 0) printf(s84er,8);
+ rc = rc+8;
+ }
+
+ return rc;
+}
+
+#ifndef NO_OLD_FUNC_DECL
+array(a,size,start)
+int a[],size,start;
+#else
+int array(int a[],int size,int start)
+#endif
+{
+/*
+#ifndef NO_OLD_FUNC_DECL
+array(a,size,start)
+int a[],
+#else
+int array(int a[],
+#endif
+#ifdef NO_TYPELESS_INT
+int
+#endif
+#ifdef NO_TYPELESS_INT
+int
+#endif
+
+#ifndef NO_OLD_FUNC_DECL
+start; {
+#else
+start){
+#endif
+*/
+ int i;
+ for(i=0; i<size; i++)
+ if(a[i] != i+start) return 1;
+
+ return 0;
+}
+#ifndef NO_OLD_FUNC_DECL
+int *fip(x)
+int x;
+{
+#else
+int *fip(int x){
+#endif
+ static int y;
+ y = x;
+ return &y;
+}
+#ifndef NO_OLD_FUNC_DECL
+glork(x)
+int x;
+{
+#else
+int glork(int x){
+#endif
+return x;}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s84(pd0);
+ }
+}
+
+#define cq_sections 1
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 8.5: Structure and Union declarations
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+#ifndef NO_OLD_FUNC_DECL
+s85(pd0) /* 8.5 Structure and union declarations */
+struct defs *pd0;
+{
+#else
+int s85(struct defs *pd0){
+#endif
+ static char s85er[] = "s85,er%d\n";
+ static char qs85[8] = "s85 ";
+ int rc;
+ char *ps, *pt;
+
+ struct tnode {
+ char tword[20];
+ int count;
+ struct tnode *left;
+ struct tnode *right;
+ };
+
+ struct tnode s1, s2, *sp;
+
+ struct{
+ char cdummy;
+ char c;
+ } sc;
+
+ struct{
+ char cdummy;
+ short s;
+ } ss;
+
+ struct{
+ char cdummy;
+ int i;
+ } si;
+
+ struct{
+ char cdummy;
+ long l;
+ } sl;
+
+ struct{
+ char cdummy;
+ unsigned u;
+ } su;
+
+ struct{
+ char cdummy;
+ #ifndef NO_FLOATS
+ float f;
+ #else
+ signed f;
+ #endif
+ } sf;
+
+ struct{
+ char cdummy;
+ #ifndef NO_FLOATS
+ double d;
+ #else
+ signed d;
+ #endif
+ } sd;
+
+ int diff[7], j;
+
+ static char *type[] = {
+ "char",
+ "short",
+ "int",
+ "long",
+ "unsigned",
+ #ifdef NO_FLOATS
+ "signed",
+ "signed",
+ #else
+ "float",
+ "double"
+ #endif
+ };
+
+ static char aln[] = " alignment: ";
+
+ #ifndef NO_BITFIELDS
+ struct{
+ int twobit:2;
+ int :1;
+ int threebit:3;
+ int onebit:1;
+ } s3;
+ #else
+ struct{
+ unsigned char twobit;
+ unsigned char threebit;
+ unsigned char onebit;
+ } s3;
+ #endif
+
+ union{
+ char u1[30];
+ short u2[30];
+ int u3[30];
+ long u4[30];
+ unsigned u5[30];
+ #ifndef NO_FLOATS
+ float u6[30];
+ double u7[30];
+ #else
+ signed u6[30];
+ signed u7[30];
+ #endif
+ } u0;
+
+ ps = qs85;
+ pt = pd0->rfs;
+ rc = 0;
+ while (*pt++ = *ps++);
+
+ /* Within a structure, the objects declared have
+ addresses which increase as their declarations are
+ read left to right.
+ */
+
+ if( (char *)&s1.count - &s1.tword[0] <= 0
+ ||(char *)&s1.left - (char *)&s1.count <= 0
+ ||(char *)&s1.right - (char *)&s1.left <= 0){
+ if(pd0->flgd != 0) printf(s85er,1);
+ rc = rc+1;
+ }
+
+ /* Each non-field member of a structure begins on an
+ addressing boundary appropriate to its type.
+ */
+
+ diff[0] = &sc.c - &sc.cdummy;
+ diff[1] = (char *)&ss.s - &ss.cdummy;
+ diff[2] = (char *)&si.i - &si.cdummy;
+ diff[3] = (char *)&sl.l - &sl.cdummy;
+ diff[4] = (char *)&su.u - &su.cdummy;
+ diff[5] = (char *)&sf.f - &sf.cdummy;
+ diff[6] = (char *)&sd.d - &sd.cdummy;
+
+ if(pd0->flgm != 0)
+ for(j=0; j<7; j++)
+ printf("%s%s%d\n",type[j],aln,diff[j]);
+
+ /* Field specifications are highly implementation de-
+ pendent. About the only thing we can do here is to
+ check is that the compiler accepts the field constructs,
+ and that they seem to work, after a fashion, at
+ run time...
+ */
+
+ s3.threebit = 7;
+ s3.twobit = s3.threebit;
+ s3.threebit = s3.twobit;
+
+ if(s3.threebit != 3){
+ if(s3.threebit == -1){
+ if(pd0->flgm != 0) printf("Sign extension in fields\n");
+ }
+ else{
+ #ifdef NO_BITFIELDS
+ if(pd0->flgd != 0) printf("NO_BITFIELDS\n");
+ #else
+ if(pd0->flgd != 0) printf(s85er,2);
+ rc = rc+2;
+ #endif
+ }
+ }
+
+ s3.onebit = 1;
+ if(s3.onebit != 1){
+ if(pd0->flgm != 0)
+ printf("Be especially careful with 1-bit fields!\n");
+ }
+
+ /* A union may be thought of as a structure all of whose
+ members begin at offset 0 and whose size is sufficient
+ to contain any of its members.
+ */
+
+ if( (char *)u0.u1 - (char *)&u0 != 0
+ ||(char *)u0.u2 - (char *)&u0 != 0
+ ||(char *)u0.u3 - (char *)&u0 != 0
+ ||(char *)u0.u4 - (char *)&u0 != 0
+ ||(char *)u0.u5 - (char *)&u0 != 0
+ ||(char *)u0.u6 - (char *)&u0 != 0
+ ||(char *)u0.u7 - (char *)&u0 != 0){
+ if(pd0->flgd != 0) printf(s85er,4);
+ rc = rc+4;
+ }
+
+ if( sizeof u0 < sizeof u0.u1
+ ||sizeof u0 < sizeof u0.u2
+ ||sizeof u0 < sizeof u0.u3
+ ||sizeof u0 < sizeof u0.u4
+ ||sizeof u0 < sizeof u0.u5
+ ||sizeof u0 < sizeof u0.u6
+ ||sizeof u0 < sizeof u0.u7){
+ if(pd0->flgd != 0) printf(s85er,8);
+ rc = rc+8;
+ }
+
+ /* Finally, we check that the pointers work. */
+
+ s1.right = &s2;
+ s2.tword[0] = 2;
+ s1.right->tword[0] += 1;
+ if(s2.tword[0] != 3){
+ if(pd0->flgd != 0) printf(s85er,16);
+ rc = rc+16;
+ }
+ return rc;
+}
+
+#ifdef NO_LOCAL_PROTOTYPES
+int one();
+#endif
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s85(pd0);
+ }
+}
+
+#define cq_sections 1
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 8.6: Initialization
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+#ifdef NO_LOCAL_PROTOTYPES
+int one();
+#endif
+
+#ifndef NO_OLD_FUNC_DECL
+s86(pd0) /* 8.6 Initialization */
+struct defs *pd0;
+{
+#else
+int s86(struct defs *pd0){
+#endif
+ static char s86er[] = "s86,er%d\n";
+ static char qs86[8] = "s86 ";
+ int lrc, rc;
+ char *ps, *pt;
+ #ifndef NO_LOCAL_PROTOTYPES
+ int one();
+ #endif
+ int i, j, k;
+ static int x[] = {1,3,5};
+ static int *pint = x+2;
+ static int zero[10];
+ int *apint = pint-1;
+ register int *rpint = apint+one();
+
+ #ifndef NO_FLOATS
+ static float y0[] = {1,3,5,2,4,6,3,5,7,0,0,0};
+ static float y1[4][3] = {
+ {1,3,5},
+ {2,4,6},
+ {3,5,7},
+ };
+ static float y2[4][3] = {1,3,5,2,4,6,3,5,7};
+ static float y3[4][3] = {
+ {1},{2},{3},{4}
+ };
+ #else
+ static signed y0[] = {1,3,5,2,4,6,3,5,7,0,0,0};
+ static signed y1[4][3] = {
+ {1,3,5},
+ {2,4,6},
+ {3,5,7},
+ };
+ #ifndef NO_SLOPPY_STRUCT_INIT
+ static signed y2[4][3] = {1,3,5,2,4,6,3,5,7};
+ #else
+ static signed y2[4][3] = {{1,3,5},{2,4,6},{3,5,7}};
+ #endif
+ static signed y3[4][3] = {
+ {1},{2},{3},{4}
+ };
+ #endif
+
+ ps = qs86;
+ pt = pd0->rfs;
+ rc = 0;
+ while (*pt++ = *ps++);
+
+ /* The expression in an initializer for a static or
+ external variable must be a constant expression or
+ an expression that reduces to the address of a pre-
+ viously declared variable, possibly offset by a
+ constant expression.
+ */
+
+ if(*pint != 5){
+ if(pd0->flgd != 0) printf(s86er,1);
+ rc = rc+1;
+ }
+
+ /* Automatic and register variables may be initialized
+ by arbitrary expressions involving constants and previously
+ declared variables and functions.
+ */
+
+ if(*apint != 3){
+ if(pd0->flgd != 0) printf(s86er,2);
+ rc = rc+2;
+ }
+
+ if(*rpint != 5){
+ if(pd0->flgd != 0) printf(s86er,4);
+ rc = rc+4;
+ }
+
+ /* Static variables that are not initialized are guar-
+ anteed to start off as zero.
+ */
+
+ lrc = 0;
+ for(j=0; j<10; j++)
+ if(zero[j] != 0) lrc = 1;
+ if(lrc != 0){
+ if(pd0->flgd != 0) printf(s86er,8);
+ rc = rc+8;
+ }
+
+ /* y0, y1, and y2, as declared, should define and
+ initialize identical arrays.
+ */
+ lrc = 0;
+ for(i=0; i<4; i++)
+ for(j=0; j<3; j++){
+ k = 3*i+j;
+ if( y1[i][j] != y2[i][j]
+ ||y1[i][j] != y0[k]) lrc = 1;
+ }
+
+ if(lrc != 0){
+ if(pd0->flgd != 0) printf(s86er,16);
+ rc = rc+16;
+ }
+
+ /* y3 initializes the first column of the array and
+ leaves the rest zero.
+ */
+
+ lrc = 0;
+ for(j=0; j<4; j++) if(y3[j][0] != j+1) lrc = 1;
+
+ if(lrc != 0){
+ if(pd0->flgd != 0) printf(s86er,32);
+ rc = rc+32;
+ }
+ return rc;
+}
+#ifndef NO_OLD_FUNC_DECL
+one(){
+#else
+int one(){
+#endif
+ return 1;
+}
+int *metricp;
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s86(pd0);
+ }
+}
+
+#define cq_sections 1
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 8.8: typedef
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+one(){
+ return 1;
+}
+int *metricp;
+#ifndef NO_OLD_FUNC_DECL
+s88(pd0) /* 8.8 Typedef */
+struct defs *pd0;
+{
+#else
+int s88(struct defs *pd0){
+#endif
+ static char s88er[] = "s88,er%d\n";
+ static char qs88[8] = "s88 ";
+ int rc;
+ char *ps, *pt;
+
+ /* Declarations whose "storage class" is typdef do not
+ define storage, but instead define identifiers which
+ can later be used as if they were type keywords naming
+ fundamental or derived types.
+ */
+
+ typedef int MILES, *KLICKSP;
+
+ #ifndef NO_FLOATS
+ typedef struct {double re, im;} complex;
+ #else
+ typedef struct {signed re, im;} complex;
+ #endif
+
+ MILES distance;
+ #ifndef NO_SLOPPY_EXTERN
+ extern KLICKSP metricp;
+ #else
+ KLICKSP metricp;
+ #endif
+ complex z, *zp;
+
+ ps = qs88;
+ pt = pd0->rfs;
+ rc = 0;
+ while(*pt++ = *ps++);
+
+ /* Hopefully, all of this stuff will compile. After that,
+ we can only make some superficial tests.
+
+ The type of distance is int,
+ */
+
+ if(sizeof distance != sizeof(int)){
+ if(pd0->flgd != 0) printf(s88er,1);
+ rc = rc+1;
+ }
+
+ /* that of metricp is "pointer to int", */
+
+ metricp = &distance;
+ distance = 2;
+ *metricp = 3;
+
+ if(distance != 3){
+ if(pd0->flgd != 0) printf(s88er,2);
+ rc = rc+2;
+ }
+
+ /* and that of z is the specified structure. zp is a
+ pointer to such a structure.
+ */
+
+ #ifndef NO_FLOATS
+ z.re = 0.;
+ z.im = 0.;
+ zp = &z;
+ zp->re = 1.;
+ zp->im = 1.;
+ if(z.re+z.im != 2.){
+ #else
+ z.re = 0;
+ z.im = 0;
+ zp = &z;
+ zp->re = 1;
+ zp->im = 1;
+ if(z.re+z.im != 2){
+ #endif
+ if(pd0->flgd != 0) printf(s88er,4);
+ rc = rc+4;
+ }
+
+ return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s88(pd0);
+ }
+}
+
+#define cq_sections 1
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! C-Manual Chapter 9: Statements
+ !!ORIGIN!! LCC 4.1 Testsuite
+ !!LICENCE!! own, freely distributeable for non-profit. read CPYRIGHT.LCC
+*/
+
+#include "common.h"
+
+struct defs {
+ int cbits; /* No. of bits per char */
+ int ibits; /* int */
+ int sbits; /* short */
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+};
+
+ int lbits; /* long */
+ int ubits; /* unsigned */
+ int fbits; /* float */
+ int dbits; /* double */
+ #ifndef NO_FLOATS
+ float fprec; /* Smallest number that can be */
+ float dprec; /* significantly added to 1. */
+ #endif
+ int flgs; /* Print return codes, by section */
+ int flgm; /* Announce machine dependencies */
+ int flgd; /* give explicit diagnostics */
+ int flgl; /* Report local return codes. */
+ int rrc; /* recent return code */
+ int crc; /* Cumulative return code */
+ char rfs[8]; /* Return from section */
+
+#ifndef NO_OLD_FUNC_DECL
+s9(pd0) /* 9 Statements */
+struct defs *pd0;
+{
+#else
+int s9(struct defs *pd0){
+#endif
+ static char s9er[] = "s9,er%d\n";
+ static char qs9[8] = "s9 ";
+ int rc;
+ char *ps, *pt;
+ int lrc, i;
+
+ ps = qs9;
+ pt = pd0->rfs;
+ rc = 0;
+ while (*pt++ = *ps++);
+
+ /* One would think that the section on statements would
+ provide the most variety in the entire sequence of tests.
+ As it turns out, most of the material in this section has
+ already been checked in the process of checking out
+ everything else, and the section at this point is somewhat
+ anticlimactic. For this reason, we restrict ourselves
+ to testing two features not already covered.
+
+ Compound statements are delimited by braces. They have the
+ nice property that identifiers of the auto and register
+ variety are pushed and popped. It is currently legal to
+ transfer into a block, but we wont...
+ */
+
+ lrc = 0;
+ for(i=0; i<2; i++){
+ int j;
+ register int k;
+ j = k = 2;
+ {
+ int j;
+ register int k;
+ j = k = 3;
+ if((j != 3) || (k != 3)) lrc = 1;
+ }
+ if((j != 2) || (k != 2)) lrc = 1;
+ }
+
+ if(lrc != 0){
+ if(pd0->flgd != 0) printf(s9er,1);
+ rc = rc+1;
+ }
+
+ /* Goto statements go to labeled statements, we hope. */
+
+ goto nobarf;
+ if(pd0->flgd != 0) printf(s9er,2);
+ rc = rc+2;
+ nobarf:;
+
+ return rc;
+}
+
+/*********************************************************************************************
+ the main loop that launches the sections
+*********************************************************************************************/
+
+#ifndef NO_TYPELESS_STRUCT_PTR
+ int section(int j,struct* pd0){
+#else
+ int section(int j,void* pd0){
+#endif
+ switch(j){
+ case 0: return s9(pd0);
+ }
+}
+
+#define cq_sections 1
+
+/*
+ C REFERENCE MANUAL (main)
+*/
+
+#ifndef NO_OLD_FUNC_DECL
+main(n,args)
+int n;
+char **args;
+{
+#else
+int main(int n,char **args) {
+#endif
+
+int j;
+static struct defs d0, *pd0;
+
+ d0.flgs = 1; /* These flags dictate */
+ d0.flgm = 1; /* the verbosity of */
+ d0.flgd = 1; /* the program. */
+ d0.flgl = 1;
+
+ pd0 = &d0;
+
+ for (j=0; j<cq_sections; j++) {
+ d0.rrc=section(j,pd0);
+ d0.crc=d0.crc+d0.rrc;
+ if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+ }
+
+ if(d0.crc == 0) printf("\nNo errors detected.\n");
+ else printf("\nFailed.\n");
+
+ return d0.crc;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+
+void done()
+{
+ dummy++;
+}
+
+void for1(void)
+{
+ unsigned char i=0;
+
+ for(i=0; i<10; i++)
+ uchar0++;
+
+ if(uchar0 != 10)
+ failures++;
+}
+
+void for2(void)
+{
+ unsigned char i=0;
+
+ for(i=0; i<10; i++)
+ uchar0++;
+
+ if(i < 10)
+ failures++;
+}
+
+void for3(void)
+{
+ unsigned int i=0;
+
+ for(i=0; i<10; i++)
+ uint0++;
+
+ if(i < 10)
+ failures++;
+}
+
+void for4(void)
+{
+ for(uint0=1; uint0<10; uint0++)
+ uchar0++;
+
+ if(uchar0 != 9)
+ failures++;
+}
+
+void for5(void)
+{
+ for(uint0=1; uint0<=10; uint0++)
+ uchar0++;
+
+ if(uchar0 != 10)
+ failures++;
+}
+
+void inc_uchar0(void)
+{
+ uchar0++;
+}
+
+void for6(void)
+{
+ uchar0 = 0;
+ for(uint0=1; uint0<=10; uint0++)
+ inc_uchar0();
+}
+
+int main(void)
+{
+ for1();
+ for2();
+ for3();
+ uchar0 = 0;
+ for4();
+ uchar0 = 0;
+ for5();
+
+ for6();
+ if(uchar0 != 10)
+ failures++;
+
+ success = failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+#define TESTLIT 0x05
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+signed char c1,c2,c3;
+unsigned char uc1,uc2,uc3;
+
+unsigned int ui1,ui2,ui3;
+signed int i1,i2;
+
+void done()
+{
+ dummy++;
+}
+
+void m1(void)
+{
+ c1 = c1*5; /* char = char * lit */
+
+ c2 = c1 *c3; /* char = char * char */
+
+ uc1= uc1*5; /* uchar = uchar * lit *
+ uc2=uc1*uc3; /* uchar = uchar * uchar */
+
+ if(c2 != 25)
+ failures++;
+}
+
+void m2(unsigned char uc)
+{
+ uc2 = uc1 * uc;
+
+ if(uc2 != 0x20)
+ failures++;
+}
+
+void m3(unsigned char uc)
+{
+ volatile unsigned char vuc;
+
+ /* uchar = uchar * lit */
+ /* testing literal multiply with same source and destination */
+ vuc = uc;
+ uc2 = 0;
+ uc1 = vuc; uc1 = uc1*1; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*2; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*3; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*4; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*5; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*6; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*7; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*8; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*9; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*10; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*11; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*12; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*13; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*14; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*15; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*16; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*17; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*18; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*19; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*20; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*21; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*22; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*23; if( uc1 != (uc2+=TESTLIT) ) failures++;
+ uc1 = vuc; uc1 = uc1*24; if( uc1 != (uc2+=TESTLIT) ) failures++;
+
+ uc1 = vuc; uc1 = uc1*31; if( uc1 != ((31*TESTLIT) & 0xff) ) failures++;
+ uc1 = vuc; uc1 = uc1*32; if( uc1 != ((32*TESTLIT) & 0xff) ) failures++;
+ uc1 = vuc; uc1 = uc1*64; if( uc1 != ((64*TESTLIT) & 0xff) ) failures++;
+ uc1 = vuc; uc1 = uc1*128;if( uc1 != ((128*TESTLIT)& 0xff) ) failures++;
+
+ /* testing literal multiply with different source and destination */
+ uc1 = vuc*1; if( uc1 != ((1*TESTLIT) & 0xff) ) failures++;
+ uc1 = vuc*2; if( uc1 != ((2*TESTLIT) & 0xff) ) failures++;
+ uc1 = vuc*4; if( uc1 != ((4*TESTLIT) & 0xff) ) failures++;
+}
+
+int main(void)
+{
+ dummy = 0;
+
+ c1 = 1;
+ c3 = 5;
+
+ m1();
+
+ uc1 = 0x10;
+ m2(2);
+
+ ui1 = uc1*uc2; /* uint = uchar * uchar */
+
+ i1 = c1*c2; /* int = char * char */
+
+ ui3 = ui1*ui2; /* uint = uint * unit */
+
+ /*m3(TESTLIT);*/
+
+ success = failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+
+void dput(unsigned char val)
+{
+ /*PORTB = val;
+ PORTA = 0x01;
+ PORTA = 0x00;
+ */
+}
+
+void done()
+{
+ dummy++;
+}
+
+/* both loops use the loop variable inside the inner loop */
+void for1(void)
+{
+ unsigned char i, j;
+
+ uchar0 = 0;
+ uchar1 = 0;
+ for(i = 0; i < 3; i++) {
+ uchar0++;
+ for(j = 0; j < 4; j++) {
+ uchar1++;
+ dput(i);
+ dput(j);
+ }
+ }
+ if(uchar0 != 3)
+ failures++;
+ if(uchar1 != 12)
+ failures++;
+}
+
+/* only the outer loop's variable is used inside, inner can be optimized into a repeat-loop */
+void for2(void)
+{
+ unsigned char i, j;
+
+ uchar0 = 0;
+ uchar1 = 0;
+ for(i = 0; i < 3; i++) {
+ uchar0++;
+ for(j = 0; j < 4; j++) {
+ uchar1++;
+ dput(i);
+ }
+ }
+ if(uchar0 != 3)
+ failures++;
+ if(uchar1 != 12)
+ failures++;
+}
+
+/* only the inner loop's variable is used inside */
+void for3(void)
+{
+ unsigned char i, j;
+
+ uchar0 = 0;
+ uchar1 = 0;
+ for(i = 0; i < 3; i++) {
+ uchar0++;
+ for(j = 0; j < 4; j++) {
+ uchar1++;
+ dput(j);
+ }
+ }
+ if(uchar0 != 3)
+ failures++;
+ if(uchar1 != 12)
+ failures++;
+}
+
+/* neither loop variable used inside the loops */
+void for4(void)
+{
+ unsigned char i, j;
+
+ uchar0 = 0;
+ uchar1 = 0;
+ for(i = 0; i < 3; i++) {
+ uchar0++;
+ for(j = 0; j < 4; j++) {
+ uchar1++;
+ dput(uchar0);
+ dput(uchar1);
+ }
+ }
+ if(uchar0 != 3)
+ failures++;
+ if(uchar1 != 12)
+ failures++;
+}
+
+/* like for1 but different condition in inner loop */
+void for5(void)
+{
+ unsigned char i, j;
+
+ uchar0 = 0;
+ uchar1 = 0;
+ for(i = 0; i < 3; i++) {
+ uchar0++;
+ for(j = 10; j >= 5; j--) {
+ uchar1++;
+ dput(i);
+ dput(j);
+ }
+ }
+ if(uchar0 != 3)
+ failures++;
+ if(uchar1 != 18)
+ failures++;
+}
+
+int main(void)
+{
+ for1();
+ for2();
+ for3();
+ for4();
+ for5();
+
+ success = failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#if SUPPORT_BIT_TYPES
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+#endif
+
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+unsigned long ulong0 = 0;
+unsigned long ulong1 = 0;
+
+void done()
+{
+ dummy++;
+}
+
+/* uchar0 = 0; */
+void or_lit2uchar(void)
+{
+ if(uchar0)
+ failures++;
+
+ uchar0 |= 1;
+
+ if(uchar0 != 1)
+ failures++;
+
+ uchar0 |= 2;
+
+ if(uchar0 != 3)
+ failures++;
+
+ uchar0 |= 0x0e;
+
+ if(uchar0 != 0x0f)
+ failures++;
+}
+
+void or_lit2uint(void)
+{
+ if(uint0)
+ failures++;
+
+ uint0 |= 1;
+ if(uint0 != 1)
+ failures++;
+
+ uint0 |= 2;
+ if(uint0 != 3)
+ failures++;
+
+ uint0 |= 0x100;
+ if(uint0 != 0x103)
+ failures++;
+
+ uint0 |= 0x102;
+ if(uint0 != 0x103)
+ failures++;
+
+ uint0 |= 0x303;
+ if(uint0 != 0x303)
+ failures++;
+}
+
+void or_lit2ulong(void)
+{
+ if(ulong0)
+ failures++;
+
+ ulong0 |= 1;
+ if(ulong0 != 1)
+ failures++;
+
+ ulong0 |= 2;
+ if(ulong0 != 3)
+ failures++;
+
+ ulong0 |= 0x100;
+ if(ulong0 != 0x103)
+ failures++;
+
+ ulong0 |= 0x102;
+ if(ulong0 != 0x103)
+ failures++;
+
+ ulong0 |= 0x303;
+ if(ulong0 != 0x303)
+ failures++;
+
+ ulong0 |= 0x80000000;
+ if(ulong0 != 0x80000303)
+ failures++;
+}
+
+/*-----------*/
+void or_uchar2uchar(void)
+{
+ uchar0 |= uchar1;
+
+ if(uchar0 != 1)
+ failures++;
+
+ uchar1 |= 0x0f;
+
+ uchar0 = uchar1 | 0x10;
+
+ if(uchar0 != 0x1f)
+ failures++;
+}
+
+void or_uint2uint(void)
+{
+ uint0 |= uint1;
+
+ if(uint0 != 1)
+ failures++;
+
+ uint1 |= 0x0f;
+
+ uint0 = uint1 | 0x10;
+
+ if(uint0 != 0x1f)
+ failures++;
+}
+
+#if SUPPORT_BIT_TYPES
+
+void or_bits1(void)
+{
+ bit0 = bit0 | bit1 | bit2;
+}
+
+void or_bits2(void)
+{
+ bit0 = bit1 | bit2;
+}
+#endif
+
+int main(void)
+{
+ or_lit2uchar();
+ or_lit2uint();
+ or_lit2ulong();
+
+ uchar0=0;
+ uchar1=1;
+ or_uchar2uchar();
+
+ uint0=0;
+ uint1=1;
+ or_uint2uint();
+
+#if SUPPORT_BIT_TYPES
+ or_bits1();
+ if(bit0)
+ failures++;
+
+ or_bits2();
+ if(bit0)
+ failures++;
+
+ bit1=1;
+ or_bits1();
+ if(!bit0)
+ failures++;
+
+ or_bits2();
+ if(!bit0)
+ failures++;
+#endif
+
+ success = failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Pointer tests
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char *acharP = 0;
+
+char buff[10];
+
+void
+done ()
+{
+ dummy++;
+}
+
+void
+f1 (unsigned char *ucP)
+{
+ if (ucP == 0)
+ {
+ failures++;
+ return;
+ }
+
+ if (*ucP)
+ failures++;
+}
+
+void
+f2 (unsigned int *uiP)
+{
+ if (uiP == 0)
+ {
+ failures++;
+ return;
+ }
+
+ if (*uiP)
+ failures++;
+}
+
+unsigned char *
+f3 (void)
+{
+ return &achar0;
+}
+
+void f4(unsigned char *ucP, unsigned char uc)
+{
+ if(!ucP) {
+ failures++;
+ return;
+ }
+
+ if(*ucP != uc)
+ failures++;
+}
+
+void init_array(char start_value)
+{
+ unsigned char c;
+
+ for(c=0; c<sizeof(buff); c++)
+ buff[c] = start_value++;
+}
+
+void check_array(char base_value)
+{
+ unsigned char c;
+
+ for(c=0; c<sizeof(buff); c++)
+ if(buff[c] != (base_value+c))
+ failures++;
+}
+
+void index_by_pointer(unsigned char *index, unsigned char expected_value)
+{
+ if(buff[*index] != expected_value)
+ failures++;
+}
+
+int
+main (void)
+{
+ init_array(4);
+ check_array(4);
+
+ if(buff[achar0 + 7] != 4+7)
+ failures++;
+
+ dummy = buff[achar0];
+
+ if(dummy != 4)
+ failures++;
+
+ if(dummy != (buff[achar0+1] -1))
+ failures++;
+
+ index_by_pointer(&dummy, 8);
+
+ f1 (&achar0);
+ f2 (&aint0);
+
+ acharP = f3 ();
+ if ((acharP == 0) || (*acharP))
+ failures++;
+ achar0 = 42;
+ if(*acharP != 42)
+ failures++;
+
+ achar0 = 5;
+ f4(&achar0, achar0);
+
+ success = failures;
+ done ();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+
+/*
+ * BUG: if these aren't volatile, an overzealous optimizer or somthing
+ * wreaks havoc with the simple tests like "if(uchar != 3)failures++"
+ */
+
+#if 0
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+unsigned char uchar2 = 0;
+#else
+volatile unsigned char uchar0 = 0;
+volatile unsigned char uchar1 = 0;
+volatile unsigned char uchar2 = 0;
+#endif
+
+#ifdef NO_IMPLICIT_FUNCPTR_CONV
+void (*pfunc)(void);
+void (*p1func)(void);
+unsigned char (*pcfunc)(void);
+#else
+void (*pfunc)();
+void (*p1func)();
+unsigned char (*pcfunc)();
+#endif
+
+void done()
+{
+ dummy++;
+}
+
+void call0(void)
+{
+ uchar0++;
+}
+
+void call1(void)
+{
+ uchar1++;
+}
+
+unsigned char call2(void)
+{
+ return uchar0 + 9;
+}
+
+void docall0(void)
+{
+ pfunc = call0;
+ (pfunc)();
+ if(uchar0 != 1)
+ failures++;
+}
+
+void docall1()
+{
+ unsigned char i;
+ for(i = 0; i < 3; i++) {
+ (*p1func)();
+ }
+}
+
+#ifdef NO_IMPLICIT_FUNCPTR_CONV
+void docall2( void(*pf)(void) )
+#else
+void docall2( void(*pf)() )
+#endif
+{
+ unsigned char i;
+ for(i = 0; i < 2; i++) {
+ pf();
+ }
+}
+
+int main(void)
+{
+ docall0();
+
+ p1func = call1;
+ docall1();
+ if(uchar1 != 3)
+ failures++;
+ if(uchar0 != 1)
+ failures++;
+
+ p1func = call0;
+ docall1();
+ if(uchar1 != 3)
+ failures++;
+ if(uchar0 != 4)
+ failures++;
+
+ docall2(call0);
+ if(uchar1 != 3)
+ failures++;
+ if(uchar0 != 6)
+ failures++;
+
+ docall2(call1);
+ if(uchar1 != 5)
+ failures++;
+ if(uchar0 != 6)
+ failures++;
+
+ pcfunc = call2;
+ uchar2 = (*pcfunc)();
+ if(uchar2 != 15)
+ failures++;
+
+ uchar2 += (pcfunc)();
+ uchar2 += pcfunc();
+
+ success = failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Shift bytes left and right by a constant.
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+
+void done()
+{
+ dummy++;
+}
+
+void check(void)
+{
+ if(achar0 != achar1)
+ failures++;
+}
+
+void shift_left_1(void)
+{
+ achar0 <<= 1;
+
+ check();
+}
+
+void shift_left_2(void)
+{
+ achar0 <<= 2;
+
+ if(achar0 != achar1)
+ failures++;
+}
+
+void shift_left_3(void)
+{
+ achar0 <<= 3;
+
+ if(achar0 != achar1)
+ failures++;
+}
+
+void shift_left_4(void)
+{
+ achar0 <<= 4;
+
+ if(achar0 != achar1)
+ failures++;
+}
+
+void shift_left_5(void)
+{
+ achar0 <<= 5;
+
+ if(achar0 != achar1)
+ failures++;
+}
+
+void shift_left_6(void)
+{
+ achar0 <<= 6;
+
+ if(achar0 != achar1)
+ failures++;
+}
+
+void shift_left_7(void)
+{
+ achar0 <<= 7;
+
+ if(achar0 != achar1)
+ failures++;
+}
+
+void shift_right_1(void)
+{
+ achar0 >>= 1;
+
+ check();
+}
+
+void shift_right_2(void)
+{
+ achar0 >>= 2;
+
+ check();
+}
+
+void shift_right_3(void)
+{
+ achar0 >>= 3;
+
+ check();
+}
+
+void shift_right_4(void)
+{
+ achar0 >>= 4;
+
+ check();
+}
+
+void shift_right_5(void)
+{
+ achar0 >>= 5;
+
+ check();
+}
+
+void shift_right_6(void)
+{
+ achar0 >>= 6;
+
+ check();
+}
+
+void shift_right_7(void)
+{
+ achar0 >>= 7;
+
+ check();
+}
+
+int main(void)
+{
+ /* call with both values zero */
+ shift_left_1();
+
+ achar0 = 1;
+ achar1 = 2;
+ for(achar2=0; achar2<6; achar2++) {
+ shift_left_1();
+ achar1 <<=1;
+ }
+
+ achar0 = 1;
+ achar1 = 4;
+ shift_left_2();
+
+ achar0 = 1;
+ achar1 = 8;
+ shift_left_3();
+
+ achar0 = 1;
+ achar1 = 0x10;
+ shift_left_4();
+
+ achar0 = 1;
+ achar1 = 0x20;
+ shift_left_5();
+
+ achar0 = 1;
+ achar1 = 0x40;
+ shift_left_6();
+
+ achar0 = 1;
+ achar1 = 0x80;
+ shift_left_7();
+
+ achar0 = 2;
+ achar1 = 1;
+ shift_right_1();
+
+ achar0 = 4;
+ shift_right_2();
+
+ achar0 = 8;
+ shift_right_3();
+
+ achar0 = 0x10;
+ shift_right_4();
+
+ achar0 = 0x20;
+ shift_right_5();
+
+ achar0 = 0x40;
+ shift_right_6();
+
+ achar0 = 0x80;
+ shift_right_7();
+
+ success=failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Shift bytes left and right by a variable.
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+
+void done()
+{
+ dummy++;
+}
+
+void shift_right_var(void)
+{
+ achar0 >>= achar1;
+}
+
+void shift_left_var(void)
+{
+ achar0 <<= achar1;
+}
+
+void shift_int_left_1(void)
+{
+ aint0 <<= 1;
+}
+
+int main(void)
+{
+ char i;
+
+ achar0 = 1;
+ achar1 = 1;
+ shift_left_var();
+
+ if(achar0 !=2)
+ failures++;
+
+ achar0 = 1;
+ achar1 = 1;
+ achar2 = 1;
+ for(i=0; i<7; i++) {
+ shift_left_var();
+ achar2 <<= 1;
+
+ if(achar2 != achar0)
+ failures++;
+ }
+
+ success=failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Shift ints left and right
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+#ifdef SIZEOF_INT_16BIT
+#if defined(__LINUX__) || defined(LINUX)
+unsigned short aint0 = 0;
+unsigned short aint1 = 0;
+
+#else
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+
+#endif
+
+#else
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+
+#endif
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+
+void done()
+{
+ dummy++;
+}
+
+void shift_int_left_1(void)
+{
+ aint0 <<= 1;
+}
+
+void shift_int_left_2(void)
+{
+ aint0 <<= 2;
+}
+
+void shift_int_left_3(void)
+{
+ aint0 <<= 3;
+}
+
+void shift_int_left_4(void)
+{
+ aint0 <<= 4;
+}
+
+void shift_int_left_5(void)
+{
+ aint0 <<= 5;
+}
+
+void shift_int_left_6(void)
+{
+ aint0 <<= 6;
+}
+
+void shift_int_left_7(void)
+{
+ aint0 <<= 7;
+}
+
+void shift_int_left_8(void)
+{
+ aint0 <<= 8;
+}
+
+void shift_int_left_9(void)
+{
+ aint0 <<= 9;
+}
+
+void shift_int_left_10(void)
+{
+ aint0 <<= 10;
+}
+
+void shift_int_left_11(void)
+{
+ aint0 <<= 11;
+}
+
+void shift_int_left_12(void)
+{
+ aint0 <<= 12;
+}
+
+void shift_int_left_13(void)
+{
+ aint0 <<= 13;
+}
+
+void shift_int_left_14(void)
+{
+ aint0 <<= 14;
+}
+
+void shift_int_left_15(void)
+{
+ aint0 <<= 15;
+}
+
+/*****************************************************/
+void shift_int_right_1(void)
+{
+ aint0 >>= 1;
+}
+
+void shift_int_right_2(void)
+{
+ aint0 >>= 2;
+}
+
+void shift_int_right_3(void)
+{
+ aint0 >>= 3;
+}
+
+void shift_int_right_4(void)
+{
+ aint0 >>= 4;
+}
+
+void shift_int_right_5(void)
+{
+ aint0 >>= 5;
+}
+
+void shift_int_right_6(void)
+{
+ aint0 >>= 6;
+}
+
+void shift_int_right_7(void)
+{
+ aint0 >>= 7;
+}
+
+void shift_int_right_8(void)
+{
+ aint0 >>= 8;
+}
+
+void shift_int_right_9(void)
+{
+ aint0 >>= 9;
+}
+
+void shift_int_right_10(void)
+{
+ aint0 >>= 10;
+}
+
+void shift_int_right_11(void)
+{
+ aint0 >>= 11;
+}
+
+void shift_int_right_12(void)
+{
+ aint0 >>= 12;
+}
+
+void shift_int_right_13(void)
+{
+ aint0 >>= 13;
+}
+
+void shift_int_right_14(void)
+{
+ aint0 >>= 14;
+}
+
+void shift_int_right_15(void)
+{
+ aint0 >>= 15;
+}
+
+/*****************************************************/
+int main(void)
+{
+ /*char i;*/
+ aint0 = 0xabcd;
+
+ shift_int_left_1();
+ if(aint0 != 0x579a)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_left_2();
+ if(aint0 != 0xaf34)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_left_3();
+ if(aint0 != 0x5e68)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_left_4();
+ if(aint0 != 0xbcd0)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_left_5();
+ if(aint0 != 0x79a0)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_left_6();
+ if(aint0 != 0xf340)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_left_7();
+ if(aint0 != 0xe680)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_left_8();
+ if(aint0 != 0xcd00)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_left_9();
+ if(aint0 != 0x9a00)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_left_10();
+ if(aint0 != 0x3400)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_left_11();
+ if(aint0 != 0x6800)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_left_12();
+ if(aint0 != 0xd000)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_left_13();
+ if(aint0 != 0xa000)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_left_14();
+ if(aint0 != 0x4000)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_left_15();
+ if(aint0 != 0x8000)
+ failures++;
+
+ /***********************/
+ aint0 = 0xabcd;
+
+ shift_int_right_1();
+ if(aint0 != 0x55e6)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_right_2();
+ if(aint0 != 0x2af3)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_right_3();
+ if(aint0 != 0x1579)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_right_4();
+ if(aint0 != 0x0abc)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_right_5();
+ if(aint0 != 0x055e)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_right_6();
+ if(aint0 != 0x02af)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_right_7();
+ if(aint0 != 0x0157)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_right_8();
+ if(aint0 != 0x00ab)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_right_9();
+ if(aint0 != 0x0055)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_right_10();
+ if(aint0 != 0x002a)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_right_11();
+ if(aint0 != 0x0015)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_right_12();
+ if(aint0 != 0x000a)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_right_13();
+ if(aint0 != 0x0005)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_right_14();
+ if(aint0 != 0x0002)
+ failures++;
+
+ aint0 = 0xabcd;
+
+ shift_int_right_15();
+ if(aint0 != 0x0001)
+ failures++;
+
+ success=failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! rotate bytes left and right by a constant.
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+#ifdef SIZEOF_INT_16BIT
+#if defined(__LINUX__) || defined(LINUX)
+unsigned short aint0 = 0;
+unsigned short aint1 = 0;
+
+#else
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+
+#endif
+
+#else
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+
+#endif
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+unsigned char uchar2 = 0;
+
+void done()
+{
+ dummy++;
+}
+
+void check(void)
+{
+ if(uchar0 != uchar1)
+ failures++;
+}
+
+void rotate_left_1(void)
+{
+ uchar0 = (uchar0<<1) | (uchar0>>7);
+
+ check();
+}
+
+void rotate_left_2(void)
+{
+ uchar0 = (uchar0<<2) | (uchar0>>6);
+
+ check();
+}
+
+void rotate_left_3(void)
+{
+ uchar0 <<= 3;
+
+ if(uchar0 != uchar1)
+ failures++;
+}
+
+void rotate_left_4(void)
+{
+ uchar0 <<= 4;
+
+ if(uchar0 != uchar1)
+ failures++;
+}
+
+void rotate_left_5(void)
+{
+ uchar0 <<= 5;
+
+ if(uchar0 != uchar1)
+ failures++;
+}
+
+void rotate_left_6(void)
+{
+ uchar0 <<= 6;
+
+ if(uchar0 != uchar1)
+ failures++;
+}
+
+void rotate_left_7(void)
+{
+ uchar0 <<= 7;
+
+ if(uchar0 != uchar1)
+ failures++;
+}
+
+void rotate_right_1(void)
+{
+ uchar0 = (uchar0>>1) | (uchar0<<7);
+
+ check();
+}
+
+void rotate_right_2(void)
+{
+ uchar0 = (uchar0>>2) | (uchar0<<6);
+
+ check();
+}
+
+void rotate_right_3(void)
+{
+ uchar0 >>= 3;
+
+ check();
+}
+
+void rotate_right_4(void)
+{
+ uchar0 >>= 4;
+
+ check();
+}
+
+void rotate_right_5(void)
+{
+ uchar0 >>= 5;
+
+ check();
+}
+
+void rotate_right_6(void)
+{
+ uchar0 >>= 6;
+
+ check();
+}
+
+void rotate_right_7(void)
+{
+ uchar0 >>= 7;
+
+ check();
+}
+
+int main(void)
+{
+ /* call with both values zero */
+ rotate_left_1();
+
+ uchar0 = 1;
+ uchar1 = 2;
+
+ rotate_left_1();
+
+ uchar0 = 0x80;
+ uchar1 = 1;
+
+ rotate_left_1();
+
+ uchar1 = 2;
+ for(uchar2=0; uchar2<6; uchar2++) {
+ rotate_left_1();
+ uchar1 <<=1;
+ }
+
+ uchar0 = 1;
+ uchar1 = 4;
+ rotate_left_2();
+
+ uchar0 = 1;
+ uchar1 = 8;
+ rotate_left_3();
+
+ uchar0 = 1;
+ uchar1 = 0x10;
+ rotate_left_4();
+
+ uchar0 = 1;
+ uchar1 = 0x20;
+ rotate_left_5();
+
+ uchar0 = 1;
+ uchar1 = 0x40;
+ rotate_left_6();
+
+ uchar0 = 1;
+ uchar1 = 0x80;
+ rotate_left_7();
+
+ uchar0 = 2;
+ uchar1 = 1;
+ rotate_right_1();
+
+ uchar0 = 1;
+ uchar1 = 0x80;
+ rotate_right_1();
+
+ uchar0 = 4;
+ uchar1 = 1;
+ rotate_right_2();
+
+ uchar0 = 8;
+ rotate_right_3();
+
+ uchar0 = 0x10;
+ rotate_right_4();
+
+ uchar0 = 0x20;
+ rotate_right_5();
+
+ uchar0 = 0x40;
+ rotate_right_6();
+
+ uchar0 = 0x80;
+ rotate_right_7();
+
+ success=failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Shift bytes left and right by a constant.
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+#ifdef SIZEOF_INT_16BIT
+#if defined(__LINUX__) || defined(LINUX)
+signed short aint0 = 0;
+signed short aint1 = 0;
+
+#else
+signed int aint0 = 0;
+signed int aint1 = 0;
+
+#endif
+
+#else
+signed int aint0 = 0;
+signed int aint1 = 0;
+
+#endif
+signed char achar0 = 0;
+signed char achar1 = 0;
+signed char achar2 = 0;
+
+void done()
+{
+ dummy++;
+}
+
+void check(void)
+{
+ if(achar0 != achar1)
+ failures++;
+}
+
+void shift_left_1(void)
+{
+ achar0 <<= 1;
+
+ check();
+}
+
+void shift_left_2(void)
+{
+ achar0 <<= 2;
+
+ if(achar0 != achar1)
+ failures++;
+}
+
+void shift_left_3(void)
+{
+ achar0 <<= 3;
+
+ if(achar0 != achar1)
+ failures++;
+}
+
+void shift_left_4(void)
+{
+ achar0 <<= 4;
+
+ if(achar0 != achar1)
+ failures++;
+}
+
+void shift_left_5(void)
+{
+ achar0 <<= 5;
+
+ if(achar0 != achar1)
+ failures++;
+}
+
+void shift_left_6(void)
+{
+ achar0 <<= 6;
+
+ if(achar0 != achar1)
+ failures++;
+}
+
+void shift_left_7(void)
+{
+ achar0 <<= 7;
+
+ if(achar0 != achar1)
+ failures++;
+}
+
+void shift_right_1(void)
+{
+ achar0 >>= 1;
+
+ check();
+}
+
+void shift_right_2(void)
+{
+ achar0 >>= 2;
+
+ check();
+}
+
+void shift_right_3(void)
+{
+ achar0 >>= 3;
+
+ check();
+}
+
+void shift_right_4(void)
+{
+ achar0 >>= 4;
+
+ check();
+}
+
+void shift_right_5(void)
+{
+ achar0 >>= 5;
+
+ check();
+}
+
+void shift_right_6(void)
+{
+ achar0 >>= 6;
+
+ check();
+}
+
+void shift_right_7(void)
+{
+ achar0 >>= 7;
+
+ check();
+}
+
+int main(void)
+{
+ /* call with both values zero */
+ shift_left_1();
+ printf("failures: %d\n",failures);
+
+ achar0 = 1;
+ achar1 = 2;
+ for(achar2=0; achar2<6; achar2++) {
+ shift_left_1();
+ achar1 <<=1;
+ }
+ printf("failures: %d\n",failures);
+
+ achar0 = 1;
+ achar1 = 4;
+ shift_left_2();
+ printf("failures: %d\n",failures);
+
+ achar0 = 1;
+ achar1 = 8;
+ shift_left_3();
+ printf("failures: %d\n",failures);
+
+ achar0 = 1;
+ achar1 = 0x10;
+ shift_left_4();
+ printf("failures: %d\n",failures);
+
+ achar0 = 1;
+ achar1 = 0x20;
+ shift_left_5();
+ printf("failures: %d\n",failures);
+
+ achar0 = 1;
+ achar1 = 0x40;
+ shift_left_6();
+ printf("failures: %d\n",failures);
+
+ achar0 = 1;
+ achar1 = 0x80;
+ shift_left_7();
+ printf("failures: %d\n",failures);
+
+ achar0 = 2;
+ achar1 = 1;
+ shift_right_1();
+ printf("failures: %d\n",failures);
+
+ achar0 = 4;
+ shift_right_2();
+ printf("failures: %d\n",failures);
+
+ achar0 = 8;
+ shift_right_3();
+ printf("failures: %d\n",failures);
+
+ achar0 = 0x10;
+ shift_right_4();
+ printf("failures: %d\n",failures);
+
+ achar0 = 0x20;
+ shift_right_5();
+ printf("failures: %d\n",failures);
+
+ achar0 = 0x40;
+ shift_right_6();
+ printf("failures: %d\n",failures);
+
+ achar0 = 0xff;
+ achar1 = 0xff;
+ shift_right_1();
+ printf("failures: %d\n",failures);
+
+ achar0 = 0xfe;
+ achar1 = 0xff;
+ shift_right_1();
+ printf("failures: %d\n",failures);
+
+ achar0 = 0xfc;
+ shift_right_2();
+ printf("failures: %d\n",failures);
+
+ achar0 = 0xf8;
+ shift_right_3();
+ printf("failures: %d\n",failures);
+
+ achar0 = 0xf0;
+ shift_right_4();
+ printf("failures: %d\n",failures);
+
+ achar0 = 0xe0;
+ shift_right_5();
+ printf("failures: %d\n",failures);
+
+ achar0 = 0xc0;
+ shift_right_6();
+ printf("failures: %d\n",failures);
+
+ achar0 = 0x80;
+ achar1 = 0xff;
+ shift_right_7();
+
+ success=failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Shift bytes left and right by a variable.
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+#ifdef SIZEOF_INT_16BIT
+#if defined(__LINUX__) || defined(LINUX)
+signed short aint0 = 0;
+signed short aint1 = 0;
+
+#else
+signed int aint0 = 0;
+signed int aint1 = 0;
+
+#endif
+
+#else
+signed int aint0 = 0;
+signed int aint1 = 0;
+
+#endif
+signed char achar0 = 0;
+signed char achar1 = 0;
+signed char achar2 = 0;
+signed char achar3 = 0;
+
+void done()
+{
+ dummy++;
+}
+
+void shift_right_var(void)
+{
+ achar0 >>= achar1;
+}
+
+void shift_left_var(void)
+{
+ achar0 <<= achar1;
+}
+
+void shift_int_left_var(void)
+{
+ aint0 <<= achar1;
+}
+
+void shift_int_right_var(void)
+{
+ aint0 >>= achar1;
+}
+
+void shift_int_right_var2(void)
+{
+ aint0 = aint1 >> achar1;
+}
+
+void shift_int_left_var2(void)
+{
+ aint0 = aint1 << achar1;
+}
+
+int
+main (void)
+{
+ char i;
+
+ achar0 = 1;
+ achar1 = 1;
+ shift_left_var();
+
+ if(achar0 !=2)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ achar0 = 1;
+ achar1 = 1;
+ achar2 = 1;
+ for(i=0; i<7; i++) {
+ shift_left_var();
+ achar2 <<= 1;
+
+ if(achar2 != achar0)
+ failures++;
+ }
+ printf("failures: %d\n",failures);
+
+ achar1 = 4;
+ achar0 = 0xf0;
+ shift_right_var();
+ if(((unsigned char)achar0) != 0xff)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 1;
+ aint1 = 1;
+ achar1 = 1;
+
+ for(i=0; i<15; i++) {
+ shift_int_left_var();
+ aint1 <<= 1;
+ if(aint0 != aint1)
+ failures++;
+ }
+ printf("failures: %d\n",failures);
+
+ aint0 = 0x4000;
+ aint1 = 0x4000;
+
+ for(i=0; i<15; i++) {
+ shift_int_right_var();
+ aint1 >>= 1;
+ if(aint0 != aint1)
+ failures++;
+ }
+ printf("failures: %d\n",failures);
+
+ aint0 = -0x4000;
+ aint1 = -0x4000;
+
+ for(i=0; i<15; i++) {
+ shift_int_right_var();
+ aint1 >>= 1;
+ if(aint0 != aint1)
+ failures++;
+ }
+ printf("failures: %d\n",failures);
+
+ aint1 = 0xf000;
+ achar1 = 10;
+ shift_int_right_var2();
+
+ if(((unsigned short)aint0) != 0xfffc)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint1 = aint0;
+ shift_int_left_var2();
+
+ if(((unsigned short)aint0) != 0xf000)
+ failures++;
+
+ success=failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Shift ints left and right
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SIZEOF_INT_16BIT
+#if defined(__LINUX__) || defined(LINUX)
+signed short aint0 = 0;
+signed short aint1 = 0;
+
+#else
+signed int aint0 = 0;
+signed int aint1 = 0;
+
+#endif
+
+#else
+signed int aint0 = 0;
+signed int aint1 = 0;
+
+#endif
+
+/*
+signed char achar0 = 0;
+signed char achar1 = 0;
+signed char achar2 = 0;
+signed char achar3 = 0;
+*/
+
+void done()
+{
+ dummy++;
+}
+
+void shift_int_left_1(void)
+{
+ aint0 <<= 1;
+}
+
+void shift_int_left_2(void)
+{
+ aint0 <<= 2;
+}
+
+void shift_int_left_3(void)
+{
+ aint0 <<= 3;
+}
+
+void shift_int_left_4(void)
+{
+ aint0 <<= 4;
+}
+
+void shift_int_left_5(void)
+{
+ aint0 <<= 5;
+}
+
+void shift_int_left_6(void)
+{
+ aint0 <<= 6;
+}
+
+void shift_int_left_7(void)
+{
+ aint0 <<= 7;
+}
+
+void shift_int_left_8(void)
+{
+ aint0 <<= 8;
+}
+
+void shift_int_left_9(void)
+{
+ aint0 <<= 9;
+}
+
+void shift_int_left_10(void)
+{
+ aint0 <<= 10;
+}
+
+void shift_int_left_11(void)
+{
+ aint0 <<= 11;
+}
+
+void shift_int_left_12(void)
+{
+ aint0 <<= 12;
+}
+
+void shift_int_left_13(void)
+{
+ aint0 <<= 13;
+}
+
+void shift_int_left_14(void)
+{
+ aint0 <<= 14;
+}
+
+void shift_int_left_15(void)
+{
+ aint0 <<= 15;
+}
+
+/*****************************************************/
+void shift_int_right_1(void)
+{
+ aint0 >>= 1;
+}
+
+void shift_int_right_2(void)
+{
+ aint0 >>= 2;
+}
+
+void shift_int_right_3(void)
+{
+ aint0 >>= 3;
+}
+
+void shift_int_right_4(void)
+{
+ aint0 >>= 4;
+}
+
+void shift_int_right_5(void)
+{
+ aint0 >>= 5;
+}
+
+void shift_int_right_6(void)
+{
+ aint0 >>= 6;
+}
+
+void shift_int_right_7(void)
+{
+ aint0 >>= 7;
+}
+
+void shift_int_right_8(void)
+{
+ aint0 >>= 8;
+}
+
+void shift_int_right_9(void)
+{
+ aint0 >>= 9;
+}
+
+void shift_int_right_10(void)
+{
+ aint0 >>= 10;
+}
+
+void shift_int_right_11(void)
+{
+ aint0 >>= 11;
+}
+
+void shift_int_right_12(void)
+{
+ aint0 >>= 12;
+}
+
+void shift_int_right_13(void)
+{
+ aint0 >>= 13;
+}
+
+void shift_int_right_14(void)
+{
+ aint0 >>= 14;
+}
+
+void shift_int_right_15(void)
+{
+ aint0 >>= 15;
+}
+
+/*****************************************************/
+int
+main (void)
+{
+ aint0 = 0xabcd;
+
+ shift_int_left_1();
+ if(aint0 != 0x579a)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_left_2();
+ if((unsigned short)aint0 != 0xaf34)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_left_3();
+ if(aint0 != 0x5e68)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_left_4();
+ if((unsigned short)aint0 != 0xbcd0)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_left_5();
+ if(aint0 != 0x79a0)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_left_6();
+ if((unsigned short)aint0 != 0xf340)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_left_7();
+ if((unsigned short)aint0 != 0xe680)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_left_8();
+ if((unsigned short)aint0 != 0xcd00)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_left_9();
+ if((unsigned short)aint0 != 0x9a00)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_left_10();
+ if(aint0 != 0x3400)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_left_11();
+ if(aint0 != 0x6800)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_left_12();
+ if((unsigned short)aint0 != 0xd000)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_left_13();
+ if((unsigned short)aint0 != 0xa000)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_left_14();
+ if(aint0 != 0x4000)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_left_15();
+ if((unsigned short)aint0 != 0x8000)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ /***********************/
+ aint0 = 0xabcd;
+
+ shift_int_right_1();
+ if((unsigned short)aint0 != 0xd5e6)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_right_2();
+ if((unsigned short)aint0 != 0xeaf3)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_right_3();
+ if((unsigned short)aint0 != 0xf579)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_right_4();
+ if((unsigned short)aint0 != 0xfabc)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_right_5();
+ if((unsigned short)aint0 != 0xfd5e)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_right_6();
+ if((unsigned short)aint0 != 0xfeaf)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_right_7();
+ if((unsigned short)aint0 != 0xff57)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_right_8();
+ if((unsigned short)aint0 != 0xffab)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_right_9();
+ if((unsigned short)aint0 != 0xffd5)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_right_10();
+ if((unsigned short)aint0 != 0xffea)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_right_11();
+ if((unsigned short)aint0 != 0xfff5)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_right_12();
+ if((unsigned short)aint0 != 0xfffa)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_right_13();
+ if((unsigned short)aint0 != 0xfffd)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_right_14();
+ if((unsigned short)aint0 != 0xfffe)
+ failures++;
+ printf("failures: %d\n",failures);
+
+ aint0 = 0xabcd;
+
+ shift_int_right_15();
+ if(aint0 != -1)
+ failures++;
+
+ success=failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! A small test for atoi/strtol. Assumes twos complement
+ !!ORIGIN!!
+ !!LICENCE!!
+ !!AUTHOR!!
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+#define ERROR 0
+#define OK 1
+
+static unsigned int Failures = 0;
+
+static void IncStr (char* Buf)
+/* Increment a number represented as a string by one. The string MUST not
+ * start with a '9', we cannot handle overflow in this case.
+ */
+{
+ int Len = strlen (Buf);
+
+ while (--Len >= 0) {
+ switch (Buf[Len]) {
+ case '9':
+ Buf[Len] = '0';
+ break;
+
+ default:
+ ++(Buf[Len]);
+ return;
+ }
+ }
+}
+
+static void CheckStrToL (const char* Str, int Base, long Val, unsigned char Ok)
+{
+ char* EndPtr;
+ long Res = strtol (Str, &EndPtr, Base);
+ if (Ok) {
+ if (Res != Val) {
+ printf ("strtol error in \"%s\":\n"
+ " result = %ld, should be %ld, chars = %d\n",
+ Str, Res, Val, EndPtr - Str);
+ ++Failures;
+ }
+ } else {
+ if (errno != ERANGE) {
+ printf ("strtol error in \"%s\":\n"
+ " should not convert, but errno = %d\n",
+ Str, errno);
+ ++Failures;
+ }
+ if (Res != Val) {
+ printf ("strtol error in \"%s\":\n"
+ " result = %ld, should be %ld, chars = %d\n",
+ Str, Res, Val, EndPtr - Str);
+ ++Failures;
+ }
+ }
+}
+
+int main (void)
+{
+ char Buf[80];
+
+ /* Prefixed allowed if base = 0 */
+ CheckStrToL ("\t 0x10G ", 0, 16L, OK);
+ CheckStrToL ("\t 0X10G ", 0, 16L, OK);
+ CheckStrToL (" \t0377\t", 0, 255L, OK);
+ CheckStrToL (" 377", 0, 377L, OK);
+
+ CheckStrToL ("\t -0x10G ", 0, -16L, OK);
+ CheckStrToL ("\t -0X10G ", 0, -16L, OK);
+ CheckStrToL (" \t-0377\t", 0, -255L, OK);
+ CheckStrToL (" -377", 0, -377L, OK);
+
+ /* No prefixes if base = 10 */
+ CheckStrToL ("\t 1234 ", 10, 1234L, OK);
+ CheckStrToL ("\t -1234 ", 10, -1234L, OK);
+ CheckStrToL ("\t -0x10G ", 10, 0L, OK);
+ CheckStrToL ("\t -0X10G ", 10, 0L, OK);
+ CheckStrToL (" \t-0377\t", 10, -377L, OK);
+ CheckStrToL (" 0377", 10, 377L, OK);
+
+ /* 0x prefix is allowed if base = 16 */
+ CheckStrToL ("\t 0x1234 ", 16, 0x1234L, OK);
+ CheckStrToL ("\t -0x1234 ", 16, -0x1234L, OK);
+ CheckStrToL ("\t -010G ", 16, -16L, OK);
+ CheckStrToL ("\t 10G ", 16, 16L, OK);
+
+ /* Check LONG_MIN and LONG_MAX */
+ sprintf (Buf, "%ld", LONG_MIN);
+ CheckStrToL (Buf, 0, LONG_MIN, OK);
+ sprintf (Buf, "%ld", LONG_MAX);
+ CheckStrToL (Buf, 0, LONG_MAX, OK);
+
+ /* Check value one smaller */
+ sprintf (Buf+1, "%ld", LONG_MIN);
+ Buf[1] = '0'; /* Overwrite '-' */
+ IncStr (Buf+1);
+ if (Buf[1] == '0') {
+ Buf[1] = '-';
+ Buf[0] = ' ';
+ } else {
+ Buf[0] = '-';
+ }
+ CheckStrToL (Buf, 0, LONG_MIN, ERROR);
+
+ /* Check value one larger */
+ sprintf (Buf+1, "%ld", LONG_MAX);
+ Buf[0] = '0';
+ IncStr (Buf);
+ if (Buf[0] == '0') {
+ Buf[0] = ' ';
+ }
+ CheckStrToL (Buf, 0, LONG_MAX, ERROR);
+
+ /* Check numbers that are much too large or small */
+ CheckStrToL ("-999999999999999999999999999999999999999999999999999999999", 0, LONG_MIN, ERROR);
+ CheckStrToL ("+999999999999999999999999999999999999999999999999999999999", 0, LONG_MAX, ERROR);
+ CheckStrToL (" 999999999999999999999999999999999999999999999999999999999", 0, LONG_MAX, ERROR);
+
+ /* Check a few other bases */
+ CheckStrToL ("aBcD", 36, 481261L, OK);
+ CheckStrToL ("zyaB", 35, 0L, ERROR);
+ CheckStrToL ("zyaB", 36, 1677395L, ERROR);
+
+ printf ("Failures: %u\n", Failures);
+
+ return Failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! A small test for strtuol. Assumes twos complement
+ !!ORIGIN!!
+ !!LICENCE!!
+ !!AUTHOR!!
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+#define ERROR 0
+#define OK 1
+
+static unsigned int Failures = 0;
+
+static void IncStr (char* Buf)
+/* Increment a number represented as a string by one. The string MUST not
+ * start with a '9', we cannot handle overflow in this case.
+ */
+{
+ int Len = strlen (Buf);
+
+ while (--Len >= 0) {
+ switch (Buf[Len]) {
+ case '9':
+ Buf[Len] = '0';
+ break;
+
+ default:
+ ++(Buf[Len]);
+ return;
+ }
+ }
+}
+
+static void CheckStrToUL (const char* Str, int Base, unsigned long Val, unsigned char Ok)
+{
+ char* EndPtr;
+ unsigned long Res = strtoul (Str, &EndPtr, Base);
+ if (Ok) {
+ if (Res != Val) {
+ printf ("strtol error in \"%s\":\n"
+ " result = %lu, should be %lu, chars = %d\n",
+ Str, Res, Val, EndPtr - Str);
+ ++Failures;
+ }
+ } else {
+ if (errno != ERANGE) {
+ printf ("strtol error in \"%s\":\n"
+ " should not convert, but errno = %d\n",
+ Str, errno);
+ ++Failures;
+ }
+ if (Res != Val) {
+ printf ("strtol error in \"%s\":\n"
+ " result = %lu, should be %lu, chars = %d\n",
+ Str, Res, Val, EndPtr - Str);
+ ++Failures;
+ }
+ }
+}
+
+int main (void)
+{
+ char Buf[80];
+
+ /* Prefixed allowed if base = 0 */
+ CheckStrToUL ("\t 0x10G ", 0, 16UL, OK);
+ CheckStrToUL ("\t 0X10G ", 0, 16UL, OK);
+ CheckStrToUL (" \t0377\t", 0, 255UL, OK);
+ CheckStrToUL (" 377", 0, 377UL, OK);
+
+ CheckStrToUL ("\t -0x10G ", 0, (unsigned long) -16L, OK);
+ CheckStrToUL ("\t -0X10G ", 0, (unsigned long) -16L, OK);
+ CheckStrToUL (" \t-0377\t", 0, (unsigned long) -255L, OK);
+ CheckStrToUL (" -377", 0, (unsigned long) -377L, OK);
+
+ /* No prefixes if base = 10 */
+ CheckStrToUL ("\t 1234 ", 10, 1234UL, OK);
+ CheckStrToUL ("\t -1234 ", 10, (unsigned long) -1234L, OK);
+ CheckStrToUL ("\t -0x10G ", 10, 0UL, OK);
+ CheckStrToUL ("\t -0X10G ", 10, 0UL, OK);
+ CheckStrToUL (" \t-0377\t", 10, (unsigned long) -377L, OK);
+ CheckStrToUL (" 0377", 10, 377UL, OK);
+
+ /* 0x prefix is allowed if base = 16 */
+ CheckStrToUL ("\t 0x1234 ", 16, 0x1234UL, OK);
+ CheckStrToUL ("\t -0x1234 ", 16, (unsigned long) -0x1234L, OK);
+ CheckStrToUL ("\t -010G ", 16, (unsigned long) -16L, OK);
+ CheckStrToUL ("\t 10G ", 16, 16UL, OK);
+
+ /* Check ULONG_MAX */
+ sprintf (Buf, "%lu", ULONG_MAX);
+ CheckStrToUL (Buf, 0, ULONG_MAX, OK);
+
+ /* Check value one larger */
+ sprintf (Buf+1, "%lu", ULONG_MAX);
+ Buf[0] = '0';
+ IncStr (Buf);
+ if (Buf[0] == '0') {
+ Buf[0] = ' ';
+ }
+ CheckStrToUL (Buf, 0, ULONG_MAX, ERROR);
+
+ /* Check numbers that are much too large or small */
+ CheckStrToUL ("-999999999999999999999999999999999999999999999999999999999", 0, ULONG_MAX, ERROR);
+ CheckStrToUL ("+999999999999999999999999999999999999999999999999999999999", 0, ULONG_MAX, ERROR);
+ CheckStrToUL (" 999999999999999999999999999999999999999999999999999999999", 0, ULONG_MAX, ERROR);
+
+ /* Check a few other bases */
+ CheckStrToUL ("aBcD", 36, 481261UL, OK);
+ CheckStrToUL ("zyaB", 35, 0UL, ERROR);
+ CheckStrToUL ("zyaB", 36, 1677395UL, ERROR);
+
+ printf ("Failures: %u\n", Failures);
+
+ return Failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#if SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char *acharP = 0;
+
+struct chars
+ {
+ unsigned char c0, c1;
+ unsigned int i0, i1;
+ };
+
+struct chars struct1;
+
+void
+done ()
+{
+ dummy++;
+}
+
+void
+struct_test (void)
+{
+ if (struct1.c0 || struct1.c1)
+ failures++;
+
+ struct1.c0++;
+
+ if (struct1.c0 != 1)
+ failures++;
+}
+
+void
+ptr_to_struct (struct chars *p)
+{
+ if (p->c1)
+ failures++;
+
+ p->c1++;
+
+ if (p->c1 != 1)
+ failures++;
+}
+
+void add_chars(void)
+{
+ achar0 = struct1.c0 + struct1.c1;
+
+ if(achar0 != 1)
+ failures++;
+}
+
+int
+main (void)
+{
+ struct1.c0 = 0;
+ struct1.c1 = 0;
+ struct_test ();
+ ptr_to_struct (&struct1);
+
+ struct1.c0 = 0;
+ struct1.c1 = 1;
+ add_chars();
+
+ success = failures;
+ done ();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Substraction Test
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#if SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+#ifdef SIZEOF_INT_16BIT
+#if defined(__LINUX__) || defined(LINUX)
+unsigned short aint0 = 0;
+unsigned short aint1 = 0;
+#else
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+#endif
+
+#else
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+#endif
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+unsigned char *acharP = 0;
+
+void done()
+{
+ dummy++;
+}
+
+void sub_lit_from_uchar(void)
+{
+ achar0 = achar0 - 5;
+
+ if(achar0 != 0xfb)
+ failures++;
+
+ achar0 -= 10;
+
+ if(achar0 != 0xf1)
+ failures++;
+
+ achar0 = achar0 -1; /* Should be a decrement */
+ if(achar0 != 0xf0)
+ failures++;
+
+ for(achar1 = 0; achar1 < 100; achar1++)
+ achar0 -= 2;
+
+ if(achar0 != 40)
+ failures++;
+}
+
+/* achar0 = 1
+ achar1 = 100
+*/
+
+void sub_uchar2uchar(void)
+{
+ achar1 = achar1 - achar0;
+
+ if(achar1 != 99)
+ failures++;
+
+ for(achar2 = 0; achar2<7; achar2++)
+ achar1 -= achar0;
+
+ if(achar1 != 92)
+ failures++;
+}
+
+/* assumes
+ achar0 = 10
+ achar1 = 32
+ achar2, achar3 can be anything.
+*/
+void sub_uchar2uchar2(void)
+{
+ achar0--;
+ achar0 = achar0 - 1;
+ achar0 = achar0 - 2;
+ achar0 = achar0 - 3;
+ if(achar0 != 3)
+ failures++;
+
+ achar1 -= achar0;
+ if(achar1 != 29)
+ failures++;
+
+ achar2 = achar1 - achar0;
+ if(achar2 != 26)
+ failures++;
+
+ achar3 = achar2 - achar1 - achar0;
+ if(achar3 != 0xfa)
+ failures++;
+}
+
+/* sub_bits
+ all bit variables are 0 upon entry.
+*/
+#if SUPPORT_BIT_TYPES
+void sub_bits(void)
+{
+ bit1 = bit0;
+
+ bit0 = 1;
+
+ if(bit1 != 0)
+ failures++;
+
+ bit1 = bit0-bit1; /* 1 - 0 => 1 */
+ if(bit1 != 1)
+ failures++;
+
+#if SUPPORT_BIT_ARITHMETIC
+ bit2 = bit1-bit0; /* 1 - 1 => 0 */
+ if(bit2)
+ failures++;
+
+ bit7 = bit4-bit5;
+ bit6 = bit4+bit5;
+ bit3 = bit4-bit5-bit6-bit7-bit0; /* 0-0-0-0-1 => 1 */
+ if(!bit3)
+ failures++;
+#endif
+}
+
+/* sub_bit2uchar(void) - assumes bit0 = 1, achar0 = 7 */
+
+void sub_bit2uchar(void)
+{
+ achar0 -= bit0;
+
+ if(achar0 != 6)
+ failures++;
+
+ if(achar0 == bit0)
+ failures++;
+}
+
+void sub_bit2uint(void)
+{
+ if(aint0 != bit11)
+ failures++;
+
+ aint0 -= bit0;
+ if(aint0!=0xffff)
+ failures++;
+}
+#endif
+
+void sub_ucharFromLit(void)
+{
+ achar0 = 2 - achar0;
+
+ if(achar0 != 2)
+ {
+ printf("%x != %x\n",0x02,achar0);
+ failures++;
+ }
+
+ aint0 = 2 - aint0;
+
+ if(aint0 != 2)
+ {
+ printf("%x != %x\n",0x02,aint0);
+ failures++;
+ }
+
+ aint0--;
+
+ if(aint0 != 1)
+ {
+ printf("%x != %x\n",0x01,aint0);
+ failures++;
+ }
+
+ aint0 = 0x100 - aint0;
+
+ if(aint0 != 0xff)
+ {
+ printf("%x != %x\n",0xff,aint0);
+ failures++;
+ }
+
+ aint0 = 0xff00 - aint0;
+
+ if(aint0 != 0xfe01)
+ {
+ printf("%x != %x\n",0xfe01,aint0);
+ failures++;
+ }
+
+ aint0 = 0x0e01 - aint0;
+
+ if(aint0 != 0x1000)
+ {
+ printf("%x != %x\n",0x1000,aint0);
+ failures++;
+ }
+
+ aint0 = 0x10ff - aint0;
+
+ if(aint0 != 0xff)
+ {
+ printf("%x != %x\n",0xff,aint0);
+ failures++;
+ }
+}
+
+int main(void)
+{
+ sub_lit_from_uchar();
+ printf("failures: %d\n",failures);
+
+ achar0=1;
+ achar1=100;
+ sub_uchar2uchar();
+ printf("failures: %d\n",failures);
+
+ achar0 = 10;
+ achar1 = 32;
+ sub_uchar2uchar2();
+ printf("failures: %d\n",failures);
+
+#if SUPPORT_BIT_TYPES
+ sub_bits();
+
+ achar0 = 7;
+ bit0 = 1;
+ sub_bit2uchar();
+ printf("failures: %d\n",failures);
+ sub_bit2uint();
+ printf("failures: %d\n",failures);
+#endif
+
+ aint0 = 0;
+ achar0 = 0;
+ sub_ucharFromLit();
+
+ success = failures;
+ done();
+
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!! Substraction Test
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#if SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+int int0 = 0;
+int int1 = 0;
+
+signed char char0 = 0;
+signed char char1 = 0;
+signed char char2 = 0;
+
+void done()
+{
+ dummy++;
+}
+
+void sub_int1(void)
+{
+ if(int0 != 5)
+ failures++;
+
+ if(int1 != 4)
+ failures++;
+
+ int0 = int0 - int1;
+
+ if(int0 != 1)
+ failures++;
+
+ int0 = 4 - int0;
+ if(int0 != 3)
+ failures++;
+
+ int0 = int0 - int1;
+
+ if(int0 != -1)
+ failures++;
+
+ int0 = int0 - 0xff;
+
+ if(int0 != -0x100)
+ failures++;
+
+ int0 = 0xff - int0;
+
+ if(int0 != 0x1ff)
+ failures++;
+}
+
+void sub_char_int(void)
+{
+ int0 = int0 - char0;
+
+ if(int0 != 3)
+ failures++;
+
+ if(int0 < char0)
+ failures++;
+
+ int0 = int0 - char0;
+
+ if(int0 != 1)
+ failures++;
+
+ if(int0 > char0)
+ failures++;
+
+ int0 = int0 - char0;
+ if(int0 != -1)
+ failures++;
+
+ if(int0>0)
+ failures++;
+}
+
+void assign_char2int(void)
+{
+ int0 = char0;
+ if(int0 != 0x7f)
+ failures++;
+
+ /* printf("%2x %2x %2x %d\n",0x7f,int0,char0,failures); */
+
+ int1 = char1;
+ if(int1 != -5)
+ failures++;
+
+ /* printf("%2x,%d %2x,%d %2x,%d %d\n",-5,-5,(int)int1,(int)int1,(int)char1,(int)char1,failures); */
+}
+
+void sub_compound_char(void)
+{
+ char0 = char1 - 5;
+ if(char0 != 4)
+ failures++;
+
+ if((char1 - char0 - 5) != 0)
+ failures++;
+}
+
+void sub_compound_int(void)
+{
+ int0 = int1 - 5;
+ if(int0 != 4)
+ failures++;
+
+ if((int1 - int0 - 5) != 0)
+ failures++;
+}
+
+int main(void)
+{
+ int0 = 5;
+ int1 = 4;
+
+ sub_int1();
+ printf("failures: %d\n",failures);
+
+ int0 = 5;
+ int1 = 4;
+ char0 = 2;
+
+ sub_char_int();
+ printf("failures: %d\n",failures);
+
+ char0 = 0x7f;
+ char1 = -5;
+ assign_char2int();
+ printf("failures: %d\n",failures);
+
+ char1 = 9;
+ sub_compound_char();
+ printf("failures: %d\n",failures);
+
+ int1 = 9;
+ sub_compound_int();
+
+ success = failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void done()
+{
+ dummy++;
+}
+
+void switch1(void)
+{
+ switch(achar0) {
+ case 0:
+ achar0 = 9;
+ break;
+ case 1:
+ achar0 = 18;
+ break;
+
+ default:
+ achar0 = 0;
+ }
+}
+
+void switch2(void)
+{
+ switch(achar1) {
+ case 0: achar0 = 9; break;
+ case 1: achar0 = 8; break;
+ case 2: achar0 = 7; break;
+ case 3: achar0 = 6; break;
+ case 4: achar0 = 5; break;
+ case 5: achar0 = 4; break;
+ case 6: achar0 = 3; break;
+ case 7: achar0 = 2; break;
+ case 8: achar0 = 1; break;
+ case 9: achar0 = 0; break;
+ case 10: achar0 = 9; break;
+ case 11: achar0 = 8; break;
+ case 12: achar0 = 7; break;
+ default: achar0 = 0xff; break;
+ }
+}
+
+int main(void)
+{
+ achar0 = 0;
+ switch1();
+ if(achar0 != 9)
+ failures++;
+
+ switch1();
+ if(achar0 != 0)
+ failures++;
+
+ achar0++;
+
+ switch1();
+ if(achar0 != 18)
+ failures++;
+
+ for(achar1=0; achar1<10;achar1++){
+ switch2();
+ if(achar0 != (9-achar1))
+ failures++;
+
+ }
+
+ success=failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+#ifdef SUPPORT_BIT_TYPES
+bit bit0 = 0;
+#endif
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void
+done ()
+{
+ dummy++;
+}
+
+void
+while1 (void)
+{
+ unsigned char i = 10;
+
+ do
+ {
+ achar0++;
+ }
+ while (--i);
+
+ if (achar0 != 10)
+ failures++;
+}
+
+int
+main (void)
+{
+ while1 ();
+
+ success = failures;
+ done ();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+/*
+ !!DESCRIPTION!!
+ !!ORIGIN!! SDCC regression tests
+ !!LICENCE!! GPL, read COPYING.GPL
+*/
+
+#include <stdio.h>
+#include <limits.h>
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+
+void done()
+{
+ dummy++;
+}
+
+void xor_chars_0_1(void)
+{
+ achar2 = achar0 ^ achar1;
+
+ achar0 = achar0 ^ 0x1;
+
+ achar1 = achar0 ^ achar1 ^ 4;
+}
+
+void xor_if(void)
+{
+ if(achar0 ^ achar1)
+ failures++;
+
+ achar0 ^= 0xff;
+
+ if( !(achar0 ^ achar1) )
+ failures++;
+}
+
+int main(void)
+{
+ xor_chars_0_1();
+
+ if(achar2)
+ failures++;
+
+ if(achar0 != 1)
+ failures++;
+
+ if(achar1 != 5)
+ failures++;
+
+ achar0 = achar1;
+ xor_if();
+
+ success = failures;
+ done();
+ printf("failures: %d\n",failures);
+
+ return failures;
+}
--- /dev/null
+chkillegal.bin
+chklegal.bin
+chkall.bin
+legal.o
+illegal.o
+all.o
--- /dev/null
+
+all: chklegal.bin chkillegal.bin chkall.bin
+ @#
+
+.PHONY: chklegal.bin chkillegal.bin chkall.bin
+
+chklegal.bin: legal.s
+ ../../bin/cl65 --target none --cpu 6502X -o chklegal.bin legal.s
+ diff -q legal.ref chklegal.bin || hex chklegal.bin
+
+chkillegal.bin: illegal.s
+ ../../bin/cl65 --target none --cpu 6502X -o chkillegal.bin illegal.s
+ diff -q illegal.ref chkillegal.bin || hex chkillegal.bin
+
+chkall.bin: all.s
+ ../../bin/cl65 --target none --cpu 6502X -o chkall.bin all.s
+
+ref: legal.s illegal.s
+ ../../bin/cl65 --target none --cpu 6502X -o legal.ref legal.s
+ ../../bin/cl65 --target none --cpu 6502X -o illegal.ref illegal.s
+
+clean:
+ rm -f legal.o chklegal.bin
+ rm -f illegal.o chkillegal.bin
+ rm -f all.o chkall.bin
--- /dev/null
+ .setcpu "6502X"
+
+; all legal and illegal opcodes as they would be disassembled by da65
+; note that this would not assemble into the exact same binary
+
+ brk ; 00
+ ora ($12,x) ; 01 12
+ jam ; 02
+ slo ($12,x) ; 03 12
+ nop $12 ; 04 12
+ ora $12 ; 05 12
+ asl $12 ; 06 12
+ slo $12 ; 07 12
+ php ; 08
+ ora #$12 ; 09 12
+ asl a ; 0a
+ anc #$12 ; 0b 12
+ nop $1234 ; 0c 34 12
+ ora $1234 ; 0d 34 12
+ asl $1234 ; 0e 34 12
+ slo $1234 ; 0f 34 12
+ bpl *+$14 ; 10 12
+ ora ($12),y ; 11 12
+ jam ; 12
+ slo ($12),y ; 13 12
+ nop $12,x ; 14 12
+ ora $12,x ; 15 12
+ asl $12,x ; 16 12
+ slo $12,x ; 17 12
+ clc ; 18
+ ora $1234,y ; 19 34 12
+ nop ; 1a
+ slo $1234,y ; 1b 34 12
+ nop $1234,x ; 1c 34 12
+ ora $1234,x ; 1d 34 12
+ asl $1234,x ; 1e 34 12
+ slo $1234,x ; 1f 34 12
+ jsr $1234 ; 20 34 12
+ and ($12,x) ; 21 12
+ jam ; 22
+ rla ($12,x) ; 23 12
+ bit $12 ; 24 12
+ and $12 ; 25 12
+ rol $12 ; 26 12
+ rla $12 ; 27 12
+ plp ; 28
+ and #$12 ; 29 12
+ rol a ; 2a
+ anc #$12 ; 2b 12
+ bit $1234 ; 2c 34 12
+ and $1234 ; 2d 34 12
+ rol $1234 ; 2e 34 12
+ rla $1234 ; 2f 34 12
+ bmi *+$14 ; 30 12
+ and ($12),y ; 31 12
+ jam ; 32
+ rla ($12),y ; 33 12
+ nop $12,x ; 34 12
+ and $12,x ; 35 12
+ rol $12,x ; 36 12
+ rla $12,x ; 37 12
+ sec ; 38
+ and $1234,y ; 39 34 12
+ nop ; 3a
+ rla $1234,y ; 3b 34 12
+ nop $1234,x ; 3c 34 12
+ and $1234,x ; 3d 34 12
+ rol $1234,x ; 3e 34 12
+ rla $1234,x ; 3f 34 12
+ rti ; 40
+ eor ($12,x) ; 41 12
+ jam ; 42
+ sre ($12,x) ; 43 12
+ nop $12 ; 44 12
+ eor $12 ; 45 12
+ lsr $12 ; 46 12
+ sre $12 ; 47 12
+ pha ; 48
+ eor #$12 ; 49 12
+ lsr a ; 4a
+ alr #$12 ; 4b 12
+ jmp $1234 ; 4c 34 12
+ eor $1234 ; 4d 34 12
+ lsr $1234 ; 4e 34 12
+ sre $1234 ; 4f 34 12
+ bvc *+$14 ; 50 12
+ eor ($12),y ; 51 12
+ jam ; 52
+ sre ($12),y ; 53 12
+ nop $12,x ; 54 12
+ eor $12,x ; 55 12
+ lsr $12,x ; 56 12
+ sre $12,x ; 57 12
+ cli ; 58
+ eor $1234,y ; 59 34 12
+ nop ; 5a
+ sre $1234,y ; 5b 34 12
+ nop $1234,x ; 5c 34 12
+ eor $1234,x ; 5d 34 12
+ lsr $1234,x ; 5e 34 12
+ sre $1234,x ; 5f 34 12
+ rts ; 60
+ adc ($12,x) ; 61 12
+ jam ; 62
+ rra ($12,x) ; 63 12
+ nop $12 ; 64 12
+ adc $12 ; 65 12
+ ror $12 ; 66 12
+ rra $12 ; 67 12
+ pla ; 68
+ adc #$12 ; 69 12
+ ror a ; 6a
+ arr #$12 ; 6b 12
+ jmp ($1234) ; 6c 34 12
+ adc $1234 ; 6d 34 12
+ ror $1234 ; 6e 34 12
+ rra $1234 ; 6f 34 12
+ bvs *+$14 ; 70 12
+ adc ($12),y ; 71 12
+ jam ; 72
+ rra ($12),y ; 73 12
+ nop $12,x ; 74 12
+ adc $12,x ; 75 12
+ ror $12,x ; 76 12
+ rra $12,x ; 77 12
+ sei ; 78
+ adc $1234,y ; 79 34 12
+ nop ; 7a
+ rra $1234,y ; 7b 34 12
+ nop $1234,x ; 7c 34 12
+ adc $1234,x ; 7d 34 12
+ ror $1234,x ; 7e 34 12
+ rra $1234,x ; 7f 34 12
+ nop #$12 ; 80 12
+ sta ($12,x) ; 81 12
+ nop #$12 ; 82 12
+ sax ($12,x) ; 83 12
+ sty $12 ; 84 12
+ sta $12 ; 85 12
+ stx $12 ; 86 12
+ sax $12 ; 87 12
+ dey ; 88
+ nop #$12 ; 89 12
+ txa ; 8a
+ ane #$12 ; 8b 12
+ sty $1234 ; 8c 34 12
+ sta $1234 ; 8d 34 12
+ stx $1234 ; 8e 34 12
+ sax $1234 ; 8f 34 12
+ bcc *+$14 ; 90 12
+ sta ($12),y ; 91 12
+ jam ; 92
+ sha ($12),y ; 93 12
+ sty $12,x ; 94 12
+ sta $12,x ; 95 12
+ stx $12,y ; 96 12
+ sax $12,y ; 97 12
+ tya ; 98
+ sta $1234,y ; 99 34 12
+ txs ; 9a
+ tas $1234,y ; 9b 34 12
+ shy $1234,x ; 9c 34 12
+ sta $1234,x ; 9d 34 12
+ shx $1234,y ; 9e 34 12
+ sha $1234,y ; 9f 34 12
+ ldy #$12 ; a0 12
+ lda ($12,x) ; a1 12
+ ldx #$12 ; a2 12
+ lax ($12,x) ; a3 12
+ ldy $12 ; a4 12
+ lda $12 ; a5 12
+ ldx $12 ; a6 12
+ lax $12 ; a7 12
+ tay ; a8
+ lda #$12 ; a9 12
+ tax ; aa
+ lax #$12 ; ab 12
+ ldy $1234 ; ac 34 12
+ lda $1234 ; ad 34 12
+ ldx $1234 ; ae 34 12
+ lax $1234 ; af 34 12
+ bcs *+$14 ; b0 12
+ lda ($12),y ; b1 12
+ jam ; b2
+ lax ($12),y ; b3 12
+ ldy $12,x ; b4 12
+ lda $12,x ; b5 12
+ ldx $12,y ; b6 12
+ lax $12,y ; b7 12
+ clv ; b8
+ lda $1234,y ; b9 34 12
+ tsx ; ba
+ las $1234,y ; bb 34 12
+ ldy $1234,x ; bc 34 12
+ lda $1234,x ; bd 34 12
+ ldx $1234,y ; be 34 12
+ lax $1234,y ; bf 34 12
+ cpy #$12 ; c0 12
+ cmp ($12,x) ; c1 12
+ nop #$12 ; c2 12
+ dcp ($12,x) ; c3 12
+ cpy $12 ; c4 12
+ cmp $12 ; c5 12
+ dec $12 ; c6 12
+ dcp $12 ; c7 12
+ iny ; c8
+ cmp #$12 ; c9 12
+ dex ; ca
+ axs #$12 ; cb 12
+ cpy $1234 ; cc 34 12
+ cmp $1234 ; cd 34 12
+ dec $1234 ; ce 34 12
+ dcp $1234 ; cf 34 12
+ bne *+$14 ; d0 12
+ cmp ($12),y ; d1 12
+ jam ; d2
+ dcp ($12),y ; d3 12
+ nop $12,x ; d4 12
+ cmp $12,x ; d5 12
+ dec $12,x ; d6 12
+ dcp $12,x ; d7 12
+ cld ; d8
+ cmp $1234,y ; d9 34 12
+ nop ; da
+ dcp $1234,y ; db 34 12
+ nop $1234,x ; dc 34 12
+ cmp $1234,x ; dd 34 12
+ dec $1234,x ; de 34 12
+ dcp $1234,x ; df 34 12
+ cpx #$12 ; e0 12
+ sbc ($12,x) ; e1 12
+ nop #$12 ; e2 12
+ isc ($12,x) ; e3 12
+ cpx $12 ; e4 12
+ sbc $12 ; e5 12
+ inc $12 ; e6 12
+ isc $12 ; e7 12
+ inx ; e8
+ sbc #$12 ; e9 12
+ nop ; ea
+ sbc #$12 ; eb 12
+ cpx $1234 ; ec 34 12
+ sbc $1234 ; ed 34 12
+ inc $1234 ; ee 34 12
+ isc $1234 ; ef 34 12
+ beq *+$14 ; f0 12
+ sbc ($12),y ; f1 12
+ jam ; f2
+ isc ($12),y ; f3 12
+ nop $12,x ; f4 12
+ sbc $12,x ; f5 12
+ inc $12,x ; f6 12
+ isc $12,x ; f7 12
+ sed ; f8
+ sbc $1234,y ; f9 34 12
+ isc $1234,y ; fb 34 12
+ nop $1234,x ; fc 34 12
+ sbc $1234,x ; fd 34 12
+ inc $1234,x ; fe 34 12
+ isc $1234,x ; ff 34 12
--- /dev/null
+\a\12\ f4\12\1f4\12\e4\12\ 3\12\17\12\13\12'\12/4\12?4\12;4\12#\127\123\12O4\12_4\12[4\12G\12C\12W\12S\12o4\12\7f4\12{4\12g\12c\12w\12s\12Ï4\12ß4\12Û4\12Ç\12Ã\12×\12Ó\12ï4\12ÿ4\12û4\12ç\12ã\12÷\12ó\12\8f4\12\87\12\83\12\97\12¯4\12¿4\12§\12£\12³\12·\12\v\12k\12K\12Ë\12\f4\12\1c4\12\ 4\12\14\12\80\12\ 2\93\12\9f4\12\9e4\12\9c4\12\9b4\12»4\12«\12\8b\12
\ No newline at end of file
.setcpu "6502X"
+; all so called "illegal" opcodes. duplicated (functionally identical) ones
+; are commented out
-.macro test opc
+; first all totally stable undocs:
- opc $00
- opc $00,x
- opc ($00,x)
- opc ($00),y
- opc $1234
- opc $1234,x
- opc $1234,y
+ slo $12 ; 07 12
+ slo $1234 ; 0f 34 12
+ slo $1234,x ; 1f 34 12
+ slo $1234,y ; 1b 34 12
+ slo ($12,x) ; 03 12
+ slo $12,x ; 17 12
+ slo ($12),y ; 13 12
-.endmacro
+ rla $12 ; 27 12
+ rla $1234 ; 2f 34 12
+ rla $1234,x ; 3f 34 12
+ rla $1234,y ; 3b 34 12
+ rla ($12,x) ; 23 12
+ rla $12,x ; 37 12
+ rla ($12),y ; 33 12
+ sre $1234 ; 4f 34 12
+ sre $1234,x ; 5f 34 12
+ sre $1234,y ; 5b 34 12
+ sre $12 ; 47 12
+ sre ($12,x) ; 43 12
+ sre $12,x ; 57 12
+ sre ($12),y ; 53 12
- test slo
- test rla
- test sre
- test rra
- test dcp
- test isc
+ rra $1234 ; 6f 34 12
+ rra $1234,x ; 7f 34 12
+ rra $1234,y ; 7b 34 12
+ rra $12 ; 67 12
+ rra ($12,x) ; 63 12
+ rra $12,x ; 77 12
+ rra ($12),y ; 73 12
- sax $00
- sax $00,y
- sax ($00,x)
- sax $1234
+ dcp $1234 ; cf 34 12
+ dcp $1234,x ; df 34 12
+ dcp $1234,y ; db 34 12
+ dcp $12 ; c7 12
+ dcp ($12,x) ; c3 12
+ dcp $12,x ; d7 12
+ dcp ($12),y ; d3 12
- lax $00
- lax $00,y
- lax ($00,x)
- lax ($00),y
- lax $1234
- lax $1234,y
+ isc $1234 ; ef 34 12
+ isc $1234,x ; ff 34 12
+ isc $1234,y ; fb 34 12
+ isc $12 ; e7 12
+ isc ($12,x) ; e3 12
+ isc $12,x ; f7 12
+ isc ($12),y ; f3 12
- anc #$55
- alr #$55
- arr #$55
- axs #$55
+ sax $1234 ; 8f 34 12
+ sax $12 ; 87 12
+ sax ($12,x) ; 83 12
+ sax $12,y ; 97 12
- las $1234,y
+ lax $1234 ; af 34 12
+ lax $1234,y ; bf 34 12
+ lax $12 ; a7 12
+ lax ($12,x) ; a3 12
+ lax ($12),y ; b3 12
+ lax $12,y ; b7 12
+ anc #$12 ; 0b 12
+ ;anc #$12 ; 2b 12
+
+ arr #$12 ; 6b 12
+
+ alr #$12 ; 4b 12
+
+ axs #$12 ; cb 12
+
+ nop $1234 ; 0c 34 12
+ nop $1234,x ; 1c 34 12
+ nop $12 ; 04 12
+ nop $12,x ; 14 12
+ nop #$12 ; 80 12
+ ;nop $1234,x ; 3c 34 12
+ ;nop $1234,x ; 5c 34 12
+ ;nop $1234,x ; 7c 34 12
+ ;nop $1234,x ; dc 34 12
+ ;nop $1234,x ; fc 34 12
+ ;nop $12 ; 44 12
+ ;nop $12 ; 64 12
+ ;nop #$12 ; 82 12
+ ;nop #$12 ; 89 12
+ ;nop #$12 ; c2 12
+ ;nop #$12 ; e2 12
+ ;nop $12,x ; 34 12
+ ;nop $12,x ; 54 12
+ ;nop $12,x ; 74 12
+ ;nop $12,x ; d4 12
+ ;nop $12,x ; f4 12
+ ;nop ; 1a
+ ;nop ; 3a
+ ;nop ; 5a
+ ;nop ; 7a
+ ;nop ; da
+
+ jam ; 02
+ ;jam ; 12
+ ;jam ; 22
+ ;jam ; 32
+ ;jam ; 42
+ ;jam ; 52
+ ;jam ; 62
+ ;jam ; 72
+ ;jam ; 92
+ ;jam ; b2
+ ;jam ; d2
+ ;jam ; f2
+
+ ;sbc #$12 ; eb 12
+
+; the so-called "unstable" ones:
+
+ sha ($12),y ; 93 12
+ sha $1234,y ; 9f 34 12
+
+ shx $1234,y ; 9e 34 12
+ shy $1234,x ; 9c 34 12
+
+ tas $1234,y ; 9b 34 12
+ las $1234,y ; bb 34 12
+
+; the two so-called "highly unstable" ones:
+
+ lax #$12 ; ab 12
+
+ ane #$12 ; 8b 12
--- /dev/null
+
+ .setcpu "6502"
+
+ adc $1234 ; 6d 34 12
+ adc $1234,x ; 7d 34 12
+ adc $1234,y ; 79 34 12
+ adc $12 ; 65 12
+ adc #$12 ; 69 12
+ adc ($12,x) ; 61 12
+ adc $12,x ; 75 12
+ adc ($12),y ; 71 12
+
+ and $12 ; 25 12
+ and #$12 ; 29 12
+ and $1234 ; 2d 34 12
+ and $1234,x ; 3d 34 12
+ and $1234,y ; 39 34 12
+ and ($12,x) ; 21 12
+ and $12,x ; 35 12
+ and ($12),y ; 31 12
+
+ asl $12 ; 06 12
+ asl $1234 ; 0e 34 12
+ asl $1234,x ; 1e 34 12
+ asl $12,x ; 16 12
+ asl a ; 0a
+
+ bcc *+$14 ; 90 12
+ bcs *+$14 ; b0 12
+ beq *+$14 ; f0 12
+ bmi *+$14 ; 30 12
+ bne *+$14 ; d0 12
+ bpl *+$14 ; 10 12
+ bvc *+$14 ; 50 12
+ bvs *+$14 ; 70 12
+
+ bit $12 ; 24 12
+ bit $1234 ; 2c 34 12
+
+ brk ; 00
+
+ clc ; 18
+ cld ; d8
+ cli ; 58
+ clv ; b8
+
+ cmp $1234 ; cd 34 12
+ cmp $1234,x ; dd 34 12
+ cmp $1234,y ; d9 34 12
+ cmp $12 ; c5 12
+ cmp #$12 ; c9 12
+ cmp ($12,x) ; c1 12
+ cmp $12,x ; d5 12
+ cmp ($12),y ; d1 12
+
+ cpx $1234 ; ec 34 12
+ cpx #$12 ; e0 12
+ cpx $12 ; e4 12
+
+ cpy $1234 ; cc 34 12
+ cpy #$12 ; c0 12
+ cpy $12 ; c4 12
+
+ dec $1234 ; ce 34 12
+ dec $1234,x ; de 34 12
+ dec $12 ; c6 12
+ dec $12,x ; d6 12
+
+ dex ; ca
+ dey ; 88
+
+ eor $1234 ; 4d 34 12
+ eor $1234,x ; 5d 34 12
+ eor $1234,y ; 59 34 12
+ eor $12 ; 45 12
+ eor #$12 ; 49 12
+ eor ($12,x) ; 41 12
+ eor $12,x ; 55 12
+ eor ($12),y ; 51 12
+
+ inc $1234 ; ee 34 12
+ inc $1234,x ; fe 34 12
+ inc $12 ; e6 12
+ inc $12,x ; f6 12
+
+ inx ; e8
+ iny ; c8
+
+ jmp $1234 ; 4c 34 12
+ jmp ($1234) ; 6c 34 12
+
+ jsr $1234 ; 20 34 12
+
+ lda $1234 ; ad 34 12
+ lda $1234,x ; bd 34 12
+ lda $1234,y ; b9 34 12
+ lda $12 ; a5 12
+ lda #$12 ; a9 12
+ lda ($12,x) ; a1 12
+ lda $12,x ; b5 12
+ lda ($12),y ; b1 12
+
+ ldx $1234 ; ae 34 12
+ ldx $1234,y ; be 34 12
+ ldx #$12 ; a2 12
+ ldx $12 ; a6 12
+ ldx $12,y ; b6 12
+
+ ldy $1234 ; ac 34 12
+ ldy $1234,x ; bc 34 12
+ ldy #$12 ; a0 12
+ ldy $12 ; a4 12
+ ldy $12,x ; b4 12
+
+ lsr $1234 ; 4e 34 12
+ lsr $1234,x ; 5e 34 12
+ lsr $12 ; 46 12
+ lsr $12,x ; 56 12
+ lsr a ; 4a
+
+ nop ; ea
+
+ ora $12 ; 05 12
+ ora #$12 ; 09 12
+ ora $1234 ; 0d 34 12
+ ora $1234,x ; 1d 34 12
+ ora $1234,y ; 19 34 12
+ ora ($12,x) ; 01 12
+ ora $12,x ; 15 12
+ ora ($12),y ; 11 12
+
+ pha ; 48
+ php ; 08
+ pla ; 68
+ plp ; 28
+
+ rol $12 ; 26 12
+ rol $1234 ; 2e 34 12
+ rol $1234,x ; 3e 34 12
+ rol $12,x ; 36 12
+ rol a ; 2a
+ ror $1234 ; 6e 34 12
+ ror $1234,x ; 7e 34 12
+ ror $12 ; 66 12
+ ror $12,x ; 76 12
+ ror a ; 6a
+
+ rti ; 40
+ rts ; 60
+
+ sbc $1234 ; ed 34 12
+ sbc $1234,x ; fd 34 12
+ sbc $1234,y ; f9 34 12
+ sbc $12 ; e5 12
+ sbc #$12 ; e9 12
+ sbc ($12,x) ; e1 12
+ sbc $12,x ; f5 12
+ sbc ($12),y ; f1 12
+
+ sec ; 38
+ sed ; f8
+ sei ; 78
+
+ sta $1234 ; 8d 34 12
+ sta $1234,x ; 9d 34 12
+ sta $1234,y ; 99 34 12
+ sta $12 ; 85 12
+ sta ($12,x) ; 81 12
+ sta $12,x ; 95 12
+ sta ($12),y ; 91 12
+
+ stx $1234 ; 8e 34 12
+ stx $12 ; 86 12
+ stx $12,y ; 96 12
+
+ sty $1234 ; 8c 34 12
+ sty $12 ; 84 12
+ sty $12,x ; 94 12
+
+ tax ; aa
+ tay ; a8
+ tsx ; ba
+ txa ; 8a
+ txs ; 9a
+ tya ; 98
projects / cc65 / commitdiff