The IBM 5100/5110 MAME Emulators How-To

Introduction

It finally happened on April 25, 2024: an emulator for the IBM 5100 finally was made available to the public (in MAME build 0.265). The honor goes to Patrick Mackinlay for cracking the IBM architecture of this, after volunteering many hours to make this available, and in a way that takes advantage of all the debug and visualization capabilities of MAME.

Initially I had misunderstood Patrick, I thought he wanted to put the Corti-derived IBM 5110 emulator into MAME. But no, Patrick was trying to tell me that he had independently developed an IBM 5100 emulator (essentially “clean room” style on his own just from the available IBM documentation), and in fact he was having the opposite problem that we were having: we were struggling to emulate the 5100 after already having a 5110 emulator, while he was struggling (a bit, for one day) to emulate the 5110 after he had his 5100 emulator up and going. Very neat to see two independent approaches come to the same conclusion: there was one fundamental difference between these two systems, that were otherwise quite similar!

Here is the link to one of the early 5100 emulation merges committed to MAME (note it is dated April 1st, 2024, but this is no Aprils Fools tease!):
https://github.com/mamedev/mame/commit/85a3c394d20e82da9e1dd6f40d2be6ac2ac3cece

Awesome job Patrick, many thanks! Though this does suggest the IBM 5100 is just “yet another Turing complete code crank” 🙂 Still, the 5100 is an example of how a microprocessor isn’t the only way to make a computer. That is, however the machine cycles through instructions (it could be a sewing machine for all that matter), emulation is just interpreting some instruction set that manipulates some registers or address space. But then beyond that, a “system” then coordinates that fundamental capability into user-features and the speed/performance and utility of those system features is what sets one system apart from another. Did the features of the IBM 5100 make it worth over $6,000 in 1975? (that was for the very base model, while fully decked out models were up to $20K). Maybe this emulator will now help examine that question. But by our estimates, only about 30,000 units of IBM 5100/5110’s were sold – but they were all sold and put to good use at small businesses (such as doctor offices or parts-production shops, where “small” to IBM still means dozens of employees to payroll).

HOW TO RUN THIS EMULATOR (on desktop PC)

Norbert integrated Corti’s original IBM 5110 emulator into a JavaScript for online usage (here), which also had a nice looking front end (and some limited file support for LOADing content). But this MAME version opens up a lot of new features to help explore “under the hood” of the address space, with breakpoints and debug monitors, etc.

Then, from the command-line, run MAME like this:

  • mame ibm5100 -window -nomax -ui_active -debug
  • mame ibm5110 -window -nomax -ui_active -debug
  • Alternative: or just run MAME.EXE and use the menu to navigate/search to IBM5100 and IBM5110 and run them that way (but without the debug/UI utilities).
  • NOTE “j2.ros ROM NEEDS REDUMP WARNING: the machine might not run correctly.” This message corresponds to the fact that the DISPLAY ROM content was not yet extracted, and instead we’ve reconstructed a “best guess” approximation of what we think that ROS content ought to be (from various sources, like the IBM manuals and CRT screenshots of all the font symbols). For the IBM 5110, this is the g2.ros instead of j2.ros (but same idea).

The emulation should look similar as this:

  • Once the emulation is started, press F12 to just run and hide the debug window. Or don’t pass the -debug on command line.
  • Within the emulation window, press TAB and go to “Machine Configuration” to adjust settings like amount of RWS/RAM and BASIC vs APL.
  • NOTE: For the first cycle, the screen content you see on the CRT corresponds to whatever the first defined font entry looks like.
  • Press F4 (then ENTER) to see the “tile editor” which will show the character font in more details. [ WARNING: this doesn’t seem to work anymore as of MAME 0.277 ]
  • Use F10 to toggle a “warp” mode that will run the emulator as fast as possible on your system. NOTE: Pressing INSERT seems to invoke a temporary warp or fast-forward mode. This is useful to quickly fast-forward through the initial memory check and ROS CRC checks.
  • F11 to see CPU runtime stats of how close your system is maintaining the expected speed of the emulated system.
  • Avoid the temptation to press ESCAPE! Doing so will close/exit the emulation.

