*** Official Fargo status report ***

[Prev][Next][Index][Thread]

*** Official Fargo status report ***

Fargo is very near to being finished. For all of you who are looking
forward to seeing it released, here is a status report to show you
what we've done and what we plan to do before releasing it. First,
I'll list some of its current features. Second, I'll list some of the
things we're working on implementing. I'll end by listing some of the
components that will be released along with Fargo.


Here are some of Fargo's current features:


1) Fargo may be called from almost anywhere. It is triggered by
pressing Shift-ON, which starts the Fargo shell. As a rule of thumb,
if you can turn the calculator off with Diamond-ON, you can start
Fargo with Shift-ON. Fargo is normally only inaccessible if the BUSY
signal is lit.


2) The Fargo shell has the same format as other Fargo programs. What
actually happens when you press Shift-ON is, the program named "shell"
is executed. By default, this pops up a list of programs, allowing you
to choose one and execute it. However, *any* Fargo program renamed to
"shell" will be executed when you press Shift-ON.


3) Library support. Commonly-used routines can be grouped together and
stored in a single module. The routines in this module may then be
accessed by any Fargo program, even another library. The code for the
routines is stored only once, thus saving valuable RAM. Also, the
author of the library routines need not release their source code; all
that is needed is the compiled library and a list of the routines in
order.


4) ROM-independence. The Fargo package includes a ROM library (called
romlib) that allows programs to call useful routines in ROM. The
addresses of these routines are looked up in such a way that Fargo is
likely to be compatible with future versions of the TI-92's ROM. It
takes advantage of the fact that there are small blocks of contiguous
code that exist in all versions of the TI-92's ROM. While these blocks
may move around in different ROM versions, as a unit, a block is the
same in all ROM versions. So far, we have found this method to be
compatible with everything from ROM 1.2 to ROM 1.12 (that's one point
twelve) for all the routines we've needed. However, if it turns out
that there are some routines we need for which this method will not
work, we may need to restrict Fargo to specific ROM versions.


5) Relocation. Some 68000 instructions that access memory must refer
an absolute address; however, Fargo programs, as TI-92 variables, are
subject to being moved around. An address within a Fargo program stays
constant relative to the beginning of the program, but as an absolute
address, it can change. To solve this problem, a compiled program has
a "relocation table" which Fargo uses to modify the program upon
runtime. It adds the program's beginning address to all absolute
pointers in the program that need adjustment. All this is done
automatically, so the programmer does not have to worry about it.


6) Memory allocation. Fargo programs have access (through romlib) to
memory allocation routines. They can create, resize, and delete memory
blocks. However, this currently has some limitations; see the "to-do"
list.


Here are some of the things we're working on:


1) Finding and figuring out more ROM calls, especially those relating
the the TI-92's GUI.


2) Allowing Fargo programs to be executed just like TI-BASIC programs;
they're stored as program variables, so why not? For example, typing
ftris() at the home screen would jump directly into FTris. (This is in
principle similar to Ulterior Motive for ZShell, but integrated with
Fargo and implemented in a much cleaner way.)


3) Safer memory allocation. Currently, if a Fargo program tries to
delete or resize a memory block below itself, it will be moved around,
thus invalidating the relocation info and all the return addresses
stored in the stack. It will promptly crash. We have decided that the
best way to fix this is to move all Fargo programs and libraries, when
they are loaded, into "high memory", where they will *not* be moved
until they are unloaded. This will also allow "Fargo TSRs" to be
loaded and run in the background without worrying if they are going to
be moved.


4) A program to transfer Fargo directly from one TI-92 to another. Due
to difficulties in transferring backups between TI-92s with different
ROM versions, this may or may not be released with Fargo.


Here are some of the things that will be released along with Fargo:


1) An MS-DOS program to support both the parallel and serial homemade
link cables. This program can send and receive TI-92 variables, group
files, and backups. It can also receive TI-92 screen dumps, and even
has a remote control feature (note: the TI-92 does *not* have to be in
a special mode for remote control to work).


2) A group of text files categorizing (virtually) everything we've
found out about the internals of the TI-92 so far, including RAM
addresses, data structures, memory handles, ports, interrupts, and
trap vectors.


3) FTris, a Fargo game based on GameBoy Tetris. The speed, scoring,
and game play are equivalent to GameBoy version. GameBoy Tetris has 18
rows; to make room for this in FTris, it is played sideways. Pieces
fall to the right. If the TI-92 is rotated 90 degrees clockwise, it
will look and feel just like regular Tetris.


4) FTerm, a communications program for the TI-92. FTerm's split-screen
mode makes it easy for two people to chat full duplex; when
split-screen is turned off, FTerm can be used to dial BBSes if you can
figure out how to connect your TI-92 to an external modem.


5) Some compilable sample source code to show how Fargo programs are
written.


6) Everything you need to compile your own Fargo programs on a PC.
This includes the relocating AmigaDOS assembler A68K v2.71 (which has
been compiled as an MS-DOS program), PRGM92 (which converts AmigaDOS
object files into Fargo executables), and a batch file that automates
the process of compiling Fargo programs.




<pre>
---
David Ellsworth
the ticalc.org project
davidell@ticalc.org
<pre>
---
</pre>