Apple Assembly Line
Volume 8 -- Issue 7 April 1988

68HC11 Cross Assembler Now Here!

At long last, I have written a cross assembler for the Motorola 68HC11. A lot of you have been asking about it, and thanks to the persistence of one customer it is now available. See our ad on page 3 for pricing and a list of other cross assemblers.

A Visit to Phoenix

The weekend of June 10-12 I attended the AZ Apple Fiesta in Phoenix, Arizona. (How can this be reported in the "April" issue? Sorry, we are still woefully behind in the publishing schedule, it is now late June.) The main attraction for me was a chance to spend a day at Western Design Center with Bill Mensch, the chief designer of the 65816 and its predecessors.

Secondly, I wanted to attend Randy Hyde's mini-conference on a new standard for 6502 family assembly language. Randy was there, with Brian Fitzgerald who now supports and markets the Lisa assembler. Roger Wagner represented the Merlin interests, and Mike Westerfield the ORCA/M and APW. Paul Santa-Maria and Chuck Kelly from ProDev Inc. in Michigan came to see about standardizing a symbol table format for use with symbolic debuggers. I also met P. J. Curran from ProData 21 in Florida. Since one cannot fly the 1000 miles to Phoenix directly from Dallas for less than $250 each way, I drove 200 miles south to Austin to get a round trip ticket for only $138. Bill Morgan lives in Austin now, and he decided to come also. Jeff Creamer and Don Lancaster were also involved in this conference. As far as I could tell, we did not make any real decisions about any changes to existing assemblers, or even future ones. Neither did we gain any hard data about the new opcodes and addressing modes of the 65832. But it was a very positive meeting.

Bill Mensch gave several interesting talks regarding the history of the 6502 family and its future. The 65832 is on the horizon, but not fully defined. We know it will have 32-bit registers, multiply/divide instructions, and probably even floating point arithmetic. We can also be certain it will be plug compatible with the 65816, so we will be able to plop them directly into Apple IIgs sockets. We still have opportunity to send ideas for its features to Bill. Suggestion: do it in writing, be brief, keep any such letter to one or two ideas and no more than two pages. If you have more ideas, send them in separate letters, giving Bill time to digest them. Send your ideas direcly to Bill at Western Design Center, 2166 East Brown Road, Mesa, AZ 85213. If you are VERY serious, give him a call at (602)962-4545.

You might also want to write for information about their new line of microCOMPUTERs: the W65C134 includes a 65C02, RAM, ROM, and oodles of I/O goodies all in one 68-pin package; the W65C265 will be even better, and built around a 65C816; and the W65C365 will include a 65C832.

A real highlight of the trip was meeting Don Lancaster, and his wife and daughter. Don was there to show and sell his many books and disks full of Apple and Postcript knowledge, and both he and wife Bea gave several seminars during the conference. If you are doing ANYTHING with laser printers, you need to look at what Don has. His "Ask the Guru" column in Computer Shopper is a gold mine, and you can get a neatly bound set of reprints for only $24.50. Speaking of gold mines reminds me of caves, and the fact that the Lancasters are avid spelunkers.

Bill and I also enjoyed our lengthy discussions with Jeff Creamer, Steve Stephenson, and John & Ron Wrenholt. Jeff is a teacher in Prescott, AZ, and has published in these pages. Steve is chief programmer for Checkmate Technology, and gave me some wonderful disk files about AppleWorks. Expect to see some of his stuff here in the near future. John is the founder of Big Red Apple Club, now called Big Red Computer Club. He and brother Ron have quite a lot to offer any Print Shop afficionados, including a new program which lets you print labels with color graphics.

"Do not be conformed to this world,
but be transformed by the renewing of your mind,
that you may discover
the good, and acceptable, and perfect will of God."

Peeking Inside AppleWorks 1.3, Part 5:
Menu Display and Selection Subroutines
Bob Sander-Cederlof

Part 5 already? This is rapidly turning into a major series, and a popular one at that. A lot of you have called or written telling how much you like it (thank you!), so I will do my best to keep it interesting and useful.

This month I am going to document some subroutines which constitute a major portion of the "AppleWorks Human Interface". Namely, the menu display and selection subroutines.

We hear so much these days about the MacIntosh human interface, and indeed it has become the standard for the IIgs, like it or not. Personally, I can live with it, but I prefer plain old text menus. Why? They are faster, consume less of the computer's resources (leaving more of them for end users), and are quicker (for me) to use. Well-designed text menus with a consistent screen layout and selection method are easier for me than icons and mice.

How can that be? I thought Apple had proven the icon menu to be easier? I suppose they decided that after asking "the rest of us", leaving out the experienced computer people. But isn't text what we are trained from childhood to read? Some languages are written with icons (Chinese, for example), but MOST languages are written with text. And isn't the text-menu drilled into us from childhood also? Even the word "menu" reminds us of a list of textual lines for selecting the components of a meal. And what about multiple-choice tests?

And even some of the Apple folk believe in text, as is evidenced by the Control Panel and other Classic Desk Accessories on the IIgs.

All the above to justify adding my voice to that of Tom Weishaar. Tom is the author of the Open-Apple newsletter, which all Apple II lovers ought to read. We both think the AppleWorks human interface is a great starting point for the Apple II general operating environment. With just a little improvement, mostly in the area of pathname entry, and just a little generalization, we could use it for running all sorts of applications and compilers for all sorts of languages.

AppleWorks has an amazingly consistent human interface throughout. At almost every level you will see a simple list of numbered choices, with the same control scheme. One of the lines will be displayed in inverse mode, and you can either move the "bar" with the up- and down-arrow keys, or by typing the item number. When the bar is on your choice, the RETURN key will select it. ESCAPE will pop out of the menu to the previous level. You can usually get a help screen by typing Apple-?. The directions for getting help are shown at the right end of the bottom line, and the action ESCAPE will cause are shown at the right end of the top line.

If there happen to be more than nine numbered options, so that some of them have two-digit options, AppleWorks even allows you to move the bar to the two-digit lines by typing their numbers. When you type a digit, the bar moves to one of the first nine lines. Then if you type a second digit, AppleWorks tries to move to the line with that two-digit number. If there is not one, you will hear a beep. If there is, the bar will move to that line. You can observe this action even on a menu with fewer than ten lines. When you select a line by typing a digit, you will not only see the bar move, but also the help and escape messages will change. On the top line you will see "Escape: Erase entry", and on the bottom line instead of an offer of help you will see "xxxK Avail." (the number of available memory bytes). When you type a second digit, you hear the beep and the help and escape info changes back to what it was before you typed the first digit.

Pretty slick. Until now I always assumed that numeric selection would either be limited to single-digit items, or that I would have to require a terminating character from the user so I would know when he had typed all the digits. Robert Lissner wins again! (Some of you have pointed out his name used to be "Rupert", but I read somewhere that he now prefers "Robert", or Bob.)

AppleWorks also allows the menu items to be anywhere on the screen. They do not even all have to be in one column, or vertically aligned. You can use single, double, or even variable vertical spacing.

Look ahead to the DISPLAY.MENU.LINE subroutine, lines 4580-5190. When you want to put a menu on the screen, you call this subroutine. The variable LAST.LINE.NUMBER.OF.MENU must be initially zeroed, and this subroutine will increment it each time you call. You call this subroutine once for each numbered line of your menu. Call it like this:

       .DA #column,#line
       .DA string