Please understand the emulator will be a little difficult to use with a modern keyboard until you get used to a few keymap settings (which you can also customize yourself, though I try to get myself used to how things are “out of the box”). There will be a bit of a learning curve since this system doesn’t use “normal” ASCII anywhere (SCRL-LOCK can toggle interception of keys by the emulator itself, if -ui_active ever gets in your way). Also, especially if you’ve never typed on one of the original keyboards, the arrangement is still different than anything after the 1981 IBM PC keyboard. Here is an initial guide that may help (at least for typical English keyboards):

  5100 Key    Mapping        NOTE
  --------    -------        ---------
  +/-         - / SHFT-      
  ×/÷         = / SHFT=      
  ←/→         ; / SHFT;      
  =           ' (or SHFT+5)  (next to ENTER, not next to 1)
  [/(         [ / SHFT[        
  ]/)         ] / SHFT]            
  #/@         \ / SHFT|            
  ;           SHFT < (,)
  :           SHFT > (.)
  &/$         ` / SHFT~      (by default, also pause emulation)

  l/r/u/d     arrow keys     
  Attention   DELETE         
  Hold        BACKSPACE      
  Execute     ENTER          
  Command     L/R Control    (example: CTRL+1 is "LOAD" keyword command)

  "           SHIFT+1
  '           SHIFT+K        (single quote for strings, not double)
  <           SHIFT+3
  >           SHIFT+7
  ^           SHIFT+Y        (exponential)

OTHER EDITING FEATURES:
CTRL+LEFT ARROW    insert a space (move current line content to the right)
CTRL+RIGHT ARROW   like pressing delete to erase the current character
                     (i.e. move current line content to the left)
CTRL+DELETE        erase from cursor to the rest of the current line

Some other tidbits and notes:

  • Note that apostrophe ` is also mapped to bring up the debug window in MAME, as well as a mapped key to the IBM 5100/5100 system. So, for example, after typing $ (dollar sign) using open apostrophe, you might need to press F12 again to resume the emulation.
  • TIP: Configure the machine with less RWS (RAM, memory) to boot it up faster.
  • If you type a mistake, the system will flash and show an up-arrow starting at the mistake. Press DELETE (translates to ATTN) to acknowledge the error and proceed to fix the syntax error.
  • To INSERT a space/blank, use CTRL+RIGHT ARROW.
  • There is no NEW keyword, instead you type “LOAD 0” (basically “load nothing” tells BASIC to re-initialize itself – note this is why you see “LOAD 0” during startup of the system)
  • A string quote on this system if SHIFT+K (single quote) which works for PRINT
  • Many APL symbols are entered by typing SHIFT A-Z.
  • You can PRINT any symbol using X (hex) like this: assign a string variable A$=X’00’ then PRINT A$.
  • To make an exclamation mark (!), first type “.” (dot, period) then cursor left and then type SHIFT+K (you can do this in reverse also, where you can type SHIFT+K first, cursor left back over, and then type “,”). For a list of other overstruck characters, refer to here.
  • To reset the system, you can do TAB -> Machine Configuration -> Reset System at the bottom of the popup menu

HOW TO ENTER THE DCP (what in more modern systems we could call “the monitor”)

During the ROS checksum during startup for the 5100, you can press CTRL+DELETE to invoke the key that originally corresponds to COMMAND+ATTN, and this will enter the DCP (Diagnostic Control Program). Don’t do this when the “ABCDEFGH” letters are the only thing present on the display, wait until the bootup process is showing the ROS number (where it is doing CRC checks on those modules). If you do CTRL+DELETE too early in the process, the system will just show you the keyboard scan code of whatever key you first pressed.

This DCP is a program built into the System ROS (ROM) that essentially lets you activate a machine code monitor (so you can enter machine code into RWS/RAM and execute it). The DCP also has features to SAVE regions of RWS/RAM to cassette (and disk, for the 5110) and, of course, to LOAD file content back into RWS/RAM later. I made a video of using the DCP on an IBM 5100 to do this (here about 20minutes into the video, for the IBM 5110 version see about 90 seconds into this video here).

The machine code used here would be what is called the PALM instruction set. A documentation on that instruction set is available here: IBM_5100_DOCS/PDFs_5100/IBM5100_ISA_opcodes_micro-instruction_set.pdf at main · voidstar78/IBM_5100_DOCS

TBD: I am working on a more concise overview of the instruction set, that includes both IBM and Corti’s alternative mnemonics (either one is supported by the AS assembler).

