PiDP-8/I Software: Changes To A Field Guide to PDP-8 Assemblers

[pml]: https://groups.google.com/forum/#!forum/pidp-8
[sml]: http://mailman.trailing-edge.com/mailman/listinfo/simh


# The Assemblers


## PAL-III
## <a id="pal-iii" name="pal3"></a>PAL-III

| **Introduced** | 1965
| **Manual** | [PDF, 790 kB](http://www.telegraphics.com.au/doc/paliii.pdf)
| **Delivery** | paper tape

The PAL-III assembler shipped on [punched paper tape](https://en.wikipedia.org/wiki/Punched_tape) as part of the grandiosely-named "PDP-8 Assembly System." This amounted to an assembler, an editor, a debugger, and a loader, each a separate paper tape. The programmer would first toggle the RIM loader into the PDP-8's front panel, then use that to load the BIN loader from yet a fifth paper tape, then run each of these tapes through the paper tape reader repeatedly — reusing the still-in-core BIN loader each time — in order to iterate his way toward a working program!

The assembler tape required at least two passes through the tape reader in order to produce a computer-readable BIN format output tape, plus an optional third pass if you wanted a human-readable listing on the terminal.

If you look at pictures of PDP-8 computers, you can often see a tray with narrow slots in it, each meant to hold one of these key paper tapes, as they were needed near at hand when using the computer. There is a good picture of a blue one on [the cover of the 1974 edition of the OS/8 Handbook](https://archive.org/stream/bitsavers_decpdp8os8_39414792/OS8_Handbook_Apr1974?ui=embed#page/n0/mode/1up).

PAL-III can be considered the baseline assembler for a PDP-8, since almost every PDP-8 at least included some kind of paper tape reader, and most of the other assemblers surveyed here share its basic syntax.


## MACRO-8
## <a id="macro-8"></a>MACRO-8

| **Introduced** | 1965
| **Manual** | [PDF, 1.7 MB](https://www.grc.com/pdp-8/docs/MACRO-8_Programming_Manual.pdf)
| **Delivery** | paper tape

MACRO-8 was another paper tape assembler for the PDP-8. Its main advantage over PAL-III is that it added [macros](https://en.wikipedia.org/wiki/Macro_instruction), a very useful feature in assembly language programming as it reduces a lot of the tedium of writing such programs.


## PAL-D
## <a id="pal-d"></a>PAL-D

| **Introduced** | 1967
| **Manual** | ??
| **Delivery** | paper tape

PAL-D is basically PAL-III for the [PDP-8 Disk Monitor System](https://en.wikipedia.org/wiki/4K_Disk_Monitor_System), one of OS/8's predecessors.


## The OS/8 Assemblers
## <a id="os8"></a>The OS/8 Assemblers

| **Introduced** | 1971
| **Manual** | most any OS/8 manual, such as [this 1974 edition][os8m]
| **Delivery** | part of OS/8

[OS/8](https://en.wikipedia.org/wiki/OS/8) was [the primary programming system from DEC][faq10] for the PDP-8 in its later years. It included several different assemblers, all documented in its manual, one edition of which is linked above.

The introduction date is that of OS/8, but OS/8 has a [complicated development history][faq10] that stretches back to 1966 or so. I do not mean by this grouping to imply that they were all created and introduced at the same time. As historical evidence arrives, I will make finer distinctions in the dates. Until then, we have a years-wide window for each of these OS/8 assemblers' creation dates: after PAL-III (1965) and before 1974, the publication date of the linked manual.

[faq10]: http://www.faqs.org/faqs/dec-faq/pdp8/section-10.html
[os8m]: https://archive.org/details/bitsavers_decpdp8os8_39414792


### PAL8
### <a id="pal8" name="pal-8"></a>PAL8

PAL8 understands the same basic language as PAL-III and generally has more features, most especially related to running under OS/8, such as the ability to set options via OS/8's command interpreter (CCL) rather than via the PDP-8's front panel switches.

I consider it the default assembler for OS/8 users. If none of the information below guides you to one of the other assemblers, you should probably start with PAL8. If you have a piece of assembly code that is meant to be assembled under OS/8, and you have no evidence that is for any other assembler, it's probably meant to be assembled by PAL8.

PAL8 has many features not present in PAL-III:








-
+












-
+

    *   `RELOC`: assemble code for relocation after loading
    *   `XLIST`: suppress part of the listing output
    *   `ZBLOCK`: reserve memory, setting initial values to zero

PAL-III has one feature not implemented in PAL8:  the ability to get a brief listing of the undefined symbols in a program. The information is instead presented inline in the listing output, not grouped together into a single place, which can make refinement of an in-development program tedious as you need to comb information about undefined symbols out from among all the other output.


### RALF/FLAP
### <a id="ralf" name="flap"></a>RALF/FLAP

RALF is the back-end assembler for OS/8's FORTRAN IV compiler. As a result of that support role, it has a few primary advantages over PAL8:

*   relocatable output code

*   easy access to the optional [floating-point processor](http://dustyoldcomputers.com/pdp12/fpp12.html)

The RALF assembler has a mode switch that causes it to generate absolute-addressed code, as PAL8 does. In this mode, it is called FLAP.

The FPP modes are the key advantage of RALF/FLAP. Vincent Slygnstad [suggests](http://so-much-stuff.com/pdp8/C/Assembler.php) that you think of these as assemblers for the FPP rather than for the PDP-8.


### SABR
### <a id="sabr"></a>SABR

As RALF is to OS/8's FORTRAN IV compiler, so [SABR](http://homepage.cs.uiowa.edu/~jones/pdp8/faqs/#langs) is to OS/8's FORTRAN II compiler.

SABR is a relative assembler, unlike PAL8 or FLAP, meaning that the OS/8 linking loader (`LOADER.SV`) adjusts all of the addresses in the assembled `*.RL` output to their final values.

SABR does not have any tie to the FPP, unlike RALF/FLAP.








-
+












+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+





-
+

-
+





+

+
+
+
-
+


[Ian Schofield's CC8 compiler][cc8] compiler operates like the OS/8 FORTRAN II compiler, emitting SABR output and depending upon the FORTRAN II library and runtime. Inline assembly via `#asm` is sent as-is to SABR.

[cc8]: /doc/trunk/src/cc8/README.md
[mm8]: https://tangentsoft.com/pidp8i/wiki?name=PDP-8+Memory+Addressing


## MACREL
## <a id="macrel" name="macrel-2"></a>MACREL

| Introduced | 1980
| Manual | [text, 384 kB](http://vandermark.ch/pdp8/uploads/PDP8/PDP8.Manuals/AA-J073A-TA.txt)
| Delivery | DECtape for OS/8

Although this is technically another OS/8 assembler, its late introduction, separate documentation, and separate distribution from OS/8 proper require that we consider it separately.

Aside from MACRO-8, none of the assemblers above support macros, a very helpful feature in assembly language programming. MACREL was intended to be DEC's offered solution to the want of a macro assembler for the PDP-8 in the disk-based operating system era.

Unfortunately, it never achieved widespread use outside of DEC.


## <a id="smal" name="smal8"></a>SMAL8

| **Introduced** | 1980, 2012
| **Manual** | [SMAL32][smal32], [SMAL8][smal8]
| **Delivery** | Internet, same links as above

SMAL is a series of cross-assemblers initially created by [Douglas W. Jones][dwj]. He wrote the initial versions in Pascal but later ported it to C. Some versions of SMAL — such as the SMAL32 version linked above for its wonderful manual — are machine-independent, meaning that it provides only the skeleton of the assembler, and is not able to generate code for any particular machine. Other versions of SMAL were targeted at specific machines, mostly 8-bit microcontrollers. Oddly enough, Dr. Jones did not base his `pal.c` PDP-8 cross-assembler upon SMAL. (See [palbart](#palbart) below for more on that thread of history.)

Vincent Slyngstad took up the challenge of targeting SMAL at the PDP-8, producing [SMAL8][smal8], offering it as part of his [C compiler system for the PDP-8](http://so-much-stuff.com/pdp8/C/C.php).

The basic syntax of SMAL8 is roughly in the PAL-III family. Because of the spare feature set of [PAL-III](#pal-iii), it is likely to compile a large subset of programs meant for PAL-III, but there are enough differences between SMAL8 and [PAL8](#pal8) that it is likely to assemble only relatively simple programs. 

If you read through the SMAL32 manual and see differences relative to PAL syntax but don't see the difference documented below, chances are that Vincent Slyngstad fixed these differences in SMAL8. For example, like PAL8 but unlike SMAL32, SMAL8 uses `/` to introduce comments, defaults to octal, allows `*` to set the output origin, and uses the `EJECT` pseudo-op rather than `PAGE` to put a page break into the output listing.

SMAL8 has many feature additions relative to PAL8:

*   relocatable output
*   `MACRO` and `ENDM`: MACREL-like macro feature
*   `COMMON`, `EXTERNAL`, `GLOBAL`: module and linkage support
*   comparison operators in expressions `<` and `>`
*   bit shifting operators in expressions `<<`, `>>`, and `>>>`
*   double and single quoted strings; PAL8 supports only double-quoted single-character constants
*   labels separated from the code by either comma (PAL8 style) or colon (SMAL32 style)
*   arbitrary radices in numeric constants using `r#n` syntax, which gives `n` base `r`
*   the &brvbar; operator is allowed as an alias for PAL8's `!` form of Boolean OR
*   `ABS`, `DEF`, `FWD`, `LEN`, `REL`, `TYP` assembly-time functions

Some things are simply different in SMAL8 as compared to PAL8:

*   powerful expressions in SMAL allow modern `IF`, `ELSE`, `ELSEIF` and `ENDIF` for conditional assembly
*   `PAGE` takes no argument, as in [SABR](#sabr)

There are also some features removed relative to PAL8:

*   multiplication not allowed in expressions; `*` was given PAL8 meaning and `^` not implemented as PAL8 multiply
*   division not allowed in expressions; `/` was given PAL8 meaning and `%` not implemented as PAL8 divide
*   no inline literals, either the `(N)` or `[N]` syntaxes; parens used for groups and lists instead

Some features of SMAL32 were removed in SMAL8, either to be compatible with PAL8 or simply because the PDP-8 is too different from the abstract 32-bit machine assumed by the original design of SMAL32:

*   the byte (`B`), halfword (`H`), threeword (`T`), and fullword (`W`) data storage specifiers do not work

[dwj]: http://homepage.divms.uiowa.edu/~jones/
[smal8]: http://so-much-stuff.com/pdp8/C/Assembler.php
[smal32]: http://homepage.divms.uiowa.edu/~jones/cross/smal32/


## palbart
## <a id="palbart"></a>palbart

| **Introduced** | 1996
| **Manual** | [man page](http://manpages.ubuntu.com/manpages/artful/man1/palbart.1.html)
| **Delivery** | Internet, PiDP-8/I project

This assembler was written by Gary A. Messenbrink — and later enhanced by several others — to support the fleet of PDP-8/e computers in the [Bay Area Rapid Transit](https://en.wikipedia.org/wiki/Bay_Area_Rapid_Transit) system; thus the name.
`palbart` is a popular fork of the `pal.c` assembler by [Douglas W. Jones](http://homepage.divms.uiowa.edu/~jones/) and Rich Coon, originally spun off by Gary A. Messenbrink — and later enhanced by several others — to support the fleet of PDP-8/e computers in the [Bay Area Rapid Transit](https://en.wikipedia.org/wiki/Bay_Area_Rapid_Transit) system; thus the name.

We ship a version calling itself "pal-2.13, 03 May 2015" as part of the PiDP-8/I project. If you place a `*.pal` file in either its `asm` or `examples` subdirectories, then type `make`, the project's build system will generate several output files named after the input file:
The PiDP-8/I software distribution includes a version calling itself "pal-2.13, 03 May 2015." If you place a `*.pal` file in either the `asm` or `examples` subdirectories of the software distribution, then type `make`, the build system will find your file and generate several output files named after it:

*   **<code>obj/*.lst</code>** — the assembler's text listing output, giving the assembled machine code alongside the source code, plus any error messages
*   **<code>bin/*.pt</code>** — the machine code output in RIM paper tape format, suitable for loading into SIMH's PDP-8 simulator
*   **<code>boot/*.script</code>** — a SIMH init script that deposits the machine code into the PDP-8 simulator's core memory and starts it running; pass the file name to `bin/pidp8i-sim`

This makes for a very smooth code-build-run-debug cycle!

At this time, we do not yet have a comprehensive list of differences relative to PAL-III or PAL8.


## pdpnasm
## <a id="pdpnasm"></a>pdpnasm

| **Introduced** | 2006
| **Manual** | see its [home page][pdpnasm]
| **Delivery** | [Internet][pdpnasm]

This is a PDP-8 assembler accepting the PAL-III syntax for Unix type systems.

︙
45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106	45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106	- + - + - + - + - +	[pml]: https://groups.google.com/forum/#!forum/pidp-8 [sml]: http://mailman.trailing-edge.com/mailman/listinfo/simh # The Assemblers ~~## PAL-III~~ ## <a id="pal-iii" name="pal3"></a>PAL-III \| Introduced \| 1965 \| Manual \| [PDF, 790 kB](http://www.telegraphics.com.au/doc/paliii.pdf) \| Delivery \| paper tape The PAL-III assembler shipped on [punched paper tape](https://en.wikipedia.org/wiki/Punched_tape) as part of the grandiosely-named "PDP-8 Assembly System." This amounted to an assembler, an editor, a debugger, and a loader, each a separate paper tape. The programmer would first toggle the RIM loader into the PDP-8's front panel, then use that to load the BIN loader from yet a fifth paper tape, then run each of these tapes through the paper tape reader repeatedly — reusing the still-in-core BIN loader each time — in order to iterate his way toward a working program! The assembler tape required at least two passes through the tape reader in order to produce a computer-readable BIN format output tape, plus an optional third pass if you wanted a human-readable listing on the terminal. If you look at pictures of PDP-8 computers, you can often see a tray with narrow slots in it, each meant to hold one of these key paper tapes, as they were needed near at hand when using the computer. There is a good picture of a blue one on [the cover of the 1974 edition of the OS/8 Handbook](https://archive.org/stream/bitsavers_decpdp8os8_39414792/OS8_Handbook_Apr1974?ui=embed#page/n0/mode/1up). PAL-III can be considered the baseline assembler for a PDP-8, since almost every PDP-8 at least included some kind of paper tape reader, and most of the other assemblers surveyed here share its basic syntax. ~~## MACRO-8~~ ## <a id="macro-8"></a>MACRO-8 \| Introduced \| 1965 \| Manual \| [PDF, 1.7 MB](https://www.grc.com/pdp-8/docs/MACRO-8_Programming_Manual.pdf) \| Delivery \| paper tape MACRO-8 was another paper tape assembler for the PDP-8. Its main advantage over PAL-III is that it added [macros](https://en.wikipedia.org/wiki/Macro_instruction), a very useful feature in assembly language programming as it reduces a lot of the tedium of writing such programs. ~~## PAL-D~~ ## <a id="pal-d"></a>PAL-D \| Introduced \| 1967 \| Manual \| ?? \| Delivery \| paper tape PAL-D is basically PAL-III for the [PDP-8 Disk Monitor System](https://en.wikipedia.org/wiki/4K_Disk_Monitor_System), one of OS/8's predecessors. ~~## The OS/8 Assemblers~~ ## <a id="os8"></a>The OS/8 Assemblers \| Introduced \| 1971 \| Manual \| most any OS/8 manual, such as [this 1974 edition][os8m] \| Delivery \| part of OS/8 [OS/8](https://en.wikipedia.org/wiki/OS/8) was [the primary programming system from DEC][faq10] for the PDP-8 in its later years. It included several different assemblers, all documented in its manual, one edition of which is linked above. The introduction date is that of OS/8, but OS/8 has a [complicated development history][faq10] that stretches back to 1966 or so. I do not mean by this grouping to imply that they were all created and introduced at the same time. As historical evidence arrives, I will make finer distinctions in the dates. Until then, we have a years-wide window for each of these OS/8 assemblers' creation dates: after PAL-III (1965) and before 1974, the publication date of the linked manual. [faq10]: http://www.faqs.org/faqs/dec-faq/pdp8/section-10.html [os8m]: https://archive.org/details/bitsavers_decpdp8os8_39414792 ~~### PAL8~~ ### <a id="pal8" name="pal-8"></a>PAL8 PAL8 understands the same basic language as PAL-III and generally has more features, most especially related to running under OS/8, such as the ability to set options via OS/8's command interpreter (CCL) rather than via the PDP-8's front panel switches. I consider it the default assembler for OS/8 users. If none of the information below guides you to one of the other assemblers, you should probably start with PAL8. If you have a piece of assembly code that is meant to be assembled under OS/8, and you have no evidence that is for any other assembler, it's probably meant to be assembled by PAL8. PAL8 has many features not present in PAL-III:
︙
123 124 125 126 127 128 129 ~~130~~ 131 132 133 134 135 136 137 138 139 140 141 142 ~~143~~ 144 145 146 147 148 149 150	123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150	- + - +	* `RELOC`: assemble code for relocation after loading * `XLIST`: suppress part of the listing output * `ZBLOCK`: reserve memory, setting initial values to zero PAL-III has one feature not implemented in PAL8: the ability to get a brief listing of the undefined symbols in a program. The information is instead presented inline in the listing output, not grouped together into a single place, which can make refinement of an in-development program tedious as you need to comb information about undefined symbols out from among all the other output. ~~### RALF/FLAP~~ ### <a id="ralf" name="flap"></a>RALF/FLAP RALF is the back-end assembler for OS/8's FORTRAN IV compiler. As a result of that support role, it has a few primary advantages over PAL8: * relocatable output code * easy access to the optional [floating-point processor](http://dustyoldcomputers.com/pdp12/fpp12.html) The RALF assembler has a mode switch that causes it to generate absolute-addressed code, as PAL8 does. In this mode, it is called FLAP. The FPP modes are the key advantage of RALF/FLAP. Vincent Slygnstad [suggests](http://so-much-stuff.com/pdp8/C/Assembler.php) that you think of these as assemblers for the FPP rather than for the PDP-8. ~~### SABR~~ ### <a id="sabr"></a>SABR As RALF is to OS/8's FORTRAN IV compiler, so [SABR](http://homepage.cs.uiowa.edu/~jones/pdp8/faqs/#langs) is to OS/8's FORTRAN II compiler. SABR is a relative assembler, unlike PAL8 or FLAP, meaning that the OS/8 linking loader (`LOADER.SV`) adjusts all of the addresses in the assembled `*.RL` output to their final values. SABR does not have any tie to the FPP, unlike RALF/FLAP.
︙
205 206 207 208 209 210 211 ~~212~~ 213 214 215 216 217 218 219 220 221 222 223 224 ~~225~~ 226 227 228 229 230 ~~231~~ 232 ~~233~~ 234 235 236 237 238 239 ~~240~~ 241 242 243 244 245 246 247	205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298	- + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + + + + + - +	[Ian Schofield's CC8 compiler][cc8] compiler operates like the OS/8 FORTRAN II compiler, emitting SABR output and depending upon the FORTRAN II library and runtime. Inline assembly via `#asm` is sent as-is to SABR. [cc8]: /doc/trunk/src/cc8/README.md [mm8]: https://tangentsoft.com/pidp8i/wiki?name=PDP-8+Memory+Addressing ~~## MACREL~~ ## <a id="macrel" name="macrel-2"></a>MACREL \| Introduced \| 1980 \| Manual \| [text, 384 kB](http://vandermark.ch/pdp8/uploads/PDP8/PDP8.Manuals/AA-J073A-TA.txt) \| Delivery \| DECtape for OS/8 Although this is technically another OS/8 assembler, its late introduction, separate documentation, and separate distribution from OS/8 proper require that we consider it separately. Aside from MACRO-8, none of the assemblers above support macros, a very helpful feature in assembly language programming. MACREL was intended to be DEC's offered solution to the want of a macro assembler for the PDP-8 in the disk-based operating system era. Unfortunately, it never achieved widespread use outside of DEC. ## <a id="smal" name="smal8"></a>SMAL8 \| Introduced \| 1980, 2012 \| Manual \| [SMAL32][smal32], [SMAL8][smal8] \| Delivery \| Internet, same links as above SMAL is a series of cross-assemblers initially created by [Douglas W. Jones][dwj]. He wrote the initial versions in Pascal but later ported it to C. Some versions of SMAL — such as the SMAL32 version linked above for its wonderful manual — are machine-independent, meaning that it provides only the skeleton of the assembler, and is not able to generate code for any particular machine. Other versions of SMAL were targeted at specific machines, mostly 8-bit microcontrollers. Oddly enough, Dr. Jones did not base his `pal.c` PDP-8 cross-assembler upon SMAL. (See [palbart](#palbart) below for more on that thread of history.) Vincent Slyngstad took up the challenge of targeting SMAL at the PDP-8, producing [SMAL8][smal8], offering it as part of his [C compiler system for the PDP-8](http://so-much-stuff.com/pdp8/C/C.php). The basic syntax of SMAL8 is roughly in the PAL-III family. Because of the spare feature set of [PAL-III](#pal-iii), it is likely to compile a large subset of programs meant for PAL-III, but there are enough differences between SMAL8 and [PAL8](#pal8) that it is likely to assemble only relatively simple programs. If you read through the SMAL32 manual and see differences relative to PAL syntax but don't see the difference documented below, chances are that Vincent Slyngstad fixed these differences in SMAL8. For example, like PAL8 but unlike SMAL32, SMAL8 uses `/` to introduce comments, defaults to octal, allows `` to set the output origin, and uses the `EJECT` pseudo-op rather than `PAGE` to put a page break into the output listing. SMAL8 has many feature additions relative to PAL8: relocatable output * `MACRO` and `ENDM`: MACREL-like macro feature * `COMMON`, `EXTERNAL`, `GLOBAL`: module and linkage support * comparison operators in expressions `<` and `>` * bit shifting operators in expressions `<<`, `>>`, and `>>>` * double and single quoted strings; PAL8 supports only double-quoted single-character constants * labels separated from the code by either comma (PAL8 style) or colon (SMAL32 style) * arbitrary radices in numeric constants using `r#n` syntax, which gives `n` base `r` * the ¦ operator is allowed as an alias for PAL8's `!` form of Boolean OR * `ABS`, `DEF`, `FWD`, `LEN`, `REL`, `TYP` assembly-time functions Some things are simply different in SMAL8 as compared to PAL8: * powerful expressions in SMAL allow modern `IF`, `ELSE`, `ELSEIF` and `ENDIF` for conditional assembly * `PAGE` takes no argument, as in [SABR](#sabr) There are also some features removed relative to PAL8: * multiplication not allowed in expressions; `` was given PAL8 meaning and `^` not implemented as PAL8 multiply division not allowed in expressions; `/` was given PAL8 meaning and `%` not implemented as PAL8 divide * no inline literals, either the `(N)` or `[N]` syntaxes; parens used for groups and lists instead Some features of SMAL32 were removed in SMAL8, either to be compatible with PAL8 or simply because the PDP-8 is too different from the abstract 32-bit machine assumed by the original design of SMAL32: * the byte (`B`), halfword (`H`), threeword (`T`), and fullword (`W`) data storage specifiers do not work [dwj]: http://homepage.divms.uiowa.edu/~jones/ [smal8]: http://so-much-stuff.com/pdp8/C/Assembler.php [smal32]: http://homepage.divms.uiowa.edu/~jones/cross/smal32/ ~~## palbart~~ ## <a id="palbart"></a>palbart \| Introduced \| 1996 \| Manual \| [man page](http://manpages.ubuntu.com/manpages/artful/man1/palbart.1.html) \| Delivery \| Internet, PiDP-8/I project ~~This~~ assembler was wri~~tten~~ by Gary A. Messenbrink — and later enhanced by several others — to support the fleet of PDP-8/e computers in the [Bay Area Rapid Transit](https://en.wikipedia.org/wiki/Bay_Area_Rapid_Transit) system; thus the name. `palbart` is a popular fork of the `pal.c` assembler by [Douglas W. Jones](http://homepage.divms.uiowa.edu/~jones/) and Rich Coon, originally spun off by Gary A. Messenbrink — and later enhanced by several others — to support the fleet of PDP-8/e computers in the [Bay Area Rapid Transit](https://en.wikipedia.org/wiki/Bay_Area_Rapid_Transit) system; thus the name. ~~We ship~~ a version calling itself "pal-2.13, 03 May 2015~~" as part of the PiDP-8/I project.~~ If you place a `.pal` file in either ~~its~~ `asm` or `examples` subdirectories, then type `make`, the ~~project's~~ build system will generate several output files named after ~~the input file~~: The PiDP-8/I software distribution includes a version calling itself "pal-2.13, 03 May 2015." If you place a `.pal` file in either the `asm` or `examples` subdirectories of the software distribution, then type `make`, the build system will find your file and generate several output files named after it: * *<code>obj/.lst</code>** — the assembler's text listing output, giving the assembled machine code alongside the source code, plus any error messages * *<code>bin/.pt</code>** — the machine code output in RIM paper tape format, suitable for loading into SIMH's PDP-8 simulator * *<code>boot/.script</code> — a SIMH init script that deposits the machine code into the PDP-8 simulator's core memory and starts it running; pass the file name to `bin/pidp8i-sim` This makes for a very smooth code-build-run-debug cycle! At this time, we do not yet have a comprehensive list of differences relative to PAL-III or PAL8. ~~## pdpnasm~~ ## <a id="pdpnasm"></a>pdpnasm \| Introduced \| 2006 \| Manual \| see its [home page][pdpnasm] \| Delivery** \| [Internet][pdpnasm] This is a PDP-8 assembler accepting the PAL-III syntax for Unix type systems.
︙

Changes to "A Field Guide to PDP-8 Assemblers" between 2017-12-10 12:35:58 and 2017-12-10 14:32:52