The string parameter is the address of a string which begins with a length byte. Column and line numbers are either absolute or relative. If you give values like 0-23 for line and 0-79 for column, they are absolute. If you add $80 to line and/or column, it/they become relative to the coordinates stored in MENU.CORNER.LEFT and MENU.CORNER.TOP. Lines 4850-5000 compute the actual coordinates of the beginning of your menu line.

A block of 93 bytes called MENU.TABLE allows for keeping track of 30 menu lines. Each entry in this table is three bytes, and the zero'th entry is not used. Each time you call DISPLAY.MENU.LINE one entry is added to this table. Each three-byte entry consists of the column, line, and length of the menu item.

DISPLAY.MENU.LINE also takes care of prefixing the menu line number. You do not include it in your string. (This allows you to use the same strings in different menus.) Lines 4690-4800 start building a display string in what I call the STR.A00 buffer. It begins with token $05, which means "position cursor". Then it inserts the line number in the format " d. " or "dd. ". Lines 4850-5000 insert the chosen cursor position after the $05 token. Lines 5010-5140 append your string to this position and line number string. Finally, lines 5150-5190 display the result.

So you can see that to put a complete menu on the screen we would first zero LAST.LINE.NUMBER.OF.MENU; then clear the window we are using; then call DISPLAY.MENU.LINE once for each menu item; and finally, add any titles and explanations.

Once a menu is on the screen, the next logical step is to call SELECT.MENU.LINE so the user can tell you his choice. This subroutine is shown beginning at line 2000. You call it with a line number in the A-register. The subroutine even expects that you have just loaded that number into the A-register, because it starts with a BEQ instruction. If the EQ status is set, probably meaning you just did a LDA #0, the menu will begin with the bar on the first menu line. You will also get the first item if the value in A is larger than the last menu item number, or if A=1. You can begin with any other line by putting that line number in A. You could keep track of the item selected that last time this menu was used, like Copy II Plus does.

The subroutine finally returns when you type either ESCAPE, Apple-?, or RETURN. In the first two cases MENU.LINE.SELECTED and the A-register will be zero; in the third case they will be, you guessed it, the number of the menu line selected.

Lines 2000-2110 figure out which line you want to begin with, and inverse it. Unless, that is, the value in Z.A4 is non-zero. I think that variable must be an "escape flag" of some sort. If it is non-zero, SELECT.MENU.LINE exits the same way it would if you typed the ESCAPE key.

Lines 2120-2130 display the generic instructions for making a menu selection on the screen. The text of this message is shown in lines 5200-5230.

The rest of SELECT.MENU.LINE divides nicely into two main sections. Lines 2150-2770 handle the selection until you type a digit; lines 2780-3430 take over when you type a digit, and don't let go until you either type an arrow (up-, down, or left-), DELETE, RETURN, or ESCAPE. I noticed a significant chunk of duplicate code in the two sections: see lines 2420-2470 and lines 3330-3380. I feel certain that the code could be re-arranged a little and save space. We don't really need it, but a little here and a little there could make room for many new features.

Lines 2150-2190 invert the current line, move the cursor down to the bottom line at the end of the "Type..." message, and wait for you to type something. If you remember AW.KEYIN from the Feb 88 issue, it will also take its own action if you type certain keys. For example, Apple-/ gets changed into Apple-?; Apple-Q and Apple-S store a non-zero value in Z.A4 and change the character to ESCAPE; and several other interesting things. Look at page 13 in that issue, lines 2580-2790, for a summary.

Look ahead to lines 2900-3000 for an interesting use of the Z.A4 flag. If you typed Apple-Q or Apple-S, it will be changed into ESCAPE by AW.KEYIN and Z.A4 will be set non-zero. Then the test at 2970-2980 will make the jump all the way to SML.ESCAPED. If you typed ESCAPE, that test will merely send you back to SML.WAITING. Interesting.... So if you are at this level, where the escape info line says "Escape: Erase entry": typing one ESCAPE takes you back to SML.WAITING; typing two ESCAPEs would get you to SML.ESCAPED, or typing one Apple-Q would do the same thing. Whoever called SELECT.MENU.LINE can tell the difference, though, because Z.A4 will still be non-zero for Apple-Q or zero for two ESCAPEs. (For some reason I never can remember what Apple-Q and -S are really used for.)

Lines 2240-2310 branch appropriately for up- or down-arrow or RETURN. Lines 2590-2770 handle the up- and down-arrows: simply a matter of changing the display of the current line back to normal mode, and raising or lowering the selected line number. The line number changes circularly, so that up-arrow off the top wraps around to the bottom, and down-arrow at the bottom goes to the top.

Lines 2340-2500 check for a digit and operate on it. Notice that only digits 1-9 are accepted here, while digits 0-9 are accepted at lines 3170-3200. This will be the first digit of a menu line number, so it cannot be zero. The other place it will be the second digit, so it could be zero. If this first digit is acceptable (between 1 and the last menu line number), lines 2420-2470 will echo the character at the cursor on line 23, restore the current line to normal mode, and store the new menu line number.

Lines 2480-2490 call a subroutine in the $D000 area to change the escape and help info. This subroutine decides which pair of messages to display by the letter in the caller's A-register. Letter "E" makes escape say "Escape: Erase entry" and help say how much memory is left. Letter "S", used in lines 1910-1920, makes help say "Apple-? for help" and escape say whatever string was saved in a buffer at $0CFD. The subroutine has several other options.

There appears to be either a bug or a leftover at lines 2520-2530. If you type Apple-? you get to this line. It loads up Z.89, and then acts like you typed ESCAPE. However, the contents of Z.89 are not needed here, because the first instruction after the JMP is another LDA!

I have probably already said enough about lines 2800-3430, especially since it is so similar to the section above. I would, however, like to look at a few lines. The code in lines 3210-3280 multiplies the previous menu line number by ten and adds in the next digit. At first glance it looks reasonably efficient for space, since it calls on a multplication subroutine. Nevertheless, I can recode it in one less byte and many fewer cycles without calling the subroutine. Change lines 3210-3280 to the following:

       3210    AND #$0F        isolate new digit
       3220    STA Z.91        save for later
       3240    ASL             old * 2
       3250    ASL             old * 4
       3260    ADC MENU.LINE.SELECTED  old*5
       3270    ASL             old * 10
       3280    ADC Z.91        plus new digit

Let's move ahead. When you type RETURN, lines 3600-3720 will clear line 23, restore the selected line to normal mode, and draw an arrow over the line number ("-->"). Either ESCAPE or RETURN brings you to lines 3740-3810, which erase the MENU.TABLE and return with the selected line number in the A-register. It makes no sense to me to erase MENU.TABLE, since it will not be used again until it is re-loaded anyway, but maybe there is some reason it is needed.

Lines 3860-4540 will copy the selected line off the screen into a buffer at $0900, and then re-display it in one of three ways: the entire line NORMAL, the entire line INVERSE, or just the portion (A) characters long starting in column (X) in INVERSE.