For the IBM 5110 emulation, so far CTRL+DEL during startup doesn’t seem to be working reliably (it works on the IBM 5100 emulation, and on the real systems the sequence is the same; so this inconsistency in the emulator is a little curious). Instead, use the regular documented way to enter the DCP., which goes like this:

  • after the Language (APL or BASIC) has booted to its prompt, do CTRL+BACKSPACE (original keys were CMD+HOLD),
  • keep holding CTRL (CMD) and then press NUMBER-PAD MINUS (original key CMD+MINUS). It must be minus on the number pad, not the one near BACKSPACE. This can be a problem for laptops that don’t have an easy proxy to the number pad. For laptop, I remapped NUMBER PAD – MINUS like this (using the MAME TAB menu, Input Assignments, scroll down to KEYPAD -, and I set it to CTRL ALT \ ):
  • IMPORTANT: One more step – to actually get into DIAG mode where you use the BR command, keeping holding CMD and also press KEYPAD+ASTERICK (original CMD+ASTERICK, star). At the top of the screen, it should now say “DIAG DCP.” Likewise, on a keyboard without a keypad, you might need to remap this as well.
  • To clarify, there are “two stages” to the DCP. In the first stage, you can use “D” (or A) to display memory content, and then there is a way to return back to the Language prompt. But in the second stage, now you can do Execute and other commands, but won’t be able to return back to the language prompt without doing a reset. This “second stage” is indicated by the word “DIAG” (diagnostic) appearing at the top of the screen. If you don’t see that, then the Branch command and some other DIAG features won’t be available.
  • The following is how the manual descripts entering the DCP, but you then have to use CMD+ASTERICK to get into the more interesting “full DCP mode.” You might need to press this a couple times (whether the IBM 5100 or IBM 5110, it should say “DIAG” near the top of the screen to indicate you are now fully in “diagnostic” mode).

Below is one of the shortest PALM machine code examples, that is also visually interesting, that I came up with. It shows the entire display card character set, so you can see each encoded symbol. Once in DCP, you would type “A” to ALTER an address, then specify 2000 at the hex offset (you can use other addresses, but the example below was hard-coded to start at address 2000). Type in a couple lines of machine code (then SPACEBAR to finish on the 5100, use ENTER on the 5110). Use “D” DISPLAY to verify the entry, then use “BR” (branch run) to execute the code at the address of 2000.

The emulators do not yet support the tape or disk systems, but that’s still in work — hopefully someday we can exercise the SAVE and LOAD features of the DCP (the operations are described in the IBM MIM manuals) and load other archived media for these systems.

Here is the assembly that corresponds to this machine code (there are note further below on how to paste this into the emulator, but I would manually type the CODE content as a practice for a few times):

ADDR   CODE       PALM ASSEMBLY     COMMENTS
----   ----       -------------     ----------
2000   D501 0200  LWI R5, #$0200  ; Begin of display buffer
2004   8606       LBI R6, #$06    ; High byte of end address
2006   8740       LBI R7, #' '    ; Blank (Hex $40) (use 8700 on 5100) 
2008   7750       MOVB (R5)+, R7 
200A   C567       SBSH R5, R6 
200C   F005       BRA $2008

200E   D501 0200  LWI R5, #$0200  ; Let REG[R5] = Begin of display 
                                    buffer 0x0200
2012   8604       LBI R6, #$04    ; High byte of end address  (256 only)
2014   8700       LBI R7, 00      ; start R7 at 0x00
2016   7750       MOVB (R5)+, R7  ; RWS[R5] = value in R7 
                                    (and increment R5)
2018   0772       INC R7,R7       ; increment R7
201A   0552       INC R5,R5       ; increment R5 (to skip a column)
201C   C567       SBSH R5, R6     ; SKIP if all bits in R6 are also 
                                    set in HI(R5)
201E   F009       BRA $2016       ; 8 bytes (4 instructions) plus one 
                                    extra byte
2020   0000       HALT

NOTE: Because of the HALT at the end, this program might not let you access back to the DCP. It would be better to replace the HALT with a JUMP that goes back to 2000, to repeat the execution. Anyway, I suggest using D to display and make sure you’ve typed in the sequence correctly before running.

More machine code examples will be at the end.

Some Technical Aspects and Examples

The following is my diagram from a couple years ago, which depicted my “best guess” of where the ROS/ROM code was arranged across the cards of the system. This shows 232KB of “included software” on the IBM 5100, and 284KB on the IBM 5110. “included” meaning in what we later call a System ROM and available as-delivered with the system (and these would be “fully configured” systems, with both BASIC and APL). NOTE: “nx” means non-executable, which means “not native PALM processor” content (the system uses emulators to run the “nx” code).

Comparison of IBM 5100/5110 ROS vs Card-Slot Arrangements

