Jake-S@cup.portal.com (Jake G Schwartz) (01/30/91)
A Combined HP48SX Internals Address List
Sorted by Object Type and Function
The list to follow this message is a combined HP48 internals list, sorted
by object type and function. It includes Jan Brittenson's symbol table,
his recent internal constants list, Derek Nickel's internals list, and a
newly acquired list of entry points from Rick Grevelle.
Several modifications have been made to this list since the last posting
in increasing address order. Addresses originating from Jan's list are
followed by either a colon or equals sign, addresses from Rick's list are
followed by a dash, and those from Derek's list have just a space. In order
to save space, multiple definitions of the same address have been merged
onto the same line (wherever possible). These entries were left intact
in order to get the most possible information about the addresses in question.
When a entry point second definition appears on a given line,
it is separated from the first by a slash followed by a colon (/:), equals
sign (/=) or dash (/-) based on the originator of the additional definition.
(The definition at a specific address always begins with Derek's entry first,
if it exists.) If a third meaning is present, an additional slash and author's
symbol (/:, /= or /-) is used in front of this definition as well. If there
is no room on the line for all definitions, they continue onto a second line
without the address being repeated.
------------------------------------------
Just a couple of terms:
GC = Garbage Collect
TOS = Top Of Stack (i.e., level 1; TOS-1 is level 2, etc.)
SB = System Binary (also "Syst Bin" and "Short")
MC = Machine Code (also "code")
R = Real
Push = Item goes into stack level 1 and others move up the stack
Pop = Item from stack level 1 is removed (and used) and others move down
Nm = Name
Notes:
If a function name is followed by "(boolean)" this means that this is a
test which returns a True or False to stack level one.
An attempt was made to fix typos wherever found, and also to check for
inconsistencies and repair them. In a future version of this list, the
multiple definitions shall be collapsed down to single, clear ones. This
list is not perfect and should not be assumed to be so, as errors can
creep in. It might be useful to keep the prior list (sorted by address)
handy as a cross-reference, especially when disassembling by hand. As
new address lists appear, I shall try to incorporate them into this list.
Jake Schwartz
-------------------------------------------
Jan Brittenson's notes on his symbol table (corresponding to all entries
here which have a colon or equals sign after the address or after the
slash if the definition is an auxiliary one):
Symbols starting with a capital
letter (e.g. `Foo') are RPL objects, all others are ML labels (e.g.
`foo'). A symbol, ending with `'p' is a predicate which returns True
(#3a81?) or False (#3ac0?). A symbol ending with `q' is questionable,
i.e. it's what I *think* it is, or a part of its function; it may for
instance be some test that also alters the heap, or messes with local
registers, or something, name `Testq'. Symbols ending with _ref or
_ref_<ordinal> are simply references, i.e. jump instructions. For
instance, "jump.a foo" may exist only for the purpose of addressing
foo using local branches, and could then be preceded with `foo_ref:'
or `foo_ref_2:' - you get the idea. A short is a 5-nibble integer, and
is the default operand type. If only one operand type follows the
name, then all operands are of this type. For instance, `Sub' (Not
Substring, that would be `Sub_string' or `Substring_string'!)
subtracts two shorts, while `Sub_real"' subtracts two reals. They may
sometimes appear as `Sub_short_short' or `Sub_real_real' which are
essentially the same thing. The are still great possibilities for
amibiguity, though, my usage is not always coherent, and there are
typos. If a routine does more than one thing, then the names are
(ideally, in simple cases) concatenated, e.g. `Swap_Over' which tells
us that this piece of code is an RPL object that first Swaps, and then
does an Over. Or `Dup_Inc_Gtp' would do a Dup, Increment (short of
course) and test if Greater Than (always False).
Other conventions I've used are: "Return" (i.e. End) exits the
current program level; "Ret" exits *two* levels (i.e. it exits the
level above, sorry about the stupid names); anything starting with a
type name (e.g. "Short_17h") is a constant; Get recalls something to
the stack; Set overwrites something (usually the top of the stack, but
sometimes a variable).
Enough. Help yourself to whatever is new to you.
--------------------------------------------------------------------------
(The list appears in three parts, due to its size.)