Now if only AppleWorks could handle pathname entry as easily! The human interface presented by such Quit Code replacements as ProSel, Squirt, or the S-C Program Selector would be an improvement.

  1000 *SAVE AW.SRC.V8N7
  1010        .list moff
  1020 *--------------------------------
  1030 PSTR   .EQ $80,81
  1040 CHAR.FROM.KEYIN     .EQ $84
  1060 Z.89   .EQ $89
  1070 Z.91   .EQ $91      result of multiply here
  1080 P0     .EQ $9A      parameters from GET.4.PARMS
  1090 P1     .EQ $9B           "
  1100 P2     .EQ $9C           "
  1110 Z.A4   .EQ $A4      escape flag???
  1120 *--------------------------------
  1130 STR.A00    .EQ $A00
  1150 MENU.CORNER.TOP     .EQ $0FBF
  1160 *--------------------------------
  1170        .DUMMY
  1180        .OR $0EB6
  1190 MENU.TABLE .BS 3*31      Room for 30 3-byte entries
  1210        .ED
  1220 *-------------------------------------Covered in AAL---
  1230 DISPLAY.STRING           .EQ $14D1   Jan 88, page 10
  1250 BEEP.AND.CLEAR.KEYBUF    .EQ $1818
  1260 MOVE.CURSOR.TO.XY        .EQ $1823   Feb 88, page 17
  1270 MULTIPLY.X.BY.Y          .EQ $1B3A
  1280 COPY.SCRN.LINE.TO.0900   .EQ $187A   Feb 88, page 18
  1290 GET.4.PARMS              .EQ $18AE   Dec 87, page 7
  1300 AW.KEYIN                 .EQ $1D35   Feb 88, page 12
  1320 POINT.PSTR.AT.STR.A00    .EQ $1EA9   Feb 88, page 18
  1330 MOVE.STRING              .EQ $1EF8   Dec 87, page 8
  1340 DISPLAY.AT               .EQ $1F3E
  1350 CLEAR.KEYBUF             .EQ $1FE0   Feb 88, page 17
  1360 DISPLAY.STRING.P0        .EQ $2093
  1370 DISPLAY.TOKEN.X          .EQ $1FE9
  1380 DISPLAY.ON.LINE.23       .EQ $1FF5
  1390 *--------------------------------
  1410 *--------------------------------
  1420        .MA MSG      Macro to make a string with
  1430        .DA #:1-*-1  first byte is the length,
  1440        .AS "]1"     the rest is ASCII.
  1450 :1
  1460        .EM
  1470 *--------------------------------
  1480        .PH $18DD
  1490 *--------------------------------
  1500 *   Load X-reg with pointer into MENU.TABLE
  1510 *      which is menu line number times 3.
  1520 * (18DD) 18E4 18F2 1A4D
  1550        ASL
  1570        TAX
  1580        RTS
  1590 *--------------------------------
  1600 *   Re-display entire line in NORMAL mode.
  1610 * (18E4) 1973 198B 199A 1A21 1A39 1A4A
  1640        LDA MENU.TABLE+1,X   Get screen line #
  1650        TAY
  1660        LDA #$00     Display entire line NORMAL
  1670        TAX
  1690        RTS
  1700 *--------------------------------
  1710 *   Re-Display the menu line in INVERSE mode.
  1720 * (18F2) 1936 19AF 1A27
  1750        LDA MENU.TABLE+2,X   get length of menu msg
  1760        PHA
  1770        LDA MENU.TABLE+1,X   get screen line #
  1780        TAY
  1790        LDA MENU.TABLE,X     get starting column of msg
  1800        CLC
  1810        ADC #4               skip over "##. "
  1820        TAX               start at blank before msg itself
  1830        PLA               get length again
  1840        CLC
  1850        ADC #2            include leading and trailing blank
  1870        RTS
  1880 *--------------------------------
  1890 * (190C) 19D8 19E2 19EC 19F6
  1910        LDA #$53
  1940        JSR DISPLAY.STRING.P0
  1950        .DA TWO.BLANKS
  1960        RTS
  1970 *--------------------------------
  1980 TWO.BLANKS .HS 02.20.20
  1990 *--------------------------------
  2000 *      (A) = menu line number; if =0, or >lastline, use 1
  2010 *--------------------------------
  2030        BEQ .1       Use top menu line
  2050        BCC .2       Use selected line
  2060        BEQ .2       Use selected line (bottom)
  2070 .1     LDA #1       Use top menu line
  2090        LDA Z.A4
  2100        BEQ .3
  2120 .3     JSR DISPLAY.ON.LINE.23
  2130        .DA MENU.MSG "Type number, or use arrows, then press Return"
  2140 * (1936) 1997 19AC 19DB
  2170 .1     JSR CLEAR.KEYBUF
  2190        JSR AW.KEYIN
  2200        CMP #$1B     did he type ESCAPE?
  2210        BNE .2       ...not ESCAPE
  2220        JMP SML.ESCAPED
  2230 *--------------------------------
  2240 .2     CMP #$0D     is it RETURN?
  2250        BNE .3       ...not RETURN
  2260        JMP SML.RETURN
  2270 *--------------------------------
  2280 .3     CMP #$0B     up arrow?
  2290        BEQ SML.UP.ARROW
  2300        CMP #$0A     down arrow?
  2310        BEQ SML.DOWN.ARROW
  2320        CMP #"?"     Apple and "?"
  2330        BEQ .5       ...question mark
  2340        CMP #$31
  2350        BCC .6       ...not digit, beep!
  2360        CMP #$3A
  2370        BCS .6       ...not digit, beep!
  2380        AND #$0F
  2400        BEQ .4       ...bottom line
  2410        BCS .6       ...beyond the bottom, beep!
  2420 .4     PHA          save the digit typed
  2430        LDX CHAR.FROM.KEYIN
  2440        JSR DISPLAY.TOKEN.X
  2460        PLA          get digit typed again
  2470        STA MENU.LINE.SELECTED  select line 1-9
  2480        LDA #$45
  2500        JMP SML.DIGIT
  2510 *---Apple-? typed----------------
  2520 .5     LDA Z.89     ...why? opcode JMPed to is LDA also!
  2540 *--------------------------------
  2560        BNE .1       ...always
  2570 *--------------------------------
  2580 * (198B) 1952 19EF
  2620        BNE .1       ...still in range
  2650 .1     JMP SML.WAITING
  2660 *--------------------------------
  2670 * (199A) 1956 19F9
  2720        BCS .1       ...already on bottom, wrap to top
  2730        INC MENU.LINE.SELECTED   next line down
  2740        BNE .2       ...always
  2750 .1     LDA #1       top line now
  2770 .2     JMP SML.WAITING
  2780 *--------------------------------
  2790 * (19AF) 197E
  2800 SML.DIGIT
  2830        LDX #$07     CURSOR RIGHT TOKEN
  2840        JSR DISPLAY.TOKEN.X
  2860        CMP #10      on line 1-9?
  2870        BCC .2       ...yes
  2880        LDX #$07     CURSOR RIGHT TOKEN
  2890        JSR DISPLAY.TOKEN.X
  2900 .2     JSR AW.KEYIN get another char, maybe 2nd digit
  2910        CMP #$1B     is it ESCAPE?
  2920        BEQ .3       ...yes
  2930        CMP #$08
  2940        BEQ .3       ...backspace
  2950        CMP #$7F it DELETE?
  2960        BNE .4       ...yes
  2970 .3     LDA Z.A4
  2980        BNE SML.ESCAPED
  3000        JMP SML.WAITING
  3010 *--------------------------------
  3020 .4     CMP #$0D     is it RETURN?
  3030        BNE .5
  3050        JMP SML.RETURN
  3060 *--------------------------------
  3070 .5     CMP #$0B     up arrow?
  3080        BNE .6
  3100        JMP SML.UP.ARROW
  3110 *--------------------------------
  3120 .6     CMP #$0A     down arrow?
  3130        BNE .7
  3150        JMP SML.DOWN.ARROW
  3160 *--------------------------------
  3170 .7     CMP #$30     another digit?
  3180        BCC .10      ...not a digit, beep!
  3190        CMP #$3A
  3200        BCS .10      ...not a digit, beep!
  3210        PHA          save the digit
  3230        LDY #10      multiply previous line# by 10
  3240        JSR MULTIPLY.X.BY.Y
  3250        PLA          add the new digit
  3260        AND #$0F
  3270        CLC
  3280        ADC Z.91     product here
  3290        BCS .10      ...too large, beep!
  3310        BEQ .8       ...bottom line
  3320        BCS .10      ...too large, beep!
  3330 .8     PHA          save the new line number
  3340        LDX CHAR.FROM.KEYIN
  3350        JSR DISPLAY.TOKEN.X
  3370        PLA          get the new line number
  3400 .9     JMP .1
  3410 *--------------------------------
  3430        BNE .9       ...always
  3440 *--------------------------------
  3450 * (1A32) 1946 19D6
  3470        LDA Z.A4
  3480        PHA
  3490        LDA #$00
  3500        STA Z.A4
  3520        PLA
  3530        STA Z.A4
  3540 * (1A3F) 192E 1983
  3560        LDA #$00
  3590 *--------------------------------
  3600 * (1A45) 194D 19E5
  3620        JSR DISPLAY.ON.LINE.23
  3630        .DA I.1A72   1 Byte String, Clear-Line Token
  3660        LDA MENU.TABLE+1,X
  3670        TAY          draw an arrow "-->" over number
  3680        LDA MENU.TABLE,X
  3690        TAX
  3700        JSR MOVE.CURSOR.TO.XY
  3710        JSR DISPLAY.STRING.P0
  3720        .DA ARROW
  3730 * (1A60) 1A43
  3750        LDA #0
  3760        LDX #3*31+1  entire table & highest line number
  3770 .1     STA MENU.TABLE-1,X
  3780        DEX
  3790        BNE .1
  3810        RTS
  3820 *--------------------------------
  3830 ARROW  >MSG " -->"
  3840 I.1A72 .HS 01.02    1 BYTE STRING, CLEAR LINE TOKEN
  3850 *--------------------------------
  3860 *   Re-display a screen line in INVERSE or NORMAL mode
  3870 *      (Y) = screen line to be re-displayed
  3880 *      (X) = column number to begin with
  3890 *      (A) = 0 then re-display entire line NORMAL
  3900 *      (A) > 78 then redisplay entire line INVERSE
  3910 *      (A) = length of middle section of line to be 
  3920 *            displayed in INVERSE.
  3930 *--------------------------------
  3940 RASL.X .BS 1
  3950 RASL.Y .BS 1
  3960 RASL.A .BS 1
  3970 *--------------------------------
  3980 * (1A77) 103F 18EE 1908
  4000        STX RASL.X   Save the column
  4010        STY RASL.Y   Save the line
  4020        STA RASL.A   Save the length
  4030        TYA          get line number
  4040        JSR COPY.SCRN.LINE.TO.0900
  4050        LDX #0       start in column 0
  4060        LDY RASL.Y   on line Y
  4070        JSR MOVE.CURSOR.TO.XY
  4080        LDA RASL.A   get specified length
  4090        BEQ .1       ...0 means display it all NORMAL
  4100        CMP #79
  4110        BCC .2 really is a length
  4120        LDX #$0A     ...>78, INVERSE the line
  4130        JSR DISPLAY.TOKEN.X
  4140 .1     LDA HANDLE.0900
  4150        STA PSTR
  4160        LDA HANDLE.0900+1
  4170        STA PSTR+1
  4180        LDA #79      display 79 characters
  4190        JSR DISPLAY.STRING
  4200        LDX #$0B     NORMAL TOKEN
  4210        JSR DISPLAY.TOKEN.X
  4220        JMP .3       ...ONLY AN RTS
  4230 *--------------------------------
  4240 .2     LDA HANDLE.0900   Point to line image
  4250        STA PSTR
  4260        LDA HANDLE.0900+1
  4270        STA PSTR+1
  4280        LDA RASL.X        Display up to X in NORMAL
  4290        JSR DISPLAY.STRING
  4300        LDX #$0A     INVERSE TOKEN
  4310        JSR DISPLAY.TOKEN.X
  4320        LDA RASL.X        Display middle section INVERSE
  4330        STA PSTR
  4340        LDA HANDLE.0900+1
  4350        STA PSTR+1
  4360        LDA RASL.A        # chars in middle section
  4370        JSR DISPLAY.STRING
  4380        LDX #$0B     NORMAL TOKEN
  4390        JSR DISPLAY.TOKEN.X
  4400        LDA RASL.X        Display rest of line NORMAL
  4410        CLC
  4420        ADC RASL.A
  4430        BCS .3       ...line too long, forget the rest
  4440        CMP #79
  4450        BCS .3       ...line too long, forget the rest
  4460        STA PSTR
  4470        LDA HANDLE.0900+1
  4480        STA PSTR+1
  4490        LDA #79      79 chars
  4500        SEC
  4510        SBC PSTR
  4520        BEQ .3 space left on the line
  4530        JSR DISPLAY.STRING
  4540 .3     RTS
  4550 *--------------------------------
  4560 HANDLE.0900 .DA $0900
  4570 *--------------------------------
  4580        .PH $2029
  4590 *--------------------------------
  4600 *   Display string P2 at P0,P1 after "xx.  "
  4610 *      where xx is decimal form of (LAST.LINE.NUMBER.OF.MENU)
  4620 *      LAST.LINE.NUMBER.OF.MENU is incremented by this routine
  4630 *      Stores 3 bytes in MENU.TABLE:
  4640 *          column, line, and string length
  4650 *      MENU.TABLE has room for 31 such entries.
  4660 *--------------------------------
  4680        JSR GET.4.PARMS   Get P0-P3
  4700        LDA #$05     "GO TO XY" TOKEN
  4710        STA STR.A00
  4740        STX STR.A00+3       blank or first digit of ##
  4750        STY STR.A00+4       units digit of ##
  4760        LDA #'.'
  4770        STA STR.A00+5       string is "##.  "
  4780        LDA #' '
  4790        STA STR.A00+6
  4800        STA STR.A00+7
  4820        ASL               multiply by 3
  4840        TAX               save for index into MENU.TABLE
  4850 *---Column number----------------
  4860        LDA P0       Get specified column
  4870        BPL .1 is absolute
  4880        AND #$7F is relative
  4890        CLC
  4900        ADC MENU.CORNER.LEFT
  4910 .1     STA STR.A00+1  Put column # into string
  4920        STA MENU.TABLE,X      and save in table
  4930 *---Line number------------------
  4940        LDA P1       Get specified line number
  4950        BPL .2 is absolute
  4960        AND #$7F is relative
  4970        CLC
  4980        ADC MENU.CORNER.TOP
  4990 .2     STA STR.A00+2  Put line # into string
  5000        STA MENU.TABLE+1,X   and save in table
  5010 *---Append text of menu line-----
  5020        LDY #0
  5030        LDA (P2),Y   Save length of string in table
  5040        STA MENU.TABLE+2,X
  5050        TAY          Point at last char in string
  5060        CLC          Compute length of combined strings
  5070        ADC #8       05.xx.yy "##.  " = 8 chars
  5080        TAX          Point at last char of combination
  5090        PHA          Save total length for display subr.
  5100 .3     LDA (P2),Y   get next char of caller's string
  5110        STA STR.A00-1,X     append to ours
  5120        DEX
  5130        DEY
  5140        BNE .3       ...more to copy
  5150 *---Display the string-----------
  5160        JSR POINT.PSTR.AT.STR.A00
  5170        PLA          Get length off stack
  5180        JSR DISPLAY.STRING
  5190        RTS
  5200 *--------------------------------
  5210        .PH $146A
  5220 MENU.MSG  >MSG "Type number, or use arrows, then press Return  "
  5230 *--------------------------------