Tom originally had this extracted into three files: exeros.bin [64KB], binary_BCom.bin [54KB], binary_APL_LROS.bin [96KB]. This is all complete, except what was hard (for me) to realize is that the BCom (BASIC and Common) is both ROS Control/Common (in PALM) and BASIC (in System/3 code), and the last 18KB there is the ROS Control portion that actually resides in a different card slot (but is still accessed seamlessly “after BASIC NX” across the logical address space). Patrick organized the ROS/ROM by slot, which does align with my earlier diagram (where based on the SLM, the 18KB for the ROS Control had to be on that card, but at the time it seemed to me this had to be accessed as a different Device – but that turned out not to be necessary):

  • c2.ros [32KB]: APL NX ROS #3 (S/370 code)
  • c4.ros [36KB]: BASIC NX ROS (System/3 code)
  • d2.ros [32KB]: APL NX ROS #1 (S/370 code)
  • d4.ros [32KB] APL NX ROS #2 (S/370 code)
  • e2.ros [18KB] ROS Control (was part of BASIC NX in Tom’s original bin)
  • h2.ros [32KB] BASIC, IO, Diagnostics, Executable ROS
  • h4.ros [32KB] APL Supervisor

For j2.ros [2KB], note that the Display ROS character set was not extracted by Corti or Tom, and it is unknown if it actually could be (perhaps as some undocumented Device?). But based on the IBM manuals and inline screen captures of the systems, Patrick was able to reconstruct what that character set ROS “most likely” would be arranged as (and in a format that is readable by the existing ROS executive software). To zoom in on that a little bit, the top portion of that j2.ros (which is just data, not code) is like this:

I’m not sure how the padding from 08 to 0F columns was determined (maybe just trial and error), but decoding the first non-blank row (the sequence of “10 28 44 82 AA 82 82 00” in hex), we get this (symbol “A” which is indeed the first non-blank character for the IBM 5100, but is different for the IBM 5110):

For the IBM 5110: Corti extracted the IBM 5110 ROS essentially in the same groups (APLNX, APLROS, BASICNX, BASIC, Common ROS, Executive ROS). He began the “NX” term to represent “non-executable” ROS – from this perspective, the APL/BASIC NX is just “data” that happens to correspond to “code of a different instruction set (that this system doesn’t support executing natively, hence “non-executable”). So that would be the S/370 and S/3 code. Common ROS, APL ROS, BASIC ROS are all in PALM machine code, to coordinate the mechanism where this new CRT/keyboard system wraps around a legacy line-printer system.

  • e4.ros (128KB): All of APL NX ROS is now in a single half-card
  • f2_b.ros (72KB): BASIC NX ROS
  • f2_c.ros (16KB): Common ROS (common aspects, like getting keystrokes, display codes, printer, and tape/disk IO)
  • g2.ros (4KB): Character set (artificially derived, not extracted)
  • l2_1.ros (32KB): Executable ROS
  • l2_2a.ros (20KB): APL ROS (Supervisor)
  • l2_2b.ros (16KB): BASIC ROS (coordinates “line printer” input/output to the CRT/keyboard interfaces)

For completeness, let’s examine that g2.ros for a bit:

This is the “first character” on the 5110 (which on the IBM 5100 was “purely blank”). So, it matches the expectation, though still unsure where the padding from 08 to 0F comes from.

For reference, here is the full character set between the two systems, IBM 5100 and IBM 5110:

Note how the later IBM 5110 is more EBCDIC like than the IBM 5100. Right around the time ASCII was emerging as a standard, IBM tried to internally standardize their own systems around what they called EBCDIC (both starting around early 1960s). ASCII eventually gained wider acceptance, but it is curious why the IBM 5100 “did its own thing” rather than adopt either standard.

IBM 5100 reference images of cards:
IBM 5100 context: https://vintagecomputer.ca/ibm-5100-in-pictures/
https://deskthority.net/viewtopic.php?t=20163
https://www.oldcomputr.com/ibm-5100-1975/ (good APL examples)

BASIC EXAMPLES

I have an original print of IBM 5100 BASIC Computer Aided Instruction (IBM SR30-0076-0) which I don’t think has been archived yet. It has a few interesting BASIC examples:

A plotting example (Example 3.2), a straightforward depiction of a sinusoidal wave in text mode.

40 P=800
50 FOR I=0 TO P STEP 15
55 PRINT I,'  :';
60 FOR J=1 TO (20+(SIN(RAD(I))*15))
70 PRINT ' ';
80 NEXT J
90 PRINT '*'
100 NEXT I

