Fix typo in documentation

Signed-off-by: Antonio Niño Díaz <antonio_nd@outlook.com>

.checkpatch.conf

@@ -0,0 +1,60 @@
+# Configuration for checkpatch.pl
+# ===============================
+
+# Enable more tests
+--strict
+
+# Quiet
+--quiet
+
+# No per-file summary
+--no-summary
+
+# Don't expect the Linux kernel tree
+--no-tree
+
+# Show file line, not input line
+--showfile
+
+# List of ignored rules
+# ---------------------
+
+# There's no BIT macro
+--ignore BIT_MACRO
+
+# Allow CamelCase
+--ignore CAMELCASE
+
+# Comparing to NULL explicitly isn't a bad thing
+--ignore COMPARISON_TO_NULL
+
+# Causes false positives
+--ignore COMPLEX_MACRO
+
+# Don't complain about structs not being const
+--ignore CONST_STRUCT
+
+# Do not check the format of commit messages
+--ignore GIT_COMMIT_ID
+
+# We don't have a MAINTAINERS file, don't complain about it.
+--ignore FILE_PATH_CHANGES
+
+# Writing the continuation on the start of the line can make it clearer
+--ignore LOGICAL_CONTINUATIONS
+
+# Don't complain if a line that contains a string is too long. It's better to
+# have a really long line that can be found with grep.
+--ignore LONG_LINE_STRING
+
+# Allow new typedefs
+--ignore NEW_TYPEDEFS
+
+# Prefer stdint.h types over kernel types
+--ignore PREFER_KERNEL_TYPES
+
+# Parentheses can make the code clearer
+--ignore UNNECESSARY_PARENTHESES
+
+# Don't complain when files are modified in 'include/asm'
+--ignore MODIFIED_INCLUDE_ASM

.gitignore

@@ -5,3 +5,4 @@ rgbgfx
 *.o
 *.exe
 *.html
+.checkpatch-camelcase.*

.travis-deps.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+
+if [ $TRAVIS_OS_NAME = "osx" ]; then
+    brew update
+    brew install libpng pkg-config
+else # linux
+    sudo apt-get -qq update
+    sudo apt-get install -y -q bison flex libpng-dev pkg-config
+fi
+
+echo "Dependencies:"
+yacc --version
+flex --version

.travis.yml

@@ -0,0 +1,16 @@
+language: c
+sudo: required
+install:
+  - ./.travis-deps.sh
+os:
+  - linux
+  - osx
+compiler:
+  - clang
+  - gcc
+script:
+  - make
+  - sudo make install
+after_success:
+  - pushd test/asm/ && ./test.sh && popd
+  - pushd test/link/ && ./test.sh && popd

CONTRIBUTING.rst

@@ -0,0 +1,88 @@
+Contributing
+============
+
+RGBDS was created in the late 90's and has received contributions from several
+developers since then. It wouldn't have been possible to get to this point
+without their work and, for that reason, it is always open to the contributions
+of other people.
+
+Reporting Bugs
+--------------
+
+Bug reports are essential to improve RGBDS and they are always welcome. If you
+want to report a bug:
+
+1. Make sure that there isn't a similar issue already reported
+   `here <https://github.com/rednex/rgbds/issues>`__.
+
+2. Figure out a way of reproducing it reliably.
+
+3. If there is a piece of code that triggers the bug, try to reduce it to the
+   smallest file you can.
+
+4. Create a new `issue <https://github.com/rednex/rgbds/issues>`__.
+
+Of course, it may not always be possible to give an accurate bug report, but it
+always helps to fix it.
+
+Requesting new features
+-----------------------
+
+If you come up with a good idea that could be implemented, you can propose it to
+be done.
+
+1. Create a new `issue <https://github.com/rednex/rgbds/issues>`__.
+
+2. Try to be as accurate as possible. Describe what you need and why you need
+   it, maybe with examples.
+
+Please understand that the contributors are doing it in their free time, so
+simple requests are more likely to catch the interest of a contributor than
+complicated ones. If you really need something to be done, and you think you can
+implement it yourself, you can always contribute to RGBDS with your own code.
+
+Contributing code
+-----------------
+
+If you want to contribute with your own code, whether it is to fix a current
+issue or to add something that nobody had requested, you should first consider
+if your change is going to be small (and likely to be accepted as-is) or big
+(and will have to go through some rework).
+
+Big changes will most likely require some discussion, so open an
+`issue <https://github.com/rednex/rgbds/issues>`__ and explain what you want to
+do and how you intend to do it. If you already have a prototype, it's always a
+good idea to show it. Tests help, too.
+
+If you are going to work on a specific issue that involves a lot of work, it is
+always a good idea to leave a message, just in case someone else is interested
+but doesn't know that there's someone working on it.
+
+1. Fork this repository.
+
+2. Checkout the ``develop`` branch.
+
+3. Create a new branch to work on. You could still work on ``develop``, but it's
+   easier that way.
+
+4. Sign off your commits: ``git commit -s``
+
+5. Follow the Linux kernel coding style, which can be found in the file
+   ``Documentation/process/coding-style.rst`` in the Linux kernel repository.
+   Note that the coding style isn't writen on stone, if there is a good reason
+   to deviate from it, it should be fine.
+
+6. Download the files ``checkpatch.pl``, ``const_structs.checkpatch`` and
+   ``spelling.txt`` from the folder ``scripts`` in the Linux kernel repository.
+
+7. To use ``checkpatch.pl`` you can use ``make checkpatch``, which will check
+   the coding style of all patches between the current one and the upstream
+   code. By default, the Makefile expects the script (and associate files) to be
+   located in ``../linux/scripts/``, but you can place them anywhere you like as
+   long as you specify it when executing the command:
+   ``CHECKPATCH=../path/to/folder make checkpatch``.
+
+8. Create a pull request against the branch ``develop``.
+
+9. Be prepared to get some comments about your code and to modify it. Tip: Use
+   ``git rebase -i origin/develop`` to modify chains of commits.

GNUmakefile

@@ -1,6 +0,0 @@
-# GNU Make 3.x doesn't support the "!=" shell syntax, so here's an alternative
-
-PKG_CONFIG = pkg-config
-PNGFLAGS = $(shell ${PKG_CONFIG} --cflags libpng)
-
-include Makefile

LICENSE

@@ -1,34 +0,0 @@
-rgbasm and rgblink are derived from Justin Lloyd's RGBDS, which is
-released under the following license:
-
-                      DO WHATEVER PUBLIC LICENSE*
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. You can do whatever you want to with the work.
-  1. You cannot stop anybody from doing whatever they want to with the work.
-  2. You cannot revoke anybody elses DO WHATEVER PUBLIC LICENSE in the work.
-
- This program is free software. It comes without any warranty, to
- the extent permitted by applicable law. You can redistribute it
- and/or modify it under the terms of the DO WHATEVER PUBLIC LICENSE
- 
- Software originally created by Justin Lloyd @ http://otakunozoku.com/
-
-
-rgbfix was rewritten from scratch by Anthony J. Bentley, and is released
-under the ISC license; see the source file for the text of the license.
-
-rgbgfx was written by stag019, and is released under the ISC license.
-
-The UTF-8 decoder in src/asm/charmap.c was written by Björn Höhrmann and is
-released under the MIT license. The remainder of charmap.c was written by
-stag019, and is released under the ISC license.
-
-extern/err.c is derived from the Musl C library, http://www.musl-libc.org,
-and is released under the MIT license.
-
-extern/reallocarray.c is derived from the OpenBSD Project,
-http://www.openbsd.org, and is released under the ISC license.
-
-extern/strl.c is derived from the OpenBSD Project, http://www.openbsd.org,
-and is released under the BSD license.

LICENSE.rst

@@ -0,0 +1,81 @@
+LICENSE
+=======
+
+Original code
+-------------
+
+Copyright (C) 1997 Carsten Sorensen <surfsmurf@matilde.demon.co.uk>
+
+The ASMotor package (xAsm, xLink, RGBFix, examples and documentation) is
+freeware and distributed as is. The author retains his copyright and right to
+modify the specifications and operation of the software without notice.
+
+In other words this means I encourage you to...
+
+- use it for whatever purpose even professional work without me charging you a
+  penny
+- copy it to another person (wholly or in part, though I'm sure he'd appreciate
+  the whole package) in whatever form you find suitable
+- mass-distribute the ASMotor package if it is complete (xAsm, xLink, RGBFix and
+  documentation).
+- contact me if you have any problems
+
+This also means you can't...
+
+- blame me for loss of profit, data, sleep, food or other nasty things through
+  the use or distribution of ASMotor. If you choose to use ASMotor you do so at
+  your own risk.
+- expect me to be able to help you should you have a problem related or not to
+  ASMotor.
+
+Otaku no Zoku's modifications
+-----------------------------
+
+Copyright (C) 1999 Justin Lloyd <jlloyd@imf.la> (?)
+
+::
+
+                         DO WHATEVER PUBLIC LICENSE*
+      TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+     0. You can do whatever you want to with the work.
+     1. You cannot stop anybody from doing whatever they want to with the work.
+     2. You cannot revoke anybody elses DO WHATEVER PUBLIC LICENSE in the work.
+
+    This program is free software. It comes without any warranty, to
+    the extent permitted by applicable law. You can redistribute it
+    and/or modify it under the terms of the DO WHATEVER PUBLIC LICENSE
+
+    Software originally created by Justin Lloyd @ http://otakunozoku.com/
+
+rgbds-linux
+-----------
+
+Copyright (C) 2009 Vegard Nossum <vegard.nossum@gmail.com>
+
+Current
+-------
+
+rgbasm and rgblink are derived from Justin Lloyd's RGBDS.
+
+rgbfix was rewritten from scratch by Anthony J. Bentley, and is released under
+the ISC license; see the source file for the text of the license.
+
+rgbgfx was written by stag019, and is released under the ISC license.
+
+Some files of rgblink were written by Antonio Niño Díaz, and they are relased
+under the ISC license. The affected files have the appropriate license in the
+header of the file.
+
+The UTF-8 decoder in src/asm/charmap.c was written by Björn Höhrmann and is
+released under the MIT license. The remainder of charmap.c was written by
+stag019, and is released under the ISC license.
+
+extern/err.c is derived from the Musl C library, http://www.musl-libc.org, and
+is released under the MIT license.
+
+extern/reallocarray.c is derived from the OpenBSD Project,
+http://www.openbsd.org, and is released under the ISC license.
+
+extern/strl.c is derived from the OpenBSD Project, http://www.openbsd.org, and
+is released under the BSD license.

Makefile

@@ -1,16 +1,43 @@
-PKG_CONFIG =	pkg-config
-WARNFLAGS =	-Wall -Werror=implicit
-PNGFLAGS !=	${PKG_CONFIG} --cflags libpng
-REALCFLAGS =	${CFLAGS} ${WARNFLAGS} ${PNGFLAGS} -Iinclude -g \
-		-std=c99 -D_POSIX_C_SOURCE=200809L
-
 # User-defined variables
-PREFIX =	/usr/local
-BINPREFIX =	${PREFIX}/bin
-MANPREFIX =	${PREFIX}/man
-Q =		@
 
-rgbasm_obj = \
+Q		:= @
+PREFIX		:= /usr/local
+bindir		:= ${PREFIX}/bin
+mandir		:= ${PREFIX}/man
+STRIP		:= -s
+BINMODE		:= 555
+MANMODE		:= 444
+CHECKPATCH	:= ../linux/scripts/checkpatch.pl
+
+# Other variables
+
+PKG_CONFIG	:= pkg-config
+PNGCFLAGS	:= `${PKG_CONFIG} --static --cflags libpng`
+PNGLDFLAGS	:= `${PKG_CONFIG} --static --libs-only-L libpng`
+PNGLDLIBS	:= `${PKG_CONFIG} --static --libs-only-l libpng`
+
+VERSION_STRING	:= `git describe --tags --dirty --always 2>/dev/null`
+
+WARNFLAGS	:= -Wall -Werror
+
+# Overridable CFLAGS
+CFLAGS		:= -g
+# Non-overridable CFLAGS
+REALCFLAGS	:= ${CFLAGS} ${WARNFLAGS} -std=c99 -D_POSIX_C_SOURCE=200809L \
+		   -Iinclude -DBUILD_VERSION_STRING=\"${VERSION_STRING}\"
+
+YFLAGS		:=
+LFLAGS		:= --nounistd
+
+YACC		:= yacc
+LEX		:= flex
+RM		:= rm -rf
+
+# Rules to build the RGBDS binaries
+
+all: rgbasm rgblink rgbfix rgbgfx
+
+rgbasm_obj := \
 	src/asm/asmy.o \
 	src/asm/charmap.o \
 	src/asm/fstack.o \
@@ -21,55 +48,45 @@ rgbasm_obj = \
 	src/asm/output.o \
 	src/asm/rpn.o \
 	src/asm/symbol.o \
-	src/asm/locallex.o \
 	src/extern/err.o \
 	src/extern/reallocarray.o \
 	src/extern/strlcpy.o \
-	src/extern/strlcat.o
+	src/extern/strlcat.o \
+	src/extern/version.o
 
-rgblink_obj = \
+
+src/asm/asmy.h: src/asm/asmy.c
+src/asm/locallex.o src/asm/globlex.o src/asm/lexer.o: src/asm/asmy.h
+
+rgblink_obj := \
 	src/link/assign.o \
+	src/link/lexer.o \
 	src/link/library.o \
 	src/link/main.o \
 	src/link/mapfile.o \
 	src/link/object.o \
 	src/link/output.o \
 	src/link/patch.o \
+	src/link/parser.o \
+	src/link/script.o \
 	src/link/symbol.o \
-	src/extern/err.o
+	src/extern/err.o \
+	src/extern/version.o
 
-rgbfix_obj = \
+src/link/parser.h: src/link/parser.c
+src/link/lexer.o: src/link/parser.h
+
+rgbfix_obj := \
 	src/fix/main.o \
-	src/extern/err.o
+	src/extern/err.o \
+	src/extern/version.o
 
-rgbgfx_obj = \
+rgbgfx_obj := \
 	src/gfx/gb.o \
 	src/gfx/main.o \
 	src/gfx/makepng.o \
-	src/extern/err.o
-
-all: rgbasm rgblink rgbfix rgbgfx
-
-clean:
-	$Qrm -rf rgbds.html
-	$Qrm -rf rgbasm rgbasm.exe ${rgbasm_obj} rgbasm.html
-	$Qrm -rf rgblink rgblink.exe ${rgblink_obj} rgblink.html
-	$Qrm -rf rgbfix rgbfix.exe ${rgbfix_obj} rgbfix.html
-	$Qrm -rf rgbgfx rgbgfx.exe ${rgbgfx_obj} rgbgfx.html
-	$Qrm -rf src/asm/asmy.c src/asm/asmy.h
-
-install: all
-	$Qmkdir -p ${BINPREFIX}
-	$Qinstall -s -m 555 rgbasm ${BINPREFIX}/rgbasm
-	$Qinstall -s -m 555 rgbfix ${BINPREFIX}/rgbfix
-	$Qinstall -s -m 555 rgblink ${BINPREFIX}/rgblink
-	$Qinstall -s -m 555 rgbgfx ${BINPREFIX}/rgbgfx
-	$Qmkdir -p ${MANPREFIX}/man1 ${MANPREFIX}/man7
-	$Qinstall -m 444 src/rgbds.7 ${MANPREFIX}/man7/rgbds.7
-	$Qinstall -m 444 src/asm/rgbasm.1 ${MANPREFIX}/man1/rgbasm.1
-	$Qinstall -m 444 src/fix/rgbfix.1 ${MANPREFIX}/man1/rgbfix.1
-	$Qinstall -m 444 src/link/rgblink.1 ${MANPREFIX}/man1/rgblink.1
-	$Qinstall -m 444 src/gfx/rgbgfx.1 ${MANPREFIX}/man1/rgbgfx.1
+	src/extern/err.o \
+	src/extern/version.o
 
 rgbasm: ${rgbasm_obj}
 	$Q${CC} ${REALCFLAGS} -o $@ ${rgbasm_obj} -lm
@@ -81,42 +98,104 @@ rgbfix: ${rgbfix_obj}
 	$Q${CC} ${REALCFLAGS} -o $@ ${rgbfix_obj}
 
 rgbgfx: ${rgbgfx_obj}
-	$Q${CC} ${REALCFLAGS} -o $@ ${rgbgfx_obj} `${PKG_CONFIG} --libs libpng`
+	$Q${CC} ${REALCFLAGS} ${PNGLDFLAGS} -o $@ ${rgbgfx_obj} ${PNGLDLIBS}
+
+# Rules to process files
 
 .y.c:
 	$Q${YACC} -d ${YFLAGS} -o $@ $<
 
+.l.o:
+	$Q${RM} $*.c
+	$Q${LEX} ${LFLAGS} -o $*.c $<
+	$Q${CC} ${REALCFLAGS} -c -o $@ $*.c
+	$Q${RM} $*.c
+
 .c.o:
-	$Q${CC} ${REALCFLAGS} -c -o $@ $<
+	$Q${CC} ${REALCFLAGS} ${PNGCFLAGS} -c -o $@ $<
 
-src/asm/locallex.o src/asm/globlex.o src/asm/lexer.o: src/asm/asmy.h
-src/asm/asmy.h: src/asm/asmy.c
+# Target used to remove all files generated by other Makefile targets.
 
-# Below is a target for the project maintainer to easily create win32 exes.
+clean:
+	$Q${RM} rgbds.7.html gbz80.7.html rgbds.5.html
+	$Q${RM} rgbasm rgbasm.exe ${rgbasm_obj} rgbasm.1.html rgbasm.5.html
+	$Q${RM} rgblink rgblink.exe ${rgblink_obj} rgblink.1.html rgblink.5.html
+	$Q${RM} rgbfix rgbfix.exe ${rgbfix_obj} rgbfix.1.html
+	$Q${RM} rgbgfx rgbgfx.exe ${rgbgfx_obj} rgbgfx.1.html
+	$Q${RM} src/asm/asmy.c src/asm/asmy.h
+	$Q${RM} src/link/lexer.c src/link/parser.c src/link/parser.h
+
+# Target used to install the binaries and man pages.
+
+install: all
+	$Qmkdir -p ${DESTDIR}${bindir}
+	$Qinstall ${STRIP} -m ${BINMODE} rgbasm ${DESTDIR}${bindir}/rgbasm
+	$Qinstall ${STRIP} -m ${BINMODE} rgbfix ${DESTDIR}${bindir}/rgbfix
+	$Qinstall ${STRIP} -m ${BINMODE} rgblink ${DESTDIR}${bindir}/rgblink
+	$Qinstall ${STRIP} -m ${BINMODE} rgbgfx ${DESTDIR}${bindir}/rgbgfx
+	$Qmkdir -p ${DESTDIR}${mandir}/man1 ${DESTDIR}${mandir}/man5 ${DESTDIR}${mandir}/man7
+	$Qinstall -m ${MANMODE} src/rgbds.7 ${DESTDIR}${mandir}/man7/rgbds.7
+	$Qinstall -m ${MANMODE} src/gbz80.7 ${DESTDIR}${mandir}/man7/gbz80.7
+	$Qinstall -m ${MANMODE} src/rgbds.5 ${DESTDIR}${mandir}/man5/rgbds.5
+	$Qinstall -m ${MANMODE} src/asm/rgbasm.1 ${DESTDIR}${mandir}/man1/rgbasm.1
+	$Qinstall -m ${MANMODE} src/asm/rgbasm.5 ${DESTDIR}${mandir}/man5/rgbasm.5
+	$Qinstall -m ${MANMODE} src/fix/rgbfix.1 ${DESTDIR}${mandir}/man1/rgbfix.1
+	$Qinstall -m ${MANMODE} src/link/rgblink.1 ${DESTDIR}${mandir}/man1/rgblink.1
+	$Qinstall -m ${MANMODE} src/link/rgblink.5 ${DESTDIR}${mandir}/man5/rgblink.5
+	$Qinstall -m ${MANMODE} src/gfx/rgbgfx.1 ${DESTDIR}${mandir}/man1/rgbgfx.1
+
+# Target used to check the coding style of the whole codebase. '.y' and '.l'
+# files aren't checked, unfortunately...
+checkcodebase:
+	$Qfor file in `git ls-files | grep -E '\.c|\.h'`; do	\
+		${CHECKPATCH} -f "$$file";			\
+	done
+
+# Target used to check the coding style of the patches from the upstream branch
+# to the HEAD. Runs checkpatch once for each commit between the current HEAD and
+# the first common commit between the HEAD and origin/develop. '.y' and '.l'
+# files aren't checked, unfortunately...
+checkpatch:
+	$Qeval COMMON_COMMIT=$$(git merge-base HEAD origin/develop);	\
+	for commit in `git rev-list $$COMMON_COMMIT..HEAD`; do		\
+		echo "[*] Analyzing commit '$$commit'";			\
+		git format-patch --stdout "$$commit~..$$commit"		\
+			| ${CHECKPATCH} - || true;			\
+	done
+
+# Target for the project maintainer to easily create web manuals.
+# It relies on mandoc: http://mdocml.bsd.lv
+
+MANDOC	:= -Thtml -Ios=General -Oman=%N.%S.html -Ostyle=manual.css
+
+wwwman:
+	$Qmandoc ${MANDOC} src/rgbds.7 > rgbds.7.html
+	$Qmandoc ${MANDOC} src/gbz80.7 > gbz80.7.html
+	$Qmandoc ${MANDOC} src/rgbds.5 > rgbds.5.html
+	$Qmandoc ${MANDOC} src/asm/rgbasm.1 > rgbasm.1.html
+	$Qmandoc ${MANDOC} src/asm/rgbasm.5 > rgbasm.5.html
+	$Qmandoc ${MANDOC} src/fix/rgbfix.1 > rgbfix.1.html
+	$Qmandoc ${MANDOC} src/link/rgblink.1 > rgblink.1.html
+	$Qmandoc ${MANDOC} src/link/rgblink.5 > rgblink.5.html
+	$Qmandoc ${MANDOC} src/gfx/rgbgfx.1 > rgbgfx.1.html
+
+# Targets for the project maintainer to easily create Windows exes.
 # This is not for Windows users!
 # If you're building on Windows with Cygwin or Mingw, just follow the Unix
 # install instructions instead.
-mingw:
-	$Qenv PATH=/usr/local/mingw32/bin:/bin:/usr/bin:/usr/local/bin \
-		make WARNFLAGS= CC=gcc CFLAGS="-I/usr/local/mingw32/include \
-			${CFLAGS}"
+
+mingw32:
+	$Qenv PKG_CONFIG_PATH=/usr/i686-w64-mingw32/sys-root/mingw/lib/pkgconfig/ \
+		make CC=i686-w64-mingw32-gcc YACC=bison WARNFLAGS= -j
 	$Qmv rgbasm rgbasm.exe
 	$Qmv rgblink rgblink.exe
 	$Qmv rgbfix rgbfix.exe
 	$Qmv rgbgfx rgbgfx.exe
 
-# Below is a target for the project maintainer to easily create web manuals.
-# It relies on mandoc: http://mdocml.bsd.lv
-MANDOC =	-Thtml -Ios=General -Oman=/rgbds/manual/%N/ \
-			-Ostyle=/rgbds/manual/manual.css
-
-wwwman:
-	$Qmandoc ${MANDOC} src/rgbds.7 | sed s/OpenBSD/General/ > rgbds.html
-	$Qmandoc ${MANDOC} src/asm/rgbasm.1 | sed s/OpenBSD/General/ > \
-		rgbasm.html
-	$Qmandoc ${MANDOC} src/fix/rgbfix.1 | sed s/OpenBSD/General/ > \
-		rgbfix.html
-	$Qmandoc ${MANDOC} src/link/rgblink.1 | sed s/OpenBSD/General/ > \
-		rgblink.html
-	$Qmandoc ${MANDOC} src/gfx/rgbgfx.1 | sed s/OpenBSD/General/ > \
-		rgbgfx.html
+mingw64:
+	$Qenv PKG_CONFIG_PATH=/usr/x86_64-w64-mingw32/sys-root/mingw/lib/pkgconfig/ \
+		make CC=x86_64-w64-mingw32-gcc YACC=bison WARNFLAGS= -j
+	$Qmv rgbasm rgbasm.exe
+	$Qmv rgblink rgblink.exe
+	$Qmv rgbfix rgbfix.exe
+	$Qmv rgbgfx rgbgfx.exe

README.md

@@ -1,70 +0,0 @@
-# RGBDS
-
-RGBDS (Rednex Game Boy Development System) is a free assembler/linker package
-for the Game Boy and Game Boy Color. It consists of:
-
-  - rgbasm  (assembler)
-  - rgblink (linker)
-  - rgbfix  (checksum/header fixer)
-  - rgbgfx  (PNG‐to‐Game Boy graphics converter)
-
-rgbds-linux is a fork of the original RGBDS which aims to make the programs
-more like other UNIX tools.
-
-
-## Installing RGBDS (UNIX)
-
-RGBDS requires libpng and pkg-config to be installed.
-
-On Mac OS X, install them with [Homebrew](http://brew.sh/). On other Unixes,
-use the built-in package manager.
-
-You can test if they're installed by running `pkg-config --cflags libpng`:
-if the output is a path, then you're good, and if it outputs an error then
-you need to install them via a package manager.
-
-To build the programs on a UNIX or UNIX-like system, just run in your terminal:
-
-```sh
-make
-```
-
-Then to install the compiled programs and manual pages, run (with appropriate
-privileges):
-
-```sh
-make install
-```
-
-After installation, you can read the manuals with the man(1) command. E.g.,
-
-```sh
-man 1 rgbasm
-```
-
-Note: the variables described below can affect installation behavior when given
-on the make command line. For example, to install rgbds in your home directory
-instead of systemwide, run the following:
-
-```sh
-mkdir -p $HOME/{bin,man/man1,man/man7}
-make install PREFIX=$HOME
-```
-
-`PREFIX`: Location where RGBDS will be installed. Defaults to /usr/local.
-
-`BINPREFIX`: Location where the RGBDS programs will be installed. Defaults
-to ${PREFIX}/bin.
-
-`MANPREFIX`: Location where the RGBDS man pages will be installed. Defaults
-to ${PREFIX}/man.
-
-`Q`: Whether to quiet the build or not. To make the build more verbose, clear
-this variable. Defaults to @.
-
-
-## Installing RGBDS (Windows)
-
-Windows builds are available here: https://github.com/bentley/rgbds/releases
-
-Copy the .exe files to C:\Windows\ or similar.

README.rst

@@ -0,0 +1,173 @@
+RGBDS
+=====
+
+RGBDS (Rednex Game Boy Development System) is a free assembler/linker package
+for the Game Boy and Game Boy Color. It consists of:
+
+- rgbasm (assembler)
+- rgblink (linker)
+- rgbfix (checksum/header fixer)
+- rgbgfx (PNG‐to‐Game Boy graphics converter)
+
+This is a fork of the original RGBDS which aims to make the programs more like
+other UNIX tools.
+
+This toolchain is maintained on `GitHub <https://github.com/rednex/rgbds>`__, as
+well as its `documentation <https://github.com/rednex/rednex.github.io>`__.
+
+The documentation of this toolchain can be viewed online
+`here <https://rednex.github.io/>`__, it is generated from the man pages found
+in this repository.
+
+1. Installing RGBDS
+-------------------
+
+1.1 Windows
+~~~~~~~~~~~
+
+Windows builds are available in the releases page on GitHub:
+
+::
+
+    https://github.com/rednex/rgbds/releases
+
+Copy the ``.exe`` files to ``C:\Windows\`` or similar.
+
+If you require the latest version in development, it should be possible to
+compile RGBDS with MinGW or Cygwin by following the instructions to build it on
+UNIX systems.
+
+1.2 macOS
+~~~~~~~~~
+
+You can build RGBDS by following the instructions below. However, if you would
+prefer not to build RGBDS yourself, you may also install it using
+`Homebrew <http://brew.sh/>`__.
+
+To install the latest release, use:
+
+.. code:: sh
+
+    brew install rgbds
+
+To install RGBDS with all of the current changes in development (as seen on the
+``master`` branch on GitHub), use:
+
+.. code:: sh
+
+    brew install rgbds --HEAD
+
+1.3 Other UNIX-like systems
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+No official binaries of RGBDS are distributed for these systems, you must follow
+the simple instructions below to compile and install it.
+
+2. Building RGBDS from source
+-----------------------------
+
+RGBDS can be built in UNIX-like systems by following the instructions below.
+
+2.1 Dependencies
+~~~~~~~~~~~~~~~~
+
+RGBDS requires yacc, flex, libpng and pkg-config to be installed.
+
+On macOS, install the latter two with `Homebrew <http://brew.sh/>`__:
+
+.. code:: sh
+
+    brew install libpng pkg-config
+
+On other Unixes, use the built-in package manager. For example, on Debian or
+Ubuntu:
+
+.. code:: sh
+
+    sudo apt-get install byacc flex pkg-config libpng-dev
+
+You can test if libpng and pkg-config are installed by running ``pkg-config
+--cflags libpng``: if the output is a path, then you're good, and if it outputs
+an error then you need to install them via a package manager.
+
+2.2 Build process
+~~~~~~~~~~~~~~~~~
+
+To build the programs, run in your terminal:
+
+.. code:: sh
+
+    make
+
+Then, to install the compiled programs and manual pages, run (with appropriate
+privileges, e.g, with ``sudo``):
+
+.. code:: sh
+
+    make install
+
+After installation, you can read the manuals with the ``man`` command. E.g.,
+
+.. code:: sh
+
+    man 7 rgbds
+
+There are some variables in the Makefile that can be redefined by the user. The
+variables described below can affect installation behavior when given on the
+make command line. For example, to install RGBDS in your home directory instead
+of systemwide, run the following:
+
+.. code:: sh
+
+    make install PREFIX=$HOME
+
+To do a verbose build, run:
+
+.. code:: sh
+
+    make Q=
+
+This is the complete list of user-defined variables:
+
+- ``PREFIX``: Location where RGBDS will be installed. Defaults to
+  ``/usr/local``.
+
+- ``bindir``: Location where the binaries will be installed. Defaults to
+  ``${PREFIX}/bin``.
+
+- ``mandir``: Location where the manpages will be installed. Defaults to
+  ``${PREFIX}/man``.
+
+- ``DESTDIR``: This is prepended to all paths during the installation. It is
+  mainly used for packaging.
+
+- ``Q``: Whether to quiet the build or not. To make the build more verbose,
+  clear this variable. Defaults to ``@``.
+
+- ``STRIP``: Whether to strip the installed binaries of debug symbols or not.
+  Defaults to ``-s``.
+
+- ``BINMODE``: Permissions of the installed binaries. Defaults to ``555``.
+
+- ``MANMODE``: Permissions of the installed manpages. Defaults to ``444``.
+
+- ``CHECKPATCH``: Path of the script ``checkpatch.pl`` of the Linux kernel.
+  Defaults to ``../linux/scripts/checkpatch.pl``.
+
+3 History
+---------
+
+- Around 1997, Carsten Sorensen (AKA SurfSmurf) writes ASMotor as a
+  general-purpose assembler/linker system for DOS/Win32
+
+- Around 1999, Justin Lloyd (AKA Otaku no Zoku) adapts ASMotor to read and
+  produce GBZ80 assembly/machine code, and releases this version as RGBDS.
+
+- 2009, Vegard Nossum adapts the code to be more UNIX-like and releases
+  this version as rgbds-linux on
+  `GitHub <https://github.com/vegard/rgbds-linux>`__.
+
+- 2010, Anthony J. Bentley forks that repository. The fork becomes the reference
+  implementation of rgbds.
+
+- 2017, Bentley's repository is moved to a neutral name.

include/asm/asm.h

@@ -1,35 +1,41 @@
-/*	asm.h
+/*
+ * asm.h
  *
- *	Contains some assembler-wide defines and externs
- *
- *	Copyright 1997 Carsten Sorensen
+ * Contains some assembler-wide defines and externs
  *
+ * Copyright 1997 Carsten Sorensen
  */
 
 #ifndef RGBDS_ASM_ASM_H
 #define RGBDS_ASM_ASM_H
 
 #include <stdbool.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "types.h"
+#include "asm/localasm.h"
 #include "asm/symbol.h"
 
-#include "asm/localasm.h"
+#define MAXUNIONS	128
+#define MAXMACROARGS	256
+#define MAXINCPATHS	128
 
-extern SLONG nLineNo;
-extern ULONG nTotalLines;
-extern ULONG nPC;
-extern ULONG nPass;
-extern ULONG nIFDepth;
+extern int32_t nLineNo;
+extern uint32_t nTotalLines;
+extern uint32_t nPC;
+extern uint32_t nPass;
+extern uint32_t nIFDepth;
+extern bool skipElif;
+extern uint32_t nUnionDepth;
+extern uint32_t unionStart[MAXUNIONS];
+extern uint32_t unionSize[MAXUNIONS];
 extern char tzCurrentFileName[_MAX_PATH + 1];
 extern struct Section *pCurrentSection;
 extern struct sSymbol *tHashedSymbols[HASHSIZE];
 extern struct sSymbol *pPCSymbol;
 extern bool oDontExpandStrings;
 
-#define MAXMACROARGS	256
-#define MAXINCPATHS		128
+size_t symvaluetostring(char *dest, size_t maxLength, char *sym);
 
-#endif	/* //       ASM_H */
+#endif /* RGBDS_ASM_ASM_H */

include/asm/charmap.h

@@ -1,18 +1,19 @@
 #ifndef RGBDS_ASM_CHARMAP_H
 #define RGBDS_ASM_CHARMAP_H
 
+#include <stdint.h>
+
 #define MAXCHARMAPS	512
 #define CHARMAPLENGTH	16
 
 struct Charmap {
-	int count;
+	int32_t count;
 	char input[MAXCHARMAPS][CHARMAPLENGTH + 1];
 	char output[MAXCHARMAPS];
 };
 
-int readUTF8Char(char *destination, char *source);
-void charmap_Sort();
-int charmap_Add(char *input, UBYTE output);
-int charmap_Convert(char **input);
+int32_t readUTF8Char(char *destination, char *source);
+int32_t charmap_Add(char *input, uint8_t output);
+int32_t charmap_Convert(char **input);
 
-#endif
+#endif /* RGBDS_ASM_CHARMAP_H */

include/asm/fstack.h

@@ -1,46 +1,44 @@
-/*	fstack.h
+/*  fstack.h
  *
- *	Contains some assembler-wide defines and externs
+ *  Contains some assembler-wide defines and externs
  *
- *	Copyright 1997 Carsten Sorensen
+ *  Copyright 1997 Carsten Sorensen
  *
  */
 
 #ifndef RGBDS_ASM_FSTACK_H
 #define RGBDS_ASM_FSTACK_H
 
+#include <stdint.h>
 #include <stdio.h>
 
 #include "asm/asm.h"
-#include "types.h"
 #include "asm/lexer.h"
 
+#include "types.h"
+
 struct sContext {
 	YY_BUFFER_STATE FlexHandle;
 	struct sSymbol *pMacro;
 	struct sContext *pNext;
 	char tzFileName[_MAX_PATH + 1];
 	char *tzMacroArgs[MAXMACROARGS + 1];
-	SLONG nLine;
-	ULONG nStatus;
+	int32_t nLine;
+	uint32_t nStatus;
 	FILE *pFile;
 	char *pREPTBlock;
-	ULONG nREPTBlockCount;
-	ULONG nREPTBlockSize;
+	uint32_t nREPTBlockCount;
+	uint32_t nREPTBlockSize;
 };
 
-void
-fstk_RunInclude(char *);
-extern void fstk_RunMacroArg(SLONG s);
-void
-fstk_Init(char *);
-extern void fstk_Dump(void);
-extern void fstk_AddIncludePath(char *s);
-extern ULONG fstk_RunMacro(char *s);
-extern void fstk_RunRept(ULONG count);
-FILE *
-fstk_FindFile(char *);
+void fstk_RunInclude(char *tzFileName);
+void fstk_RunMacroArg(int32_t s);
+void fstk_Init(char *s);
+void fstk_Dump(void);
+void fstk_AddIncludePath(char *s);
+uint32_t fstk_RunMacro(char *s);
+void fstk_RunRept(uint32_t count);
+FILE *fstk_FindFile(char *fname);
+int32_t fstk_GetLine(void);
 
-extern int yywrap(void);
-
-#endif
+#endif /* RGBDS_ASM_FSTACK_H */

include/asm/lexer.h

@@ -1,65 +1,69 @@
 #ifndef RGBDS_ASM_LEXER_H
 #define RGBDS_ASM_LEXER_H
 
+#include <stdint.h>
 #include <stdio.h>
 
-#include "types.h"
-
-#define LEXHASHSIZE (1 << 11)
-#define MAXSTRLEN 255
+#define LEXHASHSIZE	(1 << 11)
+#define MAXSTRLEN	255
 
 struct sLexInitString {
 	char *tzName;
-	ULONG nToken;
+	uint32_t nToken;
 };
 
 struct sLexFloat {
-	ULONG(*Callback) (char *s, ULONG size);
-	ULONG nToken;
+	uint32_t (*Callback)(char *s, uint32_t size);
+	uint32_t nToken;
 };
 
 struct yy_buffer_state {
-	char *pBufferRealStart; // actual starting address
-	char *pBufferStart; // address where the data is initially written
-	                    // after the "safety margin"
+	/* Actual starting address */
+	char *pBufferRealStart;
+	/* Address where the data is initially written after a safety margin */
+	char *pBufferStart;
 	char *pBuffer;
-	ULONG nBufferSize;
-	ULONG oAtLineStart;
+	uint32_t nBufferSize;
+	uint32_t oAtLineStart;
 };
 
 enum eLexerState {
 	LEX_STATE_NORMAL,
 	LEX_STATE_MACROARGS
 };
-#define INITIAL			0
-#define macroarg		3
+
+#define INITIAL		0
+#define macroarg	3
 
 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 
-extern void yy_set_state(enum eLexerState i);
-extern YY_BUFFER_STATE yy_create_buffer(FILE * f);
-extern YY_BUFFER_STATE yy_scan_bytes(char *mem, ULONG size);
-extern void yy_delete_buffer(YY_BUFFER_STATE);
-extern void yy_switch_to_buffer(YY_BUFFER_STATE);
-extern ULONG lex_FloatAlloc(struct sLexFloat * tok);
-extern void lex_FloatAddRange(ULONG id, UWORD start, UWORD end);
-extern void lex_FloatDeleteRange(ULONG id, UWORD start, UWORD end);
-extern void lex_FloatAddFirstRange(ULONG id, UWORD start, UWORD end);
-extern void lex_FloatDeleteFirstRange(ULONG id, UWORD start, UWORD end);
-extern void lex_FloatAddSecondRange(ULONG id, UWORD start, UWORD end);
-extern void lex_FloatDeleteSecondRange(ULONG id, UWORD start, UWORD end);
-extern void lex_Init(void);
-extern void lex_AddStrings(struct sLexInitString * lex);
-extern void lex_SetBuffer(char *buffer, ULONG len);
-extern ULONG yylex(void);
-extern void yyunput(char c);
-extern void yyunputstr(char *s);
-extern void yyskipbytes(ULONG count);
-extern void yyunputbytes(ULONG count);
+void setup_lexer(void);
+
+void yy_set_state(enum eLexerState i);
+YY_BUFFER_STATE yy_create_buffer(FILE *f);
+YY_BUFFER_STATE yy_scan_bytes(char *mem, uint32_t size);
+void yy_delete_buffer(YY_BUFFER_STATE buf);
+void yy_switch_to_buffer(YY_BUFFER_STATE buf);
+uint32_t lex_FloatAlloc(const struct sLexFloat *tok);
+void lex_FloatAddRange(uint32_t id, uint16_t start, uint16_t end);
+void lex_FloatDeleteRange(uint32_t id, uint16_t start, uint16_t end);
+void lex_FloatAddFirstRange(uint32_t id, uint16_t start, uint16_t end);
+void lex_FloatDeleteFirstRange(uint32_t id, uint16_t start, uint16_t end);
+void lex_FloatAddSecondRange(uint32_t id, uint16_t start, uint16_t end);
+void lex_FloatDeleteSecondRange(uint32_t id, uint16_t start, uint16_t end);
+void lex_Init(void);
+void lex_AddStrings(const struct sLexInitString *lex);
+void lex_SetBuffer(char *buffer, uint32_t len);
+int yywrap(void);
+uint32_t yylex(void);
+void yyunput(char c);
+void yyunputstr(char *s);
+void yyskipbytes(uint32_t count);
+void yyunputbytes(uint32_t count);
 
 extern YY_BUFFER_STATE pCurrentBuffer;
 
-extern void upperstring(char *s);
-extern void lowerstring(char *s);
+void upperstring(char *s);
+void lowerstring(char *s);
 
-#endif
+#endif /* RGBDS_ASM_LEXER_H */

include/asm/localasm.h

@@ -1,95 +1,89 @@
-/* GB Z80 instruction groups
-
- n3 = 3-bit
- n  = 8-bit
- nn = 16-bit
-
-*ADC  A,n				:	0xCE
-*ADC  A,r				:	0x88|r
-*ADD  A,n				:	0xC6
-*ADD  A,r				:	0x80|r
-*ADD  HL,ss			:	0x09|(ss<<4)
-*ADD  SP,n			:	0xE8
-*AND  A,n				:	0xE6
-*AND  A,r				:	0xA0|r
-*BIT  n3,r			:	0xCB 0x40|(n3<<3)|r
-*CALL cc,nn 			:	0xC4|(cc<<3)
-*CALL nn				:	0xCD
-*CCF					:	0x3F
-*CP   A,n				:	0xFE
-*CP   A,r				:	0xB8|r
-*CPL					:	0x2F
-*DAA					:	0x27
-*DEC  r 				:	0x05|(r<<3)
-*DEC  ss				:	0x0B|(ss<<4)
-*DI						:	0xF3
-*EI						:	0xFB
-*EX   HL,(SP)		:	0xE3
-*HALT					:	0x76
-*INC  r 				:	0x04|(r<<3)
-*INC  ss				:	0x03|(ss<<4)
-*JP   (HL)			:	0xE9
-*JP   cc,nn 			:	0xC2|(cc<<3)
-*JP   nn 				:	0xC3|(cc<<3)
-*JR	n				:	0x18
-*JR   cc,n 			:	0x20|(cc<<3)
-*LD	(nn),SP		:	0x08
-*LD   ($FF00+C),A	:	0xE2
-*LD   ($FF00+n),A	:	0xE0
-*LD   (nn),A			:	0xEA
-*LD   (rr),A			:	0x02|(rr<<4)
-*LD   A,($FF00+C)	:	0xF2
-*LD   A,($FF00+n)	:	0xF0
-*LD   A,(nn)			:	0xFA
-*LD   A,(rr)			:	0x0A|(rr<<4)
-*LD   HL,(SP+n)		:	0xF8
-*LD   SP,HL			:	0xF9
-*LD   r,n				:	0x06|(r<<3)
-*LD   r,r' 			:	0x40|(r<<3)|r' // NOTE: LD (HL),(HL) not allowed
-*LD   ss,nn			:	0x01|(ss<<4)
-*NOP					:	0x00
-*OR   A,n				:	0xF6
-*OR   A,r				:	0xB0|r
-*POP  tt				:	0xC1|(tt<<4)
-*PUSH tt				:	0xC5|(tt<<4)
-*RES  n3,r			:	0xCB 0x80|(n3<<3)|r
-*RET					:	0xC9
-*RET  cc				:	0xC0|(cc<<3)
-*RETI					:	0xD9
-*RL   r				:	0xCB 0x10|r
-*RLA					:	0x17
-*RLC  r				:	0xCB 0x00|r
-*RLCA					:	0x07
-*RR   r				:	0xCB 0x18|r
-*RRA					:	0x1F
-*RRC  r				:	0xCB 0x08|r
-*RRCA					:	0x0F
-*RST  n				:	0xC7|n
-*SBC  A,n				:	0xDE
-*SBC  A,r				:	0x98|r
-*SCF					:	0x37
-*SET  n3,r			:	0xCB 0xC0|(n8<<3)|r
-*SLA  r				:	0xCB 0x20|r
-*SRA  r				:	0xCB 0x28|r
-*SRL  r				:	0xCB 0x38|r
-*STOP					:	0x10
-*SUB  A,n				:	0xD6
-*SUB  A,r				:	0x90|r
-*SWAP r				:	0xCB 0x30|r
-*XOR  A,n				:	0xEE
-*XOR  A,r				:	0xA8|r
+#ifndef RGBDS_ASM_LOCALASM_H
+#define RGBDS_ASM_LOCALASM_H
 
+/*
+ * GB Z80 instruction groups
+ *
+ * n3 = 3-bit
+ * n  = 8-bit
+ * nn = 16-bit
+ *
+ * ADC  A,n         :   0xCE
+ * ADC  A,r         :   0x88|r
+ * ADD  A,n         :   0xC6
+ * ADD  A,r         :   0x80|r
+ * ADD  HL,ss       :   0x09|(ss<<4)
+ * ADD  SP,n        :   0xE8
+ * AND  A,n         :   0xE6
+ * AND  A,r         :   0xA0|r
+ * BIT  n3,r        :   0xCB 0x40|(n3<<3)|r
+ * CALL cc,nn       :   0xC4|(cc<<3)
+ * CALL nn          :   0xCD
+ * CCF              :   0x3F
+ * CP   A,n         :   0xFE
+ * CP   A,r         :   0xB8|r
+ * CPL              :   0x2F
+ * DAA              :   0x27
+ * DEC  r           :   0x05|(r<<3)
+ * DEC  ss          :   0x0B|(ss<<4)
+ * DI               :   0xF3
+ * EI               :   0xFB
+ * HALT             :   0x76
+ * INC  r           :   0x04|(r<<3)
+ * INC  ss          :   0x03|(ss<<4)
+ * JP   HL          :   0xE9
+ * JP   cc,nn       :   0xC2|(cc<<3)
+ * JP   nn          :   0xC3|(cc<<3)
+ * JR   n           :   0x18
+ * JR   cc,n        :   0x20|(cc<<3)
+ * LD   (nn),SP     :   0x08
+ * LD   ($FF00+C),A :   0xE2
+ * LD   ($FF00+n),A :   0xE0
+ * LD   (nn),A      :   0xEA
+ * LD   (rr),A      :   0x02|(rr<<4) // HL+ and HL- included
+ * LD   A,($FF00+C) :   0xF2
+ * LD   A,($FF00+n) :   0xF0
+ * LD   A,(nn)      :   0xFA
+ * LD   A,(rr)      :   0x0A|(rr<<4) // HL+ and HL- included
+ * LD   HL,SP+n     :   0xF8
+ * LD   SP,HL       :   0xF9
+ * LD   r,n         :   0x06|(r<<3)
+ * LD   r,r'        :   0x40|(r<<3)|r' // NOTE: LD (HL),(HL) not allowed
+ * LD   ss,nn       :   0x01|(ss<<4)
+ * NOP              :   0x00
+ * OR   A,n         :   0xF6
+ * OR   A,r         :   0xB0|r
+ * POP  tt          :   0xC1|(tt<<4)
+ * PUSH tt          :   0xC5|(tt<<4)
+ * RES  n3,r        :   0xCB 0x80|(n3<<3)|r
+ * RET              :   0xC9
+ * RET  cc          :   0xC0|(cc<<3)
+ * RETI             :   0xD9
+ * RL   r           :   0xCB 0x10|r
+ * RLA              :   0x17
+ * RLC  r           :   0xCB 0x00|r
+ * RLCA             :   0x07
+ * RR   r           :   0xCB 0x18|r
+ * RRA              :   0x1F
+ * RRC  r           :   0xCB 0x08|r
+ * RRCA             :   0x0F
+ * RST  n           :   0xC7|n
+ * SBC  A,n         :   0xDE
+ * SBC  A,r         :   0x98|r
+ * SCF              :   0x37
+ * SET  n3,r        :   0xCB 0xC0|(n8<<3)|r
+ * SLA  r           :   0xCB 0x20|r
+ * SRA  r           :   0xCB 0x28|r
+ * SRL  r           :   0xCB 0x38|r
+ * STOP             :   0x10 0x00
+ * SUB  A,n         :   0xD6
+ * SUB  A,r         :   0x90|r
+ * SWAP r           :   0xCB 0x30|r
+ * XOR  A,n         :   0xEE
+ * XOR  A,r         :   0xA8|r
  */
 
-#define MAXSECTIONSIZE	0x4000
-
-#define	NAME_DB			"db"
-#define	NAME_DW			"dw"
-#define	NAME_RB			"rb"
-#define	NAME_RW			"rw"
-
 /* "r" defs */
-
 enum {
 	REG_B = 0,
 	REG_C,
@@ -100,36 +94,30 @@ enum {
 	REG_HL_IND,
 	REG_A
 };
-/* "rr" defs */
 
+/* "rr" defs */
 enum {
 	REG_BC_IND = 0,
 	REG_DE_IND,
 	REG_HL_INDINC,
 	REG_HL_INDDEC,
 };
-/* "ss" defs */
 
+/* "ss" defs (SP) and "tt" defs (AF) */
 enum {
 	REG_BC = 0,
-	REG_DE,
-	REG_HL,
-	REG_SP
+	REG_DE = 1,
+	REG_HL = 2,
+	REG_SP = 3,
+	REG_AF = 3
 };
-/* "tt" defs */
-
-/*
-#define REG_BC		0
-#define REG_DE		1
-#define REG_HL		2
- */
-#define REG_AF		3
 
 /* "cc" defs */
-
 enum {
 	CC_NZ = 0,
 	CC_Z,
 	CC_NC,
 	CC_C
 };
+
+#endif /* RGBDS_ASM_LOCALASM_H */

include/asm/main.h

@@ -1,38 +1,63 @@
-#ifndef	RGBDS_MAIN_H
-#define	RGBDS_MAIN_H
+#ifndef RGBDS_MAIN_H
+#define RGBDS_MAIN_H
 
 #include <stdbool.h>
+#include <stdint.h>
+
 #include "extern/stdnoreturn.h"
 
 struct sOptions {
 	char gbgfx[4];
 	char binary[2];
-	SLONG fillchar;
+	int32_t fillchar;
 	bool verbose;
 	bool haltnop;
 	bool exportall;
-	    //-1 == random
+	bool warnings; /* True to enable warnings, false to disable them. */
 };
 
 extern char *tzNewMacro;
-extern ULONG ulNewMacroSize;
-extern SLONG nGBGfxID;
-extern SLONG nBinaryID;
+extern uint32_t ulNewMacroSize;
+extern int32_t nGBGfxID;
+extern int32_t nBinaryID;
 
 extern struct sOptions DefaultOptions;
 extern struct sOptions CurrentOptions;
-extern void opt_Push(void);
-extern void opt_Pop(void);
-extern void opt_Parse(char *s);
 
+extern FILE *dependfile;
+
+void opt_Push(void);
+void opt_Pop(void);
+void opt_Parse(char *s);
+
+/*
+ * Used for errors that compromise the whole assembly process by affecting the
+ * folliwing code, potencially making the assembler generate errors caused by
+ * the first one and unrelated to the code that the assembler complains about.
+ * It is also used when the assembler goes into an invalid state (for example,
+ * when it fails to allocate memory).
+ */
 noreturn void fatalerror(const char *fmt, ...);
+
+/*
+ * Used for errors that make it impossible to assemble correctly, but don't
+ * affect the following code. The code will fail to assemble but the user will
+ * get a list of all errors at the end, making it easier to fix all of them at
+ * once.
+ */
 void yyerror(const char *fmt, ...);
 
-#define	YY_FATAL_ERROR fatalerror
+/*
+ * Used to warn the user about problems that don't prevent the generation of
+ * valid code.
+ */
+void warning(const char *fmt, ...);
 
-#ifdef	YYLMAX
-#undef	YYLMAX
+#define YY_FATAL_ERROR fatalerror
+
+#ifdef YYLMAX
+#undef YYLMAX
 #endif
 #define YYLMAX 65536
 
-#endif
+#endif /* RGBDS_MAIN_H */

include/asm/mylink.h

@@ -1,120 +0,0 @@
-#ifndef RGBDS_ASM_LINK_H
-#define RGBDS_ASM_LINK_H
-
-/* RGB0 .obj format:
- *
- * Header
- * Symbols
- * Sections
- *
- * Header:
- * "RGB0"
- * LONG NumberOfSymbols
- * LONG NumberOfSections
- *
- * Symbols:
- * Symbol[NumberOfSymbols]
- *
- * Symbol:
- * char Name (NULL terminated)
- * char nType
- * if( nType!=SYM_IMPORT )
- * {
- *		LONG SectionID
- *		LONG Offset
- * }
- *
- * Sections:
- * Section[NumberOfSections]
- *
- * Section:
- * LONG SizeInBytes
- * char Type
- * if( Type!=WRAM0 )
- * {
- *		char Data[SizeInBytes]
- *		Patches
- * }
- *
- * Patches:
- * LONG NumberOfPatches
- * Patch[NumberOfPatches]
- *
- * Patch:
- * char Filename NULL-terminated
- * LONG LineNo
- * LONG Offset
- * char Type
- * LONG RpnByteSize
- * Rpn[RpnByteSize]
- *
- * Rpn:
- * Operators: 0x00-0x7F
- * Constants: 0x80 0x00000000
- * Symbols  : 0x81 0x00000000
- *
- */
-
-enum {
-	RPN_ADD = 0,
-	RPN_SUB,
-	RPN_MUL,
-	RPN_DIV,
-	RPN_MOD,
-	RPN_UNSUB,
-
-	RPN_OR,
-	RPN_AND,
-	RPN_XOR,
-	RPN_UNNOT,
-
-	RPN_LOGAND,
-	RPN_LOGOR,
-	RPN_LOGUNNOT,
-
-	RPN_LOGEQ,
-	RPN_LOGNE,
-	RPN_LOGGT,
-	RPN_LOGLT,
-	RPN_LOGGE,
-	RPN_LOGLE,
-
-	RPN_SHL,
-	RPN_SHR,
-
-	RPN_BANK,
-
-	RPN_HRAM,
-
-	RPN_PCEZP,
-
-	RPN_RANGECHECK,
-
-	RPN_CONST = 0x80,
-	RPN_SYM = 0x81
-};
-
-enum {
-	SECT_WRAM0 = 0,
-	SECT_VRAM,
-	SECT_ROMX,
-	SECT_ROM0,
-	SECT_HRAM,
-	SECT_WRAMX,
-	SECT_SRAM
-};
-
-enum {
-	SYM_LOCAL = 0,
-	SYM_IMPORT,
-	SYM_EXPORT
-};
-
-enum {
-	PATCH_BYTE = 0,
-	PATCH_WORD_L,
-	PATCH_LONG_L,
-	PATCH_WORD_B,
-	PATCH_LONG_B
-};
-#endif

include/asm/mymath.h

@@ -1,21 +1,21 @@
 #ifndef RGBDS_ASM_MATH_H
 #define RGBDS_ASM_MATH_H
 
-#include "types.h"
+#include <stdint.h>
 
 void math_DefinePI(void);
-void math_Print(SLONG i);
-SLONG math_Sin(SLONG i);
-SLONG math_Cos(SLONG i);
-SLONG math_Tan(SLONG i);
-SLONG math_ASin(SLONG i);
-SLONG math_ACos(SLONG i);
-SLONG math_ATan(SLONG i);
-SLONG math_ATan2(SLONG i, SLONG j);
-SLONG math_Mul(SLONG i, SLONG j);
-SLONG math_Div(SLONG i, SLONG j);
-SLONG math_Round(SLONG i);
-SLONG math_Ceil(SLONG i);
-SLONG math_Floor(SLONG i);
+void math_Print(int32_t i);
+int32_t math_Sin(int32_t i);
+int32_t math_Cos(int32_t i);
+int32_t math_Tan(int32_t i);
+int32_t math_ASin(int32_t i);
+int32_t math_ACos(int32_t i);
+int32_t math_ATan(int32_t i);
+int32_t math_ATan2(int32_t i, int32_t j);
+int32_t math_Mul(int32_t i, int32_t j);
+int32_t math_Div(int32_t i, int32_t j);
+int32_t math_Round(int32_t i);
+int32_t math_Ceil(int32_t i);
+int32_t math_Floor(int32_t i);
 
-#endif
+#endif /* RGBDS_ASM_MATH_H */

include/asm/output.h

@@ -1,38 +1,45 @@
 #ifndef RGBDS_ASM_OUTPUT_H
 #define RGBDS_ASM_OUTPUT_H
 
+#include <stdint.h>
+
 #include "asm/rpn.h"
-#include "types.h"
 
 struct Section {
 	char *pzName;
-	UBYTE nType;
-	ULONG nPC;
-	ULONG nOrg;
-	ULONG nBank;
+	uint8_t nType;
+	uint32_t nPC;
+	uint32_t nOrg;
+	uint32_t nBank;
+	uint32_t nAlign;
 	struct Section *pNext;
 	struct Patch *pPatches;
 	struct Charmap *charmap;
-	UBYTE *tData;
+	uint8_t *tData;
 };
 
+extern char *tzObjectname;
+
 void out_PrepPass2(void);
 void out_SetFileName(char *s);
-void out_NewSection(char *pzName, ULONG secttype);
-void out_NewAbsSection(char *pzName, ULONG secttype, SLONG org, SLONG bank);
-void out_AbsByte(int b);
-void out_AbsByteGroup(char *s, int length);
-void out_RelByte(struct Expression * expr);
-void out_RelWord(struct Expression * expr);
-void out_PCRelByte(struct Expression * expr);
+void out_NewSection(char *pzName, uint32_t secttype);
+void out_NewAbsSection(char *pzName, uint32_t secttype, int32_t org,
+		       int32_t bank);
+void out_NewAlignedSection(char *pzName, uint32_t secttype, int32_t alignment,
+			   int32_t bank);
+void out_AbsByte(int32_t b);
+void out_AbsByteGroup(char *s, int32_t length);
+void out_RelByte(struct Expression *expr);
+void out_RelWord(struct Expression *expr);
+void out_PCRelByte(struct Expression *expr);
 void out_WriteObject(void);
-void out_Skip(int skip);
+void out_Skip(int32_t skip);
 void out_BinaryFile(char *s);
-void out_BinaryFileSlice(char *s, SLONG start_pos, SLONG length);
+void out_BinaryFileSlice(char *s, int32_t start_pos, int32_t length);
 void out_String(char *s);
-void out_AbsLong(SLONG b);
-void out_RelLong(struct Expression * expr);
+void out_AbsLong(int32_t b);
+void out_RelLong(struct Expression *expr);
 void out_PushSection(void);
 void out_PopSection(void);
 
-#endif
+#endif /* RGBDS_ASM_OUTPUT_H */

include/asm/rpn.h

@@ -1,82 +1,67 @@
 #ifndef RGBDS_ASM_RPN_H
 #define RGBDS_ASM_RPN_H
 
+#include <stdint.h>
+
 struct Expression {
-	SLONG nVal;
-	UBYTE tRPN[256];
-	ULONG nRPNLength;
-	ULONG nRPNOut;
-	ULONG isReloc;
-	ULONG isPCRel;
+	int32_t  nVal;
+	uint8_t  tRPN[256];
+	uint32_t nRPNLength;
+	uint32_t nRPNOut;
+	uint32_t isReloc;
+	uint32_t isPCRel;
 };
 
-ULONG rpn_isReloc(struct Expression * expr);
-ULONG rpn_isPCRelative(struct Expression * expr);
-void rpn_Symbol(struct Expression * expr, char *tzSym);
-void rpn_Number(struct Expression * expr, ULONG i);
-void rpn_LOGNOT(struct Expression * expr, struct Expression * src1);
-void 
-rpn_LOGOR(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void 
-rpn_LOGAND(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void 
-rpn_LOGEQU(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void 
-rpn_LOGGT(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void 
-rpn_LOGLT(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void 
-rpn_LOGGE(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void 
-rpn_LOGLE(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void 
-rpn_LOGNE(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void 
-rpn_ADD(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void 
-rpn_SUB(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void 
-rpn_XOR(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void 
-rpn_OR(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void 
-rpn_AND(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void 
-rpn_SHL(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void 
-rpn_SHR(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void 
-rpn_MUL(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void 
-rpn_DIV(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void 
-rpn_MOD(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2);
-void rpn_UNNEG(struct Expression * expr, struct Expression * src);
-void rpn_UNNOT(struct Expression * expr, struct Expression * src);
-UWORD rpn_PopByte(struct Expression * expr);
-void rpn_Bank(struct Expression * expr, char *tzSym);
-void rpn_Reset(struct Expression * expr);
-int 
-rpn_RangeCheck(struct Expression * expr, struct Expression * src, SLONG low,
-    SLONG high);
-void rpn_CheckHRAM(struct Expression * expr, struct Expression * src1);
+uint32_t rpn_isReloc(const struct Expression *expr);
+uint32_t rpn_isPCRelative(const struct Expression *expr);
+void rpn_Symbol(struct Expression *expr, char *tzSym);
+void rpn_Number(struct Expression *expr, uint32_t i);
+void rpn_LOGNOT(struct Expression *expr, const struct Expression *src);
+void rpn_LOGOR(struct Expression *expr, const struct Expression *src1,
+	       const struct Expression *src2);
+void rpn_LOGAND(struct Expression *expr, const struct Expression *src1,
+		const struct Expression *src2);
+void rpn_LOGEQU(struct Expression *expr, const struct Expression *src1,
+		const struct Expression *src2);
+void rpn_LOGGT(struct Expression *expr, const struct Expression *src1,
+	       const struct Expression *src2);
+void rpn_LOGLT(struct Expression *expr, const struct Expression *src1,
+	       const struct Expression *src2);
+void rpn_LOGGE(struct Expression *expr, const struct Expression *src1,
+	       const struct Expression *src2);
+void rpn_LOGLE(struct Expression *expr, const struct Expression *src1,
+	       const struct Expression *src2);
+void rpn_LOGNE(struct Expression *expr, const struct Expression *src1,
+	       const struct Expression *src2);
+void rpn_ADD(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2);
+void rpn_SUB(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2);
+void rpn_XOR(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2);
+void rpn_OR(struct Expression *expr, const struct Expression *src1,
+	    const struct Expression *src2);
+void rpn_AND(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2);
+void rpn_SHL(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2);
+void rpn_SHR(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2);
+void rpn_MUL(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2);
+void rpn_DIV(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2);
+void rpn_MOD(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2);
+void rpn_HIGH(struct Expression *expr, const struct Expression *src);
+void rpn_LOW(struct Expression *expr, const struct Expression *src);
+void rpn_UNNEG(struct Expression *expr, const struct Expression *src);
+void rpn_UNNOT(struct Expression *expr, const struct Expression *src);
+uint16_t rpn_PopByte(struct Expression *expr);
+void rpn_BankSymbol(struct Expression *expr, char *tzSym);
+void rpn_BankSection(struct Expression *expr, char *tzSectionName);
+void rpn_BankSelf(struct Expression *expr);
+void rpn_Reset(struct Expression *expr);
+void rpn_CheckHRAM(struct Expression *expr, const struct Expression *src);
 
-#endif
+#endif /* RGBDS_ASM_RPN_H */

include/asm/symbol.h

@@ -1,42 +1,50 @@
 #ifndef RGBDS_SYMBOL_H
 #define RGBDS_SYMBOL_H
 
+#include <stdint.h>
+
 #include "types.h"
 
-#define HASHSIZE (1 << 16)
-#define MAXSYMLEN 256
+#define HASHSIZE	(1 << 16)
+#define MAXSYMLEN	256
 
 struct sSymbol {
 	char tzName[MAXSYMLEN + 1];
-	SLONG nValue;
-	ULONG nType;
+	int32_t nValue;
+	uint32_t nType;
 	struct sSymbol *pScope;
 	struct sSymbol *pNext;
 	struct Section *pSection;
-	ULONG ulMacroSize;
+	uint32_t ulMacroSize;
 	char *pMacro;
-	     SLONG(*Callback) (struct sSymbol *);
+	int32_t (*Callback)(struct sSymbol *);
+	char tzFileName[_MAX_PATH + 1]; /* File where the symbol was defined. */
+	uint32_t nFileLine; /* Line where the symbol was defined. */
 };
-#define SYMF_RELOC		0x001	/* symbol will be reloc'ed during
-					 * linking, it's absolute value is
-					 * unknown */
-#define SYMF_EQU		0x002	/* symbol is defined using EQU, will
-					 * not be changed during linking */
-#define SYMF_SET		0x004	/* symbol is (re)defined using SET,
-					 * will not be changed during linking */
-#define SYMF_EXPORT		0x008	/* symbol should be exported */
-#define SYMF_IMPORT		0x010	/* symbol is imported, it's value is
-					 * unknown */
-#define SYMF_LOCAL		0x020	/* symbol is a local symbol */
-#define SYMF_DEFINED	0x040	/* symbol has been defined, not only
-				 * referenced */
-#define SYMF_MACRO		0x080	/* symbol is a macro */
-#define SYMF_STRING		0x100	/* symbol is a stringsymbol */
-#define SYMF_CONST		0x200	/* symbol has a constant value, will
-					 * not be changed during linking */
 
-ULONG calchash(char *s);
-void sym_SetExportAll(BBOOL set);
+/* Symbol will be relocated during linking, it's absolute value is unknown */
+#define SYMF_RELOC	0x001
+/* Symbol is defined using EQU, will not be changed during linking */
+#define SYMF_EQU	0x002
+/* Symbol is (re)defined using SET, will not be changed during linking */
+#define SYMF_SET	0x004
+/* Symbol should be exported */
+#define SYMF_EXPORT	0x008
+/* Symbol is imported, it's value is unknown */
+#define SYMF_IMPORT	0x010
+/* Symbol is a local symbol */
+#define SYMF_LOCAL	0x020
+/* Symbol has been defined, not only referenced */
+#define SYMF_DEFINED	0x040
+/* Symbol is a macro */
+#define SYMF_MACRO	0x080
+/* Symbol is a stringsymbol */
+#define SYMF_STRING	0x100
+/* Symbol has a constant value, will not be changed during linking */
+#define SYMF_CONST	0x200
+
+uint32_t calchash(char *s);
+void sym_SetExportAll(uint8_t set);
 void sym_PrepPass1(void);
 void sym_PrepPass2(void);
 void sym_AddLocalReloc(char *tzSym);
@@ -50,26 +58,30 @@ void sym_SaveCurrentMacroArgs(char *save[]);
 void sym_RestoreCurrentMacroArgs(char *save[]);
 void sym_UseNewMacroArgs(void);
 void sym_FreeCurrentMacroArgs(void);
-void sym_AddEqu(char *tzSym, SLONG value);
-void sym_AddSet(char *tzSym, SLONG value);
+void sym_AddEqu(char *tzSym, int32_t value);
+void sym_AddSet(char *tzSym, int32_t value);
 void sym_Init(void);
-ULONG sym_GetConstantValue(char *s);
-void sym_Import(char *tzSym);
-ULONG sym_isConstant(char *s);
+uint32_t sym_GetConstantValue(char *s);
+uint32_t sym_isConstant(char *s);
 struct sSymbol *sym_FindSymbol(char *tzName);
 void sym_Global(char *tzSym);
-char *sym_FindMacroArg(SLONG i);
+char *sym_FindMacroArg(int32_t i);
 char *sym_GetStringValue(char *tzSym);
 void sym_UseCurrentMacroArgs(void);
-void sym_SetMacroArgID(ULONG nMacroCount);
-ULONG sym_isString(char *tzSym);
+void sym_SetMacroArgID(uint32_t nMacroCount);
+uint32_t sym_isString(char *tzSym);
 void sym_AddMacro(char *tzSym);
 void sym_ShiftCurrentMacroArgs(void);
 void sym_AddString(char *tzSym, char *tzValue);
-ULONG sym_GetValue(char *s);
-ULONG sym_GetDefinedValue(char *s);
-ULONG sym_isDefined(char *tzName);
+uint32_t sym_GetValue(char *s);
+uint32_t sym_GetDefinedValue(char *s);
+uint32_t sym_isDefined(char *tzName);
 void sym_Purge(char *tzName);
-ULONG sym_isConstDefined(char *tzName);
+uint32_t sym_isConstDefined(char *tzName);
+int32_t sym_IsRelocDiffDefined(char *tzSym1, char *tzSym2);
 
-#endif
+/* Functions to save and restore the current symbol scope. */
+struct sSymbol *sym_GetCurrentSymbolScope(void);
+void sym_SetCurrentSymbolScope(struct sSymbol *pNewScope);
+
+#endif /* RGBDS_SYMBOL_H */

include/common.h

@@ -0,0 +1,36 @@
+#ifndef RGBDS_COMMON_H
+#define RGBDS_COMMON_H
+
+#define RGBDS_OBJECT_VERSION_STRING "RGB6"
+
+enum eBankCount {
+	BANK_COUNT_ROM0  = 1,
+	BANK_COUNT_ROMX  = 511,
+	BANK_COUNT_WRAM0 = 1,
+	BANK_COUNT_WRAMX = 7,
+	BANK_COUNT_VRAM  = 2,
+	BANK_COUNT_OAM   = 1,
+	BANK_COUNT_HRAM  = 1,
+	BANK_COUNT_SRAM  = 16
+};
+
+enum eBankGBCount {
+	BANK_MIN_ROM0  = 0,
+	BANK_MAX_ROM0  = BANK_COUNT_ROM0  + BANK_MIN_ROM0  - 1,
+	BANK_MIN_ROMX  = 1,
+	BANK_MAX_ROMX  = BANK_COUNT_ROMX  + BANK_MIN_ROMX  - 1,
+	BANK_MIN_WRAM0 = 0,
+	BANK_MAX_WRAM0 = BANK_COUNT_WRAM0 + BANK_MIN_WRAM0 - 1,
+	BANK_MIN_WRAMX = 1,
+	BANK_MAX_WRAMX = BANK_COUNT_WRAMX + BANK_MIN_WRAMX - 1,
+	BANK_MIN_VRAM  = 0,
+	BANK_MAX_VRAM  = BANK_COUNT_VRAM  + BANK_MIN_VRAM  - 1,
+	BANK_MIN_OAM   = 0,
+	BANK_MAX_OAM   = BANK_COUNT_OAM   + BANK_MIN_OAM   - 1,
+	BANK_MIN_HRAM  = 0,
+	BANK_MAX_HRAM  = BANK_COUNT_HRAM  + BANK_MIN_HRAM  - 1,
+	BANK_MIN_SRAM  = 0,
+	BANK_MAX_SRAM  = BANK_COUNT_SRAM  + BANK_MIN_SRAM  - 1
+};
+
+#endif /* RGBDS_COMMON_H */

include/extern/err.h

@@ -2,10 +2,13 @@
 #define EXTERN_ERR_H
 
 #ifdef ERR_IN_LIBC
+
 #include <err.h>
-#else
+
+#else /* ERR_IN_LIBC */
 
 #include <stdarg.h>
+
 #include "extern/stdnoreturn.h"
 
 #define warn rgbds_warn
@@ -18,16 +21,16 @@
 #define errx rgbds_errx
 #define verrx rgbds_verrx
 
-void warn(const char *, ...);
-void vwarn(const char *, va_list);
-void warnx(const char *, ...);
-void vwarnx(const char *, va_list);
+void warn(const char *fmt, ...);
+void vwarn(const char *fmt, va_list ap);
+void warnx(const char *fmt, ...);
+void vwarnx(const char *fmt, va_list ap);
 
-noreturn void err(int, const char *, ...);
-noreturn void verr(int, const char *, va_list);
-noreturn void errx(int, const char *, ...);
-noreturn void verrx(int, const char *, va_list);
+noreturn void err(int status, const char *fmt, ...);
+noreturn void verr(int status, const char *fmt, va_list ap);
+noreturn void errx(int status, const char *fmt, ...);
+noreturn void verrx(int status, const char *fmt, va_list ap);
 
-#endif
+#endif /* ERR_IN_LIBC */
 
-#endif
+#endif /* EXTERN_ERR_H */

include/extern/reallocarray.h

@@ -2,13 +2,14 @@
 #define EXTERN_REALLOCARRAY_H
 
 #ifdef REALLOCARRAY_IN_LIBC
+
 #include <stdlib.h>
-#else
+
+#else /* REALLOCARRAY_IN_LIBC */
 
 #define reallocarray rgbds_reallocarray
-
 void *reallocarray(void *, size_t, size_t);
 
-#endif
+#endif /* REALLOCARRAY_IN_LIBC */
 
-#endif
+#endif /* EXTERN_REALLOCARRAY_H */

include/extern/stdnoreturn.h

@@ -1,16 +1,21 @@
+#ifndef EXTERN_STDNORETURN_H
+#define EXTERN_STDNORETURN_H
+
 #if __STDC_VERSION__ >= 201112L
-    /* C11 or newer */
-    #define noreturn _Noreturn
+	/* C11 or newer */
+	#define noreturn _Noreturn
 #elif __cplusplus >= 201103L
-    /* C++11 or newer */
-    #define noreturn [[noreturn]]
+	/* C++11 or newer */
+	#define noreturn [[noreturn]]
 #elif __GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ >= 5))
-    /* GCC 2.5 or newer */
-    #define noreturn __attribute__ ((noreturn))
+	/* GCC 2.5 or newer */
+	#define noreturn __attribute__ ((noreturn))
 #elif _MSC_VER >= 1310
-    /* MS Visual Studio 2003/.NET Framework 1.1 or newer */
-    #define noreturn _declspec( noreturn)
+	/* MS Visual Studio 2003/.NET Framework 1.1 or newer */
+	#define noreturn _declspec(noreturn)
 #else
-    /* unsupported, but no need to throw a fit */
-    #define noreturn 
+	/* Unsupported, but no need to throw a fit */
+	#define noreturn
 #endif
+
+#endif /* EXTERN_STDNORETURN_H */

include/extern/strl.h

@@ -1,13 +1,17 @@
-#ifndef STRL_H
-#define STRL_H
+#ifndef EXTERN_STRL_H
+#define EXTERN_STRL_H
 
 #ifdef STRL_IN_LIBC
+
 #include <string.h>
-#else
+
+#else /* STRL_IN_LIBC */
+
 #define strlcpy rgbds_strlcpy
 #define strlcat rgbds_strlcat
-size_t strlcpy(char *, const char *, size_t);
-size_t strlcat(char *, const char *, size_t);
-#endif
+size_t strlcpy(char *dst, const char *src, size_t dsize);
+size_t strlcat(char *dst, const char *src, size_t dsize);
 
-#endif
+#endif /* STRL_IN_LIBC */
+
+#endif /* EXTERN_STRL_H */

include/extern/version.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2017 Antonio Nino Diaz <antonio_nd@outlook.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef EXTERN_VERSION_H
+#define EXTERN_VERSION_H
+
+#define PACKAGE_VERSION_MAJOR (0)
+#define PACKAGE_VERSION_MINOR (3)
+#define PACKAGE_VERSION_PATCH (4)
+
+const char *get_package_version_string(void);
+
+#endif /* EXTERN_VERSION_H */

include/gfx/gb.h

@@ -20,11 +20,14 @@
 #include <stdint.h>
 #include "gfx/main.h"
 
-void png_to_gb(struct PNGImage png, struct GBImage *gb);
-void output_file(struct Options opts, struct GBImage gb);
-int get_tile_index(uint8_t *tile, uint8_t **tiles, int num_tiles, int tile_size);
-void create_tilemap(struct Options opts, struct GBImage *gb, struct Tilemap *tilemap);
-void output_tilemap_file(struct Options opts, struct Tilemap tilemap);
-void output_palette_file(struct Options opts, struct PNGImage png);
+void png_to_gb(const struct PNGImage png, struct GBImage *gb);
+void output_file(const struct Options opts, const struct GBImage gb);
+int get_tile_index(uint8_t *tile, uint8_t **tiles, int num_tiles,
+		   int tile_size);
+void create_tilemap(const struct Options opts, struct GBImage *gb,
+		    struct Tilemap *tilemap);
+void output_tilemap_file(const struct Options opts,
+			 const struct Tilemap tilemap);
+void output_palette_file(const struct Options opts, const struct PNGImage png);
 
 #endif

include/gfx/main.h

@@ -72,4 +72,4 @@ int depth, colors;
 #include "gfx/makepng.h"
 #include "gfx/gb.h"
 
-#endif
+#endif /* RGBDS_GFX_MAIN_H */

include/gfx/makepng.h

@@ -19,10 +19,10 @@
 
 #include "gfx/main.h"
 
-void input_png_file(struct Options opts, struct PNGImage *img);
+void input_png_file(const struct Options opts, struct PNGImage *img);
 void get_text(struct PNGImage *png);
-void set_text(struct PNGImage *png);
-void output_png_file(struct Options opts, struct PNGImage *png);
-void free_png_data(struct PNGImage *png);
+void set_text(const struct PNGImage *png);
+void output_png_file(const struct Options opts, const struct PNGImage *png);
+void free_png_data(const struct PNGImage *png);
 
-#endif
+#endif /* RGBDS_GFX_PNG_H */

include/link/assign.h

@@ -1,35 +1,45 @@
 #ifndef RGBDS_LINK_ASSIGN_H
 #define RGBDS_LINK_ASSIGN_H
 
-#include "types.h"
+#include <stdint.h>
 
+#include "common.h"
+#include "mylink.h"
+
+/* Bank numbers as seen by the linker */
 enum eBankDefine {
-	BANK_ROM0 = 0,
-	BANK_ROMX,
-	BANK_WRAM0 = 512,
-	BANK_WRAMX,
-	BANK_VRAM = 520,
-	BANK_HRAM = 522,
-	BANK_SRAM = 523
+	BANK_INDEX_ROM0  = 0,
+	BANK_INDEX_ROMX  = BANK_INDEX_ROM0  + BANK_COUNT_ROM0,
+	BANK_INDEX_WRAM0 = BANK_INDEX_ROMX  + BANK_COUNT_ROMX,
+	BANK_INDEX_WRAMX = BANK_INDEX_WRAM0 + BANK_COUNT_WRAM0,
+	BANK_INDEX_VRAM  = BANK_INDEX_WRAMX + BANK_COUNT_WRAMX,
+	BANK_INDEX_OAM   = BANK_INDEX_VRAM  + BANK_COUNT_VRAM,
+	BANK_INDEX_HRAM  = BANK_INDEX_OAM   + BANK_COUNT_OAM,
+	BANK_INDEX_SRAM  = BANK_INDEX_HRAM  + BANK_COUNT_HRAM,
+	BANK_INDEX_MAX   = BANK_INDEX_SRAM  + BANK_COUNT_SRAM
 };
 
-enum eBankCount {
-	BANK_COUNT_ROM0 = 1,
-	BANK_COUNT_ROMX = 511,
-	BANK_COUNT_WRAM0 = 1,
-	BANK_COUNT_WRAMX = 7,
-	BANK_COUNT_VRAM = 2,
-	BANK_COUNT_HRAM = 1,
-	BANK_COUNT_SRAM = 16
-};
+extern int32_t MaxBankUsed;
+extern int32_t MaxAvail[BANK_INDEX_MAX];
 
-#define MAXBANKS	(BANK_COUNT_ROM0 + BANK_COUNT_ROMX + BANK_COUNT_WRAM0 + BANK_COUNT_WRAMX \
-					+ BANK_COUNT_VRAM + BANK_COUNT_HRAM + BANK_COUNT_SRAM)
+int32_t area_Avail(int32_t bank);
+void AssignSections(void);
+void CreateSymbolTable(void);
+struct sSection *GetSectionByName(const char *name);
+int32_t IsSectionNameInUse(const char *name);
+void SetLinkerscriptName(char *tzLinkerscriptFile);
+int32_t IsSectionSameTypeBankAndFloating(const char *name,
+					 enum eSectionType type, int32_t bank);
+uint32_t AssignSectionAddressAndBankByName(const char *name, uint32_t address,
+					   int32_t bank);
 
-extern SLONG area_Avail(SLONG bank);
-extern void AssignSections(void);
-extern void CreateSymbolTable(void);
-extern SLONG MaxBankUsed;
-extern SLONG MaxAvail[MAXBANKS];
+int BankIndexIsROM0(int32_t bank);
+int BankIndexIsROMX(int32_t bank);
+int BankIndexIsWRAM0(int32_t bank);
+int BankIndexIsWRAMX(int32_t bank);
+int BankIndexIsVRAM(int32_t bank);
+int BankIndexIsOAM(int32_t bank);
+int BankIndexIsHRAM(int32_t bank);
+int BankIndexIsSRAM(int32_t bank);
 
-#endif
+#endif /* RGBDS_LINK_ASSIGN_H */

include/link/library.h

@@ -1,6 +1,6 @@
-#ifndef	RGBDS_LINK_LIBRARY_H
-#define	RGBDS_LINK_LIBRARY_H
+#ifndef RGBDS_LINK_LIBRARY_H
+#define RGBDS_LINK_LIBRARY_H
 
-extern void AddNeededModules(void);
+void AddNeededModules(void);
 
-#endif
+#endif /* RGBDS_LINK_LIBRARY_H */

include/link/main.h

@@ -1,9 +1,9 @@
 #ifndef RGBDS_LINK_MAIN_H
 #define RGBDS_LINK_MAIN_H
 
-#include "types.h"
+#include <stdint.h>
 
-extern SLONG fillchar;
+extern int32_t fillchar;
 extern char *smartlinkstartsymbol;
 
-#endif
+#endif /* RGBDS_LINK_MAIN_H */

include/link/mapfile.h

@@ -1,11 +1,13 @@
-#ifndef	RGBDS_LINK_MAPFILE_H
-#define	RGBDS_LINK_MAPFILE_H
+#ifndef RGBDS_LINK_MAPFILE_H
+#define RGBDS_LINK_MAPFILE_H
 
-extern void SetMapfileName(char *name);
-extern void SetSymfileName(char *name);
-extern void CloseMapfile(void);
-extern void MapfileWriteSection(struct sSection * pSect);
-extern void MapfileInitBank(SLONG bank);
-extern void MapfileCloseBank(SLONG slack);
+#include <stdint.h>
 
-#endif
+void SetMapfileName(char *name);
+void SetSymfileName(char *name);
+void CloseMapfile(void);
+void MapfileWriteSection(const struct sSection *pSect);
+void MapfileInitBank(int32_t bank);
+void MapfileCloseBank(int32_t slack);
+
+#endif /* RGBDS_LINK_MAPFILE_H */

include/link/mylink.h

@@ -1,114 +1,60 @@
 #ifndef RGBDS_LINK_LINK_H
 #define RGBDS_LINK_LINK_H
 
-#ifndef _MAX_PATH
-#define _MAX_PATH	512
-#endif
+#include <stdint.h>
 
-#include "types.h"
+#include "linkdefs.h"
 
-extern SLONG options;
-#define OPT_SMALL	0x01
+extern int32_t options;
+
+#define OPT_TINY		0x01
 #define OPT_SMART_C_LINK	0x02
-
-enum eRpnData {
-	RPN_ADD = 0,
-	RPN_SUB,
-	RPN_MUL,
-	RPN_DIV,
-	RPN_MOD,
-	RPN_UNSUB,
-
-	RPN_OR,
-	RPN_AND,
-	RPN_XOR,
-	RPN_UNNOT,
-
-	RPN_LOGAND,
-	RPN_LOGOR,
-	RPN_LOGUNNOT,
-
-	RPN_LOGEQ,
-	RPN_LOGNE,
-	RPN_LOGGT,
-	RPN_LOGLT,
-	RPN_LOGGE,
-	RPN_LOGLE,
-
-	RPN_SHL,
-	RPN_SHR,
-
-	RPN_BANK,
-
-	RPN_HRAM,
-
-	RPN_PCEZP,
-
-	RPN_RANGECHECK,
-
-	RPN_CONST = 0x80,
-	RPN_SYM = 0x81
-};
-
-enum eSectionType {
-	SECT_WRAM0,
-	SECT_VRAM,
-	SECT_ROMX,
-	SECT_ROM0,
-	SECT_HRAM,
-	SECT_WRAMX,
-	SECT_SRAM
-};
+#define OPT_OVERLAY		0x04
+#define OPT_CONTWRAM		0x08
+#define OPT_DMG_MODE		0x10
 
 struct sSection {
-	SLONG nBank;
-	SLONG nOrg;
-	BBOOL oAssigned;
+	int32_t nBank;
+	int32_t nOrg;
+	int32_t nAlign;
+	uint8_t oAssigned;
 
-	SLONG nByteSize;
+	char *pzName;
+	int32_t nByteSize;
 	enum eSectionType Type;
-	UBYTE *pData;
-	SLONG nNumberOfSymbols;
+	uint8_t *pData;
+	int32_t nNumberOfSymbols;
 	struct sSymbol **tSymbols;
 	struct sPatch *pPatches;
 	struct sSection *pNext;
 };
 
-enum eSymbolType {
-	SYM_LOCAL,
-	SYM_IMPORT,
-	SYM_EXPORT
-};
-
 struct sSymbol {
 	char *pzName;
 	enum eSymbolType Type;
-	/* the following 3 items only valid when Type!=SYM_IMPORT */
-	SLONG nSectionID;	/* internal to object.c */
-	struct sSection *pSection;
-	SLONG nOffset;
-};
 
-enum ePatchType {
-	PATCH_BYTE = 0,
-	PATCH_WORD_L,
-	PATCH_LONG_L,
-	PATCH_WORD_B,
-	PATCH_LONG_B
+	/* The following 3 items only valid when Type!=SYM_IMPORT */
+	int32_t nSectionID; /* Internal to object.c */
+	struct sSection *pSection;
+	int32_t nOffset;
+
+	char *pzObjFileName; /* Object file where the symbol is located. */
+	char *pzFileName; /* Source file where the symbol was defined. */
+	uint32_t nFileLine; /* Line where the symbol was defined. */
 };
 
 struct sPatch {
 	char *pzFilename;
-	SLONG nLineNo;
-	SLONG nOffset;
+	int32_t nLineNo;
+	int32_t nOffset;
 	enum ePatchType Type;
-	SLONG nRPNSize;
-	UBYTE *pRPN;
+	int32_t nRPNSize;
+	uint8_t *pRPN;
 	struct sPatch *pNext;
-	BBOOL oRelocPatch;
+	uint8_t oRelocPatch;
 };
 
 extern struct sSection *pSections;
 extern struct sSection *pLibSections;
 
-#endif
+#endif /* RGBDS_LINK_LINK_H */

include/link/object.h

@@ -1,6 +1,6 @@
-#ifndef	RGBDS_LINK_OBJECT_H
-#define	RGBDS_LINK_OBJECT_H
+#ifndef RGBDS_LINK_OBJECT_H
+#define RGBDS_LINK_OBJECT_H
 
-extern void obj_Readfile(char *tzObjectfile);
+void obj_Readfile(char *tzObjectfile);
 
-#endif
+#endif /* RGBDS_LINK_OBJECT_H */

include/link/output.h

@@ -1,7 +1,8 @@
-#ifndef	RGBDS_LINK_OUTPUT_H
-#define	RGBDS_LINK_OUTPUT_H
+#ifndef RGBDS_LINK_OUTPUT_H
+#define RGBDS_LINK_OUTPUT_H
 
 void out_Setname(char *tzOutputfile);
+void out_SetOverlayname(char *tzOverlayfile);
 void Output(void);
 
-#endif
+#endif /* RGBDS_LINK_OUTPUT_H */

include/link/patch.h

@@ -1,9 +1,9 @@
 #ifndef RGBDS_LINK_PATCH_H
 #define RGBDS_LINK_PATCH_H
 
-#include "types.h"
+#include <stdint.h>
 
 void Patch(void);
-extern SLONG nPC;
+extern int32_t nPC;
 
-#endif
+#endif /* RGBDS_LINK_PATCH_H */

include/link/script.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2017 Antonio Nino Diaz <antonio_nd@outlook.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef RGBDS_LINK_SCRIPT_H
+#define RGBDS_LINK_SCRIPT_H
+
+#include <stdint.h>
+
+#include "extern/stdnoreturn.h"
+
+noreturn void script_fatalerror(const char *fmt, ...);
+
+void script_Parse(const char *path);
+
+void script_IncludeFile(const char *path);
+int32_t script_IncludeDepthGet(void);
+void script_IncludePop(void);
+
+void script_InitSections(void);
+void script_SetCurrentSectionType(const char *type, uint32_t bank);
+void script_SetAddress(uint32_t addr);
+void script_SetAlignment(uint32_t alignment);
+void script_OutputSection(const char *section_name);
+
+#endif /* RGBDS_LINK_SCRIPT_H */

include/link/symbol.h

@@ -1,11 +1,13 @@
 #ifndef RGBDS_LINK_SYMBOL_H
 #define RGBDS_LINK_SYMBOL_H
 
-#include "types.h"
+#include <stdint.h>
 
 void sym_Init(void);
-void sym_CreateSymbol(char *tzName, SLONG nValue, SLONG nBank);
-SLONG sym_GetValue(char *tzName);
-SLONG sym_GetBank(char *tzName);
+void sym_CreateSymbol(char *tzName, int32_t nValue, int32_t nBank,
+		      char *tzObjFileName, char *tzFileName,
+		      uint32_t nFileLine);
+int32_t sym_GetValue(char *tzName);
+int32_t sym_GetBank(char *tzName);
 
-#endif
+#endif /* RGBDS_LINK_SYMBOL_H */

include/linkdefs.h

@@ -0,0 +1,64 @@
+#ifndef RGBDS_LINKDEFS_H
+#define RGBDS_LINKDEFS_H
+
+enum eRpnData {
+	RPN_ADD		= 0x00,
+	RPN_SUB		= 0x01,
+	RPN_MUL		= 0x02,
+	RPN_DIV		= 0x03,
+	RPN_MOD		= 0x04,
+	RPN_UNSUB	= 0x05,
+
+	RPN_OR		= 0x10,
+	RPN_AND		= 0x11,
+	RPN_XOR		= 0x12,
+	RPN_UNNOT	= 0x13,
+
+	RPN_LOGAND	= 0x21,
+	RPN_LOGOR	= 0x22,
+	RPN_LOGUNNOT	= 0x23,
+
+	RPN_LOGEQ	= 0x30,
+	RPN_LOGNE	= 0x31,
+	RPN_LOGGT	= 0x32,
+	RPN_LOGLT	= 0x33,
+	RPN_LOGGE	= 0x34,
+	RPN_LOGLE	= 0x35,
+
+	RPN_SHL		= 0x40,
+	RPN_SHR		= 0x41,
+
+	RPN_BANK_SYM	= 0x50,
+	RPN_BANK_SECT	= 0x51,
+	RPN_BANK_SELF	= 0x52,
+
+	RPN_HRAM	= 0x60,
+
+	RPN_CONST	= 0x80,
+	RPN_SYM		= 0x81
+};
+
+enum eSectionType {
+	SECT_WRAM0	= 0x00,
+	SECT_VRAM	= 0x01,
+	SECT_ROMX	= 0x02,
+	SECT_ROM0	= 0x03,
+	SECT_HRAM	= 0x04,
+	SECT_WRAMX	= 0x05,
+	SECT_SRAM	= 0x06,
+	SECT_OAM	= 0x07
+};
+
+enum eSymbolType {
+	SYM_LOCAL	= 0x00,
+	SYM_IMPORT	= 0x01,
+	SYM_EXPORT	= 0x02
+};
+
+enum ePatchType {
+	PATCH_BYTE	= 0x00,
+	PATCH_WORD_L	= 0x01,
+	PATCH_LONG_L	= 0x02
+};
+
+#endif /* RGBDS_LINKDEFS_H */

include/types.h

@@ -2,15 +2,7 @@
 #define RGBDS_TYPES_H
 
 #ifndef _MAX_PATH
-#define	_MAX_PATH	512
+#define _MAX_PATH 512
 #endif
 
-typedef unsigned char UBYTE;
-typedef signed char SBYTE;
-typedef unsigned short UWORD;
-typedef signed short SWORD;
-typedef unsigned long ULONG;
-typedef signed long SLONG;
-typedef signed char BBOOL;
-
-#endif
+#endif /* RGBDS_TYPES_H */

src/asm/charmap.c

@@ -24,32 +24,46 @@
 #include <stdint.h>
 
 static const uint8_t utf8d[] = {
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 00..1f
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 20..3f
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 40..5f
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 60..7f
-  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, // 80..9f
-  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, // a0..bf
-  8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, // c0..df
-  0xa,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x4,0x3,0x3, // e0..ef
-  0xb,0x6,0x6,0x6,0x5,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8, // f0..ff
-  0x0,0x1,0x2,0x3,0x5,0x8,0x7,0x1,0x1,0x1,0x4,0x6,0x1,0x1,0x1,0x1, // s0..s0
-  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,0,1,1,1,1,1,1, // s1..s2
-  1,2,1,1,1,1,1,2,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1, // s3..s4
-  1,2,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,3,1,1,1,1,1,1, // s5..s6
-  1,3,1,1,1,1,1,3,1,3,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // s7..s8
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 00..0f */
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 10..1f */
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 20..2f */
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 30..3f */
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 40..4f */
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 50..5f */
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 60..6f */
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 70..7f */
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 80..8f */
+	9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, /* 90..9f */
+	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, /* a0..af */
+	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, /* b0..bf */
+	8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* c0..cf */
+	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* d0..df */
+	0xa, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, /* e0..e7 */
+	0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, /* e8..ef */
+	0xb, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, /* f0..f7 */
+	0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, /* f8..ff */
+	0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, /* s0..   */
+	0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, /*   ..s0 */
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* s1 */
+	1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, /* s1 */
+	1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, /* s3 */
+	1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, /* s4 */
+	1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, /* s5 */
+	1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, /* s6 */
+	1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, /* s7 */
+	1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* s8 */
 };
 
-uint32_t
-decode(uint32_t* state, uint32_t* codep, uint32_t byte) {
-  uint32_t type = utf8d[byte];
+uint32_t decode(uint32_t *state, uint32_t *codep, uint32_t byte)
+{
+	uint32_t type = utf8d[byte];
 
-  *codep = (*state != 0) ?
-    (byte & 0x3fu) | (*codep << 6) :
-    (0xff >> type) & (byte);
+	*codep = (*state != 0) ?
+			(byte & 0x3fu) | (*codep << 6) :
+			(0xff >> type) & (byte);
 
-  *state = utf8d[256 + *state*16 + type];
-  return *state;
+	*state = utf8d[256 + *state * 16 + type];
+	return *state;
 }
 
 /*
@@ -79,19 +93,15 @@ decode(uint32_t* state, uint32_t* codep, uint32_t byte) {
 
 struct Charmap globalCharmap = {0};
 
-extern struct Section *pCurrentSection;
-
-int
-readUTF8Char(char *dest, char *src)
+int32_t readUTF8Char(char *dest, char *src)
 {
 	uint32_t state;
 	uint32_t codep;
-	int i;
+	int32_t i;
 
 	for (i = 0, state = 0;; i++) {
-		if (decode(&state, &codep, (uint8_t)src[i]) == 1) {
+		if (decode(&state, &codep, (uint8_t)src[i]) == 1)
 			fatalerror("invalid UTF-8 character");
-		}
 
 		dest[i] = src[i];
 
@@ -104,12 +114,12 @@ readUTF8Char(char *dest, char *src)
 	}
 }
 
-int
-charmap_Add(char *input, UBYTE output)
+int32_t charmap_Add(char *input, uint8_t output)
 {
-	int i, input_length;
-	char temp1i[CHARMAPLENGTH + 1], temp2i[CHARMAPLENGTH + 1], temp1o = 0,
-	    temp2o = 0;
+	int32_t i;
+	size_t input_length;
+	char temp1i[CHARMAPLENGTH + 1], temp2i[CHARMAPLENGTH + 1];
+	char temp1o = 0, temp2o = 0;
 
 	struct Charmap *charmap;
 
@@ -117,23 +127,21 @@ charmap_Add(char *input, UBYTE output)
 		if (pCurrentSection->charmap) {
 			charmap = pCurrentSection->charmap;
 		} else {
-			if ((charmap = calloc(1, sizeof(struct Charmap))) ==
-			    NULL) {
+			charmap = calloc(1, sizeof(struct Charmap));
+			if (charmap == NULL)
 				fatalerror("Not enough memory for charmap");
-			}
+
 			pCurrentSection->charmap = charmap;
 		}
 	} else {
 		charmap = &globalCharmap;
 	}
 
-	if (nPass == 2) {
+	if (nPass == 2)
 		return charmap->count;
-	}
 
-	if (charmap->count > MAXCHARMAPS || strlen(input) > CHARMAPLENGTH) {
+	if (charmap->count > MAXCHARMAPS || strlen(input) > CHARMAPLENGTH)
 		return -1;
-	}
 
 	input_length = strlen(input);
 	if (input_length > 1) {
@@ -141,7 +149,7 @@ charmap_Add(char *input, UBYTE output)
 		while (i < charmap->count + 1) {
 			if (input_length > strlen(charmap->input[i])) {
 				memcpy(temp1i, charmap->input[i],
-				    CHARMAPLENGTH + 1);
+				       CHARMAPLENGTH + 1);
 				memcpy(charmap->input[i], input, input_length);
 				temp1o = charmap->output[i];
 				charmap->output[i] = output;
@@ -160,7 +168,7 @@ charmap_Add(char *input, UBYTE output)
 			i++;
 		}
 		memcpy(charmap->input[charmap->count + 1], temp1i,
-		    CHARMAPLENGTH + 1);
+		       CHARMAPLENGTH + 1);
 		charmap->output[charmap->count + 1] = temp1o;
 	} else {
 		memcpy(charmap->input[charmap->count], input, input_length);
@@ -169,24 +177,22 @@ charmap_Add(char *input, UBYTE output)
 	return ++charmap->count;
 }
 
-int
-charmap_Convert(char **input)
+int32_t charmap_Convert(char **input)
 {
 	struct Charmap *charmap;
 
 	char outchar[CHARMAPLENGTH + 1];
 	char *buffer;
-	int i, j, length;
+	int32_t i, j, length;
 
-	if (pCurrentSection && pCurrentSection->charmap) {
+	if (pCurrentSection && pCurrentSection->charmap)
 		charmap = pCurrentSection->charmap;
-	} else {
+	else
 		charmap = &globalCharmap;
-	}
 
-	if ((buffer = malloc(strlen(*input))) == NULL) {
+	buffer = malloc(strlen(*input));
+	if (buffer == NULL)
 		fatalerror("Not enough memory for buffer");
-	}
 
 	length = 0;
 	while (**input) {
@@ -200,15 +206,15 @@ charmap_Convert(char **input)
 			}
 			j = 0;
 		}
-		if (!j) {
+
+		if (!j)
 			j = readUTF8Char(outchar, *input);
-		}
+
 		if (!outchar[0]) {
 			buffer[length++] = 0;
 		} else {
-			for (i = 0; outchar[i]; i++) {
+			for (i = 0; outchar[i]; i++)
 				buffer[length++] = outchar[i];
-			}
 		}
 		*input += j;
 	}

src/asm/fstack.c

@@ -4,51 +4,50 @@
 
 #include <errno.h>
 #include <limits.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#include "asm/symbol.h"
 #include "asm/fstack.h"
-#include "types.h"
-#include "asm/main.h"
 #include "asm/lexer.h"
+#include "asm/main.h"
+#include "asm/output.h"
+#include "asm/symbol.h"
+
 #include "extern/err.h"
 #include "extern/strl.h"
 
-#ifndef PATH_MAX
-#define PATH_MAX 256
-#endif
+#include "types.h"
 
-struct sContext *pFileStack;
-struct sSymbol *pCurrentMacro;
-YY_BUFFER_STATE CurrentFlexHandle;
-FILE *pCurrentFile;
-ULONG nCurrentStatus;
+static struct sContext *pFileStack;
+static struct sSymbol *pCurrentMacro;
+static YY_BUFFER_STATE CurrentFlexHandle;
+static FILE *pCurrentFile;
+static uint32_t nCurrentStatus;
 char tzCurrentFileName[_MAX_PATH + 1];
-char IncludePaths[MAXINCPATHS][_MAX_PATH + 1];
-SLONG NextIncPath = 0;
-ULONG nMacroCount;
+static char IncludePaths[MAXINCPATHS][_MAX_PATH + 1];
+static int32_t NextIncPath;
+static uint32_t nMacroCount;
 
-char *pCurrentREPTBlock;
-ULONG nCurrentREPTBlockSize;
-ULONG nCurrentREPTBlockCount;
+static char *pCurrentREPTBlock;
+static uint32_t nCurrentREPTBlockSize;
+static uint32_t nCurrentREPTBlockCount;
 
-ULONG ulMacroReturnValue;
+uint32_t ulMacroReturnValue;
 
 /*
  * defines for nCurrentStatus
  */
-#define STAT_isInclude 		0
-#define STAT_isMacro	 		1
+#define STAT_isInclude		0 /* 'Normal' state as well */
+#define STAT_isMacro		1
 #define STAT_isMacroArg		2
 #define STAT_isREPTBlock	3
 
 /*
  * Context push and pop
  */
-void 
-pushcontext(void)
+static void pushcontext(void)
 {
 	struct sContext **ppFileStack;
 
@@ -56,36 +55,37 @@ pushcontext(void)
 	while (*ppFileStack)
 		ppFileStack = &((*ppFileStack)->pNext);
 
-	if ((*ppFileStack = malloc(sizeof(struct sContext))) != NULL) {
-		(*ppFileStack)->FlexHandle = CurrentFlexHandle;
-		(*ppFileStack)->pNext = NULL;
-		strcpy((char *) (*ppFileStack)->tzFileName,
-		    (char *) tzCurrentFileName);
-		(*ppFileStack)->nLine = nLineNo;
-		switch ((*ppFileStack)->nStatus = nCurrentStatus) {
-		case STAT_isMacroArg:
-		case STAT_isMacro:
-			sym_SaveCurrentMacroArgs((*ppFileStack)->tzMacroArgs);
-			(*ppFileStack)->pMacro = pCurrentMacro;
-			break;
-		case STAT_isInclude:
-			(*ppFileStack)->pFile = pCurrentFile;
-			break;
-		case STAT_isREPTBlock:
-			sym_SaveCurrentMacroArgs((*ppFileStack)->tzMacroArgs);
-			(*ppFileStack)->pREPTBlock = pCurrentREPTBlock;
-			(*ppFileStack)->nREPTBlockSize = nCurrentREPTBlockSize;
-			(*ppFileStack)->nREPTBlockCount =
-			    nCurrentREPTBlockCount;
-			break;
-		}
-		nLineNo = 0;
-	} else
+	*ppFileStack = malloc(sizeof(struct sContext));
+
+	if (*ppFileStack == NULL)
 		fatalerror("No memory for context");
+
+	(*ppFileStack)->FlexHandle = CurrentFlexHandle;
+	(*ppFileStack)->pNext = NULL;
+	strcpy((char *)(*ppFileStack)->tzFileName, (char *)tzCurrentFileName);
+	(*ppFileStack)->nLine = nLineNo;
+
+	switch ((*ppFileStack)->nStatus = nCurrentStatus) {
+	case STAT_isMacroArg:
+	case STAT_isMacro:
+		sym_SaveCurrentMacroArgs((*ppFileStack)->tzMacroArgs);
+		(*ppFileStack)->pMacro = pCurrentMacro;
+		break;
+	case STAT_isInclude:
+		(*ppFileStack)->pFile = pCurrentFile;
+		break;
+	case STAT_isREPTBlock:
+		sym_SaveCurrentMacroArgs((*ppFileStack)->tzMacroArgs);
+		(*ppFileStack)->pREPTBlock = pCurrentREPTBlock;
+		(*ppFileStack)->nREPTBlockSize = nCurrentREPTBlockSize;
+		(*ppFileStack)->nREPTBlockCount = nCurrentREPTBlockCount;
+		break;
+	}
+
+	nLineNo = 0;
 }
 
-int 
-popcontext(void)
+static int32_t popcontext(void)
 {
 	struct sContext *pLastFile, **ppLastFile;
 
@@ -93,124 +93,165 @@ popcontext(void)
 		if (--nCurrentREPTBlockCount) {
 			yy_delete_buffer(CurrentFlexHandle);
 			CurrentFlexHandle =
-			    yy_scan_bytes(pCurrentREPTBlock,
-			    nCurrentREPTBlockSize);
+				yy_scan_bytes(pCurrentREPTBlock,
+					      nCurrentREPTBlockSize);
 			yy_switch_to_buffer(CurrentFlexHandle);
 			sym_UseCurrentMacroArgs();
 			sym_SetMacroArgID(nMacroCount++);
 			sym_UseNewMacroArgs();
-			return (0);
+			return 0;
 		}
 	}
-	if ((pLastFile = pFileStack) != NULL) {
+
+	pLastFile = pFileStack;
+	if (pLastFile == NULL)
+		return 1;
+
+	ppLastFile = &pFileStack;
+	while (pLastFile->pNext) {
+		ppLastFile = &(pLastFile->pNext);
+		pLastFile = *ppLastFile;
+	}
+
+	yy_delete_buffer(CurrentFlexHandle);
+	nLineNo = pLastFile->nLine;
+
+	if (nCurrentStatus == STAT_isInclude)
+		fclose(pCurrentFile);
+
+	if (nCurrentStatus == STAT_isMacro) {
+		sym_FreeCurrentMacroArgs();
+		nLineNo += 1;
+	}
+
+	if (nCurrentStatus == STAT_isREPTBlock)
+		nLineNo += 1;
+
+	CurrentFlexHandle = pLastFile->FlexHandle;
+	strcpy((char *)tzCurrentFileName, (char *)pLastFile->tzFileName);
+
+	switch (nCurrentStatus = pLastFile->nStatus) {
+	case STAT_isMacroArg:
+	case STAT_isMacro:
+		sym_RestoreCurrentMacroArgs(pLastFile->tzMacroArgs);
+		pCurrentMacro = pLastFile->pMacro;
+		break;
+	case STAT_isInclude:
+		pCurrentFile = pLastFile->pFile;
+		break;
+	case STAT_isREPTBlock:
+		sym_RestoreCurrentMacroArgs(pLastFile->tzMacroArgs);
+		pCurrentREPTBlock = pLastFile->pREPTBlock;
+		nCurrentREPTBlockSize = pLastFile->nREPTBlockSize;
+		nCurrentREPTBlockCount = pLastFile->nREPTBlockCount;
+		break;
+	}
+
+	free(*ppLastFile);
+	*ppLastFile = NULL;
+	yy_switch_to_buffer(CurrentFlexHandle);
+	return 0;
+}
+
+int32_t fstk_GetLine(void)
+{
+	struct sContext *pLastFile, **ppLastFile;
+
+	switch (nCurrentStatus) {
+	case STAT_isInclude:
+		/* This is the normal mode, also used when including a file. */
+		return nLineNo;
+	case STAT_isMacro:
+		break; /* Peek top file of the stack */
+	case STAT_isMacroArg:
+		return nLineNo; /* ??? */
+	case STAT_isREPTBlock:
+		break; /* Peek top file of the stack */
+	}
+
+	pLastFile = pFileStack;
+
+	if (pLastFile != NULL) {
 		ppLastFile = &pFileStack;
 		while (pLastFile->pNext) {
 			ppLastFile = &(pLastFile->pNext);
 			pLastFile = *ppLastFile;
 		}
+		return pLastFile->nLine;
+	}
 
-		yy_delete_buffer(CurrentFlexHandle);
-		nLineNo = pLastFile->nLine;
-		if (nCurrentStatus == STAT_isInclude)
-			fclose(pCurrentFile);
-		if (nCurrentStatus == STAT_isMacro) {
-			sym_FreeCurrentMacroArgs();
-			nLineNo += 1;
-		}
-		if (nCurrentStatus == STAT_isREPTBlock)
-			nLineNo += 1;
-
-		CurrentFlexHandle = pLastFile->FlexHandle;
-		strcpy((char *) tzCurrentFileName,
-		    (char *) pLastFile->tzFileName);
-		switch (nCurrentStatus = pLastFile->nStatus) {
-		case STAT_isMacroArg:
-		case STAT_isMacro:
-			sym_RestoreCurrentMacroArgs(pLastFile->tzMacroArgs);
-			pCurrentMacro = pLastFile->pMacro;
-			break;
-		case STAT_isInclude:
-			pCurrentFile = pLastFile->pFile;
-			break;
-		case STAT_isREPTBlock:
-			sym_RestoreCurrentMacroArgs(pLastFile->tzMacroArgs);
-			pCurrentREPTBlock = pLastFile->pREPTBlock;
-			nCurrentREPTBlockSize = pLastFile->nREPTBlockSize;
-			nCurrentREPTBlockCount = pLastFile->nREPTBlockCount;
-			break;
-		}
-
-		free(*ppLastFile);
-		*ppLastFile = NULL;
-		yy_switch_to_buffer(CurrentFlexHandle);
-		return (0);
-	} else
-		return (1);
+	/*
+	 * This is only reached if the lexer is in REPT or MACRO mode but there
+	 * are no saved contexts with the origin of said REPT or MACRO.
+	 */
+	fatalerror("%s: Internal error.", __func__);
 }
 
-int 
-yywrap(void)
+int yywrap(void)
 {
-	return (popcontext());
+	return popcontext();
 }
 
 /*
  * Dump the context stack to stderr
  */
-void 
-fstk_Dump(void)
+void fstk_Dump(void)
 {
-	struct sContext *pLastFile;
+	const struct sContext *pLastFile;
 
 	pLastFile = pFileStack;
 
 	while (pLastFile) {
-		fprintf(stderr, "%s(%ld) -> ", pLastFile->tzFileName,
-		    pLastFile->nLine);
+		fprintf(stderr, "%s(%d) -> ", pLastFile->tzFileName,
+			pLastFile->nLine);
 		pLastFile = pLastFile->pNext;
 	}
 
-	fprintf(stderr, "%s(%ld)", tzCurrentFileName, nLineNo);
+	fprintf(stderr, "%s(%d)", tzCurrentFileName, nLineNo);
 }
 
 /*
  * Extra includepath stuff
  */
-void 
-fstk_AddIncludePath(char *s)
+void fstk_AddIncludePath(char *s)
 {
-	if (NextIncPath == MAXINCPATHS) {
+	if (NextIncPath == MAXINCPATHS)
 		fatalerror("Too many include directories passed from command line");
-		return;
-	}
 
-	if (strlcpy(IncludePaths[NextIncPath++], s, _MAX_PATH) >= _MAX_PATH) {
-		fatalerror("Include path too long '%s'",s);
-		return;
-	}
+	if (strlcpy(IncludePaths[NextIncPath++], s, _MAX_PATH) >= _MAX_PATH)
+		fatalerror("Include path too long '%s'", s);
 }
 
-FILE *
-fstk_FindFile(char *fname)
+FILE *fstk_FindFile(char *fname)
 {
-	char path[PATH_MAX];
-	int i;
+	char path[_MAX_PATH];
+	int32_t i;
 	FILE *f;
 
-	if ((f = fopen(fname, "rb")) != NULL || errno != ENOENT) {
+	f = fopen(fname, "rb");
+
+	if (f != NULL || errno != ENOENT) {
+		if (dependfile)
+			fprintf(dependfile, "%s: %s\n", tzObjectname, fname);
+
 		return f;
 	}
 
 	for (i = 0; i < NextIncPath; ++i) {
-		if (strlcpy(path, IncludePaths[i], sizeof path) >= 
-		    sizeof path) {
+		if (strlcpy(path, IncludePaths[i], sizeof(path))
+		    >= sizeof(path))
 			continue;
-		}
-		if (strlcat(path, fname, sizeof path) >= sizeof path) {
-			continue;
-		}
 
-		if ((f = fopen(path, "rb")) != NULL || errno != ENOENT) {
+		if (strlcat(path, fname, sizeof(path)) >= sizeof(path))
+			continue;
+
+		f = fopen(path, "rb");
+
+		if (f != NULL || errno != ENOENT) {
+			if (dependfile) {
+				fprintf(dependfile, "%s: %s\n", tzObjectname,
+					path);
+			}
 			return f;
 		}
 	}
@@ -222,17 +263,12 @@ fstk_FindFile(char *fname)
 /*
  * Set up an include file for parsing
  */
-void
-fstk_RunInclude(char *tzFileName)
+void fstk_RunInclude(char *tzFileName)
 {
-	FILE *f;
+	FILE *f = fstk_FindFile(tzFileName);
 
-	f = fstk_FindFile(tzFileName);
-
-	if (f == NULL) {
-		err(1, "Unable to open included file '%s'",
-		    tzFileName);
-	}
+	if (f == NULL)
+		err(1, "Unable to open included file '%s'", tzFileName);
 
 	pushcontext();
 	nLineNo = 1;
@@ -242,7 +278,7 @@ fstk_RunInclude(char *tzFileName)
 	CurrentFlexHandle = yy_create_buffer(pCurrentFile);
 	yy_switch_to_buffer(CurrentFlexHandle);
 
-	//Dirty hack to give the INCLUDE directive a linefeed
+	/* Dirty hack to give the INCLUDE directive a linefeed */
 
 	yyunput('\n');
 	nLineNo -= 1;
@@ -251,35 +287,35 @@ fstk_RunInclude(char *tzFileName)
 /*
  * Set up a macro for parsing
  */
-ULONG 
-fstk_RunMacro(char *s)
+uint32_t fstk_RunMacro(char *s)
 {
-	struct sSymbol *sym;
+	struct sSymbol *sym = sym_FindMacro(s);
 
-	if ((sym = sym_FindMacro(s)) != NULL) {
-		pushcontext();
-		sym_SetMacroArgID(nMacroCount++);
-		nLineNo = -1;
-		sym_UseNewMacroArgs();
-		nCurrentStatus = STAT_isMacro;
-		strcpy(tzCurrentFileName, s);
-		if (sym->pMacro == NULL)
-			return 0;
-		pCurrentMacro = sym;
-		CurrentFlexHandle =
-		    yy_scan_bytes(pCurrentMacro->pMacro,
-		    strlen(pCurrentMacro->pMacro));
-		yy_switch_to_buffer(CurrentFlexHandle);
-		return (1);
-	} else
-		return (0);
+	if (sym == NULL)
+		return 0;
+
+	pushcontext();
+	sym_SetMacroArgID(nMacroCount++);
+	nLineNo = -1;
+	sym_UseNewMacroArgs();
+	nCurrentStatus = STAT_isMacro;
+	strcpy(tzCurrentFileName, s);
+
+	if (sym->pMacro == NULL)
+		return 0;
+
+	pCurrentMacro = sym;
+	CurrentFlexHandle = yy_scan_bytes(pCurrentMacro->pMacro,
+					  strlen(pCurrentMacro->pMacro));
+	yy_switch_to_buffer(CurrentFlexHandle);
+
+	return 1;
 }
 
 /*
  * Set up a macroargument for parsing
  */
-void 
-fstk_RunMacroArg(SLONG s)
+void fstk_RunMacroArg(int32_t s)
 {
 	char *sym;
 
@@ -288,40 +324,41 @@ fstk_RunMacroArg(SLONG s)
 	else
 		s -= '0';
 
-	if ((sym = sym_FindMacroArg(s)) != NULL) {
-		pushcontext();
-		nCurrentStatus = STAT_isMacroArg;
-		sprintf(tzCurrentFileName, "%c", (UBYTE) s);
-		CurrentFlexHandle = yy_scan_bytes(sym, strlen(sym));
-		yy_switch_to_buffer(CurrentFlexHandle);
-	} else
+	sym = sym_FindMacroArg(s);
+
+	if (sym == NULL)
 		fatalerror("No such macroargument");
+
+	pushcontext();
+	nCurrentStatus = STAT_isMacroArg;
+	sprintf(tzCurrentFileName, "%c", (uint8_t)s);
+	CurrentFlexHandle = yy_scan_bytes(sym, strlen(sym));
+	yy_switch_to_buffer(CurrentFlexHandle);
 }
 
 /*
  * Set up a stringequate for parsing
  */
-void 
-fstk_RunString(char *s)
+void fstk_RunString(char *s)
 {
-	struct sSymbol *pSym;
+	const struct sSymbol *pSym = sym_FindSymbol(s);
 
-	if ((pSym = sym_FindSymbol(s)) != NULL) {
+	if (pSym != NULL) {
 		pushcontext();
 		nCurrentStatus = STAT_isMacroArg;
 		strcpy(tzCurrentFileName, s);
 		CurrentFlexHandle =
-		    yy_scan_bytes(pSym->pMacro, strlen(pSym->pMacro));
+			yy_scan_bytes(pSym->pMacro, strlen(pSym->pMacro));
 		yy_switch_to_buffer(CurrentFlexHandle);
-	} else
+	} else {
 		yyerror("No such string symbol '%s'", s);
+	}
 }
 
 /*
  * Set up a repeat block for parsing
  */
-void 
-fstk_RunRept(ULONG count)
+void fstk_RunRept(uint32_t count)
 {
 	if (count) {
 		pushcontext();
@@ -333,7 +370,7 @@ fstk_RunRept(ULONG count)
 		nCurrentREPTBlockSize = ulNewMacroSize;
 		pCurrentREPTBlock = tzNewMacro;
 		CurrentFlexHandle =
-		    yy_scan_bytes(pCurrentREPTBlock, nCurrentREPTBlockSize);
+			yy_scan_bytes(pCurrentREPTBlock, nCurrentREPTBlockSize);
 		yy_switch_to_buffer(CurrentFlexHandle);
 	}
 }
@@ -341,19 +378,19 @@ fstk_RunRept(ULONG count)
 /*
  * Initialize the filestack routines
  */
-void
-fstk_Init(char *s)
+void fstk_Init(char *s)
 {
 	char tzFileName[_MAX_PATH + 1];
+	char tzSymFileName[_MAX_PATH + 1 + 2];
 
-	sym_AddString("__FILE__", s);
+	snprintf(tzSymFileName, sizeof(tzSymFileName), "\"%s\"", s);
+	sym_AddString("__FILE__", tzSymFileName);
 
 	strcpy(tzFileName, s);
 	pFileStack = NULL;
 	pCurrentFile = fopen(tzFileName, "rb");
-	if (pCurrentFile == NULL) {
+	if (pCurrentFile == NULL)
 		err(1, "Unable to open file '%s'", tzFileName);
-	}
 
 	nMacroCount = 0;
 	nCurrentStatus = STAT_isInclude;

src/asm/globlex.c

@@ -1,52 +1,48 @@
+#include <math.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
 #include "asm/asm.h"
-#include "asm/symbol.h"
+#include "asm/lexer.h"
+#include "asm/main.h"
 #include "asm/rpn.h"
 #include "asm/symbol.h"
-#include "asm/main.h"
-#include "asm/lexer.h"
+#include "asm/symbol.h"
 
 #include "asmy.h"
 
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-#include <string.h>
+bool oDontExpandStrings;
+int32_t nGBGfxID = -1;
+int32_t nBinaryID = -1;
 
-bool oDontExpandStrings = false;
-SLONG nGBGfxID = -1;
-SLONG nBinaryID = -1;
-
-SLONG 
-gbgfx2bin(char ch)
+static int32_t gbgfx2bin(char ch)
 {
-	SLONG i;
+	int32_t i;
 
 	for (i = 0; i <= 3; i += 1) {
-		if (CurrentOptions.gbgfx[i] == ch) {
-			return (i);
-		}
+		if (CurrentOptions.gbgfx[i] == ch)
+			return i;
 	}
 
-	return (0);
+	return 0;
 }
 
-SLONG 
-binary2bin(char ch)
+static int32_t binary2bin(char ch)
 {
-	SLONG i;
+	int32_t i;
 
 	for (i = 0; i <= 1; i += 1) {
-		if (CurrentOptions.binary[i] == ch) {
-			return (i);
-		}
+		if (CurrentOptions.binary[i] == ch)
+			return i;
 	}
 
-	return (0);
+	return 0;
 }
 
-SLONG 
-char2bin(char ch)
+static int32_t char2bin(char ch)
 {
 	if (ch >= 'a' && ch <= 'f')
 		return (ch - 'a' + 10);
@@ -57,16 +53,15 @@ char2bin(char ch)
 	if (ch >= '0' && ch <= '9')
 		return (ch - '0');
 
-	return (0);
+	return 0;
 }
 
-typedef SLONG(*x2bin) (char ch);
+typedef int32_t(*x2bin) (char ch);
 
-SLONG 
-ascii2bin(char *s)
+static int32_t ascii2bin(char *s)
 {
-	SLONG radix = 10;
-	SLONG result = 0;
+	int32_t radix = 10;
+	int32_t result = 0;
 	x2bin convertfunc = char2bin;
 
 	switch (*s) {
@@ -93,7 +88,7 @@ ascii2bin(char *s)
 	}
 
 	if (radix == 4) {
-		SLONG c;
+		int32_t c;
 
 		while (*s != '\0') {
 			c = convertfunc(*s++);
@@ -104,37 +99,31 @@ ascii2bin(char *s)
 			result = result * radix + convertfunc(*s++);
 	}
 
-	return (result);
+	return result;
 }
 
-ULONG 
-ParseFixedPoint(char *s, ULONG size)
+uint32_t ParseFixedPoint(char *s, uint32_t size)
 {
-	//char dest[256];
-	ULONG i = 0, dot = 0;
+	uint32_t i = 0, dot = 0;
 
 	while (size && dot != 2) {
 		if (s[i] == '.')
 			dot += 1;
 
 		if (dot < 2) {
-			//dest[i] = s[i];
 			size -= 1;
 			i += 1;
 		}
 	}
 
-	//dest[i] = 0;
-
 	yyunputbytes(size);
 
-	yylval.nConstValue = (SLONG) (atof(s) * 65536);
+	yylval.nConstValue = (int32_t)(atof(s) * 65536);
 
-	return (1);
+	return 1;
 }
 
-ULONG 
-ParseNumber(char *s, ULONG size)
+uint32_t ParseNumber(char *s, uint32_t size)
 {
 	char dest[256];
 
@@ -142,14 +131,13 @@ ParseNumber(char *s, ULONG size)
 	dest[size] = 0;
 	yylval.nConstValue = ascii2bin(dest);
 
-	return (1);
+	return 1;
 }
 
-ULONG 
-ParseSymbol(char *src, ULONG size)
+uint32_t ParseSymbol(char *src, uint32_t size)
 {
 	char dest[MAXSYMLEN + 1];
-	int copied = 0, size_backup = size;
+	int32_t copied = 0, size_backup = size;
 
 	while (size && copied < MAXSYMLEN) {
 		if (*src == '\\') {
@@ -158,13 +146,13 @@ ParseSymbol(char *src, ULONG size)
 			src += 1;
 			size -= 1;
 
-			if (*src == '@')
+			if (*src == '@') {
 				marg = sym_FindMacroArg(-1);
-			else if (*src >= '0' && *src <= '9')
+			} else if (*src >= '0' && *src <= '9') {
 				marg = sym_FindMacroArg(*src - '0');
-			else {
+			} else {
 				fatalerror("Malformed ID");
-				return (0);
+				return 0;
 			}
 
 			src += 1;
@@ -192,47 +180,48 @@ ParseSymbol(char *src, ULONG size)
 		yyunputstr(s = sym_GetStringValue(dest));
 
 		while (*s) {
-			if (*s++ == '\n') {
+			if (*s++ == '\n')
 				nLineNo -= 1;
-			}
 		}
-		return (0);
-	} else {
-		strcpy(yylval.tzString, dest);
-		return (1);
+		return 0;
 	}
+
+	strcpy(yylval.tzString, dest);
+	return 1;
 }
 
-ULONG 
-PutMacroArg(char *src, ULONG size)
+uint32_t PutMacroArg(char *src, uint32_t size)
 {
 	char *s;
 
 	yyskipbytes(size);
 	if ((size == 2 && src[1] >= '1' && src[1] <= '9')) {
-		if ((s = sym_FindMacroArg(src[1] - '0')) != NULL) {
+		s = sym_FindMacroArg(src[1] - '0');
+
+		if (s != NULL)
 			yyunputstr(s);
-		} else {
+		else
 			yyerror("Macro argument not defined");
-		}
 	} else {
 		yyerror("Invalid macro argument");
 	}
-	return (0);
+	return 0;
 }
 
-ULONG 
-PutUniqueArg(char *src, ULONG size)
+uint32_t PutUniqueArg(char *src, uint32_t size)
 {
 	char *s;
 
 	yyskipbytes(size);
-	if ((s = sym_FindMacroArg(-1)) != NULL) {
+
+	s = sym_FindMacroArg(-1);
+
+	if (s != NULL)
 		yyunputstr(s);
-	} else {
+	else
 		yyerror("Macro unique label string not defined");
-	}
-	return (0);
+
+	return 0;
 }
 
 enum {
@@ -240,9 +229,85 @@ enum {
 	T_LEX_MACROUNIQUE
 };
 
-extern struct sLexInitString localstrings[];
+const struct sLexInitString lexer_strings[] = {
+	{"adc", T_Z80_ADC},
+	{"add", T_Z80_ADD},
+	{"and", T_Z80_AND},
+	{"bit", T_Z80_BIT},
+	{"call", T_Z80_CALL},
+	{"ccf", T_Z80_CCF},
+	{"cpl", T_Z80_CPL},
+	{"cp", T_Z80_CP},
+	{"daa", T_Z80_DAA},
+	{"dec", T_Z80_DEC},
+	{"di", T_Z80_DI},
+	{"ei", T_Z80_EI},
+	{"halt", T_Z80_HALT},
+	{"inc", T_Z80_INC},
+	{"jp", T_Z80_JP},
+	{"jr", T_Z80_JR},
+	{"ld", T_Z80_LD},
+	{"ldi", T_Z80_LDI},
+	{"ldd", T_Z80_LDD},
+	{"ldio", T_Z80_LDIO},
+	{"ldh", T_Z80_LDIO},
+	{"nop", T_Z80_NOP},
+	{"or", T_Z80_OR},
+	{"pop", T_Z80_POP},
+	{"push", T_Z80_PUSH},
+	{"res", T_Z80_RES},
+	{"reti", T_Z80_RETI},
+	{"ret", T_Z80_RET},
+	{"rlca", T_Z80_RLCA},
+	{"rlc", T_Z80_RLC},
+	{"rla", T_Z80_RLA},
+	{"rl", T_Z80_RL},
+	{"rrc", T_Z80_RRC},
+	{"rrca", T_Z80_RRCA},
+	{"rra", T_Z80_RRA},
+	{"rr", T_Z80_RR},
+	{"rst", T_Z80_RST},
+	{"sbc", T_Z80_SBC},
+	{"scf", T_Z80_SCF},
+	{"set", T_POP_SET},
+	{"sla", T_Z80_SLA},
+	{"sra", T_Z80_SRA},
+	{"srl", T_Z80_SRL},
+	{"stop", T_Z80_STOP},
+	{"sub", T_Z80_SUB},
+	{"swap", T_Z80_SWAP},
+	{"xor", T_Z80_XOR},
+
+	{"nz", T_CC_NZ},
+	{"z", T_CC_Z},
+	{"nc", T_CC_NC},
+	/* Handled in list of registers */
+	/* { "c", T_TOKEN_C }, */
+
+	{"[bc]", T_MODE_BC_IND},
+	{"[de]", T_MODE_DE_IND},
+	{"[hl]", T_MODE_HL_IND},
+	{"[hl+]", T_MODE_HL_INDINC},
+	{"[hl-]", T_MODE_HL_INDDEC},
+	{"[hli]", T_MODE_HL_INDINC},
+	{"[hld]", T_MODE_HL_INDDEC},
+	{"[sp]", T_MODE_SP_IND},
+	{"af", T_MODE_AF},
+	{"bc", T_MODE_BC},
+	{"de", T_MODE_DE},
+	{"hl", T_MODE_HL},
+	{"sp", T_MODE_SP},
+	{"[c]", T_MODE_C_IND},
+	{"[$ff00+c]", T_MODE_C_IND},
+
+	{"a", T_TOKEN_A},
+	{"b", T_TOKEN_B},
+	{"c", T_TOKEN_C},
+	{"d", T_TOKEN_D},
+	{"e", T_TOKEN_E},
+	{"h", T_TOKEN_H},
+	{"l", T_TOKEN_L},
 
-struct sLexInitString staticstrings[] = {
 	{"||", T_OP_LOGICOR},
 	{"&&", T_OP_LOGICAND},
 	{"==", T_OP_LOGICEQU},
@@ -267,6 +332,7 @@ struct sLexInitString staticstrings[] = {
 	{"def", T_OP_DEF},
 
 	{"bank", T_OP_BANK},
+	{"align", T_OP_ALIGN},
 
 	{"round", T_OP_ROUND},
 	{"ceil", T_OP_CEIL},
@@ -281,6 +347,9 @@ struct sLexInitString staticstrings[] = {
 	{"atan", T_OP_ATAN},
 	{"atan2", T_OP_ATAN2},
 
+	{"high", T_OP_HIGH},
+	{"low", T_OP_LOW},
+
 	{"strcmp", T_OP_STRCMP},
 	{"strin", T_OP_STRIN},
 	{"strsub", T_OP_STRSUB},
@@ -299,11 +368,9 @@ struct sLexInitString staticstrings[] = {
 	{"xref", T_POP_IMPORT},
 	{"global", T_POP_GLOBAL},
 	{"ds", T_POP_DS},
-	{NAME_DB, T_POP_DB},
-	{NAME_DW, T_POP_DW},
-#ifdef NAME_DL
-	{NAME_DL, T_POP_DL},
-#endif
+	{"db", T_POP_DB},
+	{"dw", T_POP_DW},
+	{"dl", T_POP_DL},
 	{"section", T_POP_SECTION},
 	{"purge", T_POP_PURGE},
 
@@ -317,7 +384,6 @@ struct sLexInitString staticstrings[] = {
 	{"warn", T_POP_WARN},
 
 	{"macro", T_POP_MACRO},
-
 	/* Not needed but we have it here just to protect the name */
 	{"endm", T_POP_ENDM},
 	{"shift", T_POP_SHIFT},
@@ -328,29 +394,35 @@ struct sLexInitString staticstrings[] = {
 
 	{"if", T_POP_IF},
 	{"else", T_POP_ELSE},
+	{"elif", T_POP_ELIF},
 	{"endc", T_POP_ENDC},
 
+	{"union", T_POP_UNION},
+	{"nextu", T_POP_NEXTU},
+	{"endu", T_POP_ENDU},
+
 	{"wram0", T_SECT_WRAM0},
-	{"bss", T_SECT_WRAM0}, /* deprecated */
 	{"vram", T_SECT_VRAM},
-	{"code", T_SECT_ROMX}, /* deprecated */
-	{"data", T_SECT_ROMX}, /* deprecated */
 	{"romx", T_SECT_ROMX},
-	{"home", T_SECT_ROM0}, /* deprecated */
 	{"rom0", T_SECT_ROM0},
 	{"hram", T_SECT_HRAM},
 	{"wramx", T_SECT_WRAMX},
 	{"sram", T_SECT_SRAM},
+	{"oam", T_SECT_OAM},
 
-	{NAME_RB, T_POP_RB},
-	{NAME_RW, T_POP_RW},
-#ifdef NAME_RL
-	{NAME_RL, T_POP_RL},
-#endif
+	/* Deprecated section type names */
+	{"home", T_SECT_HOME},
+	{"code", T_SECT_CODE},
+	{"data", T_SECT_DATA},
+	{"bss", T_SECT_BSS},
+
+	{"rb", T_POP_RB},
+	{"rw", T_POP_RW},
 	{"equ", T_POP_EQU},
 	{"equs", T_POP_EQUS},
 
-	{"set", T_POP_SET},
+	/*  Handled before in list of CPU instructions */
+	/* {"set", T_POP_SET}, */
 	{"=", T_POP_SET},
 
 	{"pushs", T_POP_PUSHS},
@@ -363,43 +435,41 @@ struct sLexInitString staticstrings[] = {
 	{NULL, 0}
 };
 
-struct sLexFloat tNumberToken = {
+const struct sLexFloat tNumberToken = {
 	ParseNumber,
 	T_NUMBER
 };
 
-struct sLexFloat tFixedPointToken = {
+const struct sLexFloat tFixedPointToken = {
 	ParseFixedPoint,
 	T_NUMBER
 };
 
-struct sLexFloat tIDToken = {
+const struct sLexFloat tIDToken = {
 	ParseSymbol,
 	T_ID
 };
 
-struct sLexFloat tMacroArgToken = {
+const struct sLexFloat tMacroArgToken = {
 	PutMacroArg,
 	T_LEX_MACROARG
 };
 
-struct sLexFloat tMacroUniqueToken = {
+const struct sLexFloat tMacroUniqueToken = {
 	PutUniqueArg,
 	T_LEX_MACROUNIQUE
 };
 
-void 
-setuplex(void)
+void setup_lexer(void)
 {
-	ULONG id;
+	uint32_t id;
 
 	lex_Init();
-	lex_AddStrings(staticstrings);
-	lex_AddStrings(localstrings);
+	lex_AddStrings(lexer_strings);
 
 	//Macro arguments
 
-	    id = lex_FloatAlloc(&tMacroArgToken);
+	id = lex_FloatAlloc(&tMacroArgToken);
 	lex_FloatAddFirstRange(id, '\\', '\\');
 	lex_FloatAddSecondRange(id, '1', '9');
 	id = lex_FloatAlloc(&tMacroUniqueToken);
@@ -408,43 +478,45 @@ setuplex(void)
 
 	//Decimal constants
 
-	    id = lex_FloatAlloc(&tNumberToken);
+	id = lex_FloatAlloc(&tNumberToken);
 	lex_FloatAddFirstRange(id, '0', '9');
 	lex_FloatAddSecondRange(id, '0', '9');
 	lex_FloatAddRange(id, '0', '9');
 
 	//Binary constants
 
-	    nBinaryID = id = lex_FloatAlloc(&tNumberToken);
+	id = lex_FloatAlloc(&tNumberToken);
+	nBinaryID = id;
 	lex_FloatAddFirstRange(id, '%', '%');
 	lex_FloatAddSecondRange(id, CurrentOptions.binary[0],
-	    CurrentOptions.binary[0]);
+				CurrentOptions.binary[0]);
 	lex_FloatAddSecondRange(id, CurrentOptions.binary[1],
-	    CurrentOptions.binary[1]);
+				CurrentOptions.binary[1]);
 	lex_FloatAddRange(id, CurrentOptions.binary[0],
-	    CurrentOptions.binary[0]);
+			  CurrentOptions.binary[0]);
 	lex_FloatAddRange(id, CurrentOptions.binary[1],
-	    CurrentOptions.binary[1]);
+			  CurrentOptions.binary[1]);
 
 	//Octal constants
 
-	    id = lex_FloatAlloc(&tNumberToken);
+	id = lex_FloatAlloc(&tNumberToken);
 	lex_FloatAddFirstRange(id, '&', '&');
 	lex_FloatAddSecondRange(id, '0', '7');
 	lex_FloatAddRange(id, '0', '7');
 
 	//Gameboy gfx constants
 
-	    nGBGfxID = id = lex_FloatAlloc(&tNumberToken);
+	id = lex_FloatAlloc(&tNumberToken);
+	nGBGfxID = id;
 	lex_FloatAddFirstRange(id, '`', '`');
 	lex_FloatAddSecondRange(id, CurrentOptions.gbgfx[0],
-	    CurrentOptions.gbgfx[0]);
+				CurrentOptions.gbgfx[0]);
 	lex_FloatAddSecondRange(id, CurrentOptions.gbgfx[1],
-	    CurrentOptions.gbgfx[1]);
+				CurrentOptions.gbgfx[1]);
 	lex_FloatAddSecondRange(id, CurrentOptions.gbgfx[2],
-	    CurrentOptions.gbgfx[2]);
+				CurrentOptions.gbgfx[2]);
 	lex_FloatAddSecondRange(id, CurrentOptions.gbgfx[3],
-	    CurrentOptions.gbgfx[3]);
+				CurrentOptions.gbgfx[3]);
 	lex_FloatAddRange(id, CurrentOptions.gbgfx[0], CurrentOptions.gbgfx[0]);
 	lex_FloatAddRange(id, CurrentOptions.gbgfx[1], CurrentOptions.gbgfx[1]);
 	lex_FloatAddRange(id, CurrentOptions.gbgfx[2], CurrentOptions.gbgfx[2]);
@@ -452,7 +524,7 @@ setuplex(void)
 
 	//Hex constants
 
-	    id = lex_FloatAlloc(&tNumberToken);
+	id = lex_FloatAlloc(&tNumberToken);
 	lex_FloatAddFirstRange(id, '$', '$');
 	lex_FloatAddSecondRange(id, '0', '9');
 	lex_FloatAddSecondRange(id, 'A', 'F');
@@ -463,7 +535,7 @@ setuplex(void)
 
 	//ID 's
 
-	    id = lex_FloatAlloc(&tIDToken);
+	id = lex_FloatAlloc(&tIDToken);
 	lex_FloatAddFirstRange(id, 'a', 'z');
 	lex_FloatAddFirstRange(id, 'A', 'Z');
 	lex_FloatAddFirstRange(id, '_', '_');
@@ -474,6 +546,7 @@ setuplex(void)
 	lex_FloatAddSecondRange(id, '\\', '\\');
 	lex_FloatAddSecondRange(id, '@', '@');
 	lex_FloatAddSecondRange(id, '#', '#');
+	lex_FloatAddRange(id, '.', '.');
 	lex_FloatAddRange(id, 'a', 'z');
 	lex_FloatAddRange(id, 'A', 'Z');
 	lex_FloatAddRange(id, '0', '9');
@@ -484,7 +557,7 @@ setuplex(void)
 
 	//Local ID
 
-	    id = lex_FloatAlloc(&tIDToken);
+	id = lex_FloatAlloc(&tIDToken);
 	lex_FloatAddFirstRange(id, '.', '.');
 	lex_FloatAddSecondRange(id, 'a', 'z');
 	lex_FloatAddSecondRange(id, 'A', 'Z');
@@ -499,17 +572,16 @@ setuplex(void)
 
 	//@ID
 
-	    id = lex_FloatAlloc(&tIDToken);
+	id = lex_FloatAlloc(&tIDToken);
 	lex_FloatAddFirstRange(id, '@', '@');
 
 	//Fixed point constants
 
-	    id = lex_FloatAlloc(&tFixedPointToken);
+	id = lex_FloatAlloc(&tFixedPointToken);
 	lex_FloatAddFirstRange(id, '.', '.');
 	lex_FloatAddFirstRange(id, '0', '9');
 	lex_FloatAddSecondRange(id, '.', '.');
 	lex_FloatAddSecondRange(id, '0', '9');
 	lex_FloatAddRange(id, '.', '.');
 	lex_FloatAddRange(id, '0', '9');
-
 }

src/asm/lexer.c

@@ -1,46 +1,45 @@
 #include <stdio.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <strings.h>
 #include <ctype.h>
 
 #include "asm/asm.h"
+#include "asm/fstack.h"
 #include "asm/lexer.h"
-#include "types.h"
 #include "asm/main.h"
 #include "asm/rpn.h"
-#include "asm/fstack.h"
+
 #include "extern/err.h"
 
 #include "asmy.h"
 
 struct sLexString {
 	char *tzName;
-	ULONG nToken;
-	ULONG nNameLength;
+	uint32_t nToken;
+	uint32_t nNameLength;
 	struct sLexString *pNext;
 };
-#define pLexBufferRealStart (pCurrentBuffer->pBufferRealStart)
-#define pLexBuffer		    (pCurrentBuffer->pBuffer)
-#define AtLineStart	        (pCurrentBuffer->oAtLineStart)
 
-#define SAFETYMARGIN	1024
+#define pLexBufferRealStart	(pCurrentBuffer->pBufferRealStart)
+#define pLexBuffer		(pCurrentBuffer->pBuffer)
+#define AtLineStart		(pCurrentBuffer->oAtLineStart)
 
-extern size_t symvaluetostring(char *dest, size_t maxLength, char *sym);
+#define SAFETYMARGIN		1024
 
 struct sLexFloat tLexFloat[32];
 struct sLexString *tLexHash[LEXHASHSIZE];
 YY_BUFFER_STATE pCurrentBuffer;
-ULONG nLexMaxLength; // max length of all keywords and operators
+uint32_t nLexMaxLength; // max length of all keywords and operators
 
-ULONG tFloatingSecondChar[256];
-ULONG tFloatingFirstChar[256];
-ULONG tFloatingChars[256];
-ULONG nFloating;
+uint32_t tFloatingSecondChar[256];
+uint32_t tFloatingFirstChar[256];
+uint32_t tFloatingChars[256];
+uint32_t nFloating;
 enum eLexerState lexerstate = LEX_STATE_NORMAL;
 
-void 
-upperstring(char *s)
+void upperstring(char *s)
 {
 	while (*s) {
 		*s = toupper(*s);
@@ -48,8 +47,7 @@ upperstring(char *s)
 	}
 }
 
-void 
-lowerstring(char *s)
+void lowerstring(char *s)
 {
 	while (*s) {
 		*s = tolower(*s);
@@ -57,20 +55,17 @@ lowerstring(char *s)
 	}
 }
 
-void 
-yyskipbytes(ULONG count)
+void yyskipbytes(uint32_t count)
 {
 	pLexBuffer += count;
 }
 
-void 
-yyunputbytes(ULONG count)
+void yyunputbytes(uint32_t count)
 {
 	pLexBuffer -= count;
 }
 
-void 
-yyunput(char c)
+void yyunput(char c)
 {
 	if (pLexBuffer <= pLexBufferRealStart)
 		fatalerror("Buffer safety margin exceeded");
@@ -78,10 +73,9 @@ yyunput(char c)
 	*(--pLexBuffer) = c;
 }
 
-void 
-yyunputstr(char *s)
+void yyunputstr(char *s)
 {
-	int i, len;
+	int32_t i, len;
 
 	len = strlen(s);
 
@@ -92,114 +86,109 @@ yyunputstr(char *s)
 		*(--pLexBuffer) = s[i];
 }
 
-void 
-yy_switch_to_buffer(YY_BUFFER_STATE buf)
+void yy_switch_to_buffer(YY_BUFFER_STATE buf)
 {
 	pCurrentBuffer = buf;
 }
 
-void 
-yy_set_state(enum eLexerState i)
+void yy_set_state(enum eLexerState i)
 {
 	lexerstate = i;
 }
 
-void 
-yy_delete_buffer(YY_BUFFER_STATE buf)
+void yy_delete_buffer(YY_BUFFER_STATE buf)
 {
 	free(buf->pBufferStart - SAFETYMARGIN);
 	free(buf);
 }
 
-YY_BUFFER_STATE 
-yy_scan_bytes(char *mem, ULONG size)
+YY_BUFFER_STATE yy_scan_bytes(char *mem, uint32_t size)
 {
-	YY_BUFFER_STATE pBuffer;
+	YY_BUFFER_STATE pBuffer = malloc(sizeof(struct yy_buffer_state));
 
-	if ((pBuffer = malloc(sizeof(struct yy_buffer_state))) != NULL) {
-		if ((pBuffer->pBufferRealStart =
-		    malloc(size + 1 + SAFETYMARGIN)) != NULL) {
-			pBuffer->pBufferStart = pBuffer->pBufferRealStart + SAFETYMARGIN;
-			pBuffer->pBuffer = pBuffer->pBufferRealStart + SAFETYMARGIN;
-			memcpy(pBuffer->pBuffer, mem, size);
-			pBuffer->nBufferSize = size;
-			pBuffer->oAtLineStart = 1;
-			pBuffer->pBuffer[size] = 0;
-			return (pBuffer);
-		}
-	}
-	fatalerror("Out of memory!");
-	return (NULL);
+	if (pBuffer == NULL)
+		fatalerror("%s: Out of memory!", __func__);
+
+	pBuffer->pBufferRealStart = malloc(size + 1 + SAFETYMARGIN);
+
+	if (pBuffer->pBufferRealStart == NULL)
+		fatalerror("%s: Out of memory for buffer!", __func__);
+
+	pBuffer->pBufferStart = pBuffer->pBufferRealStart + SAFETYMARGIN;
+	pBuffer->pBuffer = pBuffer->pBufferRealStart + SAFETYMARGIN;
+	memcpy(pBuffer->pBuffer, mem, size);
+	pBuffer->nBufferSize = size;
+	pBuffer->oAtLineStart = 1;
+	pBuffer->pBuffer[size] = 0;
+
+	return pBuffer;
 }
 
-YY_BUFFER_STATE 
-yy_create_buffer(FILE * f)
+YY_BUFFER_STATE yy_create_buffer(FILE *f)
 {
-	YY_BUFFER_STATE pBuffer;
+	YY_BUFFER_STATE pBuffer = malloc(sizeof(struct yy_buffer_state));
 
-	if ((pBuffer = malloc(sizeof(struct yy_buffer_state))) != NULL) {
-		ULONG size;
+	if (pBuffer == NULL)
+		fatalerror("%s: Out of memory!", __func__);
 
-		fseek(f, 0, SEEK_END);
-		size = ftell(f);
-		fseek(f, 0, SEEK_SET);
+	uint32_t size;
 
-		if ((pBuffer->pBufferRealStart =
-			malloc(size + 2 + SAFETYMARGIN)) != NULL) {
-			char *mem;
-			ULONG instring = 0;
+	fseek(f, 0, SEEK_END);
+	size = ftell(f);
+	fseek(f, 0, SEEK_SET);
 
-			pBuffer->pBufferStart = pBuffer->pBufferRealStart + SAFETYMARGIN;
-			pBuffer->pBuffer = pBuffer->pBufferRealStart + SAFETYMARGIN;
+	pBuffer->pBufferRealStart = malloc(size + 2 + SAFETYMARGIN);
 
-			size = fread(pBuffer->pBuffer, sizeof(UBYTE), size, f);
+	if (pBuffer->pBufferRealStart == NULL)
+		fatalerror("%s: Out of memory for buffer!", __func__);
 
-			pBuffer->pBuffer[size] = '\n';
-			pBuffer->pBuffer[size + 1] = 0;
-			pBuffer->nBufferSize = size + 1;
+	pBuffer->pBufferStart = pBuffer->pBufferRealStart + SAFETYMARGIN;
+	pBuffer->pBuffer = pBuffer->pBufferRealStart + SAFETYMARGIN;
 
-			mem = pBuffer->pBuffer;
+	size = fread(pBuffer->pBuffer, sizeof(uint8_t), size, f);
 
-			while (*mem) {
-				if (*mem == '\"')
-					instring = 1 - instring;
+	pBuffer->pBuffer[size] = '\n';
+	pBuffer->pBuffer[size + 1] = 0;
+	pBuffer->nBufferSize = size + 1;
 
-				if (mem[0] == '\\' &&
-				    (mem[1] == '\"' || mem[1] == '\\')) {
-					mem += 2;
-				} else if (instring) {
-					mem += 1;
-				} else {
-					if ((mem[0] == 10 && mem[1] == 13)
-					 || (mem[0] == 13 && mem[1] == 10)) {
-						mem[0] = ' ';
-						mem[1] = '\n';
-						mem += 2;
-					} else if (mem[0] == 10 || mem[0] == 13) {
-						mem[0] = '\n';
-						mem += 1;
-					} else if (mem[0] == '\n' && mem[1] == '*') {
-						mem += 1;
-						while (!(*mem == '\n' || *mem == '\0'))
-							*mem++ = ' ';
-					} else if (*mem == ';') {
-						while (!(*mem == '\n' || *mem == '\0'))
-							*mem++ = ' ';
-					} else
-						mem += 1;
-				}
+	char *mem = pBuffer->pBuffer;
+	uint32_t instring = 0;
+
+	while (*mem) {
+		if (*mem == '\"')
+			instring = 1 - instring;
+
+		if ((mem[0] == '\\') && (mem[1] == '\"' || mem[1] == '\\')) {
+			mem += 2;
+		} else if (instring) {
+			mem += 1;
+		} else {
+			if ((mem[0] == 10 && mem[1] == 13)
+				|| (mem[0] == 13 && mem[1] == 10)) {
+				mem[0] = ' ';
+				mem[1] = '\n';
+				mem += 2;
+			} else if (mem[0] == 10 || mem[0] == 13) {
+				mem[0] = '\n';
+				mem += 1;
+			} else if (mem[0] == '\n' && mem[1] == '*') {
+				mem += 1;
+				while (!(*mem == '\n' || *mem == '\0'))
+					*mem++ = ' ';
+			} else if (*mem == ';') {
+				while (!(*mem == '\n' || *mem == '\0'))
+					*mem++ = ' ';
+			} else {
+				mem += 1;
 			}
-
-			pBuffer->oAtLineStart = 1;
-			return (pBuffer);
 		}
 	}
-	fatalerror("Out of memory!");
-	return (NULL);
+
+	pBuffer->oAtLineStart = 1;
+	return pBuffer;
 }
 
-ULONG
-lex_FloatAlloc(struct sLexFloat *token)
+uint32_t lex_FloatAlloc(const struct sLexFloat *token)
 {
 	tLexFloat[nFloating] = *token;
 
@@ -210,17 +199,15 @@ lex_FloatAlloc(struct sLexFloat *token)
  * Make sure that only non-zero ASCII characters are used. Also, check if the
  * start is greater than the end of the range.
  */
-void
-lex_CheckCharacterRange(UWORD start, UWORD end)
+void lex_CheckCharacterRange(uint16_t start, uint16_t end)
 {
 	if (start > end || start < 1 || end > 127) {
 		errx(1, "Invalid character range (start: %u, end: %u)",
-		        start, end);
+		     start, end);
 	}
 }
 
-void 
-lex_FloatDeleteRange(ULONG id, UWORD start, UWORD end)
+void lex_FloatDeleteRange(uint32_t id, uint16_t start, uint16_t end)
 {
 	lex_CheckCharacterRange(start, end);
 
@@ -230,8 +217,7 @@ lex_FloatDeleteRange(ULONG id, UWORD start, UWORD end)
 	}
 }
 
-void 
-lex_FloatAddRange(ULONG id, UWORD start, UWORD end)
+void lex_FloatAddRange(uint32_t id, uint16_t start, uint16_t end)
 {
 	lex_CheckCharacterRange(start, end);
 
@@ -241,8 +227,7 @@ lex_FloatAddRange(ULONG id, UWORD start, UWORD end)
 	}
 }
 
-void 
-lex_FloatDeleteFirstRange(ULONG id, UWORD start, UWORD end)
+void lex_FloatDeleteFirstRange(uint32_t id, uint16_t start, uint16_t end)
 {
 	lex_CheckCharacterRange(start, end);
 
@@ -252,8 +237,7 @@ lex_FloatDeleteFirstRange(ULONG id, UWORD start, UWORD end)
 	}
 }
 
-void 
-lex_FloatAddFirstRange(ULONG id, UWORD start, UWORD end)
+void lex_FloatAddFirstRange(uint32_t id, uint16_t start, uint16_t end)
 {
 	lex_CheckCharacterRange(start, end);
 
@@ -263,8 +247,7 @@ lex_FloatAddFirstRange(ULONG id, UWORD start, UWORD end)
 	}
 }
 
-void 
-lex_FloatDeleteSecondRange(ULONG id, UWORD start, UWORD end)
+void lex_FloatDeleteSecondRange(uint32_t id, uint16_t start, uint16_t end)
 {
 	lex_CheckCharacterRange(start, end);
 
@@ -274,8 +257,7 @@ lex_FloatDeleteSecondRange(ULONG id, UWORD start, UWORD end)
 	}
 }
 
-void 
-lex_FloatAddSecondRange(ULONG id, UWORD start, UWORD end)
+void lex_FloatAddSecondRange(uint32_t id, uint16_t start, uint16_t end)
 {
 	lex_CheckCharacterRange(start, end);
 
@@ -285,43 +267,37 @@ lex_FloatAddSecondRange(ULONG id, UWORD start, UWORD end)
 	}
 }
 
-struct sLexFloat *
-lexgetfloat(ULONG nFloatMask)
+static struct sLexFloat *lexgetfloat(uint32_t nFloatMask)
 {
-	if (nFloatMask == 0) {
-		fatalerror("Internal error in lexgetfloat");
-	}
+	if (nFloatMask == 0)
+		fatalerror("Internal error in %s", __func__);
 
-	int i = 0;
+	int32_t i = 0;
 
 	while ((nFloatMask & 1) == 0) {
 		nFloatMask >>= 1;
 		i++;
 	}
 
-	return (&tLexFloat[i]);
+	return &tLexFloat[i];
 }
 
-ULONG 
-lexcalchash(char *s)
+static uint32_t lexcalchash(char *s)
 {
-	ULONG hash = 0;
+	uint32_t hash = 0;
 
-	while (*s) {
+	while (*s)
 		hash = (hash * 283) ^ toupper(*s++);
-	}
 
-	return (hash % LEXHASHSIZE);
+	return hash % LEXHASHSIZE;
 }
 
-void 
-lex_Init(void)
+void lex_Init(void)
 {
-	ULONG i;
+	uint32_t i;
 
-	for (i = 0; i < LEXHASHSIZE; i++) {
+	for (i = 0; i < LEXHASHSIZE; i++)
 		tLexHash[i] = NULL;
-	}
 
 	for (i = 0; i < 256; i++) {
 		tFloatingFirstChar[i] = 0;
@@ -333,34 +309,33 @@ lex_Init(void)
 	nFloating = 0;
 }
 
-void 
-lex_AddStrings(struct sLexInitString * lex)
+void lex_AddStrings(const struct sLexInitString *lex)
 {
 	while (lex->tzName) {
 		struct sLexString **ppHash;
-		ULONG hash;
+		uint32_t hash;
 
 		ppHash = &tLexHash[hash = lexcalchash(lex->tzName)];
 		while (*ppHash)
 			ppHash = &((*ppHash)->pNext);
 
-		if (((*ppHash) = malloc(sizeof(struct sLexString))) != NULL) {
-			if (((*ppHash)->tzName =
-				(char *) strdup(lex->tzName)) != NULL) {
-				(*ppHash)->nNameLength = strlen(lex->tzName);
-				(*ppHash)->nToken = lex->nToken;
-				(*ppHash)->pNext = NULL;
-
-				upperstring((*ppHash)->tzName);
-
-				if ((*ppHash)->nNameLength > nLexMaxLength)
-					nLexMaxLength = (*ppHash)->nNameLength;
-
-			} else
-				fatalerror("Out of memory!");
-		} else
+		*ppHash = malloc(sizeof(struct sLexString));
+		if (*ppHash == NULL)
 			fatalerror("Out of memory!");
 
+		(*ppHash)->tzName = (char *)strdup(lex->tzName);
+		if ((*ppHash)->tzName == NULL)
+			fatalerror("Out of memory!");
+
+		(*ppHash)->nNameLength = strlen(lex->tzName);
+		(*ppHash)->nToken = lex->nToken;
+		(*ppHash)->pNext = NULL;
+
+		upperstring((*ppHash)->tzName);
+
+		if ((*ppHash)->nNameLength > nLexMaxLength)
+			nLexMaxLength = (*ppHash)->nNameLength;
+
 		lex += 1;
 	}
 }
@@ -375,42 +350,42 @@ lex_AddStrings(struct sLexInitString * lex)
  * The token types with the longest match from the current position in the
  * buffer will have their bits set in the float mask.
  */
-void
-yylex_GetFloatMaskAndFloatLen(ULONG *pnFloatMask, ULONG *pnFloatLen)
+void yylex_GetFloatMaskAndFloatLen(uint32_t *pnFloatMask, uint32_t *pnFloatLen)
 {
-	// Note that '\0' should always have a bit mask of 0 in the "floating"
-	// tables, so it doesn't need to be checked for separately.
+	/*
+	 * Note that '\0' should always have a bit mask of 0 in the "floating"
+	 * tables, so it doesn't need to be checked for separately.
+	 */
 
 	char *s = pLexBuffer;
-	ULONG nOldFloatMask = 0;
-	ULONG nFloatMask = tFloatingFirstChar[(int)*s];
+	uint32_t nOldFloatMask = 0;
+	uint32_t nFloatMask = tFloatingFirstChar[(int32_t)*s];
 
 	if (nFloatMask != 0) {
 		s++;
 		nOldFloatMask = nFloatMask;
-		nFloatMask &= tFloatingSecondChar[(int)*s];
+		nFloatMask &= tFloatingSecondChar[(int32_t)*s];
 
 		while (nFloatMask != 0) {
 			s++;
 			nOldFloatMask = nFloatMask;
-			nFloatMask &= tFloatingChars[(int)*s];
+			nFloatMask &= tFloatingChars[(int32_t)*s];
 		}
 	}
 
 	*pnFloatMask = nOldFloatMask;
-	*pnFloatLen = (ULONG)(s - pLexBuffer);
+	*pnFloatLen = (uint32_t)(s - pLexBuffer);
 }
 
 /*
  * Gets the longest keyword/operator from the current position in the buffer.
  */
-struct sLexString *
-yylex_GetLongestFixed()
+struct sLexString *yylex_GetLongestFixed()
 {
 	struct sLexString *pLongestFixed = NULL;
 	char *s = pLexBuffer;
-	ULONG hash = 0;
-	ULONG length = 0;
+	uint32_t hash = 0;
+	uint32_t length = 0;
 
 	while (length < nLexMaxLength && *s) {
 		hash = (hash * 283) ^ toupper(*s);
@@ -432,12 +407,11 @@ yylex_GetLongestFixed()
 	return pLongestFixed;
 }
 
-size_t
-CopyMacroArg(char *dest, size_t maxLength, char c)
+size_t CopyMacroArg(char *dest, size_t maxLength, char c)
 {
-	int i;
+	size_t i;
 	char *s;
-	int argNum;
+	int32_t argNum;
 
 	switch (c) {
 	case '1':
@@ -458,35 +432,33 @@ CopyMacroArg(char *dest, size_t maxLength, char c)
 		return 0;
 	}
 
-	if ((s = sym_FindMacroArg(argNum)) == NULL)
+	s = sym_FindMacroArg(argNum);
+
+	if (s == NULL)
 		fatalerror("Macro argument not defined");
 
 	for (i = 0; s[i] != 0; i++) {
-		if (i >= maxLength) {
+		if (i >= maxLength)
 			fatalerror("Macro argument too long to fit buffer");
-		}
+
 		dest[i] = s[i];
 	}
 
 	return i;
 }
 
-static inline void
-yylex_StringWriteChar(char *s, size_t index, char c)
+static inline void yylex_StringWriteChar(char *s, size_t index, char c)
 {
-	if (index >= MAXSTRLEN) {
+	if (index >= MAXSTRLEN)
 		fatalerror("String too long");
-	}
 
 	s[index] = c;
 }
 
-static inline void
-yylex_SymbolWriteChar(char *s, size_t index, char c)
+static inline void yylex_SymbolWriteChar(char *s, size_t index, char c)
 {
-	if (index >= MAXSYMLEN) {
+	if (index >= MAXSYMLEN)
 		fatalerror("Symbol too long");
-	}
 
 	s[index] = c;
 }
@@ -497,14 +469,15 @@ yylex_SymbolWriteChar(char *s, size_t index, char c)
  */
 void yylex_TrimEnd(char *s, size_t index)
 {
-	int i;
+	int32_t i = (int32_t)index - 1;
 
-	for (i = (int)index - 1; i >= 0 && (s[i] == ' ' || s[i] == '\t'); i--)
+	while ((i >= 0) && (s[i] == ' ' || s[i] == '\t')) {
 		s[i] = 0;
+		i--;
+	}
 }
 
-size_t
-yylex_ReadBracketedSymbol(char *dest, size_t index)
+size_t yylex_ReadBracketedSymbol(char *dest, size_t index)
 {
 	char sym[MAXSYMLEN + 1];
 	char ch;
@@ -523,25 +496,26 @@ yylex_ReadBracketedSymbol(char *dest, size_t index)
 				i += length;
 			else
 				fatalerror("Illegal character escape '%c'", ch);
-		} else
+		} else {
 			yylex_SymbolWriteChar(sym, i++, ch);
+		}
 	}
 
 	yylex_SymbolWriteChar(sym, i, 0);
 
-	maxLength = MAXSTRLEN - index; // it's assumed we're writing to a T_STRING
+	/* It's assumed we're writing to a T_STRING */
+	maxLength = MAXSTRLEN - index;
 	length = symvaluetostring(&dest[index], maxLength, sym);
 
 	if (*pLexBuffer == '}')
 		pLexBuffer++;
 	else
-		yyerror("Missing }");
+		fatalerror("Missing }");
 
 	return length;
 }
 
-void
-yylex_ReadQuotedString()
+static void yylex_ReadQuotedString(void)
 {
 	size_t index = 0;
 	size_t length, maxLength;
@@ -565,21 +539,33 @@ yylex_ReadQuotedString()
 			case '"':
 				ch = '"';
 				break;
+			case ',':
+				ch = ',';
+				break;
+			case '{':
+				ch = '{';
+				break;
+			case '}':
+				ch = '}';
+				break;
 			default:
 				maxLength = MAXSTRLEN - index;
-				length = CopyMacroArg(&yylval.tzString[index], maxLength, ch);
+				length = CopyMacroArg(&yylval.tzString[index],
+						      maxLength, ch);
 
 				if (length != 0)
 					index += length;
 				else
-					fatalerror("Illegal character escape '%c'", ch);
+					fatalerror("Illegal character escape '%c'",
+						   ch);
 
 				ch = 0;
 				break;
 			}
 		} else if (ch == '{') {
 			// Get bracketed symbol within string.
-			index += yylex_ReadBracketedSymbol(yylval.tzString, index);
+			index += yylex_ReadBracketedSymbol(yylval.tzString,
+							   index);
 			ch = 0;
 		}
 
@@ -592,15 +578,14 @@ yylex_ReadQuotedString()
 	if (*pLexBuffer == '"')
 		pLexBuffer++;
 	else
-		yyerror("Unterminated string");
+		fatalerror("Unterminated string");
 }
 
-ULONG
-yylex_NORMAL()
+static uint32_t yylex_NORMAL(void)
 {
 	struct sLexString *pLongestFixed = NULL;
-	ULONG nFloatMask, nFloatLen;
-	ULONG linestart = AtLineStart;
+	uint32_t nFloatMask, nFloatLen;
+	uint32_t linestart = AtLineStart;
 
 	AtLineStart = 0;
 
@@ -619,15 +604,20 @@ scanagain:
 		}
 	}
 
-	// Try to match an identifier, macro argument (e.g. \1),
-	// or numeric literal.
+	/*
+	 * Try to match an identifier, macro argument (e.g. \1),
+	 * or numeric literal.
+	 */
 	yylex_GetFloatMaskAndFloatLen(&nFloatMask, &nFloatLen);
 
-	// Try to match a keyword or operator.
+	/* Try to match a keyword or operator. */
 	pLongestFixed = yylex_GetLongestFixed();
 
 	if (nFloatLen == 0 && pLongestFixed == NULL) {
-		// No keyword, identifier, operator, or numerical literal matches.
+		/*
+		 * No keyword, identifier, operator, or numerical literal
+		 * matches.
+		 */
 
 		if (*pLexBuffer == '"') {
 			pLexBuffer++;
@@ -637,52 +627,55 @@ scanagain:
 			pLexBuffer++;
 			yylex_ReadBracketedSymbol(yylval.tzString, 0);
 			return T_STRING;
-		} else {
-			// It's not a keyword, operator, identifier, macro argument,
-			// numeric literal, string, or bracketed symbol, so just return
-			// the ASCII character.
-			if (*pLexBuffer == '\n')
-				AtLineStart = 1;
-
-			return *pLexBuffer++;
 		}
+
+		/*
+		 * It's not a keyword, operator, identifier, macro argument,
+		 * numeric literal, string, or bracketed symbol, so just return
+		 * the ASCII character.
+		 */
+		if (*pLexBuffer == '\n')
+			AtLineStart = 1;
+
+		return *pLexBuffer++;
 	}
 
 	if (pLongestFixed == NULL || nFloatLen > pLongestFixed->nNameLength) {
-		// Longest match was an identifier, macro argument, or numeric literal.
+		/*
+		 * Longest match was an identifier, macro argument, or numeric
+		 * literal.
+		 */
 		struct sLexFloat *token = lexgetfloat(nFloatMask);
 
 		if (token->Callback) {
-			int done = token->Callback(pLexBuffer, nFloatLen);
+			int32_t done = token->Callback(pLexBuffer, nFloatLen);
+
 			if (!done)
 				goto scanagain;
 		}
 
 		pLexBuffer += nFloatLen;
 
-		if (token->nToken == T_ID && linestart) {
+		if (token->nToken == T_ID && linestart)
 			return T_LABEL;
-		} else {
+		else
 			return token->nToken;
-		}
 	}
 
-	// Longest match was a keyword or operator.
+	/* Longest match was a keyword or operator. */
 	pLexBuffer += pLongestFixed->nNameLength;
 	return pLongestFixed->nToken;
 }
 
-ULONG
-yylex_MACROARGS()
+static uint32_t yylex_MACROARGS(void)
 {
 	size_t index = 0;
 	size_t length, maxLength;
 
-	while (*pLexBuffer == ' ' || *pLexBuffer == '\t') {
+	while ((*pLexBuffer == ' ') || (*pLexBuffer == '\t'))
 		pLexBuffer++;
-	}
 
-	while (*pLexBuffer != ',' && (*pLexBuffer != '\n')) {
+	while ((*pLexBuffer != ',') && (*pLexBuffer != '\n')) {
 		char ch = *pLexBuffer++;
 
 		if (ch == '\\') {
@@ -698,20 +691,32 @@ yylex_MACROARGS()
 			case '\\':
 				ch = '\\';
 				break;
+			case ',':
+				ch = ',';
+				break;
+			case '{':
+				ch = '{';
+				break;
+			case '}':
+				ch = '}';
+				break;
 			default:
 				maxLength = MAXSTRLEN - index;
-				length = CopyMacroArg(&yylval.tzString[index], maxLength, ch);
+				length = CopyMacroArg(&yylval.tzString[index],
+						      maxLength, ch);
 
 				if (length != 0)
 					index += length;
 				else
-					fatalerror("Illegal character escape '%c'", ch);
+					fatalerror("Illegal character escape '%c'",
+						   ch);
 
 				ch = 0;
 				break;
 			}
 		} else if (ch == '{') {
-			index += yylex_ReadBracketedSymbol(yylval.tzString, index);
+			index += yylex_ReadBracketedSymbol(yylval.tzString,
+							   index);
 			ch = 0;
 		}
 		if (ch)
@@ -721,7 +726,7 @@ yylex_MACROARGS()
 	if (index) {
 		yylex_StringWriteChar(yylval.tzString, index, 0);
 
-		// trim trailing white space at the end of the line
+		/* trim trailing white space at the end of the line */
 		if (*pLexBuffer == '\n')
 			yylex_TrimEnd(yylval.tzString, index);
 
@@ -735,12 +740,10 @@ yylex_MACROARGS()
 		return ',';
 	}
 
-	fatalerror("Internal error in yylex_MACROARGS");
-	return 0;
+	fatalerror("Internal error in %s", __func__);
 }
 
-ULONG 
-yylex(void)
+uint32_t yylex(void)
 {
 	switch (lexerstate) {
 	case LEX_STATE_NORMAL:
@@ -749,6 +752,5 @@ yylex(void)
 		return yylex_MACROARGS();
 	}
 
-	fatalerror("Internal error in yylex");
-	return 0;
+	fatalerror("Internal error in %s", __func__);
 }

src/asm/locallex.c

@@ -1,89 +0,0 @@
-#include "asm/symbol.h"
-#include "asm/lexer.h"
-#include "asm/rpn.h"
-
-#include "asmy.h"
-
-struct sLexInitString localstrings[] = {
-	{"adc", T_Z80_ADC},
-	{"add", T_Z80_ADD},
-	{"and", T_Z80_AND},
-	{"bit", T_Z80_BIT},
-	{"call", T_Z80_CALL},
-	{"ccf", T_Z80_CCF},
-	{"cpl", T_Z80_CPL},
-	{"cp", T_Z80_CP},
-	{"daa", T_Z80_DAA},
-	{"dec", T_Z80_DEC},
-	{"di", T_Z80_DI},
-	{"ei", T_Z80_EI},
-	{"ex", T_Z80_EX},
-	{"halt", T_Z80_HALT},
-	{"inc", T_Z80_INC},
-	{"jp", T_Z80_JP},
-	{"jr", T_Z80_JR},
-	{"ld", T_Z80_LD},
-	{"ldi", T_Z80_LDI},
-	{"ldd", T_Z80_LDD},
-	{"ldio", T_Z80_LDIO},
-	{"ldh", T_Z80_LDIO},
-	{"nop", T_Z80_NOP},
-	{"or", T_Z80_OR},
-	{"pop", T_Z80_POP},
-	{"push", T_Z80_PUSH},
-	{"res", T_Z80_RES},
-	{"reti", T_Z80_RETI},
-	{"ret", T_Z80_RET},
-	{"rlca", T_Z80_RLCA},
-	{"rlc", T_Z80_RLC},
-	{"rla", T_Z80_RLA},
-	{"rl", T_Z80_RL},
-	{"rrc", T_Z80_RRC},
-	{"rrca", T_Z80_RRCA},
-	{"rra", T_Z80_RRA},
-	{"rr", T_Z80_RR},
-	{"rst", T_Z80_RST},
-	{"sbc", T_Z80_SBC},
-	{"scf", T_Z80_SCF},
-
-	/* Handled by globallex.c */
-	/* { "set", T_POP_SET }, */
-
-	{"sla", T_Z80_SLA},
-	{"sra", T_Z80_SRA},
-	{"srl", T_Z80_SRL},
-	{"stop", T_Z80_STOP},
-	{"sub", T_Z80_SUB},
-	{"swap", T_Z80_SWAP},
-	{"xor", T_Z80_XOR},
-
-	{"nz", T_CC_NZ},
-	{"z", T_CC_Z},
-	{"nc", T_CC_NC},
-	/* { "c", T_MODE_C }, */
-
-	{"[hl]", T_MODE_HL_IND},
-	{"[hl+]", T_MODE_HL_INDINC},
-	{"[hl-]", T_MODE_HL_INDDEC},
-	{"[hli]", T_MODE_HL_INDINC},
-	{"[hld]", T_MODE_HL_INDDEC},
-	{"hl", T_MODE_HL},
-	{"af", T_MODE_AF},
-	{"[bc]", T_MODE_BC_IND},
-	{"bc", T_MODE_BC},
-	{"[de]", T_MODE_DE_IND},
-	{"de", T_MODE_DE},
-	{"[sp]", T_MODE_SP_IND},
-	{"sp", T_MODE_SP},
-	{"a", T_MODE_A},
-	{"b", T_MODE_B},
-	{"[$ff00+c]", T_MODE_C_IND},
-	{"[c]", T_MODE_C_IND},
-	{"c", T_MODE_C},
-	{"d", T_MODE_D},
-	{"e", T_MODE_E},
-	{"h", T_MODE_H},
-	{"l", T_MODE_L},
-
-	{NULL, 0}
-};

src/asm/main.c

@@ -1,6 +1,7 @@
 #include <math.h>
 #include <stdarg.h>
 #include <stdio.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
@@ -8,25 +9,29 @@
 
 #include "asm/symbol.h"
 #include "asm/fstack.h"
+#include "asm/lexer.h"
 #include "asm/output.h"
 #include "asm/main.h"
+
 #include "extern/err.h"
 #include "extern/reallocarray.h"
+#include "extern/version.h"
 
-int yyparse(void);
-void setuplex(void);
+extern int yyparse(void);
 
-int cldefines_index;
-int cldefines_size;
+int32_t cldefines_index;
+int32_t cldefines_size;
 char **cldefines;
 
-char *progname;
-
 clock_t nStartClock, nEndClock;
-SLONG nLineNo;
-ULONG nTotalLines, nPass, nPC, nIFDepth, nErrors;
+int32_t nLineNo;
+uint32_t nTotalLines, nPass, nPC, nIFDepth, nUnionDepth, nErrors;
+bool skipElif;
+uint32_t unionStart[128], unionSize[128];
 
-extern int yydebug;
+/* extern int yydebug; */
+
+FILE *dependfile;
 
 /*
  * Option stack
@@ -40,73 +45,71 @@ struct sOptionStackEntry {
 	struct sOptionStackEntry *pNext;
 };
 
-struct sOptionStackEntry *pOptionStack = NULL;
+struct sOptionStackEntry *pOptionStack;
 
-void 
-opt_SetCurrentOptions(struct sOptions * pOpt)
+void opt_SetCurrentOptions(struct sOptions *pOpt)
 {
 	if (nGBGfxID != -1) {
 		lex_FloatDeleteRange(nGBGfxID, CurrentOptions.gbgfx[0],
-		    CurrentOptions.gbgfx[0]);
+				     CurrentOptions.gbgfx[0]);
 		lex_FloatDeleteRange(nGBGfxID, CurrentOptions.gbgfx[1],
-		    CurrentOptions.gbgfx[1]);
+				     CurrentOptions.gbgfx[1]);
 		lex_FloatDeleteRange(nGBGfxID, CurrentOptions.gbgfx[2],
-		    CurrentOptions.gbgfx[2]);
+				     CurrentOptions.gbgfx[2]);
 		lex_FloatDeleteRange(nGBGfxID, CurrentOptions.gbgfx[3],
-		    CurrentOptions.gbgfx[3]);
+				     CurrentOptions.gbgfx[3]);
 		lex_FloatDeleteSecondRange(nGBGfxID, CurrentOptions.gbgfx[0],
-		    CurrentOptions.gbgfx[0]);
+					   CurrentOptions.gbgfx[0]);
 		lex_FloatDeleteSecondRange(nGBGfxID, CurrentOptions.gbgfx[1],
-		    CurrentOptions.gbgfx[1]);
+					   CurrentOptions.gbgfx[1]);
 		lex_FloatDeleteSecondRange(nGBGfxID, CurrentOptions.gbgfx[2],
-		    CurrentOptions.gbgfx[2]);
+					   CurrentOptions.gbgfx[2]);
 		lex_FloatDeleteSecondRange(nGBGfxID, CurrentOptions.gbgfx[3],
-		    CurrentOptions.gbgfx[3]);
+					   CurrentOptions.gbgfx[3]);
 	}
 	if (nBinaryID != -1) {
 		lex_FloatDeleteRange(nBinaryID, CurrentOptions.binary[0],
-		    CurrentOptions.binary[0]);
+				     CurrentOptions.binary[0]);
 		lex_FloatDeleteRange(nBinaryID, CurrentOptions.binary[1],
-		    CurrentOptions.binary[1]);
+				     CurrentOptions.binary[1]);
 		lex_FloatDeleteSecondRange(nBinaryID, CurrentOptions.binary[0],
-		    CurrentOptions.binary[0]);
+					   CurrentOptions.binary[0]);
 		lex_FloatDeleteSecondRange(nBinaryID, CurrentOptions.binary[1],
-		    CurrentOptions.binary[1]);
+					   CurrentOptions.binary[1]);
 	}
 	CurrentOptions = *pOpt;
 
 	if (nGBGfxID != -1) {
 		lex_FloatAddRange(nGBGfxID, CurrentOptions.gbgfx[0],
-		    CurrentOptions.gbgfx[0]);
+				  CurrentOptions.gbgfx[0]);
 		lex_FloatAddRange(nGBGfxID, CurrentOptions.gbgfx[1],
-		    CurrentOptions.gbgfx[1]);
+				  CurrentOptions.gbgfx[1]);
 		lex_FloatAddRange(nGBGfxID, CurrentOptions.gbgfx[2],
-		    CurrentOptions.gbgfx[2]);
+				  CurrentOptions.gbgfx[2]);
 		lex_FloatAddRange(nGBGfxID, CurrentOptions.gbgfx[3],
-		    CurrentOptions.gbgfx[3]);
+				  CurrentOptions.gbgfx[3]);
 		lex_FloatAddSecondRange(nGBGfxID, CurrentOptions.gbgfx[0],
-		    CurrentOptions.gbgfx[0]);
+					CurrentOptions.gbgfx[0]);
 		lex_FloatAddSecondRange(nGBGfxID, CurrentOptions.gbgfx[1],
-		    CurrentOptions.gbgfx[1]);
+					CurrentOptions.gbgfx[1]);
 		lex_FloatAddSecondRange(nGBGfxID, CurrentOptions.gbgfx[2],
-		    CurrentOptions.gbgfx[2]);
+					CurrentOptions.gbgfx[2]);
 		lex_FloatAddSecondRange(nGBGfxID, CurrentOptions.gbgfx[3],
-		    CurrentOptions.gbgfx[3]);
+					CurrentOptions.gbgfx[3]);
 	}
 	if (nBinaryID != -1) {
 		lex_FloatAddRange(nBinaryID, CurrentOptions.binary[0],
-		    CurrentOptions.binary[0]);
+				  CurrentOptions.binary[0]);
 		lex_FloatAddRange(nBinaryID, CurrentOptions.binary[1],
-		    CurrentOptions.binary[1]);
+				  CurrentOptions.binary[1]);
 		lex_FloatAddSecondRange(nBinaryID, CurrentOptions.binary[0],
-		    CurrentOptions.binary[0]);
+					CurrentOptions.binary[0]);
 		lex_FloatAddSecondRange(nBinaryID, CurrentOptions.binary[1],
-		    CurrentOptions.binary[1]);
+					CurrentOptions.binary[1]);
 	}
 }
 
-void 
-opt_Parse(char *s)
+void opt_Parse(char *s)
 {
 	struct sOptions newopt;
 
@@ -120,8 +123,7 @@ opt_Parse(char *s)
 			newopt.gbgfx[2] = s[3];
 			newopt.gbgfx[3] = s[4];
 		} else {
-			errx(1, "Must specify exactly 4 characters for "
-			    "option 'g'");
+			errx(1, "Must specify exactly 4 characters for option 'g'");
 		}
 		break;
 	case 'b':
@@ -129,21 +131,18 @@ opt_Parse(char *s)
 			newopt.binary[0] = s[1];
 			newopt.binary[1] = s[2];
 		} else {
-			errx(1, "Must specify exactly 2 characters for option "
-			    "'b'");
+			errx(1, "Must specify exactly 2 characters for option 'b'");
 		}
 		break;
 	case 'z':
 		if (strlen(&s[1]) <= 2) {
-			int result;
+			int32_t result;
 
-			result = sscanf(&s[1], "%lx", &newopt.fillchar);
-			if (!((result == EOF) || (result == 1))) {
+			result = sscanf(&s[1], "%x", &newopt.fillchar);
+			if (!((result == EOF) || (result == 1)))
 				errx(1, "Invalid argument for option 'z'");
-			}
 		} else {
 			errx(1, "Invalid argument for option 'z'");
-			exit(1);
 		}
 		break;
 	default:
@@ -154,116 +153,123 @@ opt_Parse(char *s)
 	opt_SetCurrentOptions(&newopt);
 }
 
-void 
-opt_Push(void)
+void opt_Push(void)
 {
 	struct sOptionStackEntry *pOpt;
 
-	if ((pOpt = malloc(sizeof(struct sOptionStackEntry))) != NULL) {
-		pOpt->Options = CurrentOptions;
-		pOpt->pNext = pOptionStack;
-		pOptionStack = pOpt;
-	} else
+	pOpt = malloc(sizeof(struct sOptionStackEntry));
+
+	if (pOpt == NULL)
 		fatalerror("No memory for option stack");
+
+	pOpt->Options = CurrentOptions;
+	pOpt->pNext = pOptionStack;
+	pOptionStack = pOpt;
 }
 
-void 
-opt_Pop(void)
+void opt_Pop(void)
 {
-	if (pOptionStack) {
-		struct sOptionStackEntry *pOpt;
-
-		pOpt = pOptionStack;
-		opt_SetCurrentOptions(&(pOpt->Options));
-		pOptionStack = pOpt->pNext;
-		free(pOpt);
-	} else
+	if (pOptionStack == NULL)
 		fatalerror("No entries in the option stack");
+
+	struct sOptionStackEntry *pOpt;
+
+	pOpt = pOptionStack;
+	opt_SetCurrentOptions(&(pOpt->Options));
+	pOptionStack = pOpt->pNext;
+	free(pOpt);
 }
 
-void
-opt_AddDefine(char *s)
+void opt_AddDefine(char *s)
 {
 	char *value, *equals;
-	if(cldefines_index >= cldefines_size)
-	{
+
+	if (cldefines_index >= cldefines_size) {
 		cldefines_size *= 2;
 		cldefines = reallocarray(cldefines, cldefines_size,
-		                        2 * sizeof(void *));
-		if(!cldefines)
-		{
+					 2 * sizeof(void *));
+		if (!cldefines)
 			fatalerror("No memory for command line defines");
-		}
 	}
 	equals = strchr(s, '=');
-	if(equals)
-	{
+	if (equals) {
 		*equals = '\0';
 		value = equals + 1;
-	}
-	else
-	{
+	} else {
 		value = "1";
 	}
 	cldefines[cldefines_index++] = s;
 	cldefines[cldefines_index++] = value;
 }
 
-void
-opt_ParseDefines()
+static void opt_ParseDefines(void)
 {
-	int i;
+	int32_t i;
 
-	for(i = 0; i < cldefines_index; i += 2)
-	{
+	for (i = 0; i < cldefines_index; i += 2)
 		sym_AddString(cldefines[i], cldefines[i + 1]);
-	}
 }
 
 /*
  * Error handling
  */
-void
-verror(const char *fmt, va_list args)
+void verror(const char *fmt, va_list args)
 {
-	fprintf(stderr, "ERROR:\t");
+	fprintf(stderr, "ERROR: ");
 	fstk_Dump();
-	fprintf(stderr, " :\n\t");
+	fprintf(stderr, ":\n\t");
 	vfprintf(stderr, fmt, args);
 	fprintf(stderr, "\n");
 	nErrors += 1;
 }
 
-void 
-yyerror(const char *fmt, ...)
+void yyerror(const char *fmt, ...)
 {
 	va_list args;
+
 	va_start(args, fmt);
 	verror(fmt, args);
 	va_end(args);
 }
 
-void 
-fatalerror(const char *fmt, ...)
+void fatalerror(const char *fmt, ...)
 {
 	va_list args;
+
 	va_start(args, fmt);
 	verror(fmt, args);
 	va_end(args);
+
 	exit(5);
 }
 
-static void 
-usage(void)
+void warning(const char *fmt, ...)
+{
+	if (!CurrentOptions.warnings)
+		return;
+
+	va_list args;
+
+	va_start(args, fmt);
+
+	fprintf(stderr, "warning: ");
+	fstk_Dump();
+	fprintf(stderr, ":\n\t");
+	vfprintf(stderr, fmt, args);
+	fprintf(stderr, "\n");
+
+	va_end(args);
+}
+
+static void print_usage(void)
 {
 	printf(
-"Usage: rgbasm [-hvE] [-b chars] [-Dname[=value]] [-g chars] [-i path]\n"
-"              [-o outfile] [-p pad_value] file.asm\n");
+"usage: rgbasm [-EhVvw] [-b chars] [-Dname[=value]] [-g chars] [-i path]\n"
+"              [-M dependfile] [-o outfile] [-p pad_value] file.asm\n");
 	exit(1);
 }
 
-int 
-main(int argc, char *argv[])
+int main(int argc, char *argv[])
 {
 	int ch;
 	char *ep;
@@ -272,18 +278,15 @@ main(int argc, char *argv[])
 
 	char *tzMainfile;
 
+	dependfile = NULL;
+
 	cldefines_size = 32;
-	cldefines = reallocarray(cldefines, cldefines_size,
-	                        2 * sizeof(void *));
-	if(!cldefines)
-	{
+	cldefines = reallocarray(cldefines, cldefines_size, 2 * sizeof(void *));
+	if (!cldefines)
 		fatalerror("No memory for command line defines");
-	}
 
 	if (argc == 1)
-		usage();
-
-	progname = argv[0];
+		print_usage();
 
 	/* yydebug=1; */
 
@@ -297,25 +300,28 @@ main(int argc, char *argv[])
 	DefaultOptions.verbose = false;
 	DefaultOptions.haltnop = true;
 	DefaultOptions.exportall = false;
+	DefaultOptions.warnings = true;
 
 	opt_SetCurrentOptions(&DefaultOptions);
 
 	newopt = CurrentOptions;
 
-	while ((ch = getopt(argc, argv, "b:D:g:hi:o:p:vE")) != -1) {
+	while ((ch = getopt(argc, argv, "b:D:g:hi:M:o:p:EVvw")) != -1) {
 		switch (ch) {
 		case 'b':
 			if (strlen(optarg) == 2) {
 				newopt.binary[0] = optarg[1];
 				newopt.binary[1] = optarg[2];
 			} else {
-				errx(1, "Must specify exactly 2 characters for "
-				    "option 'b'");
+				errx(1, "Must specify exactly 2 characters for option 'b'");
 			}
 			break;
 		case 'D':
 			opt_AddDefine(optarg);
 			break;
+		case 'E':
+			newopt.exportall = true;
+			break;
 		case 'g':
 			if (strlen(optarg) == 4) {
 				newopt.gbgfx[0] = optarg[1];
@@ -323,8 +329,7 @@ main(int argc, char *argv[])
 				newopt.gbgfx[2] = optarg[3];
 				newopt.gbgfx[3] = optarg[4];
 			} else {
-				errx(1, "Must specify exactly 4 characters for "
-				    "option 'g'");
+				errx(1, "Must specify exactly 4 characters for option 'g'");
 			}
 			break;
 		case 'h':
@@ -332,28 +337,38 @@ main(int argc, char *argv[])
 			break;
 		case 'i':
 			fstk_AddIncludePath(optarg);
+			break;
+		case 'M':
+			dependfile = fopen(optarg, "w");
+			if (dependfile == NULL)
+				err(1, "Could not open dependfile %s", optarg);
+
 			break;
 		case 'o':
 			out_SetFileName(optarg);
 			break;
 		case 'p':
 			newopt.fillchar = strtoul(optarg, &ep, 0);
-			if (optarg[0] == '\0' || *ep != '\0') {
+
+			if (optarg[0] == '\0' || *ep != '\0')
 				errx(1, "Invalid argument for option 'p'");
-			}
-			if (newopt.fillchar < 0 || newopt.fillchar > 0xFF) {
-				errx(1, "Argument for option 'p' must be "
-				    "between 0 and 0xFF");
-			}
+
+			if (newopt.fillchar < 0 || newopt.fillchar > 0xFF)
+				errx(1, "Argument for option 'p' must be between 0 and 0xFF");
+
 			break;
+		case 'V':
+			printf("rgbasm %s\n", get_package_version_string());
+			exit(0);
 		case 'v':
 			newopt.verbose = true;
 			break;
-		case 'E':
-			newopt.exportall = true;
+		case 'w':
+			newopt.warnings = false;
 			break;
 		default:
-			usage();
+			print_usage();
+			/* NOTREACHED */
 		}
 	}
 	argc -= optind;
@@ -364,14 +379,20 @@ main(int argc, char *argv[])
 	DefaultOptions = CurrentOptions;
 
 	if (argc == 0)
-		usage();
+		print_usage();
 
 	tzMainfile = argv[argc - 1];
 
-	setuplex();
+	setup_lexer();
 
-	if (CurrentOptions.verbose) {
+	if (CurrentOptions.verbose)
 		printf("Assembling %s\n", tzMainfile);
+
+	if (dependfile) {
+		if (!tzObjectname)
+			errx(1, "Dependency files can only be created if an output object file is specified.\n");
+
+		fprintf(dependfile, "%s: %s\n", tzObjectname, tzMainfile);
 	}
 
 	nStartClock = clock();
@@ -379,6 +400,8 @@ main(int argc, char *argv[])
 	nLineNo = 1;
 	nTotalLines = 0;
 	nIFDepth = 0;
+	skipElif = true;
+	nUnionDepth = 0;
 	nPC = 0;
 	nPass = 1;
 	nErrors = 0;
@@ -387,24 +410,28 @@ main(int argc, char *argv[])
 	fstk_Init(tzMainfile);
 	opt_ParseDefines();
 
-	if (CurrentOptions.verbose) {
+	if (CurrentOptions.verbose)
 		printf("Pass 1...\n");
-	}
 
 	yy_set_state(LEX_STATE_NORMAL);
 	opt_SetCurrentOptions(&DefaultOptions);
 
-	if (yyparse() != 0 || nErrors != 0) {
+	if (yyparse() != 0 || nErrors != 0)
 		errx(1, "Assembly aborted in pass 1 (%ld errors)!", nErrors);
-	}
 
-	if (nIFDepth != 0) {
+	if (nIFDepth != 0)
 		errx(1, "Unterminated IF construct (%ld levels)!", nIFDepth);
+
+	if (nUnionDepth != 0) {
+		errx(1, "Unterminated UNION construct (%ld levels)!",
+		     nUnionDepth);
 	}
 
 	nTotalLines = 0;
 	nLineNo = 1;
 	nIFDepth = 0;
+	skipElif = true;
+	nUnionDepth = 0;
 	nPC = 0;
 	nPass = 2;
 	nErrors = 0;
@@ -415,27 +442,25 @@ main(int argc, char *argv[])
 	opt_SetCurrentOptions(&DefaultOptions);
 	opt_ParseDefines();
 
-	if (CurrentOptions.verbose) {
+	if (CurrentOptions.verbose)
 		printf("Pass 2...\n");
-	}
 
-	if (yyparse() != 0 || nErrors != 0) {
+	if (yyparse() != 0 || nErrors != 0)
 		errx(1, "Assembly aborted in pass 2 (%ld errors)!", nErrors);
-	}
 
 	double timespent;
 
 	nEndClock = clock();
 	timespent = ((double)(nEndClock - nStartClock))
-	    / (double)CLOCKS_PER_SEC;
+		     / (double)CLOCKS_PER_SEC;
 	if (CurrentOptions.verbose) {
-		printf("Success! %ld lines in %d.%02d seconds ", nTotalLines,
-		    (int) timespent, ((int) (timespent * 100.0)) % 100);
+		printf("Success! %u lines in %d.%02d seconds ", nTotalLines,
+		       (int)timespent, ((int)(timespent * 100.0)) % 100);
 		if (timespent == 0)
 			printf("(INFINITY lines/minute)\n");
 		else
 			printf("(%d lines/minute)\n",
-			    (int) (60 / timespent * nTotalLines));
+			       (int)(60 / timespent * nTotalLines));
 	}
 	out_WriteObject();
 	return 0;

src/asm/math.c

@@ -3,146 +3,132 @@
  */
 
 #include <math.h>
+#include <stdint.h>
 #include <stdio.h>
 
-#include "types.h"
 #include "asm/mymath.h"
 #include "asm/symbol.h"
 
-#define fix2double(i)	((double)(i/65536.0))
-#define double2fix(d)	((SLONG)(d*65536.0))
-#ifndef PI
-#define PI					(acos(-1))
+#define fx2double(i)	((double)((i) / 65536.0))
+#define double2fx(d)	((int32_t)((d) * 65536.0))
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
 #endif
 
 /*
  * Define the _PI symbol
  */
-void 
-math_DefinePI(void)
+void math_DefinePI(void)
 {
-	sym_AddEqu("_PI", double2fix(PI));
+	sym_AddEqu("_PI", double2fx(M_PI));
 }
 
 /*
  * Print a fixed point value
  */
-void 
-math_Print(SLONG i)
+void math_Print(int32_t i)
 {
 	if (i >= 0)
-		printf("%ld.%05ld", i >> 16,
-		    ((SLONG) (fix2double(i) * 100000 + 0.5)) % 100000);
+		printf("%d.%05d", i >> 16,
+		       ((int32_t)(fx2double(i) * 100000 + 0.5)) % 100000);
 	else
-		printf("-%ld.%05ld", (-i) >> 16,
-		    ((SLONG) (fix2double(-i) * 100000 + 0.5)) % 100000);
+		printf("-%d.%05d", (-i) >> 16,
+		       ((int32_t)(fx2double(-i) * 100000 + 0.5)) % 100000);
 }
 
 /*
  * Calculate sine
  */
-SLONG 
-math_Sin(SLONG i)
+int32_t math_Sin(int32_t i)
 {
-	return (double2fix(sin(fix2double(i) * 2 * PI / 65536)));
+	return double2fx(sin(fx2double(i) * 2 * M_PI / 65536));
 }
 
 /*
  * Calculate cosine
  */
-SLONG 
-math_Cos(SLONG i)
+int32_t math_Cos(int32_t i)
 {
-	return (double2fix(cos(fix2double(i) * 2 * PI / 65536)));
+	return double2fx(cos(fx2double(i) * 2 * M_PI / 65536));
 }
 
 /*
  * Calculate tangent
  */
-SLONG 
-math_Tan(SLONG i)
+int32_t math_Tan(int32_t i)
 {
-	return (double2fix(tan(fix2double(i) * 2 * PI / 65536)));
+	return double2fx(tan(fx2double(i) * 2 * M_PI / 65536));
 }
 
 /*
  * Calculate arcsine
  */
-SLONG 
-math_ASin(SLONG i)
+int32_t math_ASin(int32_t i)
 {
-	return (double2fix(asin(fix2double(i)) / 2 / PI * 65536));
+	return double2fx(asin(fx2double(i)) / 2 / M_PI * 65536);
 }
 
 /*
  * Calculate arccosine
  */
-SLONG 
-math_ACos(SLONG i)
+int32_t math_ACos(int32_t i)
 {
-	return (double2fix(acos(fix2double(i)) / 2 / PI * 65536));
+	return double2fx(acos(fx2double(i)) / 2 / M_PI * 65536);
 }
 
 /*
  * Calculate arctangent
  */
-SLONG 
-math_ATan(SLONG i)
+int32_t math_ATan(int32_t i)
 {
-	return (double2fix(atan(fix2double(i)) / 2 / PI * 65536));
+	return double2fx(atan(fx2double(i)) / 2 / M_PI * 65536);
 }
 
 /*
  * Calculate atan2
  */
-SLONG 
-math_ATan2(SLONG i, SLONG j)
+int32_t math_ATan2(int32_t i, int32_t j)
 {
-	return (double2fix
-	    (atan2(fix2double(i), fix2double(j)) / 2 / PI * 65536));
+	return double2fx(atan2(fx2double(i), fx2double(j)) / 2 / M_PI * 65536);
 }
 
 /*
  * Multiplication
  */
-SLONG 
-math_Mul(SLONG i, SLONG j)
+int32_t math_Mul(int32_t i, int32_t j)
 {
-	return (double2fix(fix2double(i) * fix2double(j)));
+	return double2fx(fx2double(i) * fx2double(j));
 }
 
 /*
  * Division
  */
-SLONG 
-math_Div(SLONG i, SLONG j)
+int32_t math_Div(int32_t i, int32_t j)
 {
-	return (double2fix(fix2double(i) / fix2double(j)));
+	return double2fx(fx2double(i) / fx2double(j));
 }
 
 /*
  * Round
  */
-SLONG 
-math_Round(SLONG i)
+int32_t math_Round(int32_t i)
 {
-	return double2fix(round(fix2double(i)));
+	return double2fx(round(fx2double(i)));
 }
 
 /*
  * Ceil
  */
-SLONG 
-math_Ceil(SLONG i)
+int32_t math_Ceil(int32_t i)
 {
-	return double2fix(ceil(fix2double(i)));
+	return double2fx(ceil(fx2double(i)));
 }
 
 /*
  * Floor
  */
-SLONG 
-math_Floor(SLONG i)
+int32_t math_Floor(int32_t i)
 {
-	return double2fix(floor(fix2double(i)));
+	return double2fx(floor(fx2double(i)));
 }

src/asm/rgbasm.1

@@ -1,4 +1,18 @@
-.Dd February 26, 2015
+.\" Copyright © 2010 Anthony J. Bentley <anthony@anjbe.name>
+.\"
+.\" Permission to use, copy, modify, and distribute this software for any
+.\" purpose with or without fee is hereby granted, provided that the above
+.\" copyright notice and this permission notice appear in all copies.
+.\"
+.\" THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+.\" WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+.\" MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+.\" ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+.\" WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+.\" ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+.\" OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+.\"
+.Dd April 17, 2017
 .Dt RGBASM 1
 .Os RGBDS Manual
 .Sh NAME
@@ -6,11 +20,12 @@
 .Nd Game Boy assembler
 .Sh SYNOPSIS
 .Nm rgbasm
-.Op Fl Ehv
+.Op Fl EhVvw
 .Op Fl b Ar chars
 .Op Fl D Ar name Ns Op = Ns Ar value
 .Op Fl g Ar chars
 .Op Fl i Ar path
+.Op Fl M Ar dependfile
 .Op Fl o Ar outfile
 .Op Fl p Ar pad_value
 .Ar file
@@ -47,13 +62,22 @@ The
 option disables this behavior.
 .It Fl i Ar path
 Add an include path.
+.It Fl M Ar dependfile
+Print
+.Xr make 1
+dependencies to
+.Ar dependfile .
 .It Fl o Ar outfile
 Write an object file to the given filename.
 .It Fl p Ar pad_value
 When padding an image, pad with this value.
 The default is 0x00.
+.It Fl V
+Print the version of the program and exit.
 .It Fl v
 Be verbose.
+.It Fl w
+Disable warning output.
 .El
 .Sh EXAMPLES
 Assembling a basic source file is simple:
@@ -66,12 +90,15 @@ run through
 and
 .Xr rgbfix 1 .
 .Sh SEE ALSO
+.Xr rgbasm 5 ,
 .Xr rgbfix 1 ,
 .Xr rgblink 1 ,
-.Xr rgbds 7
-.Pp
-.Lk https://rednex.github.io/rgbds/asm.htm rgbasm assembly commands
+.Xr rgbds 5 ,
+.Xr rgbds 7 ,
+.Xr gbz80 7
 .Sh HISTORY
 .Nm
 was originally written by Carsten S\(/orensen as part of the ASMotor package,
-and was later packaged in RGBDS by Justin Lloyd.
+and was later packaged in RGBDS by Justin Lloyd. It is now maintained by a
+number of contributors at
+.Lk https://github.com/rednex/rgbds .

src/asm/rpn.c

@@ -2,19 +2,19 @@
  * Controls RPN expressions for objectfiles
  */
 
+#include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
-#include "asm/mylink.h"
-#include "types.h"
-#include "asm/symbol.h"
 #include "asm/asm.h"
 #include "asm/main.h"
 #include "asm/rpn.h"
+#include "asm/symbol.h"
 
-void 
-mergetwoexpressions(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+#include "linkdefs.h"
+
+void mergetwoexpressions(struct Expression *expr, const struct Expression *src1,
+			 const struct Expression *src2)
 {
 	*expr = *src1;
 	memcpy(&(expr->tRPN[expr->nRPNLength]), src2->tRPN, src2->nRPNLength);
@@ -23,13 +23,13 @@ mergetwoexpressions(struct Expression * expr, struct Expression * src1,
 	expr->isReloc |= src2->isReloc;
 	expr->isPCRel |= src2->isPCRel;
 }
-#define joinexpr() mergetwoexpressions(expr,src1,src2)
+
+#define joinexpr() mergetwoexpressions(expr, src1, src2)
 
 /*
  * Add a byte to the RPN expression
  */
-void 
-pushbyte(struct Expression * expr, int b)
+void pushbyte(struct Expression *expr, int b)
 {
 	expr->tRPN[expr->nRPNLength++] = b & 0xFF;
 }
@@ -37,47 +37,45 @@ pushbyte(struct Expression * expr, int b)
 /*
  * Reset the RPN module
  */
-void 
-rpn_Reset(struct Expression * expr)
+void rpn_Reset(struct Expression *expr)
 {
-	expr->nRPNLength = expr->nRPNOut = expr->isReloc = expr->isPCRel = 0;
+	expr->nRPNLength = 0;
+	expr->nRPNOut = 0;
+	expr->isReloc = 0;
+	expr->isPCRel = 0;
 }
 
 /*
  * Returns the next rpn byte in expression
  */
-UWORD 
-rpn_PopByte(struct Expression * expr)
+uint16_t rpn_PopByte(struct Expression *expr)
 {
-	if (expr->nRPNOut == expr->nRPNLength) {
-		return (0xDEAD);
-	} else
-		return (expr->tRPN[expr->nRPNOut++]);
+	if (expr->nRPNOut == expr->nRPNLength)
+		return 0xDEAD;
+
+	return expr->tRPN[expr->nRPNOut++];
 }
 
 /*
  * Determine if the current expression is relocatable
  */
-ULONG 
-rpn_isReloc(struct Expression * expr)
+uint32_t rpn_isReloc(const struct Expression *expr)
 {
-	return (expr->isReloc);
+	return expr->isReloc;
 }
 
 /*
  * Determine if the current expression can be pc-relative
  */
-ULONG 
-rpn_isPCRelative(struct Expression * expr)
+uint32_t rpn_isPCRelative(const struct Expression *expr)
 {
-	return (expr->isPCRel);
+	return expr->isPCRel;
 }
 
 /*
  * Add symbols, constants and operators to expression
  */
-void 
-rpn_Number(struct Expression * expr, ULONG i)
+void rpn_Number(struct Expression *expr, uint32_t i)
 {
 	rpn_Reset(expr);
 	pushbyte(expr, RPN_CONST);
@@ -88,11 +86,10 @@ rpn_Number(struct Expression * expr, ULONG i)
 	expr->nVal = i;
 }
 
-void 
-rpn_Symbol(struct Expression * expr, char *tzSym)
+void rpn_Symbol(struct Expression *expr, char *tzSym)
 {
 	if (!sym_isConstant(tzSym)) {
-		struct sSymbol *psym;
+		const struct sSymbol *psym;
 
 		rpn_Reset(expr);
 
@@ -106,244 +103,277 @@ rpn_Symbol(struct Expression * expr, char *tzSym)
 		while (*tzSym)
 			pushbyte(expr, *tzSym++);
 		pushbyte(expr, 0);
-	} else
-		rpn_Number(expr, sym_GetConstantValue(tzSym));
-}
-
-void 
-rpn_Bank(struct Expression * expr, char *tzSym)
-{
-	if (!sym_isConstant(tzSym)) {
-		rpn_Reset(expr);
-
-		/* Check that the symbol exists by evaluating and discarding the value. */
-		sym_GetValue(tzSym);
-
-		expr->isReloc = 1;
-		pushbyte(expr, RPN_BANK);
-		while (*tzSym)
-			pushbyte(expr, *tzSym++);
-		pushbyte(expr, 0);
-	} else
-		yyerror("BANK argument must be a relocatable identifier");
-}
-
-int 
-rpn_RangeCheck(struct Expression * expr, struct Expression * src, SLONG low,
-    SLONG high)
-{
-	*expr = *src;
-
-	if (rpn_isReloc(src)) {
-		pushbyte(expr, RPN_RANGECHECK);
-		pushbyte(expr, low);
-		pushbyte(expr, low >> 8);
-		pushbyte(expr, low >> 16);
-		pushbyte(expr, low >> 24);
-		pushbyte(expr, high);
-		pushbyte(expr, high >> 8);
-		pushbyte(expr, high >> 16);
-		pushbyte(expr, high >> 24);
-		return (1);
 	} else {
-		return (expr->nVal >= low && expr->nVal <= high);
+		rpn_Number(expr, sym_GetConstantValue(tzSym));
 	}
 }
 
-void 
-rpn_CheckHRAM(struct Expression * expr, struct Expression * src)
+void rpn_BankSelf(struct Expression *expr)
+{
+	rpn_Reset(expr);
+
+	/*
+	 * This symbol is not really relocatable, but this makes the assembler
+	 * write this expression as a RPN patch to the object file.
+	 */
+	expr->isReloc = 1;
+
+	pushbyte(expr, RPN_BANK_SELF);
+}
+
+void rpn_BankSymbol(struct Expression *expr, char *tzSym)
+{
+	/* The @ symbol is treated differently. */
+	if (sym_FindSymbol(tzSym) == pPCSymbol) {
+		rpn_BankSelf(expr);
+		return;
+	}
+
+	if (!sym_isConstant(tzSym)) {
+		rpn_Reset(expr);
+
+		/*
+		 * Check that the symbol exists by evaluating and discarding the
+		 * value.
+		 */
+		sym_GetValue(tzSym);
+
+		expr->isReloc = 1;
+		pushbyte(expr, RPN_BANK_SYM);
+		while (*tzSym)
+			pushbyte(expr, *tzSym++);
+		pushbyte(expr, 0);
+	} else {
+		yyerror("BANK argument must be a relocatable identifier");
+	}
+}
+
+void rpn_BankSection(struct Expression *expr, char *tzSectionName)
+{
+	rpn_Reset(expr);
+
+	/*
+	 * This symbol is not really relocatable, but this makes the assembler
+	 * write this expression as a RPN patch to the object file.
+	 */
+	expr->isReloc = 1;
+
+	pushbyte(expr, RPN_BANK_SECT);
+	while (*tzSectionName)
+		pushbyte(expr, *tzSectionName++);
+	pushbyte(expr, 0);
+}
+
+void rpn_CheckHRAM(struct Expression *expr, const struct Expression *src)
 {
 	*expr = *src;
 	pushbyte(expr, RPN_HRAM);
 }
 
-void 
-rpn_LOGNOT(struct Expression * expr, struct Expression * src)
+void rpn_LOGNOT(struct Expression *expr, const struct Expression *src)
 {
 	*expr = *src;
 	pushbyte(expr, RPN_LOGUNNOT);
 }
 
-void 
-rpn_LOGOR(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_LOGOR(struct Expression *expr, const struct Expression *src1,
+	       const struct Expression *src2)
 {
 	joinexpr();
 	expr->nVal = (expr->nVal || src2->nVal);
 	pushbyte(expr, RPN_LOGOR);
 }
 
-void 
-rpn_LOGAND(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_LOGAND(struct Expression *expr, const struct Expression *src1,
+		const struct Expression *src2)
 {
 	joinexpr();
 	expr->nVal = (expr->nVal && src2->nVal);
 	pushbyte(expr, RPN_LOGAND);
 }
 
-void 
-rpn_LOGEQU(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_HIGH(struct Expression *expr, const struct Expression *src)
+{
+	*expr = *src;
+
+	expr->nVal = (expr->nVal >> 8) & 0xFF;
+
+	pushbyte(expr, RPN_CONST);
+	pushbyte(expr, 8);
+	pushbyte(expr, 0);
+	pushbyte(expr, 0);
+	pushbyte(expr, 0);
+
+	pushbyte(expr, RPN_SHR);
+
+	pushbyte(expr, RPN_CONST);
+	pushbyte(expr, 0xFF);
+	pushbyte(expr, 0);
+	pushbyte(expr, 0);
+	pushbyte(expr, 0);
+
+	pushbyte(expr, RPN_AND);
+}
+
+void rpn_LOW(struct Expression *expr, const struct Expression *src)
+{
+	*expr = *src;
+
+	expr->nVal = expr->nVal & 0xFF;
+
+	pushbyte(expr, RPN_CONST);
+	pushbyte(expr, 0xFF);
+	pushbyte(expr, 0);
+	pushbyte(expr, 0);
+	pushbyte(expr, 0);
+
+	pushbyte(expr, RPN_AND);
+}
+
+void rpn_LOGEQU(struct Expression *expr, const struct Expression *src1,
+		const struct Expression *src2)
 {
 	joinexpr();
 	expr->nVal = (expr->nVal == src2->nVal);
 	pushbyte(expr, RPN_LOGEQ);
 }
 
-void 
-rpn_LOGGT(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_LOGGT(struct Expression *expr, const struct Expression *src1,
+	       const struct Expression *src2)
 {
 	joinexpr();
 	expr->nVal = (expr->nVal > src2->nVal);
 	pushbyte(expr, RPN_LOGGT);
 }
 
-void 
-rpn_LOGLT(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_LOGLT(struct Expression *expr, const struct Expression *src1,
+	       const struct Expression *src2)
 {
 	joinexpr();
 	expr->nVal = (expr->nVal < src2->nVal);
 	pushbyte(expr, RPN_LOGLT);
 }
 
-void 
-rpn_LOGGE(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_LOGGE(struct Expression *expr, const struct Expression *src1,
+	       const struct Expression *src2)
 {
 	joinexpr();
 	expr->nVal = (expr->nVal >= src2->nVal);
 	pushbyte(expr, RPN_LOGGE);
 }
 
-void 
-rpn_LOGLE(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_LOGLE(struct Expression *expr, const struct Expression *src1,
+	       const struct Expression *src2)
 {
 	joinexpr();
 	expr->nVal = (expr->nVal <= src2->nVal);
 	pushbyte(expr, RPN_LOGLE);
 }
 
-void 
-rpn_LOGNE(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_LOGNE(struct Expression *expr, const struct Expression *src1,
+	       const struct Expression *src2)
 {
 	joinexpr();
 	expr->nVal = (expr->nVal != src2->nVal);
 	pushbyte(expr, RPN_LOGNE);
 }
 
-void 
-rpn_ADD(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_ADD(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2)
 {
 	joinexpr();
 	expr->nVal = (expr->nVal + src2->nVal);
 	pushbyte(expr, RPN_ADD);
 }
 
-void 
-rpn_SUB(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_SUB(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2)
 {
 	joinexpr();
 	expr->nVal = (expr->nVal - src2->nVal);
 	pushbyte(expr, RPN_SUB);
 }
 
-void 
-rpn_XOR(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_XOR(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2)
 {
 	joinexpr();
 	expr->nVal = (expr->nVal ^ src2->nVal);
 	pushbyte(expr, RPN_XOR);
 }
 
-void 
-rpn_OR(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_OR(struct Expression *expr, const struct Expression *src1,
+	    const struct Expression *src2)
 {
 	joinexpr();
 	expr->nVal = (expr->nVal | src2->nVal);
 	pushbyte(expr, RPN_OR);
 }
 
-void 
-rpn_AND(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_AND(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2)
 {
 	joinexpr();
 	expr->nVal = (expr->nVal & src2->nVal);
 	pushbyte(expr, RPN_AND);
 }
 
-void 
-rpn_SHL(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_SHL(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2)
 {
 	joinexpr();
 	expr->nVal = (expr->nVal << src2->nVal);
 	pushbyte(expr, RPN_SHL);
 }
 
-void 
-rpn_SHR(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_SHR(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2)
 {
 	joinexpr();
 	expr->nVal = (expr->nVal >> src2->nVal);
 	pushbyte(expr, RPN_SHR);
 }
 
-void 
-rpn_MUL(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_MUL(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2)
 {
 	joinexpr();
 	expr->nVal = (expr->nVal * src2->nVal);
 	pushbyte(expr, RPN_MUL);
 }
 
-void 
-rpn_DIV(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_DIV(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2)
 {
 	joinexpr();
-	if (src2->nVal == 0) {
+	if (src2->nVal == 0)
 		fatalerror("division by zero");
-	}
+
 	expr->nVal = (expr->nVal / src2->nVal);
 	pushbyte(expr, RPN_DIV);
 }
 
-void 
-rpn_MOD(struct Expression * expr, struct Expression * src1,
-    struct Expression * src2)
+void rpn_MOD(struct Expression *expr, const struct Expression *src1,
+	     const struct Expression *src2)
 {
 	joinexpr();
-	if (src2->nVal == 0) {
+	if (src2->nVal == 0)
 		fatalerror("division by zero");
-	}
+
 	expr->nVal = (expr->nVal % src2->nVal);
 	pushbyte(expr, RPN_MOD);
 }
 
-void 
-rpn_UNNEG(struct Expression * expr, struct Expression * src)
+void rpn_UNNEG(struct Expression *expr, const struct Expression *src)
 {
 	*expr = *src;
 	expr->nVal = -expr->nVal;
 	pushbyte(expr, RPN_UNSUB);
 }
 
-void 
-rpn_UNNOT(struct Expression * expr, struct Expression * src)
+void rpn_UNNOT(struct Expression *expr, const struct Expression *src)
 {
 	*expr = *src;
-	expr->nVal = expr->nVal ^ 0xFFFFFFFF;
+	expr->nVal = ~expr->nVal;
 	pushbyte(expr, RPN_UNNOT);
 }

src/extern/err.c

@@ -21,45 +21,59 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#include <stdio.h>
 #include <stdarg.h>
+#include <stdio.h>
 #include <stdlib.h>
-#include "extern/err.h"
 
-extern char *progname;
+#include "extern/err.h"
 
 void rgbds_vwarn(const char *fmt, va_list ap)
 {
-	fprintf (stderr, "%s: ", progname);
+	fprintf(stderr, "warning");
 	if (fmt) {
+		fputs(": ", stderr);
 		vfprintf(stderr, fmt, ap);
-		fputs (": ", stderr);
 	}
+	putc('\n', stderr);
 	perror(0);
 }
 
 void rgbds_vwarnx(const char *fmt, va_list ap)
 {
-	fprintf (stderr, "%s: ", progname);
-	if (fmt) vfprintf(stderr, fmt, ap);
+	fprintf(stderr, "warning");
+	if (fmt) {
+		fputs(": ", stderr);
+		vfprintf(stderr, fmt, ap);
+	}
 	putc('\n', stderr);
 }
 
 noreturn void rgbds_verr(int status, const char *fmt, va_list ap)
 {
-	vwarn(fmt, ap);
+	fprintf(stderr, "error");
+	if (fmt) {
+		fputs(": ", stderr);
+		vfprintf(stderr, fmt, ap);
+	}
+	putc('\n', stderr);
 	exit(status);
 }
 
 noreturn void rgbds_verrx(int status, const char *fmt, va_list ap)
 {
-	vwarnx(fmt, ap);
+	fprintf(stderr, "error");
+	if (fmt) {
+		fputs(": ", stderr);
+		vfprintf(stderr, fmt, ap);
+	}
+	putc('\n', stderr);
 	exit(status);
 }
 
 void rgbds_warn(const char *fmt, ...)
 {
 	va_list ap;
+
 	va_start(ap, fmt);
 	vwarn(fmt, ap);
 	va_end(ap);
@@ -68,6 +82,7 @@ void rgbds_warn(const char *fmt, ...)
 void rgbds_warnx(const char *fmt, ...)
 {
 	va_list ap;
+
 	va_start(ap, fmt);
 	vwarnx(fmt, ap);
 	va_end(ap);
@@ -76,6 +91,7 @@ void rgbds_warnx(const char *fmt, ...)
 noreturn void rgbds_err(int status, const char *fmt, ...)
 {
 	va_list ap;
+
 	va_start(ap, fmt);
 	verr(status, fmt, ap);
 	va_end(ap);
@@ -84,6 +100,7 @@ noreturn void rgbds_err(int status, const char *fmt, ...)
 noreturn void rgbds_errx(int status, const char *fmt, ...)
 {
 	va_list ap;
+
 	va_start(ap, fmt);
 	verrx(status, fmt, ap);
 	va_end(ap);

src/extern/reallocarray.c

@@ -1,4 +1,4 @@
-/*	$OpenBSD: reallocarray.c,v 1.2 2014/12/08 03:45:00 bcook Exp $	*/
+/* $OpenBSD: reallocarray.c,v 1.2 2014/12/08 03:45:00 bcook Exp $ */
 /*
  * Copyright (c) 2008 Otto Moerbeek <otto@drijf.net>
  *
@@ -15,22 +15,21 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-#include <sys/types.h>
 #include <errno.h>
 #include <stdint.h>
 #include <stdlib.h>
+#include <sys/types.h>
 
 /*
  * This is sqrt(SIZE_MAX+1), as s1*s2 <= SIZE_MAX
  * if both s1 < MUL_NO_OVERFLOW and s2 < MUL_NO_OVERFLOW
  */
-#define MUL_NO_OVERFLOW	((size_t)1 << (sizeof(size_t) * 4))
+#define MUL_NO_OVERFLOW ((size_t)1 << (sizeof(size_t) * 4))
 
-void *
-rgbds_reallocarray(void *optr, size_t nmemb, size_t size)
+void *rgbds_reallocarray(void *optr, size_t nmemb, size_t size)
 {
-	if ((nmemb >= MUL_NO_OVERFLOW || size >= MUL_NO_OVERFLOW) &&
-	    nmemb > 0 && SIZE_MAX / nmemb < size) {
+	if (((nmemb >= MUL_NO_OVERFLOW) || (size >= MUL_NO_OVERFLOW)) &&
+	    (nmemb > 0) && (SIZE_MAX / nmemb < size)) {
 		errno = ENOMEM;
 		return NULL;
 	}

src/extern/strlcat.c

@@ -1,4 +1,4 @@
-/*	$OpenBSD: strlcat.c,v 1.14 2015/01/15 03:54:12 millert Exp $	*/
+/* $OpenBSD: strlcat.c,v 1.14 2015/01/15 03:54:12 millert Exp $ */
 
 /*
  * Copyright (c) 1998, 2015 Todd C. Miller <Todd.Miller@courtesan.com>
@@ -16,8 +16,8 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-#include <sys/types.h>
 #include <string.h>
+#include <sys/types.h>
 
 /*
  * Appends src to string dst of size dsize (unlike strncat, dsize is the
@@ -26,8 +26,7 @@
  * Returns strlen(src) + MIN(dsize, strlen(initial dst)).
  * If retval >= dsize, truncation occurred.
  */
-size_t
-rgbds_strlcat(char *dst, const char *src, size_t dsize)
+size_t rgbds_strlcat(char *dst, const char *src, size_t dsize)
 {
 	const char *odst = dst;
 	const char *osrc = src;
@@ -51,5 +50,5 @@ rgbds_strlcat(char *dst, const char *src, size_t dsize)
 	}
 	*dst = '\0';
 
-	return(dlen + (src - osrc));	/* count does not include NUL */
+	return dlen + (src - osrc); /* count does not include NUL */
 }

src/extern/strlcpy.c

@@ -1,4 +1,4 @@
-/*	$OpenBSD: strlcpy.c,v 1.12 2015/01/15 03:54:12 millert Exp $	*/
+/* $OpenBSD: strlcpy.c,v 1.12 2015/01/15 03:54:12 millert Exp $ */
 
 /*
  * Copyright (c) 1998, 2015 Todd C. Miller <Todd.Miller@courtesan.com>
@@ -16,16 +16,15 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-#include <sys/types.h>
 #include <string.h>
+#include <sys/types.h>
 
 /*
  * Copy string src to buffer dst of size dsize.  At most dsize-1
  * chars will be copied.  Always NUL terminates (unless dsize == 0).
  * Returns strlen(src); if retval >= dsize, truncation occurred.
  */
-size_t
-rgbds_strlcpy(char *dst, const char *src, size_t dsize)
+size_t rgbds_strlcpy(char *dst, const char *src, size_t dsize)
 {
 	const char *osrc = src;
 	size_t nleft = dsize;
@@ -33,7 +32,10 @@ rgbds_strlcpy(char *dst, const char *src, size_t dsize)
 	/* Copy as many bytes as will fit. */
 	if (nleft != 0) {
 		while (--nleft != 0) {
-			if ((*dst++ = *src++) == '\0')
+			char n = *src++;
+			*dst++ = n;
+
+			if (n == '\0')
 				break;
 		}
 	}
@@ -41,10 +43,10 @@ rgbds_strlcpy(char *dst, const char *src, size_t dsize)
 	/* Not enough room in dst, add NUL and traverse rest of src. */
 	if (nleft == 0) {
 		if (dsize != 0)
-			*dst = '\0';		/* NUL-terminate dst */
+			*dst = '\0'; /* NUL-terminate dst */
 		while (*src++)
 			;
 	}
 
-	return(src - osrc - 1);	/* count does not include NUL */
+	return (src - osrc - 1); /* count does not include NUL */
 }

src/extern/version.c

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2017 Antonio Nino Diaz <antonio_nd@outlook.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "extern/version.h"
+
+const char *get_package_version_string(void)
+{
+	static char s[50];
+
+	/* The following conditional should be simplified by the compiler. */
+	if (strlen(BUILD_VERSION_STRING) == 0) {
+		snprintf(s, sizeof(s), "v%d.%d.%d", PACKAGE_VERSION_MAJOR,
+			 PACKAGE_VERSION_MINOR, PACKAGE_VERSION_PATCH);
+		return s;
+	} else {
+		return BUILD_VERSION_STRING;
+	}
+}

src/fix/main.c

@@ -22,21 +22,18 @@
 #include <unistd.h>
 
 #include "extern/err.h"
+#include "extern/version.h"
 
-char *progname;
-
-static void
-usage(void)
+static void print_usage(void)
 {
 	printf(
-"usage: rgbfix [-Ccjsv] [-i game_id] [-k licensee_str] [-l licensee_id]\n"
+"usage: rgbfix [-CcjsVv] [-i game_id] [-k licensee_str] [-l licensee_id]\n"
 "              [-m mbc_type] [-n rom_version] [-p pad_value] [-r ram_size]\n"
 "              [-t title_str] file\n");
 	exit(1);
 }
 
-int
-main(int argc, char *argv[])
+int main(int argc, char *argv[])
 {
 	FILE *rom;
 	int ch;
@@ -65,15 +62,13 @@ main(int argc, char *argv[])
 	char *id; /* game ID in ASCII */
 	char *newlicensee; /* new licensee ID, two ASCII characters */
 
-	int licensee;  /* old licensee ID */
-	int cartridge; /* cartridge hardware ID */
-	int ramsize;   /* RAM size ID */
-	int version;   /* mask ROM version number */
-	int padvalue;  /* to pad the rom with if it changes size */
+	int licensee = 0;  /* old licensee ID */
+	int cartridge = 0; /* cartridge hardware ID */
+	int ramsize = 0;   /* RAM size ID */
+	int version = 0;   /* mask ROM version number */
+	int padvalue = 0;  /* to pad the rom with if it changes size */
 
-	progname = argv[0];
-
-	while ((ch = getopt(argc, argv, "Cci:jk:l:m:n:p:sr:t:v")) != -1) {
+	while ((ch = getopt(argc, argv, "Cci:jk:l:m:n:p:sr:t:Vv")) != -1) {
 		switch (ch) {
 		case 'C':
 			coloronly = true;
@@ -84,10 +79,9 @@ main(int argc, char *argv[])
 		case 'i':
 			setid = true;
 
-			if (strlen(optarg) != 4) {
-				errx(1, "Game ID %s must be exactly 4 "
-				    "characters", optarg);
-			}
+			if (strlen(optarg) != 4)
+				errx(1, "Game ID %s must be exactly 4 characters",
+				     optarg);
 
 			id = optarg;
 			break;
@@ -97,10 +91,9 @@ main(int argc, char *argv[])
 		case 'k':
 			setnewlicensee = true;
 
-			if (strlen(optarg) != 2) {
-				errx(1, "New licensee code %s is not the "
-				    "correct length of 2 characters", optarg);
-			}
+			if (strlen(optarg) != 2)
+				errx(1, "New licensee code %s is not the correct length of 2 characters",
+				     optarg);
 
 			newlicensee = optarg;
 			break;
@@ -108,61 +101,59 @@ main(int argc, char *argv[])
 			setlicensee = true;
 
 			licensee = strtoul(optarg, &ep, 0);
-			if (optarg[0] == '\0' || *ep != '\0') {
+			if (optarg[0] == '\0' || *ep != '\0')
 				errx(1, "Invalid argument for option 'l'");
-			}
-			if (licensee < 0 || licensee > 0xFF) {
-				errx(1, "Argument for option 'l' must be "
-				    "between 0 and 255");
-			}
+
+			if (licensee < 0 || licensee > 0xFF)
+				errx(1, "Argument for option 'l' must be between 0 and 255");
+
 			break;
 		case 'm':
 			setcartridge = true;
 
 			cartridge = strtoul(optarg, &ep, 0);
-			if (optarg[0] == '\0' || *ep != '\0') {
+			if (optarg[0] == '\0' || *ep != '\0')
 				errx(1, "Invalid argument for option 'm'");
-			}
-			if (cartridge < 0 || cartridge > 0xFF) {
-				errx(1, "Argument for option 'm' must be "
-				    "between 0 and 255");
-			}
+
+			if (cartridge < 0 || cartridge > 0xFF)
+				errx(1, "Argument for option 'm' must be between 0 and 255");
+
 			break;
 		case 'n':
 			setversion = true;
 
 			version = strtoul(optarg, &ep, 0);
-			if (optarg[0] == '\0' || *ep != '\0') {
+
+			if (optarg[0] == '\0' || *ep != '\0')
 				errx(1, "Invalid argument for option 'n'");
-			}
-			if (version < 0 || version > 0xFF) {
-				errx(1, "Argument for option 'n' must be "
-				    "between 0 and 255");
-			}
+
+			if (version < 0 || version > 0xFF)
+				errx(1, "Argument for option 'n' must be between 0 and 255");
+
 			break;
 		case 'p':
 			resize = true;
 
 			padvalue = strtoul(optarg, &ep, 0);
-			if (optarg[0] == '\0' || *ep != '\0') {
+
+			if (optarg[0] == '\0' || *ep != '\0')
 				errx(1, "Invalid argument for option 'p'");
-			}
-			if (padvalue < 0 || padvalue > 0xFF) {
-				errx(1, "Argument for option 'p' must be "
-				    "between 0 and 255");
-			}
+
+			if (padvalue < 0 || padvalue > 0xFF)
+				errx(1, "Argument for option 'p' must be between 0 and 255");
+
 			break;
 		case 'r':
 			setramsize = true;
 
 			ramsize = strtoul(optarg, &ep, 0);
-			if (optarg[0] == '\0' || *ep != '\0') {
+
+			if (optarg[0] == '\0' || *ep != '\0')
 				errx(1, "Invalid argument for option 'r'");
-			}
-			if (ramsize < 0 || ramsize > 0xFF) {
-				errx(1, "Argument for option 'r' must be "
-				    "between 0 and 255");
-			}
+
+			if (ramsize < 0 || ramsize > 0xFF)
+				errx(1, "Argument for option 'r' must be between 0 and 255");
+
 			break;
 		case 's':
 			super = true;
@@ -170,22 +161,24 @@ main(int argc, char *argv[])
 		case 't':
 			settitle = true;
 
-			if (strlen(optarg) > 16) {
-				errx(1, "Title %s is greater than the "
-				    "maximum of 16 characters", optarg);
-			}
+			if (strlen(optarg) > 16)
+				errx(1, "Title \"%s\" is greater than the maximum of 16 characters",
+				     optarg);
 
 			if (strlen(optarg) == 16)
-				warnx("Title %s is 16 chars, it is best to "
-				    "keep it to 15 or fewer", optarg);
+				warnx("Title \"%s\" is 16 chars, it is best to keep it to 15 or fewer",
+				      optarg);
 
 			title = optarg;
 			break;
+		case 'V':
+			printf("rgbfix %s\n", get_package_version_string());
+			exit(0);
 		case 'v':
 			validate = true;
 			break;
 		default:
-			usage();
+			print_usage();
 			/* NOTREACHED */
 		}
 	}
@@ -194,15 +187,16 @@ main(int argc, char *argv[])
 	argv += optind;
 
 	if (argc == 0)
-		usage();
+		print_usage();
 
 	/*
 	 * Open the ROM file
 	 */
 
-	if ((rom = fopen(argv[argc - 1], "rb+")) == NULL) {
+	rom = fopen(argv[argc - 1], "rb+");
+
+	if (rom == NULL)
 		err(1, "Error opening file %s", argv[argc - 1]);
-	}
 
 	/*
 	 * Write changes to ROM
@@ -266,7 +260,7 @@ main(int argc, char *argv[])
 		 * characters).
 		 */
 
-		fseek(rom,0x13F,SEEK_SET);
+		fseek(rom, 0x13F, SEEK_SET);
 		fwrite(id, 1, 4, rom);
 	}
 
@@ -332,8 +326,7 @@ main(int argc, char *argv[])
 		 */
 
 		if (!setlicensee)
-			warnx("You should probably set both '-s' and "
-			    "'-l 0x33'");
+			warnx("You should probably set both '-s' and '-l 0x33'");
 
 		fseek(rom, 0x146, SEEK_SET);
 		fputc(3, rom);
@@ -360,6 +353,7 @@ main(int argc, char *argv[])
 		long romsize, newsize;
 		int headbyte;
 		uint8_t *buf;
+
 		fseek(rom, 0, SEEK_END);
 		romsize = ftell(rom);
 		newsize = 0x8000;
@@ -433,9 +427,8 @@ main(int argc, char *argv[])
 		 * Offset 0x14D: Header Checksum
 		 */
 
-		uint8_t headcksum;
+		uint8_t headcksum = 0;
 
-		headcksum = 0;
 		fseek(rom, 0x134, SEEK_SET);
 		for (int i = 0; i < (0x14D - 0x134); ++i)
 			headcksum = headcksum - fgetc(rom) - 1;
@@ -447,15 +440,14 @@ main(int argc, char *argv[])
 		 * Offset 0x14E–0x14F: Global Checksum
 		 */
 
-		uint16_t globalcksum;
-
-		globalcksum = 0;
+		uint16_t globalcksum = 0;
 
 		rewind(rom);
 		for (int i = 0; i < 0x14E; ++i)
 			globalcksum += fgetc(rom);
 
 		int byte;
+
 		fseek(rom, 0x150, SEEK_SET);
 		while ((byte = fgetc(rom)) != EOF)
 			globalcksum += byte;

src/fix/rgbfix.1

@@ -1,4 +1,18 @@
-.Dd February 26, 2015
+.\" Copyright © 2010 Anthony J. Bentley <anthony@anjbe.name>
+.\"
+.\" Permission to use, copy, modify, and distribute this software for any
+.\" purpose with or without fee is hereby granted, provided that the above
+.\" copyright notice and this permission notice appear in all copies.
+.\"
+.\" THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+.\" WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+.\" MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+.\" ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+.\" WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+.\" ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+.\" OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+.\"
+.Dd April 17, 2017
 .Dt RGBFIX 1
 .Os RGBDS Manual
 .Sh NAME
@@ -6,7 +20,7 @@
 .Nd Game Boy checksum fixer
 .Sh SYNOPSIS
 .Nm rgbfix
-.Op Fl Ccjsv
+.Op Fl CcjsVv
 .Op Fl i Ar game_id
 .Op Fl k Ar licensee_str
 .Op Fl l Ar licensee_id
@@ -88,9 +102,14 @@ Set the title string
 to a given string, truncated to at most 16 characters.
 It is recommended to use 15 characters instead, to avoid clashing with the CGB
 flag
-.Pq Fl c No or Fl C .
+.Po Fl c
+or
+.Fl C
+.Pc .
 If both this and the game ID are set, the game ID will overwrite the
 overlapping portion of the title.
+.It Fl V
+Print the version of the program and exit.
 .It Fl v
 Validate the header and fix checksums: the Nintendo character area
 .Pq Ad 0x104 Ns \(en Ns Ad 0x133 ,
@@ -135,5 +154,6 @@ SurvivalKids.gbc
 .Sh HISTORY
 .Nm
 was originally released by Carsten S\(/orensen as a standalone program called
-gbfix.
-It was later integrated with the ASMotor package, which became RGBDS.
+gbfix, and was later packaged in RGBDS by Justin Lloyd. It is now maintained by
+a number of contributors at
+.Lk https://github.com/rednex/rgbds .

src/gfx/gb.c

@@ -19,8 +19,7 @@
 
 #include "gfx/main.h"
 
-void
-transpose_tiles(struct GBImage *gb, int width)
+void transpose_tiles(struct GBImage *gb, int width)
 {
 	uint8_t *newdata;
 	int i;
@@ -29,7 +28,9 @@ transpose_tiles(struct GBImage *gb, int width)
 	newdata = calloc(gb->size, 1);
 	for (i = 0; i < gb->size; i++) {
 		newbyte = i / (8 * depth) * width * 8 * depth;
-		newbyte = newbyte % gb->size + 8 * depth * (newbyte / gb->size) + i % (8 * depth);
+		newbyte = newbyte % gb->size
+			+ 8 * depth * (newbyte / gb->size)
+			+ i % (8 * depth);
 		newdata[newbyte] = gb->data[i];
 	}
 
@@ -38,8 +39,7 @@ transpose_tiles(struct GBImage *gb, int width)
 	gb->data = newdata;
 }
 
-void
-png_to_gb(struct PNGImage png, struct GBImage *gb)
+void png_to_gb(const struct PNGImage png, struct GBImage *gb)
 {
 	int x, y, byte;
 	png_byte index;
@@ -50,55 +50,55 @@ png_to_gb(struct PNGImage png, struct GBImage *gb)
 			index &= (1 << depth) - 1;
 
 			if (!gb->horizontal) {
-				byte = y * depth + x / 8 * png.height / 8 * 8 * depth;
+				byte = y * depth
+				     + x / 8 * png.height / 8 * 8 * depth;
 			} else {
-				byte = y * depth + x / 8 * png.height / 8 * 8 * depth;
+				byte = y * depth
+				     + x / 8 * png.height / 8 * 8 * depth;
 			}
 			gb->data[byte] |= (index & 1) << (7 - x % 8);
 			if (depth == 2) {
-				gb->data[byte + 1] |= (index >> 1) << (7 - x % 8);
+				gb->data[byte + 1] |=
+					(index >> 1) << (7 - x % 8);
 			}
 		}
 	}
 
-	if (!gb->horizontal) {
+	if (!gb->horizontal)
 		transpose_tiles(gb, png.width / 8);
-	}
 }
 
-void
-output_file(struct Options opts, struct GBImage gb)
+void output_file(const struct Options opts, const struct GBImage gb)
 {
 	FILE *f;
 
 	f = fopen(opts.outfile, "wb");
-	if (!f) {
+	if (!f)
 		err(1, "Opening output file '%s' failed", opts.outfile);
-	}
+
 	fwrite(gb.data, 1, gb.size - gb.trim * 8 * depth, f);
 
 	fclose(f);
 }
 
-int
-get_tile_index(uint8_t *tile, uint8_t **tiles, int num_tiles, int tile_size)
+int get_tile_index(uint8_t *tile, uint8_t **tiles, int num_tiles, int tile_size)
 {
 	int i, j;
+
 	for (i = 0; i < num_tiles; i++) {
 		for (j = 0; j < tile_size; j++) {
-			if (tile[j] != tiles[i][j]) {
+			if (tile[j] != tiles[i][j])
 				break;
-			}
 		}
-		if (j >= tile_size) {
+
+		if (j >= tile_size)
 			return i;
-		}
 	}
 	return -1;
 }
 
-void
-create_tilemap(struct Options opts, struct GBImage *gb, struct Tilemap *tilemap)
+void create_tilemap(const struct Options opts, struct GBImage *gb,
+		    struct Tilemap *tilemap)
 {
 	int i, j;
 	int gb_i;
@@ -113,7 +113,7 @@ create_tilemap(struct Options opts, struct GBImage *gb, struct Tilemap *tilemap)
 	tile_size = sizeof(uint8_t) * depth * 8;
 	gb_size = gb->size - (gb->trim * tile_size);
 	max_tiles = gb_size / tile_size;
-	tiles = malloc(sizeof(uint8_t*) * max_tiles);
+	tiles = malloc(sizeof(uint8_t *) * max_tiles);
 	num_tiles = 0;
 
 	tilemap->data = malloc(sizeof(uint8_t) * max_tiles);
@@ -127,7 +127,8 @@ create_tilemap(struct Options opts, struct GBImage *gb, struct Tilemap *tilemap)
 			gb_i++;
 		}
 		if (opts.unique) {
-			index = get_tile_index(tile, tiles, num_tiles, tile_size);
+			index = get_tile_index(tile, tiles, num_tiles,
+					       tile_size);
 			if (index < 0) {
 				index = num_tiles;
 				tiles[num_tiles] = tile;
@@ -147,39 +148,35 @@ create_tilemap(struct Options opts, struct GBImage *gb, struct Tilemap *tilemap)
 		gb->data = malloc(tile_size * num_tiles);
 		for (i = 0; i < num_tiles; i++) {
 			tile = tiles[i];
-			for (j = 0; j < tile_size; j++) {
+			for (j = 0; j < tile_size; j++)
 				gb->data[i * tile_size + j] = tile[j];
-			}
 		}
 		gb->size = i * tile_size;
 	}
 
-	for (i = 0; i < num_tiles; i++) {
+	for (i = 0; i < num_tiles; i++)
 		free(tiles[i]);
-	}
+
 	free(tiles);
 }
 
-void
-output_tilemap_file(struct Options opts, struct Tilemap tilemap)
+void output_tilemap_file(const struct Options opts,
+			 const struct Tilemap tilemap)
 {
 	FILE *f;
 
 	f = fopen(opts.mapfile, "wb");
-	if (!f) {
+	if (!f)
 		err(1, "Opening tilemap file '%s' failed", opts.mapfile);
-	}
 
 	fwrite(tilemap.data, 1, tilemap.size, f);
 	fclose(f);
 
-	if (opts.mapout) {
+	if (opts.mapout)
 		free(opts.mapfile);
-	}
 }
 
-void
-output_palette_file(struct Options opts, struct PNGImage png)
+void output_palette_file(const struct Options opts, const struct PNGImage png)
 {
 	FILE *f;
 	int i, colors, color;
@@ -188,16 +185,18 @@ output_palette_file(struct Options opts, struct PNGImage png)
 	if (png_get_PLTE(png.png, png.info, &palette, &colors)) {
 		f = fopen(opts.palfile, "wb");
 		if (!f) {
-			err(1, "Opening palette file '%s' failed", opts.palfile);
+			err(1, "Opening palette file '%s' failed",
+			    opts.palfile);
 		}
 		for (i = 0; i < colors; i++) {
-			color = palette[i].blue >> 3 << 10 | palette[i].green >> 3 << 5 | palette[i].red >> 3;
+			color = palette[i].blue >> 3 << 10
+			      | palette[i].green >> 3 << 5
+			      | palette[i].red >> 3;
 			fwrite(&color, 2, 1, f);
 		}
 		fclose(f);
 	}
 
-	if (opts.palout) {
+	if (opts.palout)
 		free(opts.palfile);
-	}
 }

src/gfx/main.c

@@ -14,24 +14,23 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-#include <getopt.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
+
+#include "extern/version.h"
+
 #include "gfx/main.h"
 
-char *progname;
-
-static void
-usage(void)
+static void print_usage(void)
 {
 	printf(
-"usage: rgbgfx [-DFfhPTuv] [-d #] [-o outfile] [-p palfile] [-t mapfile]\n"
-"[-x #] infile\n");
+"usage: rgbgfx [-DFfhPTuVv] [-d #] [-o outfile] [-p palfile] [-t mapfile]\n"
+"              [-x #] infile\n");
 	exit(1);
 }
 
-int
-main(int argc, char *argv[])
+int main(int argc, char *argv[])
 {
 	int ch, size;
 	struct Options opts = {0};
@@ -41,11 +40,8 @@ main(int argc, char *argv[])
 	char *ext;
 	const char *errmsg = "Warning: The PNG's %s setting is not the same as the setting defined on the command line.";
 
-	progname = argv[0];
-
-	if (argc == 1) {
-		usage();
-	}
+	if (argc == 1)
+		print_usage();
 
 	opts.mapfile = "";
 	opts.palfile = "";
@@ -53,27 +49,30 @@ main(int argc, char *argv[])
 
 	depth = 2;
 
-	while((ch = getopt(argc, argv, "DvFfd:hx:Tt:uPp:o:")) != -1) {
-		switch(ch) {
+	while ((ch = getopt(argc, argv, "Dd:Ffho:Tt:uPp:Vvx:")) != -1) {
+		switch (ch) {
 		case 'D':
 			opts.debug = true;
 			break;
-		case 'v':
-			opts.verbose = true;
+		case 'd':
+			depth = strtoul(optarg, NULL, 0);
 			break;
 		case 'F':
 			opts.hardfix = true;
 		case 'f':
 			opts.fix = true;
 			break;
-		case 'd':
-			depth = strtoul(optarg, NULL, 0);
-			break;
 		case 'h':
 			opts.horizontal = true;
 			break;
-		case 'x':
-			opts.trim = strtoul(optarg, NULL, 0);
+		case 'o':
+			opts.outfile = optarg;
+			break;
+		case 'P':
+			opts.palout = true;
+			break;
+		case 'p':
+			opts.palfile = optarg;
 			break;
 		case 'T':
 			opts.mapout = true;
@@ -84,31 +83,31 @@ main(int argc, char *argv[])
 		case 'u':
 			opts.unique = true;
 			break;
-		case 'P':
-			opts.palout = true;
+		case 'V':
+			printf("rgbgfx %s\n", get_package_version_string());
+			exit(0);
+		case 'v':
+			opts.verbose = true;
 			break;
-		case 'p':
-			opts.palfile = optarg;
-			break;
-		case 'o':
-			opts.outfile = optarg;
+		case 'x':
+			opts.trim = strtoul(optarg, NULL, 0);
 			break;
 		default:
-			usage();
+			print_usage();
+			/* NOTREACHED */
 		}
 	}
 	argc -= optind;
 	argv += optind;
 
-	if (argc == 0) {
-		usage();
-	}
+	if (argc == 0)
+		print_usage();
 
 	opts.infile = argv[argc - 1];
 
-	if (depth != 1 && depth != 2) {
+	if (depth != 1 && depth != 2)
 		errx(1, "Depth option must be either 1 or 2.");
-	}
+
 	colors = 1 << depth;
 
 	input_png_file(opts, &png);
@@ -119,82 +118,77 @@ main(int argc, char *argv[])
 	get_text(&png);
 
 	if (png.horizontal != opts.horizontal) {
-		if (opts.verbose) {
+		if (opts.verbose)
 			warnx(errmsg, "horizontal");
-		}
-		if (opts.hardfix) {
+
+		if (opts.hardfix)
 			png.horizontal = opts.horizontal;
-		}
-	}
-	if (png.horizontal) {
-		opts.horizontal = png.horizontal;
 	}
 
+	if (png.horizontal)
+		opts.horizontal = png.horizontal;
+
 	if (png.trim != opts.trim) {
-		if (opts.verbose) {
+		if (opts.verbose)
 			warnx(errmsg, "trim");
-		}
-		if (opts.hardfix) {
+
+		if (opts.hardfix)
 			png.trim = opts.trim;
-		}
 	}
-	if (png.trim) {
+
+	if (png.trim)
 		opts.trim = png.trim;
-	}
+
 	if (opts.trim > png.width / 8 - 1) {
-		errx(1, "Trim (%i) for input png file '%s' too large (max: %i)", opts.trim, opts.infile, png.width / 8 - 1);
+		errx(1, "Trim (%i) for input png file '%s' too large (max: %i)",
+		     opts.trim, opts.infile, png.width / 8 - 1);
 	}
 
 	if (strcmp(png.mapfile, opts.mapfile) != 0) {
-		if (opts.verbose) {
+		if (opts.verbose)
 			warnx(errmsg, "tilemap file");
-		}
-		if (opts.hardfix) {
+
+		if (opts.hardfix)
 			png.mapfile = opts.mapfile;
-		}
 	}
-	if (!*opts.mapfile) {
+	if (!*opts.mapfile)
 		opts.mapfile = png.mapfile;
-	}
 
 	if (png.mapout != opts.mapout) {
-		if (opts.verbose) {
+		if (opts.verbose)
 			warnx(errmsg, "tilemap file");
-		}
-		if (opts.hardfix) {
+
+		if (opts.hardfix)
 			png.mapout = opts.mapout;
-		}
 	}
-	if (png.mapout) {
+	if (png.mapout)
 		opts.mapout = png.mapout;
-	}
 
 	if (strcmp(png.palfile, opts.palfile) != 0) {
-		if (opts.verbose) {
+		if (opts.verbose)
 			warnx(errmsg, "palette file");
-		}
-		if (opts.hardfix) {
+
+		if (opts.hardfix)
 			png.palfile = opts.palfile;
-		}
 	}
-	if (!*opts.palfile) {
+	if (!*opts.palfile)
 		opts.palfile = png.palfile;
-	}
 
 	if (png.palout != opts.palout) {
-		if (opts.verbose) {
+		if (opts.verbose)
 			warnx(errmsg, "palette file");
-		}
-		if (opts.hardfix) {
+
+		if (opts.hardfix)
 			png.palout = opts.palout;
-		}
-	}
-	if (png.palout) {
-		opts.palout = png.palout;
 	}
 
+	if (png.palout)
+		opts.palout = png.palout;
+
 	if (!*opts.mapfile && opts.mapout) {
-		if ((ext = strrchr(opts.infile, '.')) != NULL) {
+		ext = strrchr(opts.infile, '.');
+
+		if (ext != NULL) {
 			size = ext - opts.infile + 9;
 			opts.mapfile = malloc(size);
 			strncpy(opts.mapfile, opts.infile, size);
@@ -208,7 +202,9 @@ main(int argc, char *argv[])
 	}
 
 	if (!*opts.palfile && opts.palout) {
-		if ((ext = strrchr(opts.infile, '.')) != NULL) {
+		ext = strrchr(opts.infile, '.');
+
+		if (ext != NULL) {
 			size = ext - opts.infile + 5;
 			opts.palfile = malloc(size);
 			strncpy(opts.palfile, opts.infile, size);
@@ -231,17 +227,14 @@ main(int argc, char *argv[])
 		create_tilemap(opts, &gb, &tilemap);
 	}
 
-	if (*opts.outfile) {
+	if (*opts.outfile)
 		output_file(opts, gb);
-	}
 
-	if (*opts.mapfile) {
+	if (*opts.mapfile)
 		output_tilemap_file(opts, tilemap);
-	}
 
-	if (*opts.palfile) {
+	if (*opts.palfile)
 		output_palette_file(opts, png);
-	}
 
 	if (opts.fix || opts.debug) {
 		set_text(&png);

src/gfx/makepng.c

@@ -16,10 +16,10 @@
 
 #include <stdlib.h>
 #include <string.h>
+
 #include "gfx/main.h"
 
-void
-input_png_file(struct Options opts, struct PNGImage *img)
+void input_png_file(const struct Options opts, struct PNGImage *img)
 {
 	FILE *f;
 	int i, y, num_trans;
@@ -30,24 +30,21 @@ input_png_file(struct Options opts, struct PNGImage *img)
 	png_color *palette;
 
 	f = fopen(opts.infile, "rb");
-	if (!f) {
+	if (!f)
 		err(1, "Opening input png file '%s' failed", opts.infile);
-	}
 
-	img->png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-	if (!img->png) {
+	img->png = png_create_read_struct(PNG_LIBPNG_VER_STRING,
+					  NULL, NULL, NULL);
+	if (!img->png)
 		errx(1, "Creating png structure failed");
-	}
 
 	img->info = png_create_info_struct(img->png);
-	if (!img->info) {
+	if (!img->info)
 		errx(1, "Creating png info structure failed");
-	}
 
-	/* Better error handling here? */
-	if (setjmp(png_jmpbuf(img->png))) {
+	/* TODO: Better error handling here? */
+	if (setjmp(png_jmpbuf(img->png)))
 		exit(1);
-	}
 
 	png_init_io(img->png, f);
 
@@ -58,41 +55,39 @@ input_png_file(struct Options opts, struct PNGImage *img)
 	img->depth  = png_get_bit_depth(img->png, img->info);
 	img->type   = png_get_color_type(img->png, img->info);
 
-	if (img->type & PNG_COLOR_MASK_ALPHA) {
+	if (img->type & PNG_COLOR_MASK_ALPHA)
 		png_set_strip_alpha(img->png);
-	}
 
 	if (img->depth != depth) {
 		if (opts.verbose) {
 			warnx("Image bit depth is not %i (is %i).", depth,
-			    img->depth);
+			      img->depth);
 		}
 	}
 
 	if (img->type == PNG_COLOR_TYPE_GRAY) {
-		if (img->depth < 8) {
+		if (img->depth < 8)
 			png_set_expand_gray_1_2_4_to_8(img->png);
-		}
+
 		png_set_gray_to_rgb(img->png);
 	} else {
-		if (img->depth < 8) {
+		if (img->depth < 8)
 			png_set_expand_gray_1_2_4_to_8(img->png);
-		}
+
 		has_palette = png_get_PLTE(img->png, img->info, &palette,
-		    &colors);
+					   &colors);
 	}
 
 	if (png_get_tRNS(img->png, img->info, &trans_alpha, &num_trans,
-	    &trans_values)) {
+			 &trans_values)) {
 		if (img->type == PNG_COLOR_TYPE_PALETTE) {
 			full_alpha = malloc(sizeof(bool) * num_trans);
 
 			for (i = 0; i < num_trans; i++) {
-				if (trans_alpha[i] > 0) {
+				if (trans_alpha[i] > 0)
 					full_alpha[i] = false;
-				} else {
+				else
 					full_alpha[i] = true;
-				}
 			}
 
 			for (i = 0; i < num_trans; i++) {
@@ -182,9 +177,8 @@ input_png_file(struct Options opts, struct PNGImage *img)
 	png_read_update_info(img->png, img->info);
 
 	img->data = malloc(sizeof(png_byte *) * img->height);
-	for (y = 0; y < img->height; y++) {
+	for (y = 0; y < img->height; y++)
 		img->data[y] = malloc(png_get_rowbytes(img->png, img->info));
-	}
 
 	png_read_image(img->png, img->data);
 	png_read_end(img->png, img->info);
@@ -192,8 +186,7 @@ input_png_file(struct Options opts, struct PNGImage *img)
 	fclose(f);
 }
 
-void
-get_text(struct PNGImage *png)
+void get_text(struct PNGImage *png)
 {
 	png_text *text;
 	int i, numtxts, numremoved;
@@ -221,11 +214,14 @@ get_text(struct PNGImage *png)
 		}
 	}
 
-	/* TODO: Remove this and simply change the warning function not to warn instead. */
+	/*
+	 * TODO: Remove this and simply change the warning function not to warn
+	 * instead.
+	 */
 	for (i = 0, numremoved = 0; i < numtxts; i++) {
-		if (text[i].key == NULL) {
+		if (text[i].key == NULL)
 			numremoved++;
-		}
+
 		text[i].key = text[i + numremoved].key;
 		text[i].text = text[i + numremoved].text;
 		text[i].compression = text[i + numremoved].compression;
@@ -233,8 +229,7 @@ get_text(struct PNGImage *png)
 	png_set_text(png->png, png->info, text, numtxts - numremoved);
 }
 
-void
-set_text(struct PNGImage *png)
+void set_text(const struct PNGImage *png)
 {
 	png_text *text;
 	char buffer[3];
@@ -282,14 +277,16 @@ set_text(struct PNGImage *png)
 	free(text);
 }
 
-void
-output_png_file(struct Options opts, struct PNGImage *png)
+void output_png_file(const struct Options opts, const struct PNGImage *png)
 {
 	FILE *f;
 	char *outfile;
 	png_struct *img;
 
-	/* Variable outfile is for debugging purposes. Eventually, opts.infile will be used directly. */
+	/*
+	 * TODO: Variable outfile is for debugging purposes. Eventually,
+	 * opts.infile will be used directly.
+	 */
 	if (opts.debug) {
 		outfile = malloc(strlen(opts.infile) + 5);
 		strcpy(outfile, opts.infile);
@@ -299,19 +296,16 @@ output_png_file(struct Options opts, struct PNGImage *png)
 	}
 
 	f = fopen(outfile, "wb");
-	if (!f) {
+	if (!f)
 		err(1, "Opening output png file '%s' failed", outfile);
-	}
 
 	img = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-	if (!img) {
+	if (!img)
 		errx(1, "Creating png structure failed");
-	}
 
-	/* Better error handling here? */
-	if (setjmp(png_jmpbuf(img))) {
+	/* TODO: Better error handling here? */
+	if (setjmp(png_jmpbuf(img)))
 		exit(1);
-	}
 
 	png_init_io(img, f);
 
@@ -322,18 +316,16 @@ output_png_file(struct Options opts, struct PNGImage *png)
 
 	fclose(f);
 
-	if (opts.debug) {
+	if (opts.debug)
 		free(outfile);
-	}
 }
 
-void
-free_png_data(struct PNGImage *png)
+void free_png_data(const struct PNGImage *png)
 {
 	int y;
 
-	for (y = 0; y < png->height; y++) {
+	for (y = 0; y < png->height; y++)
 		free(png->data[y]);
-	}
+
 	free(png->data);
 }

src/gfx/rgbgfx.1

@@ -1,4 +1,18 @@
-.Dd $Mdocdate$
+.\" Copyright © 2013 stag019 <stag019@gmail.com>
+.\"
+.\" Permission to use, copy, modify, and distribute this software for any
+.\" purpose with or without fee is hereby granted, provided that the above
+.\" copyright notice and this permission notice appear in all copies.
+.\"
+.\" THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+.\" WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+.\" MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+.\" ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+.\" WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+.\" ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+.\" OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+.\"
+.Dd April 17, 2017
 .Dt RGBGFX 1
 .Os RGBDS Manual
 .Sh NAME
@@ -6,7 +20,7 @@
 .Nd Game Boy graphics converter
 .Sh SYNOPSIS
 .Nm rgbgfx
-.Op Fl DfFhPTv
+.Op Fl DfFhPTVv
 .Op Fl o Ar outfile
 .Op Fl d Ar depth
 .Op Fl p Ar palfile
@@ -56,6 +70,8 @@ removing the file extension, and appending
 .Pa .tilemap .
 .It Fl u
 Truncate repeated tiles. Useful with tilemaps.
+.It Fl V
+Print the version of the program and exit.
 .It Fl v
 Verbose.
 Print errors when the command line parameters and the parameters in
@@ -88,3 +104,5 @@ The following will do nothing:
 was created by
 .An stag019
 to be included in RGBDS.
+It is now maintained by a number of contributors at
+.Lk https://github.com/rednex/rgbds .

src/link/.gitignore

@@ -0,0 +1,2 @@
+parser.c
+parser.h

src/link/lexer.l

@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2017 Antonio Nino Diaz <antonio_nd@outlook.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+%option noinput
+%option yylineno
+
+%{
+#include <stdarg.h>
+#include <stdint.h>
+#include <unistd.h>
+
+#include "extern/err.h"
+
+#include "link/mylink.h"
+#include "link/script.h"
+
+#include "parser.h"
+
+#include "types.h"
+
+extern int yyparse();
+
+/* File include stack. */
+
+#define MAX_INCLUDE_DEPTH 8
+
+static int32_t include_stack_ptr;
+
+static YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
+static char include_path[MAX_INCLUDE_DEPTH][_MAX_PATH + 1];
+static int32_t include_line[MAX_INCLUDE_DEPTH];
+
+static char linkerscript_path[_MAX_PATH + 1]; /* Base file */
+%}
+
+%%
+
+\"([^\\\"]|\\.)*\" {
+			if (strlen(yytext) > sizeof(yylval.s) - 1) {
+				script_fatalerror("String is too long: %s\n.",
+						  yytext);
+			}
+
+			if (strlen(yytext) < 3) { /* 2 quotes + 1 character */
+				script_fatalerror("String %s is invalid\n.",
+						  yytext);
+			}
+
+			/* Ignore first quote */
+			yytext++;
+			strcpy(yylval.s, yytext);
+			/* Remove end quote */
+			yylval.s[strlen(yylval.s)-1] = '\0';
+
+			return STRING;
+		}
+
+\$[a-fA-F0-9]+	{
+			yytext++; /* Skip prefix */
+			yylval.i = strtol(yytext, NULL, 16);
+			return INTEGER;
+		}
+[0-9]+		{
+			yylval.i = strtol(yytext, NULL, 10);
+			return INTEGER;
+		}
+
+(?i:ROM0)	{ strcpy(yylval.s, "ROM0");  return SECTION_NONBANKED; }
+(?i:ROMX)	{ strcpy(yylval.s, "ROMX");  return SECTION_BANKED; }
+(?i:VRAM)	{ strcpy(yylval.s, "VRAM");  return SECTION_BANKED; }
+(?i:WRAM0)	{ strcpy(yylval.s, "WRAM0"); return SECTION_NONBANKED; }
+(?i:WRAMX)	{ strcpy(yylval.s, "WRAMX"); return SECTION_BANKED; }
+(?i:SRAM)	{ strcpy(yylval.s, "SRAM");  return SECTION_BANKED; }
+(?i:OAM)	{ strcpy(yylval.s, "OAM");   return SECTION_NONBANKED; }
+(?i:HRAM)	{ strcpy(yylval.s, "HRAM");  return SECTION_NONBANKED; }
+
+(?i:ALIGN)	{ return COMMAND_ALIGN; }
+(?i:ORG)	{ return COMMAND_ORG; }
+
+(?i:INCLUDE)	{ return COMMAND_INCLUDE; }
+
+"\n"		{ return NEWLINE; }
+
+;.*		{ /* Ignore comments. A dot doesn't match newline. */ }
+
+[[:space:]]	{ /* Ignore whitespace. */ }
+
+.		{ script_fatalerror("Invalid character [%s]\n.", yytext); }
+
+%%
+
+extern FILE *yyin;
+
+void script_Parse(const char * path)
+{
+	yyin = fopen(path, "r");
+
+	if (!yyin)
+		errx(1, "Error opening file! \"%s\"\n", path);
+
+	strncpy(linkerscript_path, path, sizeof(linkerscript_path));
+	linkerscript_path[sizeof(linkerscript_path) - 1] = '\0';
+
+	do {
+		yyparse();
+	} while (!feof(yyin));
+
+	fclose(yyin);
+}
+
+void script_IncludeFile(const char * path)
+{
+	if (include_stack_ptr == (MAX_INCLUDE_DEPTH - 1))
+		script_fatalerror("Includes nested too deeply.");
+
+	include_line[include_stack_ptr] = yylineno;
+	include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
+
+	include_stack_ptr++;
+
+	yyin = fopen(path, "r");
+
+	if (!yyin)
+		script_fatalerror("Couldn't open file \"%s\"", path);
+
+	strncpy(include_path[include_stack_ptr], path, sizeof(include_path[0]));
+	include_path[include_stack_ptr][sizeof(include_path[0]) - 1] = '\0';
+
+	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
+	yylineno = 1;
+
+	/*
+	 * The INCLUDE keyword is handled before reaching a newline token, it's
+	 * handled right after parsing the string with the file name that has to
+	 * be included. It isn't actually needed to include a newline after the
+	 * path, the last line of the linkerscript doesn't need to have a
+	 * newline character but it can have a command.
+	 *
+	 * This means that, when opening a new file, we must tell the parser
+	 * that what it is going to start at a new line or it will think that
+	 * the first line of the included script is the continuation of the
+	 * INCLUDE line of the parent script. If this is not done, the first
+	 * line of an included linkerscript can only be a comment (or empty).
+	 */
+	unput('\n');
+}
+
+int32_t script_IncludeDepthGet(void)
+{
+	return include_stack_ptr;
+}
+
+void script_IncludePop(void)
+{
+	fclose(yyin);
+
+	include_stack_ptr--;
+
+	yy_delete_buffer(YY_CURRENT_BUFFER);
+	yy_switch_to_buffer(include_stack[include_stack_ptr]);
+	yylineno = include_line[include_stack_ptr];
+}
+
+void script_PrintFileStack(void)
+{
+	int32_t i = include_stack_ptr;
+
+	include_line[i] = yylineno;
+
+	while (i > 0) {
+		fprintf(stderr, "%s(%d) -> ", include_path[i], include_line[i]);
+		i--;
+	}
+	fprintf(stderr, "%s(%d)", linkerscript_path, include_line[i]);
+}
+
+noreturn void script_fatalerror(const char *fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	fprintf(stderr, "error: ");
+	script_PrintFileStack();
+	fprintf(stderr, ":\n\t");
+	vfprintf(stderr, fmt, args);
+	fprintf(stderr, "\n");
+	va_end(args);
+	exit(1);
+}
+

src/link/library.c

@@ -1,73 +1,71 @@
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "extern/err.h"
-#include "types.h"
+
 #include "link/mylink.h"
 #include "link/main.h"
 
-static BBOOL 
-symboldefined(char *name)
+static uint8_t symboldefined(char *name)
 {
-	struct sSection *pSect;
+	const struct sSection *pSect;
 
 	pSect = pSections;
 
 	while (pSect) {
-		ULONG i;
+		int32_t i;
 
 		for (i = 0; i < pSect->nNumberOfSymbols; i += 1) {
-			if ((pSect->tSymbols[i]->Type == SYM_EXPORT)
-			    || ((pSect->tSymbols[i]->Type == SYM_LOCAL)
-				&& (pSect == pSect->tSymbols[i]->pSection))) {
-				if (strcmp(pSect->tSymbols[i]->pzName, name) ==
-				    0)
-					return (1);
+			const struct sSymbol *tSymbol = pSect->tSymbols[i];
+
+			if ((tSymbol->Type == SYM_EXPORT)
+			    || ((tSymbol->Type == SYM_LOCAL)
+				&& (pSect == tSymbol->pSection))) {
+
+				if (strcmp(tSymbol->pzName, name) == 0)
+					return 1;
 			}
 		}
 		pSect = pSect->pNext;
 	}
-	return (0);
+	return 0;
 }
 
-static BBOOL 
-addmodulecontaining(char *name)
+static uint8_t addmodulecontaining(char *name)
 {
-	struct sSection **ppLSect;
-
-	ppLSect = &pLibSections;
+	struct sSection **ppLSect = &pLibSections;
 
 	while (*ppLSect) {
-		ULONG i;
+		int32_t i;
 
 		for (i = 0; i < (*ppLSect)->nNumberOfSymbols; i += 1) {
-			if (((*ppLSect)->tSymbols[i]->Type == SYM_EXPORT)
-			    || (((*ppLSect)->tSymbols[i]->Type == SYM_LOCAL)
-				&& ((*ppLSect) ==
-				    (*ppLSect)->tSymbols[i]->pSection))) {
-				if (strcmp
-				    ((*ppLSect)->tSymbols[i]->pzName,
-					name) == 0) {
-					struct sSection **ppSect;
-					ppSect = &pSections;
+			const struct sSymbol *tSymbol = (*ppLSect)->tSymbols[i];
+
+			if ((tSymbol->Type == SYM_EXPORT)
+			    || ((tSymbol->Type == SYM_LOCAL)
+				&& ((*ppLSect) == tSymbol->pSection))) {
+
+				if (strcmp(tSymbol->pzName, name) == 0) {
+					struct sSection **ppSect = &pSections;
+
 					while (*ppSect)
 						ppSect = &((*ppSect)->pNext);
 
 					*ppSect = *ppLSect;
 					*ppLSect = (*ppLSect)->pNext;
 					(*ppSect)->pNext = NULL;
-					return (1);
+					return 1;
 				}
 			}
 		}
 		ppLSect = &((*ppLSect)->pNext);
 	}
-	return (0);
+	return 0;
 }
 
-void 
-AddNeededModules(void)
+void AddNeededModules(void)
 {
 	struct sSection *pSect;
 
@@ -77,8 +75,8 @@ AddNeededModules(void)
 		ppLSect = &pLibSections;
 
 		while (*ppLSect) {
-			struct sSection **ppSect;
-			ppSect = &pSections;
+			struct sSection **ppSect = &pSections;
+
 			while (*ppSect)
 				ppSect = &((*ppSect)->pNext);
 
@@ -93,23 +91,22 @@ AddNeededModules(void)
 	if (options & OPT_SMART_C_LINK) {
 		if (!addmodulecontaining(smartlinkstartsymbol)) {
 			errx(1, "Can't find start symbol '%s'",
-			    smartlinkstartsymbol);
-		} else
+			     smartlinkstartsymbol);
+		} else {
 			printf("Smart linking with symbol '%s'\n",
-			    smartlinkstartsymbol);
+			       smartlinkstartsymbol);
+		}
 	}
 	pSect = pSections;
 
 	while (pSect) {
-		ULONG i;
+		int32_t i;
 
 		for (i = 0; i < pSect->nNumberOfSymbols; i += 1) {
 			if ((pSect->tSymbols[i]->Type == SYM_IMPORT)
 			    || (pSect->tSymbols[i]->Type == SYM_LOCAL)) {
-				if (!symboldefined(pSect->tSymbols[i]->pzName)) {
-					addmodulecontaining(pSect->tSymbols[i]->
-					    pzName);
-				}
+				if (!symboldefined(pSect->tSymbols[i]->pzName))
+					addmodulecontaining(pSect->tSymbols[i]->pzName);
 			}
 		}
 		pSect = pSect->pNext;

src/link/main.c

@@ -1,9 +1,12 @@
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "extern/err.h"
+#include "extern/version.h"
+
 #include "link/object.h"
 #include "link/output.h"
 #include "link/assign.h"
@@ -20,44 +23,39 @@ enum eBlockType {
 	BLOCK_OUTPUT
 };
 
-SLONG options = 0;
-SLONG fillchar = 0;
+int32_t options;
+int32_t fillchar;
 char *smartlinkstartsymbol;
 
-char *progname;
-
 /*
  * Print the usagescreen
- *
  */
 
-static void 
-usage(void)
+static void print_usage(void)
 {
 	printf(
-"usage: rgblink [-t] [-m mapfile] [-n symfile] [-o outfile] [-p pad_value]\n"
-"               [-s symbol] file [...]\n");
+"usage: rgblink [-dtVw] [-l linkerscript] [-m mapfile] [-n symfile] [-O overlay]\n"
+"               [-o outfile] [-p pad_value] [-s symbol] file [...]\n");
 	exit(1);
 }
 
 /*
  * The main routine
- *
  */
 
-int 
-main(int argc, char *argv[])
+int main(int argc, char *argv[])
 {
 	int ch;
 	char *ep;
 
 	if (argc == 1)
-		usage();
+		print_usage();
 
-	progname = argv[0];
-
-	while ((ch = getopt(argc, argv, "m:n:o:p:s:t")) != -1) {
+	while ((ch = getopt(argc, argv, "dl:m:n:O:o:p:s:tVw")) != -1) {
 		switch (ch) {
+		case 'l':
+			SetLinkerscriptName(optarg);
+			break;
 		case 'm':
 			SetMapfileName(optarg);
 			break;
@@ -67,25 +65,50 @@ main(int argc, char *argv[])
 		case 'o':
 			out_Setname(optarg);
 			break;
+		case 'O':
+			out_SetOverlayname(optarg);
+			options |= OPT_OVERLAY;
+			break;
 		case 'p':
 			fillchar = strtoul(optarg, &ep, 0);
-			if (optarg[0] == '\0' || *ep != '\0') {
+			if (optarg[0] == '\0' || *ep != '\0')
 				errx(1, "Invalid argument for option 'p'");
-			}
-			if (fillchar < 0 || fillchar > 0xFF) {
-				fprintf(stderr, "Argument for option 'p' must be between 0 and 0xFF");
-				exit(1);
-			}
+			if (fillchar < 0 || fillchar > 0xFF)
+				errx(1, "Argument for option 'p' must be between 0 and 0xFF");
 			break;
 		case 's':
 			options |= OPT_SMART_C_LINK;
 			smartlinkstartsymbol = optarg;
 			break;
 		case 't':
-			options |= OPT_SMALL;
+			options |= OPT_TINY;
 			break;
+		case 'd':
+			/*
+			 * Set to set WRAM as a single continuous block as on
+			 * DMG. All WRAM sections must be WRAM0 as bankable WRAM
+			 * sections do not exist in this mode. A WRAMX section
+			 * will raise an error. VRAM bank 1 can't be used if
+			 * this option is enabled either.
+			 *
+			 * This option implies OPT_CONTWRAM.
+			 */
+			options |= OPT_DMG_MODE;
+			/* FALLTHROUGH */
+		case 'w':
+			/*
+			 * Set to set WRAM as a single continuous block as on
+			 * DMG. All WRAM sections must be WRAM0 as bankable WRAM
+			 * sections do not exist in this mode. A WRAMX section
+			 * will raise an error.
+			 */
+			options |= OPT_CONTWRAM;
+			break;
+		case 'V':
+			printf("rgblink %s\n", get_package_version_string());
+			exit(0);
 		default:
-			usage();
+			print_usage();
 			/* NOTREACHED */
 		}
 	}
@@ -93,9 +116,9 @@ main(int argc, char *argv[])
 	argv += optind;
 
 	if (argc == 0)
-		usage();
+		print_usage();
 
-	for (int i = 0; i < argc; ++i)
+	for (int32_t i = 0; i < argc; ++i)
 		obj_Readfile(argv[i]);
 
 	AddNeededModules();
@@ -105,5 +128,5 @@ main(int argc, char *argv[])
 	Output();
 	CloseMapfile();
 
-	return (0);
+	return 0;
 }

src/link/mapfile.c

@@ -1,42 +1,39 @@
 #include <errno.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "extern/err.h"
+
+#include "link/assign.h"
 #include "link/main.h"
 #include "link/mylink.h"
-#include "link/assign.h"
 
-FILE *mf = NULL;
-FILE *sf = NULL;
-SLONG currentbank = 0;
-SLONG sfbank;
+static int32_t currentbank;
+static int32_t sfbank;
+static FILE *mf;
+static FILE *sf;
 
-void 
-SetMapfileName(char *name)
+void SetMapfileName(char *name)
 {
 	mf = fopen(name, "w");
 
-	if (mf == NULL) {
+	if (mf == NULL)
 		err(1, "Cannot open mapfile '%s'", name);
-	}
 }
 
-void 
-SetSymfileName(char *name)
+void SetSymfileName(char *name)
 {
 	sf = fopen(name, "w");
 
-	if (sf == NULL) {
+	if (sf == NULL)
 		err(1, "Cannot open symfile '%s'", name);
-	}
 
-	fprintf(sf, ";File generated by rgblink\n\n");
+	fprintf(sf, "; File generated by rgblink\n\n");
 }
 
-void 
-CloseMapfile(void)
+void CloseMapfile(void)
 {
 	if (mf) {
 		fclose(mf);
@@ -48,76 +45,89 @@ CloseMapfile(void)
 	}
 }
 
-void 
-MapfileInitBank(SLONG bank)
+void MapfileInitBank(int32_t bank)
 {
+	if ((bank < 0) || (bank >= BANK_INDEX_MAX))
+		errx(1, "%s: Unknown bank %d\n", __func__, bank);
+
 	if (mf) {
 		currentbank = bank;
-		if (bank == BANK_ROM0)
+		if (BankIndexIsROM0(bank)) {
 			fprintf(mf, "ROM Bank #0 (HOME):\n");
-		else if (bank < BANK_WRAM0)
-			fprintf(mf, "ROM Bank #%ld:\n", bank);
-		else if (bank == BANK_WRAM0)
+		} else if (BankIndexIsROMX(bank)) {
+			fprintf(mf, "ROM Bank #%d:\n",
+				bank - BANK_INDEX_ROMX + 1);
+		} else if (BankIndexIsWRAM0(bank)) {
 			fprintf(mf, "WRAM Bank #0:\n");
-		else if (bank < BANK_VRAM)
-			fprintf(mf, "WRAM Bank #%ld:\n", bank - BANK_WRAMX + 1);
-		else if (bank == BANK_HRAM)
+		} else if (BankIndexIsWRAMX(bank)) {
+			fprintf(mf, "WRAM Bank #%d:\n",
+				bank - BANK_INDEX_WRAMX + 1);
+		} else if (BankIndexIsVRAM(bank)) {
+			fprintf(mf, "VRAM Bank #%d:\n", bank - BANK_INDEX_VRAM);
+		} else if (BankIndexIsOAM(bank)) {
+			fprintf(mf, "OAM:\n");
+		} else if (BankIndexIsHRAM(bank)) {
 			fprintf(mf, "HRAM:\n");
-		else if (bank == BANK_VRAM || bank == BANK_VRAM + 1)
-			fprintf(mf, "VRAM Bank #%ld:\n", bank - BANK_VRAM);
-		else if (bank < MAXBANKS)
-			fprintf(mf, "SRAM Bank #%ld:\n", bank - BANK_SRAM);
+		} else if (BankIndexIsSRAM(bank)) {
+			fprintf(mf, "SRAM Bank #%d:\n", bank - BANK_INDEX_SRAM);
+		}
 	}
 	if (sf) {
-		if (bank < BANK_WRAM0)
-			sfbank = bank;
-		else if (bank == BANK_WRAM0)
+		if (BankIndexIsROM0(bank))
 			sfbank = 0;
-		else if (bank < BANK_VRAM)
-			sfbank = bank - BANK_WRAMX + 1;
-		else if (bank == BANK_HRAM)
+		else if (BankIndexIsROMX(bank))
+			sfbank = bank - BANK_INDEX_ROMX + 1;
+		else if (BankIndexIsWRAM0(bank))
 			sfbank = 0;
-		else if (bank == BANK_VRAM || bank == BANK_VRAM + 1)
-			sfbank = bank - BANK_VRAM;
-		else if (bank < MAXBANKS)
-			sfbank = bank - BANK_SRAM;
+		else if (BankIndexIsWRAMX(bank))
+			sfbank = bank - BANK_INDEX_WRAMX + 1;
+		else if (BankIndexIsVRAM(bank))
+			sfbank = bank - BANK_INDEX_VRAM;
+		else if (BankIndexIsOAM(bank))
+			sfbank = 0;
+		else if (BankIndexIsHRAM(bank))
+			sfbank = 0;
+		else if (BankIndexIsSRAM(bank))
+			sfbank = bank - BANK_INDEX_SRAM;
 		else
 			sfbank = 0;
 	}
 }
 
-void 
-MapfileWriteSection(struct sSection * pSect)
+void MapfileWriteSection(const struct sSection *pSect)
 {
-	SLONG i;
+	int32_t i;
 
 	if (mf) {
-		fprintf(mf, "  SECTION: $%04lX-$%04lX ($%04lX bytes)\n",
-		    pSect->nOrg, pSect->nOrg + pSect->nByteSize - 1,
-		    pSect->nByteSize);
+		if (pSect->nByteSize > 0) {
+			fprintf(mf, "  SECTION: $%04X-$%04X ($%04X bytes) [\"%s\"]\n",
+				pSect->nOrg, pSect->nOrg + pSect->nByteSize - 1,
+				pSect->nByteSize, pSect->pzName);
+		} else {
+			fprintf(mf, "  SECTION: $%04X ($0 bytes) [\"%s\"]\n",
+				pSect->nOrg, pSect->pzName);
+		}
 	}
 
 	for (i = 0; i < pSect->nNumberOfSymbols; i += 1) {
-		struct sSymbol *pSym;
-		pSym = pSect->tSymbols[i];
-		if ((pSym->pSection == pSect)
-		    && (pSym->Type != SYM_IMPORT)) {
+		const struct sSymbol *pSym = pSect->tSymbols[i];
+
+		if ((pSym->pSection == pSect) && (pSym->Type != SYM_IMPORT)) {
 			if (mf) {
-				fprintf(mf, "           $%04lX = %s\n",
-				    pSym->nOffset + pSect->nOrg,
-				    pSym->pzName);
+				fprintf(mf, "           $%04X = %s\n",
+					pSym->nOffset + pSect->nOrg,
+					pSym->pzName);
 			}
 			if (sf) {
-				fprintf(sf, "%02lX:%04lX %s\n", sfbank,
-				    pSym->nOffset + pSect->nOrg,
-				    pSym->pzName);
+				fprintf(sf, "%02X:%04X %s\n", sfbank,
+					pSym->nOffset + pSect->nOrg,
+					pSym->pzName);
 			}
 		}
 	}
 }
 
-void 
-MapfileCloseBank(SLONG slack)
+void MapfileCloseBank(int32_t slack)
 {
 	if (!mf)
 		return;
@@ -125,5 +135,5 @@ MapfileCloseBank(SLONG slack)
 	if (slack == MaxAvail[currentbank])
 		fprintf(mf, "  EMPTY\n\n");
 	else
-		fprintf(mf, "    SLACK: $%04lX bytes\n\n", slack);
+		fprintf(mf, "    SLACK: $%04X bytes\n\n", slack);
 }

src/link/object.c

@@ -1,73 +1,79 @@
 /*
  * Here we have the routines that read an objectfile
- *
  */
 
+#include <ctype.h>
 #include <errno.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include "common.h"
+
 #include "extern/err.h"
+
+#include "link/assign.h"
 #include "link/mylink.h"
 #include "link/main.h"
 
 struct sSymbol **tSymbols;
-struct sSection *pSections = NULL;
-struct sSection *pLibSections = NULL;
-UBYTE dummymem;
-BBOOL oReadLib = 0;
+struct sSection *pSections;
+struct sSection *pLibSections;
+uint8_t dummymem;
+uint8_t oReadLib;
 
 /*
- * The usual byte order stuff
- *
+ * Read 32-bit values with the correct endianness
  */
-
-SLONG 
-readlong(FILE * f)
+static int32_t readlong(FILE *f)
 {
-	SLONG r;
+	int32_t r;
 
 	r = fgetc(f);
 	r |= fgetc(f) << 8;
 	r |= fgetc(f) << 16;
 	r |= fgetc(f) << 24;
 
-	return (r);
+	return r;
 }
 
-UWORD 
-readword(FILE * f)
-{
-	UWORD r;
-
-	r = fgetc(f);
-	r |= fgetc(f) << 8;
-
-	return (r);
-}
 /*
  * Read a NULL terminated string from a file
- *
  */
-
-SLONG 
-readasciiz(char *s, FILE * f)
+int32_t readasciiz(char **dest, FILE *f)
 {
-	SLONG r = 0;
+	size_t r = 0;
 
-	while (((*s++) = fgetc(f)) != 0)
+	size_t bufferLength = 16;
+	char *start = malloc(bufferLength);
+	char *s = start;
+
+	if (!s)
+		err(1, "%s: Couldn't allocate memory", __func__);
+
+	while (((*s++) = fgetc(f)) != 0) {
 		r += 1;
 
+		if (r >= bufferLength) {
+			bufferLength *= 2;
+			start = realloc(start, bufferLength);
+			if (!start) {
+				err(1, "%s: Couldn't allocate memory",
+				    __func__);
+			}
+			s = start + r;
+		}
+	}
+
+	*dest = start;
 	return (r + 1);
 }
+
 /*
  * Allocate a new section and link it into the list
- *
  */
-
-struct sSection *
-AllocSection(void)
+struct sSection *AllocSection(void)
 {
 	struct sSection **ppSections;
 
@@ -80,288 +86,181 @@ AllocSection(void)
 		ppSections = &((*ppSections)->pNext);
 
 	*ppSections = malloc(sizeof **ppSections);
-	if (!*ppSections) {
-		err(1, NULL);
-	}
+	if (!*ppSections)
+		err(1, "%s: Couldn't allocate memory", __func__);
+
 	(*ppSections)->tSymbols = tSymbols;
 	(*ppSections)->pNext = NULL;
 	(*ppSections)->pPatches = NULL;
 	(*ppSections)->oAssigned = 0;
 	return *ppSections;
 }
+
 /*
  * Read a symbol from a file
- *
  */
-
-struct sSymbol *
-obj_ReadSymbol(FILE * f)
+struct sSymbol *obj_ReadSymbol(FILE *f, char *tzObjectfile)
 {
-	char s[256];
 	struct sSymbol *pSym;
 
-	pSym = malloc(sizeof *pSym);
-	if (!pSym) {
-		err(1, NULL);
-	}
+	pSym = malloc(sizeof(*pSym));
+	if (!pSym)
+		err(1, "%s: Couldn't allocate memory", __func__);
 
-	readasciiz(s, f);
-	pSym->pzName = malloc(strlen(s) + 1);
-	if (!pSym->pzName) {
-		err(1, NULL);
-	}
+	readasciiz(&pSym->pzName, f);
+	pSym->Type = (enum eSymbolType)fgetc(f);
+
+	pSym->pzObjFileName = tzObjectfile;
+
+	if (pSym->Type != SYM_IMPORT) {
+		readasciiz(&pSym->pzFileName, f);
+		pSym->nFileLine = readlong(f);
 
-	strcpy(pSym->pzName, s);
-	if ((pSym->Type = (enum eSymbolType) fgetc(f)) != SYM_IMPORT) {
 		pSym->nSectionID = readlong(f);
 		pSym->nOffset = readlong(f);
 	}
+
 	return pSym;
 }
-/*
- * RGB0 object reader routines
- *
- */
 
-struct sSection *
-obj_ReadRGB0Section(FILE * f)
+/*
+ * RGB object reader routines
+ */
+struct sSection *obj_ReadRGBSection(FILE *f)
 {
 	struct sSection *pSection;
+	char *pzName;
+
+	readasciiz(&pzName, f);
+	if (IsSectionNameInUse(pzName))
+		errx(1, "Section name \"%s\" is already in use.", pzName);
 
 	pSection = AllocSection();
+	pSection->pzName = pzName;
 
 	pSection->nByteSize = readlong(f);
-	pSection->Type = (enum eSectionType) fgetc(f);
-	pSection->nOrg = -1;
-	pSection->nBank = -1;
-
-	/* does the user want the -s mode? */
-
-	if ((options & OPT_SMALL) && (pSection->Type == SECT_ROMX)) {
-		pSection->Type = SECT_ROM0;
-	}
-	if ((pSection->Type == SECT_ROMX) || (pSection->Type == SECT_ROM0)) {
-		/*
-		 * These sectiontypes contain data...
-		 *
-		 */
-		if (pSection->nByteSize) {
-			pSection->pData = malloc(pSection->nByteSize);
-			if (!pSection->pData) {
-				err(1, NULL);
-			}
-
-			SLONG nNumberOfPatches;
-			struct sPatch **ppPatch, *pPatch;
-			char s[256];
-
-			fread(pSection->pData, sizeof(UBYTE),
-			    pSection->nByteSize, f);
-			nNumberOfPatches = readlong(f);
-			ppPatch = &pSection->pPatches;
-
-			/*
-			 * And patches...
-			 *
-			 */
-			while (nNumberOfPatches--) {
-				pPatch = malloc(sizeof *pPatch);
-				if (!pPatch) {
-					err(1, NULL);
-				}
-
-				*ppPatch = pPatch;
-				readasciiz(s, f);
-
-				pPatch->pzFilename = malloc(strlen(s) + 1);
-				if (!pPatch->pzFilename) {
-					err(1, NULL);
-				}
-
-				strcpy(pPatch->pzFilename, s);
-
-				pPatch->nLineNo =
-				    readlong(f);
-				pPatch->nOffset =
-				    readlong(f);
-				pPatch->Type =
-				    (enum ePatchType)
-				    fgetc(f);
-
-				if ((pPatch->nRPNSize = readlong(f)) > 0) {
-					pPatch->pRPN = malloc(pPatch->nRPNSize);
-					if (!pPatch->pRPN) {
-						err(1, NULL);
-					}
-
-					fread(pPatch->pRPN, sizeof(UBYTE),
-					    pPatch->nRPNSize, f);
-				} else
-					pPatch->pRPN = NULL;
-
-				pPatch->pNext = NULL;
-				ppPatch = &(pPatch->pNext);
-			}
-		} else {
-			/* Skip number of patches */
-			readlong(f);
-			pSection->pData = &dummymem;
-		}
-	}
-	return pSection;
-}
-
-void 
-obj_ReadRGB0(FILE * pObjfile)
-{
-	struct sSection *pFirstSection;
-	SLONG nNumberOfSymbols, nNumberOfSections, i;
-
-	nNumberOfSymbols = readlong(pObjfile);
-	nNumberOfSections = readlong(pObjfile);
-
-	/* First comes the symbols */
-
-	if (nNumberOfSymbols) {
-		tSymbols = malloc(nNumberOfSymbols * sizeof(struct sSymbol *));
-		if (!tSymbols) {
-			err(1, NULL);
-		}
-
-		for (i = 0; i < nNumberOfSymbols; i += 1)
-			tSymbols[i] = obj_ReadSymbol(pObjfile);
-	} else
-		tSymbols = (struct sSymbol **) & dummymem;
-
-	/* Next we have the sections */
-
-	pFirstSection = NULL;
-	while (nNumberOfSections--) {
-		struct sSection *pNewSection;
-
-		pNewSection = obj_ReadRGB0Section(pObjfile);
-		pNewSection->nNumberOfSymbols = nNumberOfSymbols;
-		if (pFirstSection == NULL)
-			pFirstSection = pNewSection;
-	}
-
-	/*
-	 * Fill in the pSection entry in the symbolstructure.
-	 * This REALLY needs some cleaning up... but, hey, it works
-	 *
-	 */
-
-	for (i = 0; i < nNumberOfSymbols; i += 1) {
-		struct sSection *pConvSect = pFirstSection;
-
-		if (tSymbols[i]->Type != SYM_IMPORT
-		    && tSymbols[i]->nSectionID != -1) {
-			SLONG j = 0;
-			while (j != tSymbols[i]->nSectionID) {
-				j += 1;
-				pConvSect = pConvSect->pNext;
-			}
-			tSymbols[i]->pSection = pConvSect;
-		} else
-			tSymbols[i]->pSection = NULL;
-	}
-}
-/*
- * RGB1 object reader routines
- *
- */
-
-struct sSection *
-obj_ReadRGB1Section(FILE * f)
-{
-	struct sSection *pSection;
-
-	pSection = AllocSection();
-
-	pSection->nByteSize = readlong(f);
-	pSection->Type = (enum eSectionType) fgetc(f);
-	/*
-	 * And because of THIS new feature I'll have to rewrite loads and
-	 * loads of stuff... oh well it needed to be done anyway
-	 *
-	 */
+	pSection->Type = (enum eSectionType)fgetc(f);
 	pSection->nOrg = readlong(f);
 	pSection->nBank = readlong(f);
+	pSection->nAlign = readlong(f);
 
-	/* does the user want the -s mode? */
+	if ((options & OPT_TINY) && (pSection->Type == SECT_ROMX))
+		errx(1,  "ROMX sections can't be used with option -t.");
 
-	if ((options & OPT_SMALL) && (pSection->Type == SECT_ROMX)) {
-		pSection->Type = SECT_ROM0;
+	if ((options & OPT_CONTWRAM) && (pSection->Type == SECT_WRAMX))
+		errx(1, "WRAMX sections can't be used with options -w or -d.");
+
+	if (options & OPT_DMG_MODE) {
+		/* WRAMX sections are checked for OPT_CONTWRAM */
+		if (pSection->Type == SECT_VRAM && pSection->nBank == 1)
+			errx(1, "VRAM bank 1 can't be used with option -d.");
 	}
-	if ((pSection->Type == SECT_ROMX) || (pSection->Type == SECT_ROM0)) {
-		/*
-		 * These sectiontypes contain data...
-		 *
-		 */
-		if (pSection->nByteSize) {
-			pSection->pData = malloc(pSection->nByteSize);
-			if (!pSection->pData) {
-				err(1, NULL);
+
+	uint32_t maxsize = 0;
+
+	/* Verify that the section isn't too big */
+	switch (pSection->Type) {
+	case SECT_ROM0:
+		maxsize = (options & OPT_TINY) ? 0x8000 : 0x4000;
+		break;
+	case SECT_ROMX:
+		maxsize = 0x4000;
+		break;
+	case SECT_VRAM:
+	case SECT_SRAM:
+		maxsize = 0x2000;
+		break;
+	case SECT_WRAM0:
+		maxsize = (options & OPT_CONTWRAM) ? 0x2000 : 0x1000;
+		break;
+	case SECT_WRAMX:
+		maxsize = 0x1000;
+		break;
+	case SECT_OAM:
+		maxsize = 0xA0;
+		break;
+	case SECT_HRAM:
+		maxsize = 0x7F;
+		break;
+	default:
+		errx(1, "Section \"%s\" has an invalid section type.", pzName);
+		break;
+	}
+	if (pSection->nByteSize > maxsize) {
+		errx(1, "Section \"%s\" is bigger than the max size for that type: 0x%X > 0x%X",
+		     pzName, pSection->nByteSize, maxsize);
+	}
+
+	/*
+	 * If the section doesn't contain data, it is ready
+	 */
+	if ((pSection->Type != SECT_ROMX) && (pSection->Type != SECT_ROM0))
+		return pSection;
+
+	/* If there is no data to read, exit */
+	if (pSection->nByteSize == 0) {
+		/* Skip number of patches */
+		readlong(f);
+		pSection->pData = &dummymem;
+		return pSection;
+	}
+
+	pSection->pData = malloc(pSection->nByteSize);
+	if (!pSection->pData)
+		err(1, "%s: Couldn't allocate memory", __func__);
+
+	int32_t nNumberOfPatches;
+	struct sPatch **ppPatch, *pPatch;
+
+	if (fread(pSection->pData, sizeof(uint8_t), pSection->nByteSize, f)
+	    != pSection->nByteSize) {
+		err(1, "%s: Read error", __func__);
+	}
+
+	nNumberOfPatches = readlong(f);
+	ppPatch = &pSection->pPatches;
+
+	/*
+	 * And patches...
+	 */
+	while (nNumberOfPatches--) {
+		pPatch = malloc(sizeof(*pPatch));
+		if (!pPatch)
+			err(1, "%s: Couldn't allocate memory", __func__);
+
+		*ppPatch = pPatch;
+		readasciiz(&pPatch->pzFilename, f);
+		pPatch->nLineNo = readlong(f);
+		pPatch->nOffset = readlong(f);
+		pPatch->Type = (enum ePatchType)fgetc(f);
+		pPatch->nRPNSize = readlong(f);
+
+		if (pPatch->nRPNSize > 0) {
+			pPatch->pRPN = malloc(pPatch->nRPNSize);
+			if (!pPatch->pRPN) {
+				err(1, "%s: Couldn't allocate memory",
+				    __func__);
 			}
 
-			SLONG nNumberOfPatches;
-			struct sPatch **ppPatch, *pPatch;
-			char s[256];
-
-			fread(pSection->pData, sizeof(UBYTE),
-			    pSection->nByteSize, f);
-			nNumberOfPatches = readlong(f);
-			ppPatch = &pSection->pPatches;
-
-			/*
-			 * And patches...
-			 *
-			 */
-			while (nNumberOfPatches--) {
-				pPatch = malloc(sizeof *pPatch);
-				if (!pPatch) {
-					err(1, NULL);
-				}
-
-				*ppPatch = pPatch;
-				readasciiz(s, f);
-				pPatch->pzFilename = malloc(strlen(s) + 1);
-				if (!pPatch->pzFilename) {
-					err(1, NULL);
-				}
-
-				strcpy(pPatch->pzFilename, s);
-				pPatch->nLineNo = readlong(f);
-				pPatch->nOffset = readlong(f);
-				pPatch->Type = (enum ePatchType) fgetc(f);
-				if ((pPatch->nRPNSize = readlong(f)) > 0) {
-					pPatch->pRPN = malloc(pPatch->nRPNSize);
-					if (!pPatch->pRPN) {
-						err(1, NULL);
-					}
-
-					fread(pPatch->pRPN, sizeof(UBYTE),
-					    pPatch->nRPNSize, f);
-				} else
-					pPatch->pRPN = NULL;
-
-				pPatch->pNext = NULL;
-				ppPatch = &(pPatch->pNext);
+			if (fread(pPatch->pRPN, sizeof(uint8_t),
+				  pPatch->nRPNSize, f) != pPatch->nRPNSize) {
+				errx(1, "%s: Read error", __func__);
 			}
 		} else {
-			/* Skip number of patches */
-			readlong(f);
-			pSection->pData = &dummymem;
+			pPatch->pRPN = NULL;
 		}
+
+		pPatch->pNext = NULL;
+		ppPatch = &(pPatch->pNext);
 	}
+
 	return pSection;
 }
 
-void 
-obj_ReadRGB1(FILE * pObjfile)
+void obj_ReadRGB(FILE *pObjfile, char *tzObjectfile)
 {
 	struct sSection *pFirstSection;
-	SLONG nNumberOfSymbols, nNumberOfSections, i;
+	int32_t nNumberOfSymbols, nNumberOfSections, i;
 
 	nNumberOfSymbols = readlong(pObjfile);
 	nNumberOfSections = readlong(pObjfile);
@@ -369,15 +268,15 @@ obj_ReadRGB1(FILE * pObjfile)
 	/* First comes the symbols */
 
 	if (nNumberOfSymbols) {
-		tSymbols = malloc(nNumberOfSymbols * sizeof *tSymbols);
-		if (!tSymbols) {
-			err(1, NULL);
-		}
+		tSymbols = malloc(nNumberOfSymbols * sizeof(*tSymbols));
+		if (!tSymbols)
+			err(1, "%s: Couldn't allocate memory", __func__);
 
 		for (i = 0; i < nNumberOfSymbols; i += 1)
-			tSymbols[i] = obj_ReadSymbol(pObjfile);
-	} else
-		tSymbols = (struct sSymbol **) & dummymem;
+			tSymbols[i] = obj_ReadSymbol(pObjfile, tzObjectfile);
+	} else {
+		tSymbols = (struct sSymbol **)&dummymem;
+	}
 
 	/* Next we have the sections */
 
@@ -385,7 +284,7 @@ obj_ReadRGB1(FILE * pObjfile)
 	while (nNumberOfSections--) {
 		struct sSection *pNewSection;
 
-		pNewSection = obj_ReadRGB1Section(pObjfile);
+		pNewSection = obj_ReadRGBSection(pObjfile);
 		pNewSection->nNumberOfSymbols = nNumberOfSymbols;
 		if (pFirstSection == NULL)
 			pFirstSection = pNewSection;
@@ -394,56 +293,56 @@ obj_ReadRGB1(FILE * pObjfile)
 	/*
 	 * Fill in the pSection entry in the symbolstructure.
 	 * This REALLY needs some cleaning up... but, hey, it works
-	 *
 	 */
 
 	for (i = 0; i < nNumberOfSymbols; i += 1) {
 		struct sSection *pConvSect = pFirstSection;
 
-		if (tSymbols[i]->Type != SYM_IMPORT
-		    && tSymbols[i]->nSectionID != -1) {
-			SLONG j = 0;
+		if ((tSymbols[i]->Type != SYM_IMPORT) &&
+		    (tSymbols[i]->nSectionID != -1)) {
+			int32_t j = 0;
+
 			while (j != tSymbols[i]->nSectionID) {
 				j += 1;
 				pConvSect = pConvSect->pNext;
 			}
 			tSymbols[i]->pSection = pConvSect;
-		} else
+		} else {
 			tSymbols[i]->pSection = NULL;
+		}
 	}
 }
+
 /*
  * The main objectfileloadroutine (phew)
- *
  */
-
-void 
-obj_ReadOpenFile(FILE * pObjfile, char *tzObjectfile)
+void obj_ReadOpenFile(FILE *pObjfile, char *tzObjectfile)
 {
-	char tzHeader[8];
+	char tzHeader[strlen(RGBDS_OBJECT_VERSION_STRING) + 1];
 
-	fread(tzHeader, sizeof(char), 4, pObjfile);
-	tzHeader[4] = 0;
-	if (strncmp(tzHeader, "RGB", 3) == 0) {
-		switch (tzHeader[3]) {
-		case '0':
-			obj_ReadRGB0(pObjfile);
-			break;
-		case '1':
-		case '2':
-			//V2 is really the same but the are new patch types
-			    obj_ReadRGB1(pObjfile);
-			break;
-		default:
-			errx(1, "'%s' is an unsupported version", tzObjectfile);
-		}
+	if (fread(tzHeader, sizeof(char), strlen(RGBDS_OBJECT_VERSION_STRING),
+		  pObjfile) != strlen(RGBDS_OBJECT_VERSION_STRING)) {
+		errx(1, "%s: Read error", tzObjectfile);
+	}
+
+	tzHeader[strlen(RGBDS_OBJECT_VERSION_STRING)] = 0;
+
+	if (strncmp(tzHeader, RGBDS_OBJECT_VERSION_STRING,
+		    strlen(RGBDS_OBJECT_VERSION_STRING)) == 0) {
+		obj_ReadRGB(pObjfile, tzObjectfile);
 	} else {
-		errx(1, "'%s' is not a valid object", tzObjectfile);
+		int32_t i;
+
+		for (i = 0; i < strlen(RGBDS_OBJECT_VERSION_STRING); i++)
+			if (!isprint(tzHeader[i]))
+				tzHeader[i] = '?';
+
+		errx(1, "%s: Invalid file or object file version [%s]",
+		     tzObjectfile, tzHeader);
 	}
 }
 
-void 
-obj_Readfile(char *tzObjectfile)
+void obj_Readfile(char *tzObjectfile)
 {
 	FILE *pObjfile;
 
@@ -453,44 +352,23 @@ obj_Readfile(char *tzObjectfile)
 		oReadLib = 0;
 
 	pObjfile = fopen(tzObjectfile, "rb");
-	if (pObjfile == NULL) {
+	if (pObjfile == NULL)
 		err(1, "Unable to open object '%s'", tzObjectfile);
-	}
+
 	obj_ReadOpenFile(pObjfile, tzObjectfile);
 	fclose(pObjfile);
 
 	oReadLib = 0;
 }
 
-SLONG 
-file_Length(FILE * f)
+int32_t file_Length(FILE *f)
 {
-	ULONG r, p;
+	uint32_t r, p;
 
 	p = ftell(f);
 	fseek(f, 0, SEEK_END);
 	r = ftell(f);
 	fseek(f, p, SEEK_SET);
 
-	return (r);
-}
-
-void 
-lib_ReadXLB0(FILE * f)
-{
-	SLONG size;
-
-	size = file_Length(f) - 4;
-	while (size) {
-		char name[256];
-
-		size -= readasciiz(name, f);
-		readword(f);
-		size -= 2;
-		readword(f);
-		size -= 2;
-		size -= readlong(f);
-		size -= 4;
-		obj_ReadOpenFile(f, name);
-	}
+	return r;
 }

src/link/output.c

@@ -1,32 +1,45 @@
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include "extern/err.h"
+
 #include "link/mylink.h"
 #include "link/mapfile.h"
 #include "link/main.h"
 #include "link/assign.h"
 
 char *tzOutname;
+char *tzOverlayname;
 
-void 
-writehome(FILE * f)
+int32_t MaxOverlayBank;
+
+void writehome(FILE *f, FILE *f_overlay)
 {
-	struct sSection *pSect;
-	UBYTE *mem;
+	const struct sSection *pSect;
+	uint8_t *mem;
 
-	mem = malloc(MaxAvail[BANK_ROM0]);
+	mem = malloc(MaxAvail[BANK_INDEX_ROM0]);
 	if (!mem)
 		return;
 
-	memset(mem, fillchar, MaxAvail[BANK_ROM0]);
+	if (f_overlay != NULL) {
+		fseek(f_overlay, 0L, SEEK_SET);
+		if (fread(mem, 1, MaxAvail[BANK_INDEX_ROM0], f_overlay) !=
+		    MaxAvail[BANK_INDEX_ROM0]) {
+			warnx("Failed to read data from overlay file.");
+		}
+	} else {
+		memset(mem, fillchar, MaxAvail[BANK_INDEX_ROM0]);
+	}
 	MapfileInitBank(0);
 
 	pSect = pSections;
 	while (pSect) {
 		if (pSect->Type == SECT_ROM0) {
 			memcpy(mem + pSect->nOrg, pSect->pData,
-			    pSect->nByteSize);
+			       pSect->nByteSize);
 			MapfileWriteSection(pSect);
 		}
 		pSect = pSect->pNext;
@@ -34,28 +47,33 @@ writehome(FILE * f)
 
 	MapfileCloseBank(area_Avail(0));
 
-	fwrite(mem, 1, MaxAvail[BANK_ROM0], f);
+	fwrite(mem, 1, MaxAvail[BANK_INDEX_ROM0], f);
 	free(mem);
 }
 
-void 
-writebank(FILE * f, SLONG bank)
+void writebank(FILE *f, FILE *f_overlay, int32_t bank)
 {
-	struct sSection *pSect;
-	UBYTE *mem;
+	const struct sSection *pSect;
+	uint8_t *mem;
 
 	mem = malloc(MaxAvail[bank]);
 	if (!mem)
 		return;
 
-	memset(mem, fillchar, MaxAvail[bank]);
+	if (f_overlay != NULL && bank <= MaxOverlayBank) {
+		fseek(f_overlay, bank * 0x4000, SEEK_SET);
+		if (fread(mem, 1, MaxAvail[bank], f_overlay) != MaxAvail[bank])
+			warnx("Failed to read data from overlay file.");
+	} else {
+		memset(mem, fillchar, MaxAvail[bank]);
+	}
 	MapfileInitBank(bank);
 
 	pSect = pSections;
 	while (pSect) {
 		if (pSect->Type == SECT_ROMX && pSect->nBank == bank) {
 			memcpy(mem + pSect->nOrg - 0x4000, pSect->pData,
-			    pSect->nByteSize);
+			       pSect->nByteSize);
 			MapfileWriteSection(pSect);
 		}
 		pSect = pSect->pNext;
@@ -67,33 +85,73 @@ writebank(FILE * f, SLONG bank)
 	free(mem);
 }
 
-void 
-out_Setname(char *tzOutputfile)
+void out_Setname(char *tzOutputfile)
 {
 	tzOutname = tzOutputfile;
 }
 
-void 
-Output(void)
+void out_SetOverlayname(char *tzOverlayfile)
 {
-	SLONG i;
-	FILE *f;
+	tzOverlayname = tzOverlayfile;
+}
 
-	if ((f = fopen(tzOutname, "wb"))) {
-		writehome(f);
+void Output(void)
+{
+	int32_t i;
+	FILE *f;
+	FILE *f_overlay = NULL;
+
+	/*
+	 * Apply overlay
+	 */
+
+	f = fopen(tzOutname, "wb");
+
+	if (f != NULL) {
+		if (tzOverlayname) {
+			f_overlay = fopen(tzOverlayname, "rb");
+
+			if (!f_overlay) {
+				errx(1, "Failed to open overlay file %s\n",
+				     tzOverlayname);
+			}
+
+			fseek(f_overlay, 0, SEEK_END);
+
+			if (ftell(f_overlay) % 0x4000 != 0)
+				errx(1, "Overlay file must be aligned to 0x4000 bytes.");
+
+			MaxOverlayBank = (ftell(f_overlay) / 0x4000) - 1;
+
+			if (MaxOverlayBank < 1)
+				errx(1, "Overlay file must be at least 0x8000 bytes.");
+
+			if (MaxOverlayBank > MaxBankUsed)
+				MaxBankUsed = MaxOverlayBank;
+		}
+
+		writehome(f, f_overlay);
 		for (i = 1; i <= MaxBankUsed; i += 1)
-			writebank(f, i);
+			writebank(f, f_overlay, i);
 
 		fclose(f);
+
+		if (tzOverlayname)
+			fclose(f_overlay);
 	}
-	for (i = BANK_WRAM0; i < MAXBANKS; i++) {
-		struct sSection *pSect;
+
+	/*
+	 * Add regular sections
+	 */
+
+	for (i = BANK_INDEX_WRAM0; i < BANK_INDEX_MAX; i++) {
+		const struct sSection *pSect;
+
 		MapfileInitBank(i);
 		pSect = pSections;
 		while (pSect) {
-			if (pSect->nBank == i) {
+			if (pSect->nBank == i)
 				MapfileWriteSection(pSect);
-			}
 			pSect = pSect->pNext;
 		}
 		MapfileCloseBank(area_Avail(i));

src/link/parser.y

@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2017 Antonio Nino Diaz <antonio_nd@outlook.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+%{
+#include <stdint.h>
+#include <stdio.h>
+
+#include "extern/err.h"
+
+#include "link/script.h"
+
+int yylex();
+void yyerror(char *);
+
+extern int yylineno;
+%}
+
+%union {
+	int32_t i;
+	char s[512];
+}
+
+%token<i> INTEGER
+%token<s> STRING
+
+%token<s> SECTION_NONBANKED
+%token<s> SECTION_BANKED
+
+%token COMMAND_ALIGN
+%token COMMAND_ORG
+
+%token COMMAND_INCLUDE
+
+%token NEWLINE
+
+%start lines
+
+%%
+
+lines:
+	  /* empty */
+	| lines line NEWLINE
+;
+
+line:
+	  /* empty */
+	| statement
+;
+
+statement:
+	/* Statements to set the current section */
+	  SECTION_NONBANKED
+	{
+		script_SetCurrentSectionType($1, 0);
+	}
+	| SECTION_NONBANKED INTEGER
+	{
+		script_fatalerror("Trying to assign a bank to a non-banked section.\n");
+	}
+
+	| SECTION_BANKED
+	{
+		script_fatalerror("Banked section without assigned bank.\n");
+	}
+	| SECTION_BANKED INTEGER
+	{
+		script_SetCurrentSectionType($1, $2);
+	}
+
+	/* Commands to adjust the address inside the current section */
+	| COMMAND_ALIGN INTEGER
+	{
+		script_SetAlignment($2);
+	}
+	| COMMAND_ALIGN
+	{
+		script_fatalerror("ALIGN keyword needs an argument.\n");
+	}
+	| COMMAND_ORG INTEGER
+	{
+		script_SetAddress($2);
+	}
+	| COMMAND_ORG
+	{
+		script_fatalerror("ORG keyword needs an argument.\n");
+	}
+
+	/* Section name */
+	| STRING
+	{
+		script_OutputSection($1);
+	}
+
+	/* Include file */
+	| COMMAND_INCLUDE STRING
+	{
+		script_IncludeFile($2);
+	}
+
+	/* End */
+;
+
+%%
+
+extern int yylex();
+extern int yyparse();
+
+int yywrap(void)
+{
+	if (script_IncludeDepthGet() == 0)
+		return 1;
+
+	script_IncludePop();
+
+	return 0;
+}
+
+void yyerror(char *s)
+{
+	script_fatalerror("Linkerscript parse error: \"%s\"\n", s);
+}
+

src/link/patch.c

@@ -1,89 +1,101 @@
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "extern/err.h"
+
 #include "link/assign.h"
+#include "link/main.h"
 #include "link/mylink.h"
 #include "link/symbol.h"
-#include "link/main.h"
 
-struct sSection *pCurrentSection;
-SLONG rpnstack[256];
-SLONG rpnp;
-SLONG nPC;
+static struct sSection *pCurrentSection;
+static int32_t rpnstack[256];
+static int32_t rpnp;
+int32_t nPC;
 
-void 
-rpnpush(SLONG i)
+static void rpnpush(int32_t i)
 {
-	rpnstack[rpnp++] = i;
+	rpnstack[rpnp] = i;
+	rpnp++;
 }
 
-SLONG 
-rpnpop(void)
+static int32_t rpnpop(void)
 {
-	return (rpnstack[--rpnp]);
+	rpnp--;
+	return rpnstack[rpnp];
 }
 
-SLONG 
-getsymvalue(SLONG symid)
+static int32_t getsymvalue(int32_t symid)
 {
-	switch (pCurrentSection->tSymbols[symid]->Type) {
-		case SYM_IMPORT:
-		return (sym_GetValue(pCurrentSection->tSymbols[symid]->pzName));
-		break;
-	case SYM_EXPORT:
-	case SYM_LOCAL:
-		{
-			if (strcmp
-			    (pCurrentSection->tSymbols[symid]->pzName,
-				"@") == 0) {
-				return (nPC);
-			} else
-				return (pCurrentSection->tSymbols[symid]->
-				    nOffset +
-				    pCurrentSection->tSymbols[symid]->
-				    pSection->nOrg);
-		}
-	default:
-		break;
-	}
-	errx(1, "*INTERNAL* UNKNOWN SYMBOL TYPE");
-}
+	const struct sSymbol *tSymbol = pCurrentSection->tSymbols[symid];
 
-SLONG 
-getsymbank(SLONG symid)
-{
-	SLONG nBank;
-
-	switch (pCurrentSection->tSymbols[symid]->Type) {
+	switch (tSymbol->Type) {
 	case SYM_IMPORT:
-		nBank = sym_GetBank(pCurrentSection->tSymbols[symid]->pzName);
+		return sym_GetValue(tSymbol->pzName);
+
+	case SYM_EXPORT:
+	case SYM_LOCAL:
+		if (strcmp(tSymbol->pzName, "@") == 0)
+			return nPC;
+
+		return tSymbol->nOffset + tSymbol->pSection->nOrg;
+
+	default:
+		break;
+	}
+
+	errx(1, "%s: Unknown symbol type", __func__);
+}
+
+
+static int32_t getrealbankfrominternalbank(int32_t n)
+{
+	if (BankIndexIsWRAM0(n) || BankIndexIsROM0(n) ||
+	    BankIndexIsOAM(n)   || BankIndexIsHRAM(n)) {
+		return 0;
+	} else if (BankIndexIsROMX(n)) {
+		return n - BANK_INDEX_ROMX + 1;
+	} else if (BankIndexIsWRAMX(n)) {
+		return n - BANK_INDEX_WRAMX + 1;
+	} else if (BankIndexIsVRAM(n)) {
+		return n - BANK_INDEX_VRAM;
+	} else if (BankIndexIsSRAM(n)) {
+		return n - BANK_INDEX_SRAM;
+	}
+
+	errx(1, "%s: Unknown bank %d", __func__, n);
+
+	return n;
+}
+
+static int32_t getsymbank(int32_t symid)
+{
+	int32_t nBank;
+	const struct sSymbol *tSymbol = pCurrentSection->tSymbols[symid];
+
+	switch (tSymbol->Type) {
+	case SYM_IMPORT:
+		nBank = sym_GetBank(tSymbol->pzName);
 		break;
 	case SYM_EXPORT:
 	case SYM_LOCAL:
-		nBank = pCurrentSection->tSymbols[symid]->pSection->nBank;
+		nBank = tSymbol->pSection->nBank;
 		break;
 	default:
-		errx(1, "*INTERNAL* UNKNOWN SYMBOL TYPE");
+		errx(1, "%s: Unknown symbol type", __func__);
 	}
 
-	if (nBank == BANK_WRAM0) return 0;
-	if (nBank >= BANK_WRAMX && nBank <= (BANK_WRAMX+6))
-		return nBank - BANK_WRAMX + 1;
-	if (nBank >= BANK_VRAM && nBank <= (BANK_VRAM+1))
-		return nBank - BANK_VRAM;
-	if (nBank >= BANK_SRAM && nBank <= (BANK_SRAM+3))
-		return nBank - BANK_SRAM;
-
-	return nBank;
+	return getrealbankfrominternalbank(nBank);
 }
 
-SLONG 
-calcrpn(struct sPatch * pPatch)
+int32_t calcrpn(struct sPatch *pPatch)
 {
-	SLONG t, size;
-	UBYTE *rpn;
+	int32_t t, size;
+	uint8_t *rpn;
+	uint8_t rpn_cmd;
+	int32_t nBank;
 
 	rpnp = 0;
 
@@ -93,7 +105,9 @@ calcrpn(struct sPatch * pPatch)
 
 	while (size > 0) {
 		size -= 1;
-		switch (*rpn++) {
+		rpn_cmd = *rpn++;
+
+		switch (rpn_cmd) {
 		case RPN_ADD:
 			rpnpush(rpnpop() + rpnpop());
 			break;
@@ -125,7 +139,7 @@ calcrpn(struct sPatch * pPatch)
 			rpnpush(rpnpop() ^ rpnpop());
 			break;
 		case RPN_UNNOT:
-			rpnpush(rpnpop() ^ 0xFFFFFFFF);
+			rpnpush(~rpnpop());
 			break;
 		case RPN_LOGAND:
 			rpnpush(rpnpop() && rpnpop());
@@ -171,17 +185,8 @@ calcrpn(struct sPatch * pPatch)
 			rpnpush(t & 0xFF);
 			if (t < 0 || (t > 0xFF && t < 0xFF00) || t > 0xFFFF) {
 				errx(1,
-				    "%s(%ld) : Value must be in the HRAM area",
-				    pPatch->pzFilename, pPatch->nLineNo);
-			}
-			break;
-		case RPN_PCEZP:
-			t = rpnpop();
-			rpnpush(t & 0xFF);
-			if (t < 0x2000 || t > 0x20FF) {
-				errx(1,
-				    "%s(%ld) : Value must be in the ZP area",
-				    pPatch->pzFilename, pPatch->nLineNo);
+				     "%s(%ld) : Value must be in the HRAM area",
+				     pPatch->pzFilename, pPatch->nLineNo);
 			}
 			break;
 		case RPN_CONST:
@@ -203,7 +208,7 @@ calcrpn(struct sPatch * pPatch)
 			pPatch->oRelocPatch |= (getsymbank(t) != -1);
 			size -= 4;
 			break;
-		case RPN_BANK:
+		case RPN_BANK_SYM:
 			/* symbol */
 			t = (*rpn++);
 			t |= (*rpn++) << 8;
@@ -212,36 +217,40 @@ calcrpn(struct sPatch * pPatch)
 			rpnpush(getsymbank(t));
 			size -= 4;
 			break;
-		case RPN_RANGECHECK:
-			{
-				SLONG low, high;
+		case RPN_BANK_SECT:
+		{
+			char *name = (char *)rpn;
 
-				low = (*rpn++);
-				low |= (*rpn++) << 8;
-				low |= (*rpn++) << 16;
-				low |= (*rpn++) << 24;
-				high = (*rpn++);
-				high |= (*rpn++) << 8;
-				high |= (*rpn++) << 16;
-				high |= (*rpn++) << 24;
-				t = rpnpop();
-				if (t < low || t > high) {
-					errx(1,
-					    "%s(%ld) : Value must be in the range [%ld;%ld]",
-					    pPatch->pzFilename,
-					    pPatch->nLineNo, low, high);
-				}
-				rpnpush(t);
-				size -= 8;
-				break;
+			struct sSection *pSection = GetSectionByName(name);
+
+			if (pSection == NULL) {
+				errx(1, "Requested BANK() of section \"%s\", which was not found.\n",
+				     name);
 			}
+
+			nBank = pSection->nBank;
+			rpnpush(getrealbankfrominternalbank(nBank));
+
+			int len = strlen(name);
+
+			size -= len + 1;
+			rpn += len + 1;
+			break;
+		}
+		case RPN_BANK_SELF:
+			nBank = pCurrentSection->nBank;
+			rpnpush(getrealbankfrominternalbank(nBank));
+			break;
+		default:
+			errx(1, "%s: Invalid command %d\n", __func__,
+			     rpn_cmd);
+			break;
 		}
 	}
-	return (rpnpop());
+	return rpnpop();
 }
 
-void 
-Patch(void)
+void Patch(void)
 {
 	struct sSection *pSect;
 
@@ -252,7 +261,7 @@ Patch(void)
 		pCurrentSection = pSect;
 		pPatch = pSect->pPatches;
 		while (pPatch) {
-			SLONG t;
+			int32_t t;
 
 			nPC = pSect->nOrg + pPatch->nOffset;
 			t = calcrpn(pPatch);
@@ -261,55 +270,36 @@ Patch(void)
 				if (t >= -128 && t <= 255) {
 					t &= 0xFF;
 					pSect->pData[pPatch->nOffset] =
-					    (UBYTE) t;
+						(uint8_t)t;
 				} else {
 					errx(1,
-					    "%s(%ld) : Value must be 8-bit",
-					    pPatch->pzFilename,
-					    pPatch->nLineNo);
+					     "%s(%ld) : Value must be 8-bit",
+					     pPatch->pzFilename,
+					     pPatch->nLineNo);
 				}
 				break;
 			case PATCH_WORD_L:
-			case PATCH_WORD_B:
 				if (t >= -32768 && t <= 65535) {
 					t &= 0xFFFF;
-					if (pPatch->Type == PATCH_WORD_L) {
-						pSect->pData[pPatch->nOffset] =
-						    t & 0xFF;
-						pSect->pData[pPatch->nOffset +
-						    1] =
-						    (t >> 8) & 0xFF;
-					} else {
-						//Assume big endian
-						    pSect->pData[pPatch->nOffset] =
-						    (t >> 8) & 0xFF;
-						pSect->pData[pPatch->nOffset +
-						    1] = t & 0xFF;
-					}
+					pSect->pData[pPatch->nOffset] =
+						t & 0xFF;
+					pSect->pData[pPatch->nOffset + 1] =
+						(t >> 8) & 0xFF;
 				} else {
 					errx(1,
-					    "%s(%ld) : Value must be 16-bit",
-					    pPatch->pzFilename,
-					    pPatch->nLineNo);
+					     "%s(%ld) : Value must be 16-bit",
+					     pPatch->pzFilename,
+					     pPatch->nLineNo);
 				}
 				break;
 			case PATCH_LONG_L:
 				pSect->pData[pPatch->nOffset + 0] = t & 0xFF;
 				pSect->pData[pPatch->nOffset + 1] =
-				    (t >> 8) & 0xFF;
+					(t >> 8) & 0xFF;
 				pSect->pData[pPatch->nOffset + 2] =
-				    (t >> 16) & 0xFF;
+					(t >> 16) & 0xFF;
 				pSect->pData[pPatch->nOffset + 3] =
-				    (t >> 24) & 0xFF;
-				break;
-			case PATCH_LONG_B:
-				pSect->pData[pPatch->nOffset + 0] =
-				    (t >> 24) & 0xFF;
-				pSect->pData[pPatch->nOffset + 1] =
-				    (t >> 16) & 0xFF;
-				pSect->pData[pPatch->nOffset + 2] =
-				    (t >> 8) & 0xFF;
-				pSect->pData[pPatch->nOffset + 3] = t & 0xFF;
+					(t >> 24) & 0xFF;
 				break;
 			}
 

src/link/rgblink.1

@@ -1,4 +1,18 @@
-.Dd February 26, 2015
+.\" Copyright © 2010 Anthony J. Bentley <anthony@anjbe.name>
+.\"
+.\" Permission to use, copy, modify, and distribute this software for any
+.\" purpose with or without fee is hereby granted, provided that the above
+.\" copyright notice and this permission notice appear in all copies.
+.\"
+.\" THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+.\" WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+.\" MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+.\" ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+.\" WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+.\" ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+.\" OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+.\"
+.Dd April 17, 2017
 .Dt RGBLINK 1
 .Os RGBDS Manual
 .Sh NAME
@@ -6,12 +20,14 @@
 .Nd Game Boy linker
 .Sh SYNOPSIS
 .Nm rgblink
-.Op Fl t
+.Op Fl dtVw
 .Op Fl m Ar mapfile
 .Op Fl n Ar symfile
+.Op Fl O Ar overlayfile
 .Op Fl o Ar outfile
 .Op Fl p Ar pad_value
 .Op Fl s Ar symbol
+.Op Fl l Ar linkerscript
 .Ar
 .Sh DESCRIPTION
 The
@@ -26,12 +42,29 @@ If your ROM will only be 32KiB, you can use the
 .Fl t
 option to override this.
 .Pp
+Similarly, WRAM0 sections are placed in the first 4KiB of WRAM bank 0 and WRAMX
+sections are placed in any bank except bank 0.
+If your ROM doesn't use banked WRAM you can use option
+.Fl w
+option to override this.
+.Pp
+Also, if your ROM is designed for DMG, you can make sure that you don't use any
+prohibited section by using the option
+.Fl d ,
+which implies
+.Fl w
+but also prohibits the use of VRAM bank 1.
+.Pp
 The arguments are as follows:
 .Bl -tag -width Ds
 .It Fl m Ar mapfile
 Write a mapfile to the given filename.
 .It Fl n Ar symfile
 Write a symbol file to the given filename.
+.It Fl O Ar overlayfile
+The ROM image to overlay sections over.
+When an overlay ROM is provided, all sections must be fixed.
+This may be used to patch an existing binray.
 .It Fl o Ar outfile
 Write ROM image to the given filename.
 .It Fl p Ar pad_value
@@ -39,12 +72,29 @@ When padding an image, pad with this value.
 The default is 0x00.
 .It Fl s Ar symbol
 ???
+.It Fl w
+Expand the WRAM0 section size from 4KiB to the full 8KiB assigned to WRAM and
+prohibit the use of WRAMX sections.
+.It Fl d
+Enable DMG mode.
+Prohibit the use of sections that doesn't exist on a DMG, such as WRAMX and VRAM
+bank 1.
+This option automatically enables
+.Fl w .
 .It Fl t
-Write a tiny
-.Pq 32KiB
-ROM file.
-This forces all ROMX sections to be of type ROM0, and increases the ROM0
-section size from 16KiB to 32KiB.
+Expand the ROM0 section size from 16KiB to the full 32KiB assigned to ROM and
+prohibit the use of ROMX sections.
+Useful for ROMs that fit in 32 KiB.
+.It Fl l Ar linkerscript
+Specify a linkerscript file that tells the linker how sections must be placed in
+the ROM.
+This file has priority over the attributes assigned in the source code, but they
+have to be consistent.
+See
+.Xr rgblink 5
+for more information about its format.
+.It Fl V
+Print the version of the program and exit.
 .El
 .Sh EXAMPLES
 All you need for a basic ROM is an object file, which can be made into a ROM
@@ -61,9 +111,13 @@ to fix these so that the program will actually run in a Game Boy:
 .D1 $ rgbfix -v bar.gb
 .Sh SEE ALSO
 .Xr rgbasm 1 ,
+.Xr rgblink 5 ,
 .Xr rgbfix 1 ,
+.Xr rgbds 5 ,
 .Xr rgbds 7
 .Sh HISTORY
 .Nm
 was originally written by Carsten S\(/orensen as part of the ASMotor package,
-and was later packaged in RGBDS by Justin Lloyd.
+and was later packaged in RGBDS by Justin Lloyd. It is now maintained by a
+number of contributors at
+.Lk https://github.com/rednex/rgbds .

src/link/rgblink.5

@@ -0,0 +1,102 @@
+.\" Copyright (C) 2017 Antonio Nino Diaz <antonio_nd@outlook.com>
+.\"
+.\" Permission to use, copy, modify, and distribute this software for any
+.\" purpose with or without fee is hereby granted, provided that the above
+.\" copyright notice and this permission notice appear in all copies.
+.\"
+.\" THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+.\" WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+.\" MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+.\" ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+.\" WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+.\" ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+.\" OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+.\"
+.Dd April 17, 2017
+.Dt RGBLINK 5
+.Os RGBDS Manual
+.Sh NAME
+.Nm rgblink
+.Nd linkerscript file format
+.Sh DESCRIPTION
+The linkerscript is an external file that allows the user to specify the
+order of sections without the need for doing so before assembling each object
+file.
+.Pp
+The placement of sections specified in the linkerscript is done before the
+sections whose placement is defined in the source code.
+.Pp
+A linkerscript consists on a series of banks followed by a list of sections
+and, optionally, commands.
+They can be lowercase or uppercase, it is ignored.
+Any line can contain a comment starting with
+.Ql \&;
+that ends at the end of the line:
+.Pp
+.Bd -literal -offset indent
+ROMX $F ; This is a comment
+  "Functions to read array"
+  ALIGN 8
+  "Array aligned to 256 bytes"
+
+WRAMX 2
+  "Some variables"
+.Ed
+.Pp
+Numbers can be in decimal or hexadecimal format (the prefix is
+.Ql $ ) .
+It is an error if any bank or command is found before setting a bank.
+.Pp
+Files can be included by using the
+.Ar INCLUDE
+keyword followed by a string with the path of the file that has to be included.
+.Pp
+The possible bank types are:
+.Sy ROM0 , ROMX , VRAM , WRAM0 , WRAMX , OAM
+and
+.Sy HRAM .
+Types
+.Sy ROMX , VRAM , WRAMX
+and
+.Sy SRAM
+are banked, which means that it is needed to specify a bank after the type.
+.Pp
+When a new bank statement is found, sections found after it will be placed
+right from the beginning of that bank.
+If the linkerscript switches to a different bank and then it comes back to the
+previous one it will continue from the last address that was used.
+.Pp
+The only two commands are
+.Ar ORG
+and
+.Ar ALIGN :
+.Bl -bullet
+.It
+.Ar ORG
+sets the address in which new sections will be placed.
+It can not be lower than the current address.
+.It
+.Ar ALIGN
+will increase the address until it is aligned to the specified boundary (it
+tries to set to 0 the number of bits specified after the command:
+.Sy ALIGN 8
+will align to $100).
+.El
+.Pp
+Note: The bank, alignment, address and type of sections can be specified both
+in the source code and in the linkerscript.
+For a section to be able to be placed with the linkerscript the bank must be
+left unassigned in the source code or be the same as the one specified in the
+linkerscript. The address and alignment musn't be set.
+.Sh SEE ALSO
+.Xr rgbasm 1 ,
+.Xr rgblink 1 ,
+.Xr rgbfix 1 ,
+.Xr rgbds 5 ,
+.Xr rgbds 7
+.Sh HISTORY
+.Nm
+was originally written by Carsten S\(/orensen as part of the ASMotor package,
+and was later packaged in RGBDS by Justin Lloyd. It is now maintained by a
+number of contributors at
+.Lk https://github.com/rednex/rgbds .

src/link/script.c

@@ -0,0 +1,233 @@
+/*
+ * Copyright (C) 2017 Antonio Nino Diaz <antonio_nd@outlook.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdint.h>
+#include <string.h>
+
+#include "extern/err.h"
+
+#include "link/assign.h"
+#include "link/mylink.h"
+
+static struct {
+	uint32_t address; /* current address to write sections to */
+	uint32_t top_address; /* not inclusive */
+	enum eSectionType type;
+} bank[BANK_INDEX_MAX];
+
+static int32_t current_bank = -1; /* Bank as seen by the bank array */
+static int32_t current_real_bank = -1; /* bank as seen by the GB */
+
+void script_InitSections(void)
+{
+	int32_t i;
+
+	for (i = 0; i < BANK_INDEX_MAX; i++) {
+		if (BankIndexIsROM0(i)) {
+			/* ROM0 bank */
+			bank[i].address = 0x0000;
+			if (options & OPT_TINY)
+				bank[i].top_address = 0x8000;
+			else
+				bank[i].top_address = 0x4000;
+			bank[i].type = SECT_ROM0;
+		} else if (BankIndexIsROMX(i)) {
+			/* Swappable ROM bank */
+			bank[i].address = 0x4000;
+			bank[i].top_address = 0x8000;
+			bank[i].type = SECT_ROMX;
+		} else if (BankIndexIsWRAM0(i)) {
+			/* WRAM */
+			bank[i].address = 0xC000;
+			if (options & OPT_CONTWRAM)
+				bank[i].top_address = 0xE000;
+			else
+				bank[i].top_address = 0xD000;
+			bank[i].type = SECT_WRAM0;
+		} else if (BankIndexIsSRAM(i)) {
+			/* Swappable SRAM bank */
+			bank[i].address = 0xA000;
+			bank[i].top_address = 0xC000;
+			bank[i].type = SECT_SRAM;
+		} else if (BankIndexIsWRAMX(i)) {
+			/* Swappable WRAM bank */
+			bank[i].address = 0xD000;
+			bank[i].top_address = 0xE000;
+			bank[i].type = SECT_WRAMX;
+		} else if (BankIndexIsVRAM(i)) {
+			/* Swappable VRAM bank */
+			bank[i].address = 0x8000;
+			bank[i].type = SECT_VRAM;
+			if (options & OPT_DMG_MODE && i != BANK_INDEX_VRAM) {
+				/* In DMG the only available bank is bank 0. */
+				bank[i].top_address = 0x8000;
+			} else {
+				bank[i].top_address = 0xA000;
+			}
+		} else if (BankIndexIsOAM(i)) {
+			/* OAM */
+			bank[i].address = 0xFE00;
+			bank[i].top_address = 0xFEA0;
+			bank[i].type = SECT_OAM;
+		} else if (BankIndexIsHRAM(i)) {
+			/* HRAM */
+			bank[i].address = 0xFF80;
+			bank[i].top_address = 0xFFFF;
+			bank[i].type = SECT_HRAM;
+		} else {
+			errx(1, "%s: Unknown bank type %d", __func__, i);
+		}
+	}
+}
+
+void script_SetCurrentSectionType(const char *type, uint32_t bank)
+{
+	if (strcmp(type, "ROM0") == 0) {
+		if (bank != 0)
+			errx(1, "Trying to assign a bank number to ROM0.\n");
+		current_bank = BANK_INDEX_ROM0;
+		current_real_bank = 0;
+		return;
+	} else if (strcmp(type, "ROMX") == 0) {
+		if (bank == 0)
+			errx(1, "ROMX index can't be 0.\n");
+		if (bank > BANK_COUNT_ROMX) {
+			errx(1, "ROMX index too big (%d > %d).\n", bank,
+			     BANK_COUNT_ROMX);
+		}
+		current_bank = BANK_INDEX_ROMX + bank - 1;
+		current_real_bank = bank;
+		return;
+	} else if (strcmp(type, "VRAM") == 0) {
+		if (bank >= BANK_COUNT_VRAM) {
+			errx(1, "VRAM index too big (%d >= %d).\n", bank,
+			     BANK_COUNT_VRAM);
+		}
+		current_bank = BANK_INDEX_VRAM + bank;
+		current_real_bank = bank;
+		return;
+	} else if (strcmp(type, "WRAM0") == 0) {
+		if (bank != 0) {
+			errx(1, "Trying to assign a bank number to WRAM0.\n");
+		}
+		current_bank = BANK_INDEX_WRAM0;
+		current_real_bank = 0;
+		return;
+	} else if (strcmp(type, "WRAMX") == 0) {
+		if (bank == 0)
+			errx(1, "WRAMX index can't be 0.\n");
+		if (bank > BANK_COUNT_WRAMX) {
+			errx(1, "WRAMX index too big (%d > %d).\n", bank,
+			     BANK_COUNT_WRAMX);
+		}
+		current_bank = BANK_INDEX_WRAMX + bank - 1;
+		current_real_bank = bank - 1;
+		return;
+	} else if (strcmp(type, "SRAM") == 0) {
+		if (bank >= BANK_COUNT_SRAM) {
+			errx(1, "SRAM index too big (%d >= %d).\n", bank,
+			     BANK_COUNT_SRAM);
+		}
+		current_bank = BANK_INDEX_SRAM + bank;
+		current_real_bank = bank;
+		return;
+	} else if (strcmp(type, "OAM") == 0) {
+		if (bank != 0) {
+			errx(1, "%s: Trying to assign a bank number to OAM.\n",
+			     __func__);
+		}
+		current_bank = BANK_INDEX_OAM;
+		current_real_bank = 0;
+		return;
+	} else if (strcmp(type, "HRAM") == 0) {
+		if (bank != 0) {
+			errx(1, "%s: Trying to assign a bank number to HRAM.\n",
+			     __func__);
+		}
+		current_bank = BANK_INDEX_HRAM;
+		current_real_bank = 0;
+		return;
+	}
+
+	errx(1, "%s: Unknown section type \"%s\".\n", __func__, type);
+}
+
+void script_SetAddress(uint32_t addr)
+{
+	if (current_bank == -1)
+		errx(1, "Trying to set an address without assigned bank\n");
+
+	/* Make sure that we don't go back. */
+	if (bank[current_bank].address > addr) {
+		errx(1, "Trying to go to a previous address (0x%04X to 0x%04X)\n",
+		     bank[current_bank].address, addr);
+	}
+
+	bank[current_bank].address = addr;
+
+	/* Make sure we don't overflow */
+	if (bank[current_bank].address >= bank[current_bank].top_address) {
+		errx(1, "Bank overflowed (0x%04X >= 0x%04X)\n",
+		     bank[current_bank].address,
+		     bank[current_bank].top_address);
+	}
+}
+
+void script_SetAlignment(uint32_t alignment)
+{
+	if (current_bank == -1)
+		errx(1, "Trying to set an alignment without assigned bank\n");
+
+	if (alignment > 15)
+		errx(1, "Trying to set an alignment too big: %d\n", alignment);
+
+	uint32_t size = 1 << alignment;
+	uint32_t mask = size - 1;
+
+	if (bank[current_bank].address & mask) {
+		bank[current_bank].address &= ~mask;
+		bank[current_bank].address += size;
+	}
+
+	/* Make sure we don't overflow */
+	if (bank[current_bank].address >= bank[current_bank].top_address) {
+		errx(1, "Bank overflowed (0x%04X >= 0x%04X)\n",
+		     bank[current_bank].address,
+		     bank[current_bank].top_address);
+	}
+}
+
+void script_OutputSection(const char *section_name)
+{
+	if (current_bank == -1) {
+		errx(1, "Trying to place section \"%s\" without assigned bank\n",
+		     section_name);
+	}
+
+	if (!IsSectionSameTypeBankAndFloating(section_name,
+					      bank[current_bank].type,
+					      current_real_bank)) {
+		errx(1, "Different attributes for \"%s\" in source and linkerscript\n",
+		     section_name);
+	}
+
+	/* Move section to its place. */
+	bank[current_bank].address +=
+		AssignSectionAddressAndBankByName(section_name,
+						  bank[current_bank].address,
+						  current_real_bank);
+}
+

src/link/symbol.c

@@ -1,82 +1,85 @@
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "extern/err.h"
+
 #include "link/main.h"
 #include "link/patch.h"
+
 #include "types.h"
 
 #define HASHSIZE 73
 
 struct ISymbol {
 	char *pzName;
-	SLONG nValue;
-	SLONG nBank;
-	    //-1 = const
+	int32_t nValue;
+	int32_t nBank; /* -1 = constant */
+	 /* Object file where the symbol was defined. */
+	char tzObjFileName[_MAX_PATH + 1];
+	/* Source file where the symbol was defined. */
+	char tzFileName[_MAX_PATH + 1];
+	/* Line where the symbol was defined. */
+	uint32_t nFileLine;
 	struct ISymbol *pNext;
 };
 
 struct ISymbol *tHash[HASHSIZE];
 
-SLONG 
-calchash(char *s)
+int32_t calchash(char *s)
 {
-	SLONG r = 0;
+	int32_t r = 0;
+
 	while (*s)
 		r += *s++;
 
-	return (r % HASHSIZE);
+	return r % HASHSIZE;
 }
 
-void 
-sym_Init(void)
+void sym_Init(void)
 {
-	SLONG i;
+	int32_t i;
+
 	for (i = 0; i < HASHSIZE; i += 1)
 		tHash[i] = NULL;
 }
 
-SLONG 
-sym_GetValue(char *tzName)
+int32_t sym_GetValue(char *tzName)
 {
-	if (strcmp(tzName, "@") == 0) {
-		return (nPC);
-	} else {
-		struct ISymbol **ppSym;
+	if (strcmp(tzName, "@") == 0)
+		return nPC;
 
-		ppSym = &(tHash[calchash(tzName)]);
-		while (*ppSym) {
-			if (strcmp(tzName, (*ppSym)->pzName)) {
-				ppSym = &((*ppSym)->pNext);
-			} else {
-				return ((*ppSym)->nValue);
-			}
-		}
-
-		errx(1, "Unknown symbol '%s'", tzName);
-	}
-}
-
-SLONG 
-sym_GetBank(char *tzName)
-{
 	struct ISymbol **ppSym;
 
 	ppSym = &(tHash[calchash(tzName)]);
 	while (*ppSym) {
-		if (strcmp(tzName, (*ppSym)->pzName)) {
+		if (strcmp(tzName, (*ppSym)->pzName))
 			ppSym = &((*ppSym)->pNext);
-		} else {
-			return ((*ppSym)->nBank);
-		}
+		else
+			return ((*ppSym)->nValue);
 	}
 
 	errx(1, "Unknown symbol '%s'", tzName);
 }
 
-void 
-sym_CreateSymbol(char *tzName, SLONG nValue, SLONG nBank)
+int32_t sym_GetBank(char *tzName)
+{
+	struct ISymbol **ppSym;
+
+	ppSym = &(tHash[calchash(tzName)]);
+	while (*ppSym) {
+		if (strcmp(tzName, (*ppSym)->pzName))
+			ppSym = &((*ppSym)->pNext);
+		else
+			return ((*ppSym)->nBank);
+	}
+
+	errx(1, "Unknown symbol '%s'", tzName);
+}
+
+void sym_CreateSymbol(char *tzName, int32_t nValue, int32_t nBank,
+		      char *tzObjFileName, char *tzFileName, uint32_t nFileLine)
 {
 	if (strcmp(tzName, "@") == 0)
 		return;
@@ -92,16 +95,28 @@ sym_CreateSymbol(char *tzName, SLONG nValue, SLONG nBank)
 			if (nBank == -1)
 				return;
 
-			errx(1, "Symbol '%s' defined more than once", tzName);
+			errx(1, "'%s' in both %s : %s(%d) and %s : %s(%d)",
+			     tzName, tzObjFileName, tzFileName, nFileLine,
+			     (*ppSym)->tzObjFileName,
+			     (*ppSym)->tzFileName, (*ppSym)->nFileLine);
 		}
 	}
 
-	if ((*ppSym = malloc(sizeof **ppSym))) {
-		if (((*ppSym)->pzName = malloc(strlen(tzName) + 1))) {
+	*ppSym = malloc(sizeof **ppSym);
+
+	if (*ppSym != NULL) {
+		(*ppSym)->pzName = malloc(strlen(tzName) + 1);
+
+		if ((*ppSym)->pzName != NULL) {
 			strcpy((*ppSym)->pzName, tzName);
 			(*ppSym)->nValue = nValue;
 			(*ppSym)->nBank = nBank;
 			(*ppSym)->pNext = NULL;
+			strncpy((*ppSym)->tzObjFileName, tzObjFileName,
+				sizeof((*ppSym)->tzObjFileName));
+			strncpy((*ppSym)->tzFileName, tzFileName,
+				sizeof((*ppSym)->tzFileName));
+			(*ppSym)->nFileLine = nFileLine;
 		}
 	}
 }

src/rgbds.5

@@ -0,0 +1,198 @@
+.\" Copyright (c) 2017-2018 Antonio Nino Diaz <antonio_nd@outlook.com>
+.\"
+.\" Permission to use, copy, modify, and distribute this software for any
+.\" purpose with or without fee is hereby granted, provided that the above
+.\" copyright notice and this permission notice appear in all copies.
+.\"
+.\" THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+.\" WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+.\" MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+.\" ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+.\" WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+.\" ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+.\" OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+.\"
+.Dd January 7, 2018
+.Dt RGBDS 5
+.Os RGBDS Manual
+.Sh NAME
+.Nm rgbds
+.Nd object file format documentation
+.Sh DESCRIPTION
+This is the description of the object files used by
+.Xr rgbasm 1
+and
+.Xr rgblink 1 .
+Please, note that the specifications may change.
+This toolchain is in development and new features may require adding more
+information to the current format, or modifying some fields, which would break
+compatibility with older versions.
+.Pp
+.Sh FILE STRUCTURE
+The following types are used:
+.Pp
+.Ar LONG
+is a 32‐bit integer stored in little‐endian format (Intel).
+.Ar BYTE
+is an 8‐bit integer.
+.Ar STRING
+is a 0‐terminated string of
+.Ar BYTE .
+.Pp
+.Bd -literal
+; Header
+
+BYTE    ID[4]            ; "RGB6"
+LONG    NumberOfSymbols  ; The number of symbols used in this file
+LONG    NumberOfSections ; The number of sections used in this file
+
+; Symbols
+
+REPT    NumberOfSymbols   ; Number of symbols defined in this object file.
+
+    STRING  Name          ; The name of this symbol. Local symbols are stored
+                          ; as "Scope.Symbol".
+
+    BYTE    Type          ; 0 = LOCAL symbol only used in this file.
+                          ; 1 = IMPORT this symbol from elsewhere (unused).
+                          ; 2 = EXPORT this symbol to other objects.
+
+    IF      Type != 1     ; If symbol is defined in this object file.
+
+        STRING  FileName  ; File where the symbol is defined.
+
+        LONG    LineNum   ; Line number in the file where the symbol is defined.
+
+        LONG    SectionID ; The section number (of this object file) in which
+                          ; this symbol is defined.
+
+        LONG    Value     ; The symbols value. It's the offset into that
+                          ; symbol's section.
+
+    ENDC
+
+ENDR
+
+; Sections
+
+REPT NumberOfSections
+    STRING  Name  ; Name of the section
+
+    LONG    Size  ; Size in bytes of this section
+
+    BYTE    Type  ; 0 = WRAM0
+                  ; 1 = VRAM
+                  ; 2 = ROMX
+                  ; 3 = ROM0
+                  ; 4 = HRAM
+                  ; 5 = WRAMX
+                  ; 6 = SRAM
+                  ; 7 = OAM
+
+    LONG    Org   ; Address to fix this section at. -1 if the linker should
+                  ; decide (floating address).
+
+    LONG    Bank  ; Bank to load this section into. -1 if the linker should
+                  ; decide (floating bank). This field is only valid for ROMX,
+                  ; VRAM, WRAMX and SRAM sections.
+
+    LONG    Align ; Alignment of this section (expressed as number of low bits
+                  ; to leave as 0). -1 if not defined.
+
+    IF      (Type == ROMX) || (Type == ROM0) ; Sections that can contain data.
+
+        BYTE    Data[Size]      ; Raw data of the section.
+
+        LONG    NumberOfPatches ; Number of patches to apply.
+
+        ; These types of sections may have patches
+
+        REPT    NumberOfPatches
+
+            STRING  SourceFile   ; Name of the source file (for printing error
+                                 ; messages).
+
+            LONG    Line         ; The line of the source file.
+
+            LONG    Offset       ; Offset into the section where patch should
+                                 ; be applied (in bytes).
+
+            BYTE    Type         ; 0 = BYTE patch.
+                                 ; 1 = little endian WORD patch.
+                                 ; 2 = little endian LONG patch.
+
+            LONG    RPNSize      ; Size of the buffer with the RPN.
+                                 ; expression.
+
+            BYTE    RPN[RPNSize] ; RPN expression. Definition below.
+
+        ENDR
+
+    ENDC
+
+ENDR
+.Ed
+.Ss RPN DATA
+Expressions in the object file are stored as RPN.
+This is an expression of the form
+.Do 2 5 + Dc .
+This will first push the value
+.Do 2 Dc to the stack.
+Then
+.Do 5 Dc .
+The
+.Do + Dc operator pops two arguments from the stack, adds them, and then pushes
+the result on the stack, effectively replacing the two top arguments with their
+sum.
+In the RGB format, RPN expressions are stored as BYTEs with some bytes being
+special prefixes for integers and symbols.
+.Pp
+.Bl -column -offset indent ".Sy String" ".Sy String"
+.It Sy Value Ta Sy Meaning
+.It Li $00 Ta Li + operator
+.It Li $01 Ta Li - operator
+.It Li $02 Ta Li * operator
+.It Li $03 Ta Li / operator
+.It Li $04 Ta Li % operator
+.It Li $05 Ta Li unary -
+.It Li $10 Ta Li | operator
+.It Li $11 Ta Li & operator
+.It Li $12 Ta Li ^ operator
+.It Li $13 Ta Li unary ~
+.It Li $21 Ta Li && comparison
+.It Li $22 Ta Li || comparison
+.It Li $23 Ta Li unary !
+.It Li $30 Ta Li == comparison
+.It Li $31 Ta Li != comparison
+.It Li $32 Ta Li > comparison
+.It Li $33 Ta Li < comparison
+.It Li $34 Ta Li >= comparison
+.It Li $35 Ta Li <= comparison
+.It Li $40 Ta Li << comparison
+.It Li $41 Ta Li >> comparison
+.It Li $50 Ta Li BANK(symbol),
+a
+.Ar LONG
+Symbol ID follows.
+.It Li $51 Ta Li BANK(section_name),
+a null-terminated string follows.
+.It Li $52 Ta Li Current BANK() .
+.It Li $60 Ta Li HRAMCheck.
+Check if the value is in HRAM, AND it with 0xFF.
+.It Li $80 Ta Ar LONG
+integer follows.
+.It Li $81 Ta Ar LONG
+Symbol ID follows.
+.El
+.Pp
+.Sh SEE ALSO
+.Xr rgbasm 1 ,
+.Xr rgblink 1 ,
+.Xr rgbds 7 ,
+.Xr gbz80 7
+.Sh HISTORY
+.Nm rgbds
+was originally written by Carsten S\(/orensen as part of the ASMotor package,
+and was later packaged in RGBDS by Justin Lloyd.
+It is now maintained by a number of contributors at
+.Lk https://github.com/rednex/rgbds .

src/rgbds.7

@@ -1,4 +1,18 @@
-.Dd $Mdocdate$
+.\" Copyright © 2010 Anthony J. Bentley <anthony@anjbe.name>
+.\"
+.\" Permission to use, copy, modify, and distribute this software for any
+.\" purpose with or without fee is hereby granted, provided that the above
+.\" copyright notice and this permission notice appear in all copies.
+.\"
+.\" THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+.\" WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+.\" MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+.\" ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+.\" WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+.\" ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+.\" OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+.\"
+.Dd April 17, 2017
 .Dt RGBDS 7
 .Os RGBDS Manual
 .Sh NAME
@@ -14,8 +28,24 @@ To get a working ROM image from a single assembly source file:
 .Xr rgbasm 1 ,
 .Xr rgbfix 1 ,
 .Xr rgblink 1 ,
+.Xr rgbds 5 ,
 .Xr gbz80 7
 .Sh HISTORY
-.Nm
-grew out of the ASMotor package released by Carsten S\(/orensen.
-It was first released as a Game Boy software package by Justin Lloyd.
+.Bl -ohang
+.It
+1997, Carsten S\(/orensen (AKA SurfSmurf) writes ASMotor as a general-purpose
+assembler/linker system for DOS/Win32.
+.It
+1999, Justin Lloyd (AKA Otaku no Zoku) adapts ASMotor to read and produce GBZ80
+assembly/machine code, and releases this version as RGBDS.
+.It
+2009, Vegard Nossum adapts the code to be more UNIX-like and releases this
+version as rgbds-linux on GitHub.
+.It
+2010, Anthony J. Bentley forks that repository. The fork becomes the reference
+implementation of rgbds.
+.It
+2017, Bentley's repository is moved to a neutral name.
+It is now maintained by a number of contributors at
+.Lk https://github.com/rednex/rgbds .
+.El

test/asm/bank-noexist.out

@@ -1,2 +0,0 @@
-ERROR:	bank-noexist.asm(2) :
-	'noexist' not defined

test/asm/divzero-instr.out

@@ -1,2 +1,2 @@
-ERROR:	divzero-instr.asm(2) :
+ERROR: divzero-instr.asm(2):
 	division by zero

test/asm/divzero-section-bank.out

@@ -1,2 +1,2 @@
-ERROR:	divzero-section-bank.asm(1) :
+ERROR: divzero-section-bank.asm(1):
 	division by zero

test/asm/local-wrong-parent.asm

@@ -0,0 +1,6 @@
+SECTION "sec", ROM0
+
+Parent:
+	db 0
+WrongParent.child
+	db 0

test/asm/local-wrong-parent.out

@@ -0,0 +1,3 @@
+ERROR: local-wrong-parent.asm(5):
+	Not currently in the scope of 'WrongParent'
+error: Assembly aborted in pass 1 (1 errors)!

test/asm/macro-@.out

@@ -1,2 +1,2 @@
-ERROR:	macro-@.asm(1) -> @(-1) :
+ERROR: macro-@.asm(1) -> @(-1):
 	Macro '@' not defined

test/asm/null-in-macro.out

@@ -0,0 +1,2 @@
+ERROR: null-in-macro.asm(1):
+	Unterminated MACRO definition.

test/asm/remote-local-explicit.asm

@@ -0,0 +1,7 @@
+SECTION "sec", ROM0
+
+Parent:
+Parent.child::
+	db 0
+NotParent:
+	dw Parent.child

test/asm/remote-local-noexist.asm

@@ -0,0 +1,7 @@
+SECTION "sec", ROM0
+
+Parent:
+.child:
+	db 0
+NotParent:
+	dw Parent.child.fail

test/asm/remote-local-noexist.out

@@ -0,0 +1,2 @@
+ERROR: remote-local-noexist.asm(7):
+	'Parent.child.fail' is a nonsensical reference to a nested local symbol

test/asm/remote-local.asm

@@ -0,0 +1,7 @@
+SECTION "sec", ROM0
+
+Parent:
+.child:
+	db 0
+NotParent:
+	dw Parent.child

test/asm/test.sh

@@ -1,6 +1,11 @@
+#!/bin/sh
 fname=$(mktemp)
+rc=0
 
 for i in *.asm; do
 	../../rgbasm $i >$fname 2>&1
 	diff -u $fname ${i%.asm}.out
+	rc=$(($? || $rc))
 done
+
+exit $rc

test/asm/undefined-dot.out

@@ -1,2 +1,3 @@
-ERROR:	undefined-dot.asm(3) :
+ERROR: undefined-dot.asm(3):
 	'.' not defined
+error: Assembly aborted in pass 2 (1 errors)!

test/asm/update-refs.sh

@@ -0,0 +1,9 @@
+#!/bin/sh
+fname=$(mktemp)
+
+for i in *.asm; do
+	../../rgbasm $i >$fname 2>&1
+	mv -f $fname ${i%.asm}.out
+done
+
+exit 0