ProDOS File Transformer Bob Sander-Cederlof

Have you ever wanted to convert a file from one filetype to another? I have, and it seems that there should be a command in BASIC.SYSTEM to allow it. Some other command shells, such as Davex by DAL Systems, do have such a command.

Of course, the flexibility of the BLOAD and BSAVE commands does allow you to get the job done. You can BLOAD the source file, specifying the filetype and load address; CREATE an empty file of the new type; and BSAVE into that new file, specifying the filetype, beginning RAM address, and length.

But what if you want to go just a little further, and also make some slight changes to the file's contents? Then you need an intelligent file transformer. You need a program that will ask for an input and an output pathname, read the input file and transform the data appropriately, and write the transformed data on the output file. This article presents a specific file transformer, and you may either use it as is or modify it to your own needs.

I have often been asked, by programmers who did not own the S-C Macro Assembler, for a program which would convert S-C source code files into ordinary text files. Back in the December, 1983, issue of Apple Assembly Line I published such a program, but it was written in Applesoft for running under DOS 3.3. I don't believe that program would operate properly under ProDOS, but even if it did it would be terribly slow.

Under DOS 3.3, S-C source code is stored in type "I" files. DOS does all the actual LOADing and SAVEing, being fooled into believing that the source code is Integer BASIC. Under ProDOS, S-C source code is stored in type $FA files, which Apple has set aside for Integer BASIC source programs. Since Integer BASIC has never been supported under ProDOS, and probably never will be, I chose to use this file type for S-C source code. In fact, when you are using the S-C Macro Assembler this filetype is called "S-C".