Example 3.3: Solving for simultaneous equations, a wonderful example of the power of matrix operations.
5a + 9b + 5c = 10
3a + 5b + 6c = 15
2a + 3b + 9c = 14

10 DIM A(3,1),B(3,3),C(3,3),X(3,1)
30 MAT READ A
50 MAT READ B
70 MAT C=INV(B)
80 MAT X=C*A
140 MAT PRINT X
150 REM VALUES FOR MATRIX A
160 DATA 10,15,14
170 REM VALUES FOR MATRIX B
180 DATA 5,9,5,3,5,6,2,3,9
190 STOP

Does it work? Check the result: a=62.8, b=-33, c=-1.4 Answer: YES!

Exercise 2.1: (revised to use READ instead of INPUT) This is an example of sorting numbers using BASIC. They can be floating-point DATA also. Just adjust line 200 to the desired numbers (or a real world example would load them in from a file or serial IO). Use a “very small number” as a marker for when the data is finished being gathered.

20 N=1
30 READ A
40 IF A<-999 GOTO 48
45 A(N)=A
46 N=N+1
47 GOTO 30
48 N=N-1
50 FOR J=1 TO N 
60 FOR I=1 TO (N-1)
70 Z=A(I)-A(I+1)
80 IF Z<0 GOTO 110
90 A(I)=A(I+1)
100 A(I+1)=A(I+1)+Z
110 NEXT I
120 NEXT J
130 FOR I=1 TO N
140 PRINT A(I)
150 NEXT I
160 STOP
200 DATA -5, -8, 64, 0, 37,-8, -9999

And just to show that the system can this, you can issue a “RENUM” command to clear up some of the line numbers into increments of 10.

Exercise 2.4: Find Volume of Cube vs Sphere (modified to find the intercept of when the volume of the sphere matches that of the cube). That is, imagine you have a cube with edge-length of 10 units (adjust variable i to whatever actual edge you want to test). Find an equivalent ball that would end up having same volume as this cube (i.e. find a radius of such a sphere). Mostly this is just an example of how to use the DEF FUNCTION feature.

10 DEF FNA(I)=4/3*&PI*(I^3)
20 DEF FNB(J)=J^3
30 I=10
35 J=I
40 G=GNB(I)
50 V=FNA(J)
60 IF V<G GOTO 100
70 J=J-0.1
80 GOTO 50
100 PRINT G;V
110 PRINT I;J
120 PRINT 'CUBE','BALL'
130 PRINT 'EDGE','RADIUS'

Machine Code Examples

If you have a set of PALM machine code – first, know what address it needs to be ran out. Some code might be “re-locatable” and can run from anywhere. But a lot of code will be assembled with the assumption of a starting point (.org or origin point), and branches will get hard-coded relative to that. So using the Ball Bounce as an example, I know it was coded to start at 0x0B00.

Now, there is a way to paste into the emulator. If you load the DCP, then use “A” to alter an address, the cursor is blinking waiting for content at the address you specified to alter. You can paste a sequence of text using SHIFT+SCROLL LOCK (this may work at APL and BASIC prompts). But, as they say, “YMMV” (your mileage may vary) depending on a few factors, and the paste might just be very slow (Patrick warned this is an experimental option; it worked a few times for me, but it has also dropped characters, so maybe try pasting only in small steps). If you’re on a laptop or some setup that doesn’t readily have a SCROLL LOCK, you can adjust the setting like this (MAME configuration, use TAB):

Here is another way that I’ve found to quickly get the emulator to run this code is by the following steps:

  • Enter the DCP as described earlier.
  • Get your code arranged into a hex sequence that corresponds to the PALM instruction set. One way to do this is, if you have an assembled .asm file in a .bin, you can copy the hex values directly out of something like HXD. CTRL+C this into the copy buffer. Here is what the Ball Bounce code as a sequence of hex values would look like:
2152DF010CCE51F8021C9204B201012D
315210770203D0210B660203D0210B7E
2150D2010CC881115121810351218111
5128D7010200D4010CCAD345C30BA007
A73F0331C303F007D3470738D3416678
73780203D0210BD60203D0210BE67678
F02FD0010CAAD5010200D60104008740
77500661086C0866C803F00B0024D501
04CA8605D701FFFF5758F600C60BA003
A53FF00BD50102B286035758F600C60B
A003A53FF00BD501031E86085758F600
C60BA003A53FF00BD501052686045751
F600C603F007D501041486035751F600
C603F0070024DF010BB8FF000EFC0EF6
CE03F0090024D5010CCCDF58D5010CC8
DA580DA48310CF3DA011AA008C3FCAC9
A017BF100803D0810C9CA00DFA00CA03
A0079F100803D0810C9CCAD8A0030E72
A0010E7168E889FFC892A00D0AD48910
0F970803D0810C9CA0595A58D5010CCA
DA588301CF3DA011AA008C0FCAC9A017
BF010803D0810C9CA00DFA00CA03A007
9F010803D0810C9CDB58CAB8A003AE3F
A001FE3F68E889FFC892A015D5010CC8
5D58D5010CCA0AB489010F970803D081
0C9C5A58D5010CCC5F58002489FF107E
F900C903F005107D0084DF010CCED1F8
315228FC8220C82E110428E738682867
0880205600FD0040000A000A00110000
  • In the emulator, press ` (tilde) key (near escape) – it doesn’t seem to matter if the emulator is in-focus or not – and this will pause/suspend the IBM 5100/5110 emulation (if you ran it with the -debug option). In the emulator debug menu, select Debug|New Memory Window
  • In that Memory window, use the drop down to select “IBM PALM rws space memory” (you want to modify RWS, Read/Write Storage aka main memory).
  • Go down to the offset address appropriate for this program (0x0B00 in this Ball Bounce example) and do Paste (NOTE: Ball Bounce as in the example above is coded for the 5110, only a couple minor changes are necessary to make it work for the IBM 5100 — the sound code has to be disabled and the display code used for the wall and ball).
  • I think the RWS memory updates are immediate. You can “X” or close the Memory window.
  • F12 to resume the emulation. Then if you are in the DIAG DCP, then do “BR” (branch run) at the address your code is running at. In this case “BR 0B00”. If you accidentally type something wrong, ATTN (or pressing DELETE) will generally exit. Don’t press ESCAPE locally, since that will just exit the entire emulator and lose the system state entirely.
  • Here is the “display font” program if you want to practice with a shorter example. Pasting into the memory will automatically ignore white spaces and CR/LF. This program can go at basically any address (say B800 or higher, I wouldn’t place it below 0600).

D5010200
86068740
7750C567
F005D501
02008604
87007750
07720552
C567F009
0000

OPTION 3: ANOTHER WAY TO SAVE/LOAD STATE…

In the debug UI at the bottom is a little command prompt. You can type HELP SAVE there to see the parameters for the SAVE command. save allram.bin,0,ffff will result in a 64KB file in the folder you were in when you launched MAME, which can then likewise be loaded later (loadd filename,addr where the extra d on load is directed to the RWS on this system, use “bp addr” to set breakpoints). You can adjust the parameters to write RWS/RAM content more precisely, like if we’re working just at 0x0B00 or 0x2000.

Using the Alfred Arnold Assembler

For this walk through, to get the STAR.ASM example, refer to here. This discusses both BASIC and the assembly version of this program: IBM 5100 Programming Examples — voidstar

To get the Alfred Arnold assembler, which includes support for IBM 5100/5110 PALM:

The Macro Assembler AS (rwth-aachen.de)

Go to “things that can be downloaded” and pick your platform (an old emulated DOS or a Win32 build). aswcurr.zip (AS for Windows, Current – I assume that’s what the filename refers to).

How you setup the path is up to you, but as one example of the usage of ASW for the IBM5110, here is an example:

That is ASW is extracted fully to its own folder awscurr from where I am working, then I manually path into aswcurr\bin\asl.exe like so:

aswcurr\bin\asl.exe -cpu ibm5110 -i aswcurr\include star.asm
aswcurr\bin\p2bin.exe star.p

That results in a .p file that has a little header that we don’t need. To remove that, use the ASW tool p2bin.exe like this:

As mentioned earlier, you can then open up the resulting star.bin file into HXD. Highlight all the hex sequence and CTRL+C to copy it (it won’t copy the Decoded Text part). Like this:

Paste that into 0x2000 (because the STAR.ASM uses ORG $2000 near the top) of the emulators RWS memory space. Note, this example is for the IBM 5110 (the code will still mostly work on the IBM 5100, but the spacebar feature won’t work – the address for polling that is a bit different on the 5100).

Go to the DIAG DCP, issue command “BR 2000”, should look like this:

TBD: APL program example?

Leave a Reply