The source code text is stored in a slightly compressed format in these files. The same format is used for both the DOS and ProDOS versions, so that you can use Apple's CONVERT program or a utility like COPY II PLUS to move files from one operating system to the other. If you were to read a file byte-by-byte under both operating systems, you would notice one difference: under DOS the file's length is stored in the first two bytes; under ProDOS the length is kept in the directory.

Each line of S-C source code begins with a line number. This number may be any value from 0 to 65535. The transformer should write the source lines on the output text file without this line number, because most assemblers using text files for source do not use explicit line numbers.

Each line of S-C source code is stored in the file in a form first defined by Steve Wozniak's Integer BASIC:

       byte 1:  number of bytes in entire line (n)
       byte 2:  lo-byte of line number in binary
       byte 3:  hi-byte of line number in binary
bytes 4...n-1:  tokenized form of source line
       byte n:  00

For example, an empty line with line number 1000 would be stored as:

       04 E8 03 00

The tokenized form of S-C source is almost plain ASCII. Each byte is stored in ASCII with bit 7 zero, with two exceptions. First, blanks are stored in a compressed form. One blank is stored with the code $81; two blanks are stored with the single code $82; in general, a string of n consecutive blanks is stored with the single code $80+n. The largest compressed blank code is $BF, which stands for 63 consecutive blanks. If there are more than 63 blanks in a row, they will be represented by two or more compressed-blank codes. For example, the line

      1010 STAR   LDA #0     Zero

would be stored as:

      14           number of bytes in line = 20
      F2 03        line number is $03F2 = 1010
      53 54 41 52  "STAR"
      83           three blanks
      4C 44 41 81  "LDA "
      23 30 85     "#0     "
      5A 65 72 6F  "Zero"
      00       end of line token

While blank is the most frequently repeated character in a source program, there are others. The token $C0, followed by a repetition count and an ASCII character, represents any string of the same character. For example, the line

       1020 *--------------------------------

would be stored as:

       08        8 bytes in line
       FC 03     line number 1020
       2A        "*"
       C0 20 2D  means 32 consecutive "-"
       00        end of line

With the above information, you can see that the file transformer will have to read in the first byte of each line, which tells how many bytes are in the rest of that line. Then it should read in the rest of that line. Once the entire line is in RAM, the transformer should scan through the bytes of the line, copying ASCII characters to the new line, and expanding any compressed characters into the new line. Finally, the new line should be written on the output file. When the transformer reaches the end of the input file it is finished.

Let me insert here a reminder that even though this transformer is very specific, you should be able to easily modify it to handle other types of transformations. For example, the subscriber data base I use to produce mailing labels every month is kept on a series of plain text files, understandable only to the mailing list program I wrote about eight years ago. Even though it is plain text, AppleWorks cannot read it into a structured database unless I make some "transformations" first. At a minimum, I need a transformer that will split the city, state, and zip code line into three separate lines. I could easily write such a transformer by modifying the following program a little. Another transformer could read a binary file and write out a text file in the Intel or Motorola hex format, for later transmission through a serial port to an EPROM programmer. The possibilities are endless.

Now back to the program ALREADY written. I wrote two versions, and you can assemble either one of them by changing line 1060. As shown here, the fancier version is selected. The simpler version assumes specific filenames assembled into the code in lines 4340-4480. The fancier version prompts for filenames or pathnames to be typed in when you run the program. The code for both versions is listed, but only the fancy version was actually assembled.

Lines 1200-1400 define four macros I used in the program. The first one is for calling the ProDOS Machine Language Interface, or MLI. The second one creates a call to a subroutine which prints 00-terminated strings, followed by the string to be printed. The third generates a call to a subroutine which prints strings which begin with a byte count. The fourth generates calls to a subroutine which reads a line from the keyboard into a specified buffer, and then stores the length in the first byte of the buffer.

It turns out I do not use both the PRSTR and RDSTR macros, just one or the other. In the simple version, PRSTR is used to display the pre-assembled filenames; in the fancy version, RDSTR is used to let you type in the filenames.

Lines 1450-1550 call on two subroutines to open the input and output files. If they are successful, the file reference numbers returned by MLI will be stored into parameter blocks for reading and writing those files. If not, the transformer program will just close all files and end. I'll discuss the two opening subroutines later.

I decided after a few tests that I wanted some sort of progress indication on the screen while the program was busy. I decided to list the line number on the screen. Line 1570 uses the PRINT macro to display "LINE NUMBER: ". Inside the main loop, at line 1680, I call DISPLAY.LINE.NUMBER to display the current line number in five-digit decimal, and then backspace 5 times. This makes a very attractive (to me) indicator. In a more general transformer, you might change this to display a hexadecimal file position, or some other meaningful parameter.

The main loop runs from line 1590 to line 1790. First lines 1590-1620 try to read three bytes. If there is any error, I assume it is due to reaching the end of the source file, and that ends the loop. If no error, then the input buffer contains the byte count for the whole line, and the line number. Since we already read the first three bytes, lines 1630-1670 compute the number of bytes left in the line and set up the parameter block to read that many. Then I print out the line number as described above. The DISPLAY.LINE.NUMBER subroutine also checks to see if any key has been pressed on the keyboard, which is interpreted to mean you want to abort the tranformer. Line 1690 branches in that case, and the files are closed. Lines 1700-1710 read the rest of the source line.

Line 1730 calls the CONVERT.ONE.LINE subroutine, which scans the source line and builds an expanded output line. Lines 1740-1780 write the expanded line on the output file. Any error returned by MLI from this write ends the main loop. Probably I should have printed out an error message for this condition, because it is abnormal. It could happen if you were trying to write into a write-protected file or on a write-protected disk. Looking at it now, I think I would change line 1780 to "BCS .4", and insert the following lines:

       1862 .4    JSR OPEN.ERROR
       1866       RTS

Once the main loop ends, lines 1800-1820 truncate the output file. It may be that your output file already existed, and was longer than necessary to contain the new information. These lines chop off any extra data. Line 1810 reads the current file position, and line 1820 sets that value as the new end-of-file. Finally, line 1840 closes both files.

I ended the program with a simple RTS. You might want a fancier ending. For example, you might want a message on the screen saying "I AM FINISHED" or the like. Then you might want a short menu on the screen allowing a choice of transforming another file, ending with an RTS, or doing a ProDOS QUIT call. See, I left something for you to do!

If you do start adding features, you might also like to add the ability to transform a range of lines from the source file, by specifying a beginning and ending line number. You might want to add tests for the correct file types on the input and output files. You might want to add a menu-style pathname entry, so that you could work with complicated directory structures without a photographic memory.

That last suggestion leads me to warn that the program given here requires that you enter complete pathnames, or else have a legitimate prefix set. It does not allow slot and drive specification using ",Sx" or ",Dx" either. Now don't let me discourage you by listing all the things I left out. As is, the program is quite useful.

Lines 1870-1970 are the subroutine to open the input file. It first prints the prompt message "INPUT: ", and then waits for you type in a pathname. (If you selected the "simple" version, it instead prints out the pre-assembled pathname.) Line 1950 calls on ProDOS to open the file. If there is any error, lines 1990-2050 print out the error number and the subroutine returns with carry set. If there is no error, the subroutine returns with carry clear. You might want to add some code to this subroutine to read the filetype and make sure it is type $FA.

Lines 2070-2270 open the output file. This is a little more complicated, because the output file may or may not already exist. If the file does not yet exist, the open call will return with error number $46. Line 2160 tests for this error number. Any other error will be printed out, and the subroutine will return wiht carry set. Lines 2180-2260 attempt to CREATE a file. First the current date and time are read and stored in the parameter block, and then ProDOS is called to create the file. The parameter block used here assumes you want the output file to be type TXT ($04). If you modify the program for a different transformation you may want to change the file type. You might also want to add some code to check an existing file for the correct file type.

Lines 2290-2510 are the parameter blocks for the various MLI calls I used.

Lines 2560-2830 display the current line number and test for a keypress. The subroutine converts the binary line number to decimal one digit at a time. Nothing spectacular, and in fact it is very similar to the subroutine Woz used inside Integer BASIC over ten years ago. Lines 2740-2780 send out five backspaces to put the cursor back over the first digit. I originally tried to do this by just storing a cursor position back in location $24, but that only works in 40-column mode. Using backspaces it also works in 80-column mode, even with the 80-column cards used in Apple II+ machines. Lines 2790-2830 check for a keypress and return carry set if there was one.

Finally to the heart of this transformer: lines 2870-3330 convert one input line into one output line. Lines 2950-2970 zero two pointers, one for the input line scan and the other for the output line fill. These are used by the GET.CHAR and PUT.CHAR subroutines in lines 3180-3330. GET.CHAR picks up the character pointed to from the input line, and advances the pointer. PUT.CHAR stores the character in the A-register into the output line where the pointer points, and then advances the pointer. PUT.CHAR.MULTIPLE uses the X-register to store multiple copies of the character in the A-register.

Lines 2980-3000 pick up the next character from the input line, and branch according to its type. If the character is 00, this is the end of the line: then lines 3150 tack an ASCII <RETURN code on the end of the output line, and the subroutine is finished. If the character is positive, it is simple ASCII and lines 3010 simply copy it to the output line. If the character is negative, it is either a compressed blank string or a compressed string of some other character. Lines 3030-3090 handle compressed blanks by putting the blank count into the X-register, a blank in the A-register, and calling PUT.CHAR.MULTIPLE. Lines 3100-3130 handle the other kind of repeated character by reading the repeat count and character code from the input line and then calling PUT.CHAR.MULTIPLE.

Lines 3340-3550 are very similar in function to the PRINT subroutine I published last month in my SHOW INDEX program. A difference is the use of the "\" character in the string. Last month's program would have merely printed the "\". The program this month will print a <RETURN> when it sees a "\". This enabled me to use the PRINT macro to generate calls to the PRINT subroutine.

Lines 3560-3830 are a subroutine for printing strings which begin with a length byte. This subroutine is not ever called in the fancy version of my program given here. In the simple version it would be called to print the pre-assembled pathnames. I went ahead and assembled the subroutine anyway, because it is an interesting one. The macro PRSTR will call it, putting the address of the string to be printed as data immediately after the JSR PRSTR.

The subroutine used in the fancy version to read in a pathname is given in lines 3870-4250. The address of the buffer for receiving the pathname is given as data following the JSR RDSTR. Lines 3880-4010 accomplish the task of copying this address into the code below, into lines 4150 and 4240. Where the listing shows $3333, the address of the buffer will be stored. The loop in lines 4030-4210 keeps reading characters, storing them into that buffer, and displaying them on the screen.

If a backspace is read, the character at the end of the buffer is backed out and the string backspace-space-backspace is displayed on the screen. When a <RETURN> is read, the loop terminates and the number of bytes before the <RETURN> is stored in the first byte of the buffer by lines 4200-4250.

The subroutine GET.VIA.PNTR in lines 4270-4320 is called by both PRSTR and RDSTR to pickup the address which follows the JSR calling those subroutines.

Lines 4340-4480 either assemble two 65-byte buffers (fancy version) or two pathnames. Lines 4490 to the end assemble the other buffers used. Since the buffers used by ProDOS for the open files must begin on a page boundary, line 4530 skips ahead to the next page boundary.

For those of you who do not own the S-C Macro Assembler, I will start including this file transformer in executable form on future issues of the AAL Monthly Disk. Remember, you can save yourself a lot of typing by subscribing to the Monthly Disk. These disks include all of the source code in S-C format and also the text of all of the articles.

  1000 *SAVE SC.2.TEXT
  1010        .LIST MOFF,CON
  1020 ***line missing above was ".LIST MOFF,CON"
  1030 *--------------------------------
  1040        .OR $2000
  1050 *--------------------------------
  1060 FANCY  .EQ 1        =0 to use pre-assembled file names
  1070 *--------------------------------
  1080 RDKEY  .EQ $FD0C         A few handy Monitor subroutines
  1090 CROUT  .EQ $FD8E
  1110 COUT   .EQ $FDED
  1120 *--------------------------------
  1130 MLI.DATE   .EQ $BF90 thru BF93  System DATE and TIME
  1140 *--------------------------------
  1150 KEYBOARD   .EQ $C000     For aborting a conversion run
  1160 STROBE     .EQ $C010
  1170 *--------------------------------
  1180 PIN    .EQ $00      Scanning pointer for input line
  1190 POUT   .EQ $01      Stuffing pointer for output line
  1200 *--------------------------------
  1210        .MA MLI
  1220        JSR $BF00
  1230        .DA #$]1,]2
  1240        .EM
  1250 *--------------------------------
  1260        .MA PRINT
  1270        JSR PRINT    Print 00-term'd string after 
  1280        .AS -"]1"    here is the string
  1290        .HS 00       here is the 00-terminator
  1300        .EM
  1310 *--------------------------------
  1320        .MA PRSTR
  1330        JSR PRSTR    Print string beginning with byte count
  1340        .DA ]1       address of string
  1350        .EM
  1360 *--------------------------------
  1370        .MA RDSTR    Read a string from keyboard or EXEC
  1380        JSR READ.STRING
  1390        .DA ]1       address of string
  1400        .EM
  1410 *--------------------------------
  1420 *   Program to read an S-C Macro source file
  1430 *      and write it as a text file.
  1440 *--------------------------------
  1460        JSR OPEN.INPUT.FILE   Open Source File
  1470        BCS .3            ...unable to open it
  1480        LDA IREF          Get RefNum for READ
  1490        STA IOB.READ+1
  1500 *---Open the text file-----------
  1510        JSR OPEN.OUTPUT.FILE
  1520        BCS .3            ...unable to open it
  1530        LDA OREF          Get RefNum for WRITE
  1540        STA IOB.EOF+1            and for Truncation
  1550        STA IOB.WRITE+1
  1560 *---Print "LINE NUMBER"----------
  1570     >PRINT "\LINE NUMBER:  "  for progress indicator
  1580 *---read byte count from source file
  1590 .1     LDA #3       read 3 bytes: byte count + line #
  1600        STA IOB.READ+4
  1610       >MLI CA,IOB.READ
  1620        BCS .2       END OF FILE
  1630 *---read rest of line from source file
  1640        SEC          rest of line is 3 less
  1650        LDA LINE.SC               than byte count
  1660        SBC #3
  1670        STA IOB.READ+4
  1680        JSR DISPLAY.LINE.NUMBER  to indicate progress
  1690        BCS .2                   ...wants to abort
  1700       >MLI CA,IOB.READ
  1710        BCS .2       END OF FILE
  1720 *---Build Output Line------------
  1730        JSR CONVERT.ONE.LINE
  1740 *---write line on text file------
  1750        LDA POUT
  1760        STA IOB.WRITE+4   # BYTES TO WRITE
  1770       >MLI CB,IOB.WRITE
  1780        BCS .2
  1790        JMP .1
  1800 *---truncate text file-----------
  1810 .2    >MLI CF,IOB.EOF    GET MARK
  1820       >MLI D0,IOB.EOF    SET EOF
  1830 *---Close both files-------------
  1840 .3    >MLI CC,IOB.CLOSE
  1850        JSR CROUT
  1860        RTS
  1870 *--------------------------------
  1890     >PRINT "\ INPUT:  "
  1900   .DO FANCY
  1910     >RDSTR PATHI
  1920   .ELSE
  1930     >PRSTR PATHI
  1940   .FIN
  1950       >MLI C8,IOB.OPENI
  1960        BCS OPEN.ERROR
  1970        RTS
  1980 *--------------------------------
  2000        PHA
  2010     >PRINT "\ERROR:  "
  2020        PLA
  2030        JSR PRBYTE
  2040        SEC
  2050        RTS
  2060 *--------------------------------
  2080     >PRINT "\OUTPUT:  "
  2090   .DO FANCY
  2100     >RDSTR PATHO
  2110   .ELSE
  2120     >PRSTR PATHO
  2130   .FIN
  2140 .1    >MLI C8,IOB.OPENO
  2150        BCC .3
  2160        CMP #$46     was it FILE NOT FOUND?
  2170        BNE OPEN.ERROR
  2180       >MLI 82,0
  2190        LDY #3
  2200 .2     LDA MLI.DATE,Y
  2210        STA IOB.CREATE+8,Y
  2220        DEY
  2230        BPL .2
  2240       >MLI C0,IOB.CREATE
  2250        BCC .1
  2260        BCS OPEN.ERROR
  2270 .3     RTS
  2280 *--------------------------------
  2290 IOB.CREATE .HS 07
  2300            .DA PATHO
  2310            .HS C3.04.0000.01.0000.0000
  2320 *--------------------------------
  2330 IOB.OPENI  .HS 03
  2340            .DA PATHI
  2350            .DA BUF.I
  2360 IREF       .BS 1
  2370 *--------------------------------
  2380 IOB.OPENO  .HS 03
  2390            .DA PATHO
  2400            .DA BUF.O
  2410 OREF       .BS 1
  2420 *--------------------------------
  2430 IOB.READ   .HS 04.00
  2440            .DA LINE.SC
  2450            .DA 0
  2460            .DA 0
  2470 *--------------------------------
  2480 IOB.WRITE  .HS 04.00
  2490            .DA LINE.TEXT
  2500            .DA 0
  2510            .DA 0
  2520 *--------------------------------
  2530 IOB.EOF    .HS
  2540 IOB.CLOSE  .HS 01.00
  2550 *--------------------------------
  2570        LDY #4
  2580 .1     LDX #"0"
  2590 .2     LDA LINE.SC+1
  2600        CMP DECTBL,Y
  2610        LDA LINE.SC+2
  2620        SBC DECTBH,Y
  2630        BCC .3
  2640        INX
  2650        STA LINE.SC+2
  2660        LDA LINE.SC+1
  2670        SBC DECTBL,Y
  2680        STA LINE.SC+1
  2690        JMP .2
  2700 .3     TXA
  2710        JSR COUT
  2720        DEY
  2730        BPL .1
  2740        LDY #5
  2750        LDA #$88
  2760 .4     JSR COUT
  2770        DEY
  2780        BNE .4
  2790        LDA KEYBOARD
  2800        CMP #$80     SET CARRY IF ANY KEY
  2810        BCC .5
  2820        STA STROBE
  2830 .5     RTS
  2840 *--------------------------------
  2850 DECTBL .DA #1,#10,#100,#1000,#10000
  2860 DECTBH .DA /1,/10,/100,/1000,/10000
  2870 *--------------------------------
  2880 *---build output line
  2890 *---     ignore line numbers
  2900 *---     expand blanks and multiples
  2910 *---     use low ascii
  2920 *---     end with 0D (return)
  2930 *--------------------------------
  2950        LDY #0
  2960        STY POUT
  2970        STY PIN
  2980 .1     JSR GET.CHAR
  2990        BEQ .4            ...End of Line
  3000        BMI .2            ...blanks or other multiple
  3010        JSR PUT.CHAR      simple ASCII char
  3020        JMP .1
  3030 .2     CMP #$C0
  3040        BCS .3            ...other multiple
  3050        AND #$7F
  3060        TAX
  3070        LDA #$20
  3090        JMP .1
  3100 .3     JSR GET.CHAR      get count
  3110        TAX
  3120        JSR GET.CHAR      get repeated char
  3140        JMP .1
  3150 .4     LDA #$0D
  3160        JMP PUT.CHAR
  3170 *--------------------------------
  3180 GET.CHAR
  3190        LDY PIN
  3200        INC PIN
  3210        LDA LINE.SC,Y
  3220        RTS
  3230 *--------------------------------
  3240 PUT.CHAR
  3250        LDX #1
  3270        LDY POUT
  3280 .1     STA LINE.TEXT,Y
  3290        INY
  3300        DEX
  3310        BNE .1
  3320        STY POUT
  3330        RTS
  3340 *--------------------------------
  3350 PRINT
  3360        PLA          POP RETURN ADDRESS
  3380        PLA
  3390        STA PNTR+2
  3400        JSR PRINT.VIA.PNTR
  3420        PHA
  3430        LDA PNTR+1
  3440        PHA
  3450        RTS
  3460 *--------------------------------
  3470 PVP    ORA #$80
  3480        CMP #"\"
  3490        BNE .1
  3500        LDA #$8D
  3510 .1     JSR COUT     PRINT CHAR
  3540        BNE PVP      00 = END OF STRING
  3550        RTS
  3560 *--------------------------------
  3570 *   Print a string which begins with a byte count
  3580 *      JSR PRSTR
  3590 *      .DA address of byte count
  3600 *--------------------------------
  3610 PRSTR
  3620        PLA
  3630        STA PNTR+1
  3640        PLA
  3650        STA PNTR+2
  3660        JSR GET.VIA.PNTR
  3670        TAX
  3680        JSR GET.VIA.PNTR
  3690        TAY
  3710        PHA
  3720        LDA PNTR+1
  3730        PHA
  3740        STX PNTR+1
  3750        STY PNTR+2   POINT AT STRING NOW
  3760        JSR PNTR     GET BYTE COUNT
  3770        TAX
  3790        ORA #$80
  3800        JSR COUT
  3810        DEX
  3820        BNE .1
  3830        RTS
  3840 *--------------------------------
  3850 *   Input a string from the keyboard (or EXEC file)
  3860 *--------------------------------
  3880        PLA
  3890        STA PNTR+1
  3900        PLA
  3910        STA PNTR+2
  3920        JSR GET.VIA.PNTR
  3930        STA .2+1
  3940        STA .3+1
  3950        JSR GET.VIA.PNTR
  3960        STA .2+2
  3970        STA .3+2
  3990        PHA
  4000        LDA PNTR+1
  4010        PHA
  4020 *--------------------------------
  4030 .0     LDX #1
  4040 .1     JSR RDKEY
  4050        ORA #$80
  4060        CMP #$88
  4070        BNE .2
  4080        DEX
  4090        BEQ .0
  4100        JSR COUT
  4110        LDA #" "
  4120        JSR COUT
  4130        LDA #$88
  4140        BNE .25
  4150 .2     STA $3333,X
  4160        CPX #64
  4170        BCS .1
  4180        INX
  4190 .25    JSR COUT
  4200        CMP #$8D
  4210        BNE .1
  4220        DEX
  4230        DEX
  4240 .3     STX $3333
  4250        RTS
  4260 *--------------------------------
  4290        BNE PNTR
  4300        INC PNTR+1
  4320        RTS
  4330 *--------------------------------
  4340   .DO FANCY
  4350 PATHI  .BS 65
  4360   .ELSE
  4380        .AS "SC.2.TEXT"
  4390 PATHI.LEN  .EQ *-PATHI-1
  4400   .FIN
  4410 *--------------------------------
  4420   .DO FANCY
  4430 PATHO  .BS 65
  4440   .ELSE
  4460        .AS "TTT"
  4470 PATHO.LEN  .EQ *-PATHO-1
  4480   .FIN
  4490 *--------------------------------
  4500 LINE.SC    .BS 256
  4510 LINE.TEXT  .BS 256
  4520 *--------------------------------
  4530        .BS *+255/256*256-*   Pad to next page
  4540 BUF.I  .BS $400
  4550 BUF.O  .BS $400
  4560 *--------------------------------
  4570        .LIF

Modify CATALOG to Show All AuxTypes Bob Sander-Cederlof

Apple Computer has started spreading the word that they are going to make further use of the AuxType field in the ProDOS file directory. Until now it has had three primary purposes, depending on the file type.

Binary files (type BIN, or $06) use the AuxType field to hold the loading address. System files (type SYS, or$FF) files do too, but since they always load at $2000 it is never used. Applesoft files (type BAS, or $FC) also use it for the loading address, but I don't believe it is ever used. I haven't tested it, though. If you use the S-C Macro Assembler under ProDOS, it uses a filetype called "S-C" for source code files. This is type $FA, which ProDOS reserved for Integer BASIC, just in case. S-C used type I files under DOS, so I decided to use type INT files under ProDOS. Anyway, I put the loading address in AuxType for these files too. It is never used.

Text files use AuxType to specify the record length for random-access files; it is 0000 for sequential files.

AppleWorks files (types ADB or $19, AWP or $1A, and ASP or $1B) are the most creative, using 15 of the 16 AuxType bits to modify the file name characters. Each bit corresponds to one of the file name characters, allowing AppleWorks to show and recognize the file name with lower-case letters and spaces in it. Regular ProDOS only displays upper-case letters in the names, and does not allow spaces. AppleWorks could have just stored the real ASCII codes in the filename field, but then the rest of ProDOS would not be able to access the files. By using the AuxType field, all is compatible.

Probably there are some other uses for AuxType that I do not know about. And now Apple has decided to use it to allow more than 256 different file types. It seems that 256 is not going to be enough now that we have ProDOS-16. If you are writing software for the Apple market and you need some private filetypes, you are supposed to write Apple Developer Tech Support and tell them of your needs. They in turn will assign you the appropriate file types. Since there are more requests than 256, they are starting to categorize them. For example, there may be a future file type for all word processors, with different AuxType values to distinguish various kinds of word processor files.

Apple has suggested that we start displaying the AuxType information in CATALOGs for more types than just TXT and BIN. I looked into BASIC.SYSTEM and found a patch that makes it display for all file types. I also looked into the S-C Macro Assembler's SCASM.SYSTEM for the same kind of patch.

In BASIC.SYSTEM, you need to change one byte from $27 to $11. The byte is at $A513 after BASIC.SYSTEM is operating, so you could do a POKE 42259,17 to turn the feature on, and POKE 42259,39 to turn it off. If you want to make a permanent change, you can do it this way:

       ]POKE 12051,17

Location 12051 is $2F13, which is where the code resides when the file is BLOADed as above.

In SCASM.SYSTEM, you need to change one byte from $16 to $00. The byte is near $B000 when the S-C Macro Assembler is operating, but the exact location depends on the particular edition you have. I suggest dis-assembling starting at $AFF0 and looking for the following code:

       C9 04  CMP #$04
       D0 04  BNE ...
       A9 D2  LDA #$D2
       D0 06  BNE ...
       C9 06  CMP #$06
       D0 16  BNE ...     change this "16" to "00"
       A9 C1  LDA #$C1

In the version I was using that "16" byte was at $B00E. From within the assembler I typed "$B00E:00" and that did the trick. If the "$" commands don't work in your computer, you can go to the monitor by typing "MNT" and the make the patch.

If you want to make a permanent change, you need to BLOAD SCASM.SYSTEM, patch the byte, and BSAVE it again just like I did with BASIC.SYSTEM above. In my version, I found the byte at $510E when the file was loaded.

BLOADing Directories Bob Sander-Cederlof

Did you know that ProDOS will let you BLOAD a directory just like any other kind of file? I did not until today.

For example, if I want to load the directory of my Sider hard disk into memory, I can type BLOAD /HARD1,TDIR,A$1000. I can load in any subdirectory the same way. This works under both BASIC.SYSTEM (Applesoft) and SCASM.SYSTEM (the S-C Macro Assembler) shells.

In both cases, if you care to, you can find the length of the directory in bytes in locations $BEDB and $BEDC. $BEDB will always contain 00, and $BEDC will be the number of pages in the directory, or twice the number of blocks.

I tried BSAVEing... but it is prohibited. You get a FILE LOCKED message for your efforts.

Apple Assembly Line (ISSN 0889-4302) is published monthly by S-C SOFTWARE CORPORATION, P. O. Box 280300, Dallas, TX 75228 Phone (214) 324-2050. Subscription rate is $24 per year in the USA, Canada, and Mexico, or $36 in other countries. Back issues are $1.80 each for Volumes 1-7, $2.40 each for Volume 8 (plus postage). A subscription tothe newsletter with a Monthly Disk containing all program source code and article text is $64 per year in the USA, Canada and Mexico, and $90 to other countries.

All material herein is copyrighted by S-C SOFTWARE, all rights reserved. Unless otherwise indicated, all material herein is authored by Bob Sander-Cederlof. (Apple is a registered trademark of Apple Computer, Inc.)