Page Numbers: Yes First Page: 97 X: 527 Y: 10.5"
Margins: Top: 1" Binding: 13
Odd Heading:

Appendix: Symbol Listing for Public Interfaces

Even Heading:

Appendix: Symbol Listing for Public Interfaces

maxword: --AltoDefs--CARDINAL = 177777B;

MaxWordsPerLine: --AltoDisplay--CARDINAL = 38;

memConfig: --SegmentDefs--MemoryConfig;

MemoryConfig: --SegmentDefs--TYPE = MACHINE DEPENDENT RECORD [
reserved: [0..31],
AltoType: MachineType,
xmMicroCode: BOOLEAN,
useXM: BOOLEAN,
mdsBank: BankIndex,
controlStore: ControlStoreType,
banks: [0..177777B],
mesaMicrocodeVersion: [0..177777B]];

MemoryErrorAddressRegister: --AltoHardware--POINTER TO POINTER;

MemoryErrorControl: --AltoHardware--TYPE = MACHINE DEPENDENT RECORD [
spare1: [0..15],
testHammingCode: [0..127],
testMode: [0..1],
interruptSingleBitErrors: [0..1],
interruptDoubleBitErrors: [0..1],
noErrorCorrection: [0..1],
spare2: [0..1]];

MemoryErrorControlRegister: --AltoHardware--POINTER TO POINTER;

MemoryErrorStatus: --AltoHardware--TYPE = MACHINE DEPENDENT RECORD [
hammingCode: [0..63],
parityError: [0..1],
memoryParity: [0..1],
syndrome: [0..63],
bankNumber: BankNumber];

MemoryErrorStatusRegister: --AltoHardware--POINTER TO POINTER;

MesaStringOverflow: --StringDefs--SIGNAL;

MesaToBcplLongNumber: --InlineDefs--PROCEDURE [LONG UNSPECIFIED]
RETURNS [BcplLongNumber];

MesaToBcplString: --StringDefs--PROCEDURE [s: STRING, t: POINTER TO BcplSTRING];

Milliseconds: --ProcessDefs, Process--TYPE = CARDINAL;

ModifyIndex: --StreamDefs--PROCEDURE [index: StreamIndex, change: INTEGER]
RETURNS [StreamIndex];

ModifyPosition: --StreamDefs--PROCEDURE [pos: StreamPosition, change: INTEGER]
RETURNS [StreamPosition];

Mouse: --KeyDefs--POINTER TO MouseBits;

MouseBits: --KeyDefs--TYPE = MACHINE DEPENDENT RECORD [
blank: [0..255], keyset: [0..31], buttons: MouseButton];

MouseButton: --KeyDefs--TYPE = {
RedYellowBlue, RedBlue, RedYellow, Red, BlueYellow, Blue, Yellow, None};

MouseXY: --AltoDisplay--POINTER TO Coordinate;

MoveFileSegment: --SegmentDefs--PROCEDURE [
seg: FileSegmentHandle, base: PageNumber, pages: PageCount];

MsecToTicks: --ProcessDefs, Process--PROCEDURE [Milliseconds] RETURNS [Ticks];

NewByteStream: --StreamDefs--PROCEDURE [name: STRING, access: AccessOptions]
RETURNS [DiskHandle];

NewConfig: --FrameDefs--PROCEDURE [name: STRING];

NewDataSegment: --SegmentDefs--PROCEDURE [base: PageNumber, pages: PageCount]
RETURNS [DataSegmentHandle];

NewFile: --SegmentDefs--PROCEDURE [
name: STRING, access: AccessOptions, version: VersionOptions]
RETURNS [FileHandle];

NewFileOnly: --SegmentDefs--VersionOptions = 1;

NewFileSegment: --SegmentDefs--PROCEDURE [
file: FileHandle, base: PageNumber, pages: PageCount, access: AccessOptions]
RETURNS [FileSegmentHandle];

NewLine: --IODefs--PROCEDURE RETURNS [BOOLEAN];

NewWordStream: --StreamDefs--PROCEDURE [name: STRING, access: AccessOptions]
RETURNS [DiskHandle];

NextDiskCommand: --AltoHardware--POINTER TO KCBHandle;

Node: --Storage--PROCEDURE [nwords: CARDINAL] RETURNS [p: POINTER];

NodeHeader: --FSPDefs--TYPE = RECORD [
length: BlockSize,
extension:
SELECT state: * FROM
inuse => NULL,
free => [fwdp: FreeNodePointer, backp: FreeNodePointer]
ENDCASE];

NodeLoop: --FSPDefs--ERROR [ZonePointer];

NodeOverhead: --FSPDefs--CARDINAL = 1;

NodePointer: --FSPDefs--TYPE = POINTER TO NodeHeader;

NodeSize: --FSPDefs--PROCEDURE [p: POINTER] RETURNS [BlockSize];

NoGlobalFrameSlots: --FrameDefs--SIGNAL [CARDINAL];

NormalizeIndex: --StreamDefs--PROCEDURE [index: StreamIndex]
RETURNS [StreamIndex];

NoRoomForLoader: --ImageDefs--SIGNAL;

NoRoomInCheckMap: --ImageDefs--SIGNAL;

NoRoomInImageMap: --ImageDefs--SIGNAL;

NoRoomInZone: --FSPDefs--SIGNAL [z: ZonePointer];

NotEnoughSpaceForDisplay: --DisplayDefs--ERROR;

NUL: --Ascii, CharIO, IODefs--CHARACTER = 0C;

NullFP: --AltoFileDefs--FP;

NullSN: --AltoFileDefs--SN;

Number: --Format--PROCEDURE [
n: UNSPECIFIED, format: NumberFormat, proc: StringProc];

NumberFormat: --CharIO, Format--TYPE = RECORD [
base: [2..36], zerofill: BOOLEAN, unsigned: BOOLEAN, columns: [0..255]];

NumberFormat: --IODefs--TYPE = NumberFormat;

Object: --SegmentDefs--TYPE = RECORD [
busy: PRIVATE BOOLEAN,
body:
SELECT tag: ObjectType FROM
free => [
seal: PRIVATE [0..31],
size: PRIVATE FrobSize,
fwdp: PRIVATE FrobLink,
backp: PRIVATE FrobLink],
segment => [
VMpage: [0..7777B],
info:
SELECT type: SegmentType FROM
data => [type: DataSegmentType, pages: [1..256]],
file => [
swappedin: BOOLEAN,
write: BOOLEAN,
class: FileSegmentClass,
inuse: BOOLEAN,
lock: SegLockCount,
pages: [1..256],
file: FileHandle,
base: PageNumber,
location:
SELECT loc: SegmentLocation FROM
disk => [hint: FileHint],
remote => [proc: RemoteSegProc, info: UNSPECIFIED]
ENDCASE]
ENDCASE],
file => [
open: BOOLEAN,
length: BOOLEAN,
lengthvalid: BOOLEAN,
read: BOOLEAN,
write: BOOLEAN,
append: BOOLEAN,
lengthchanged: BOOLEAN,
unused: [0..63],
lock: FileLockCount,
swapcount: RefCount,
segcount: SegCount,
fp: FP],
length => [
unused: [0..7],
byte: [0..512],
page: PageNumber,
file: FileHandle,
da: vDA]
ENDCASE];

Octal: --Format--PROCEDURE [n: UNSPECIFIED, proc: StringProc];

OctalFormat: --Format--NumberFormat;

OldFileOnly: --SegmentDefs--VersionOptions = 2;

OpenDiskStream: --StreamDefs--PROCEDURE [stream: StreamHandle];

OpenFile: --SegmentDefs--PROCEDURE [file: FileHandle];

OpenKeyStream: --StreamDefs--PROCEDURE [stream: StreamHandle];

OsStaticRecord: --OsStaticDefs--TYPE = MACHINE DEPENDENT RECORD [
EnumerateFp: PRIVATE POINTER,
fpSysDir: PRIVATE POINTER TO CFP,
fpSysStat: PRIVATE POINTER TO CFP,
fpDiskDescriptor: PRIVATE POINTER TO CFP,
fpSysLog: PRIVATE POINTER TO CFP,
fpSysTs: PRIVATE POINTER TO CFP,
fpUserCm: PRIVATE POINTER TO CFP,
fpComCm: PRIVATE POINTER TO CFP,
fpRemCm: PRIVATE POINTER TO CFP,
fpExecutive: PRIVATE POINTER TO CFP,
fpSysFont: PRIVATE POINTER TO CFP,
fpWorkingDir: PRIVATE POINTER TO CFP,
nameWorkingDir: PRIVATE POINTER TO BcplSTRING,
OsBuffer: PRIVATE POINTER TO WORD,
EventVector: POINTER TO WORD,
UserName: POINTER TO BcplSTRING,
UserPassword: POINTER TO BcplSTRING,
OsFinish: PRIVATE POINTER,

OsFinishCode: CARDINAL,
OsVersion: CARDINAL,
OsVersionCompatible: CARDINAL,
OsFinishSafeAdr: PRIVATE POINTER,
SerialNumber: CARDINAL,
lvUserFinishProc: PRIVATE POINTER,
SysErr: PRIVATE POINTER,
CounterJunta: PRIVATE POINTER,
CallSwat: PRIVATE POINTER,
lvAbortFlag: POINTER TO CARDINAL,
lvSwatContextProc: PRIVATE POINTER,
OutLd: PRIVATE POINTER,
InLd: PRIVATE POINTER,
BootFrom: PRIVATE POINTER,
DiskIOSetup: PRIVATE POINTER,
DiskIOTransfer: PRIVATE POINTER,
UpdateTime: PRIVATE POINTER,
lvParitySweepCount: PRIVATE POINTER,
LastLdCB: PRIVATE POINTER,
juntaTable: PRIVATE POINTER,
AltoVersion: AltoVersionNumber,
ErrorLogAddress: WORD,
lvParityPhantomEnable: PRIVATE POINTER,
ClockSecond: POINTER TO BcplLongNumber];

OsStatics: --OsStaticDefs--POINTER TO POINTER TO OsStaticRecord;

OtherStreamHandle: --StreamDefs--TYPE = POINTER TO Other StreamObject;

OutNumber: --IODefs--PROCEDURE [StreamHandle, UNSPECIFIED, NumberFormat];

outputDone: --AltoHardware--EthernetMicrocodeStatus;

outputLoadOverflow: --AltoHardware--EthernetMicrocodeStatus;

Overflow: --StringDefs, String--SIGNAL;

Pack: --Time--PROCEDURE [unpacked: Unpacked, computeDST: BOOLEAN]
RETURNS [time: LONG CARDINAL];

PackDT: --TimeDefs--PROCEDURE [unp: UnpackedTime, computeDST: BOOLEAN]
RETURNS [time: PackedTime];

Packed: --Time--TYPE = LONG CARDINAL;

PackedTime: --TimeDefs--TYPE = LONG CARDINAL;

PageAvailable: --SegmentDefs--PROCEDURE [page: PageNumber, info: AllocInfo]
RETURNS [BOOLEAN];

PageCount: --AltoDefs--TYPE = [0..10000B];

PageCount: --SegmentDefs--TYPE = PageCount;

PageFault: --TrapDefs--SIGNAL [page: CARDINAL];

PageFromAddress: --SegmentDefs--PROCEDURE [a: POINTER] RETURNS [PageNumber];

PageFromLongAddress: --SegmentDefs--PROCEDURE [a: LONG POINTER]
RETURNS [PageNumber];

PageNumber: --AltoDefs--TYPE = [0..77777B];

PageNumber: --SegmentDefs--TYPE = PageNumber;

PagePointer: --SegmentDefs--PROCEDURE [a: POINTER] RETURNS [POINTER];

Pages: --Storage--PROCEDURE [npages: CARDINAL] RETURNS [base: POINTER];

PagesAvailable: --SegmentDefs--PROCEDURE [
base: PageNumber, pages: PageCount, info: AllocInfo] RETURNS [BOOLEAN];

PagesForWords: --Storage--PROCEDURE [nWords: CARDINAL] RETURNS [CARDINAL];

PagesForWords: --SystemDefs--PROCEDURE [nwords: CARDINAL] RETURNS [CARDINAL];

PageSize: --AltoDefs, AltoHardware--CARDINAL = 256;

PagesPerMDS: --AltoDefs--CARDINAL = 256;

ParityError: --TrapDefs--SIGNAL [address: POINTER];

ParityErrorData: --AltoHardware--TYPE = MACHINE DEPENDENT RECORD [
DCBR: POINTER,
KNMAR: POINTER,
DWA: POINTER,
CBA: POINTER,
PC: POINTER,
SAD: POINTER];

ParityErrorDataLoc: --AltoHardware--POINTER TO ParityErrorData;

ParityLevel: --ProcessDefs--InterruptLevel = 0;

ParseFileName: --DirectoryDefs--PROCEDURE [
name: STRING, filename: STRING, dirAccess: AccessOptions]
RETURNS [DiskHandle];

PartitionName: --AltoFileDefs--FilePropertyType = 2;

Pause: --ProcessDefs, Process--PROCEDURE [ticks: Ticks];

PhantomParityError: --TrapDefs--SIGNAL;

PointerFault: --TrapDefs--SIGNAL;

PortFault: --TrapDefs--ERROR;

PositionToIndex: --StreamDefs--PROCEDURE [pos: StreamPosition]
RETURNS [index: StreamIndex];

Priority: --ProcessDefs, Process--TYPE = [0..7];

Prune: --Storage--PROCEDURE RETURNS [BOOLEAN];

PruneHeap: --SystemDefs--PROCEDURE RETURNS [BOOLEAN];

PruneZone: --FSPDefs--PROCEDURE [z: ZonePointer] RETURNS [BOOLEAN];

PuntMesa: --ImageDefs--PROCEDURE;

PupBufferDS: --SegmentDefs--DataSegmentType = 7;

Purge: --DirectoryDefs--PROCEDURE [
dir: DiskHandle, fp: POINTER TO FP, name: STRING] RETURNS [found: BOOLEAN];

PurgeFP: --DirectoryDefs--PROCEDURE [dir: DiskHandle, fp: POINTER TO FP]
RETURNS [found: BOOLEAN];

PUSH: --InlineDefs, Inline--PROCEDURE RETURNS [WORD];

PutChar: --CharIO--PROCEDURE [out: Handle, c: CHARACTER];

PutDecimal: --CharIO--PROCEDURE [Handle, INTEGER];

PutLine: --CharIO--PROCEDURE [out: Handle, s: STRING];

PutNumber: --CharIO--PROCEDURE [Handle, UNSPECIFIED, NumberFormat];

PutOctal: --CharIO--PROCEDURE [Handle, UNSPECIFIED];

PutString: --CharIO--PROCEDURE [Handle, STRING];

PutSubString: --CharIO--PROCEDURE [Handle, SubString];

Quad: --SystemDefs--PROCEDURE [u: UNSPECIFIED] RETURNS [UNSPECIFIED];

Read: --SegmentDefs, StreamDefs--AccessOptions = 1;

ReadBlock: --StreamDefs--PROCEDURE [
stream: StreamHandle, address: POINTER, words: CARDINAL] RETURNS [CARDINAL];

ReadChar: --IODefs--PROCEDURE RETURNS [CHARACTER];

ReadClock: --TimeDefs--PROCEDURE RETURNS [LONG UNSPECIFIED];

ReadDecimal: --IODefs--PROCEDURE RETURNS [INTEGER];

ReadEditedString: --IODefs--PROCEDURE [
STRING, PROCEDURE [CHARACTER] RETURNS [BOOLEAN], BOOLEAN] RETURNS [CHARACTER];

ReadID: --IODefs--PROCEDURE [STRING];

ReadLine: --IODefs--PROCEDURE [STRING];

ReadNumber: --IODefs--PROCEDURE [default: UNSPECIFIED, radix: CARDINAL]
RETURNS [UNSPECIFIED];

ReadOctal: --IODefs--PROCEDURE RETURNS [UNSPECIFIED];

ReadString: --IODefs--PROCEDURE [
STRING, PROCEDURE [CHARACTER] RETURNS [BOOLEAN]];

ReadWrite: --SegmentDefs, StreamDefs--AccessOptions = 3;

ReadWriteAppend: --SegmentDefs, StreamDefs--AccessOptions = 7;

RealTimeClock: --AltoHardware, TimeDefs--POINTER TO CARDINAL;

RefCount: --SegmentDefs--TYPE = [0..255];

ReleaseFile: --SegmentDefs--PROCEDURE [file: FileHandle];

RemoteSegCommand: --SegmentDefs--TYPE = UNSPECIFIED;

RemoteSegProc: --SegmentDefs--TYPE = PROCEDURE [
seg: FileSegmentHandle, command: RemoteSegCommand];

RemoveCleanupProcedure: --ImageDefs--PROCEDURE [POINTER TO CleanupItem];

RemoveGlobalFrame: --FrameDefs--PROCEDURE [frame: GlobalFrameHandle];

RemoveSwapStrategy: --AllocDefs--PROCEDURE [strategy: POINTER TO SwapStrategy];

ResetControlDEL: --StreamDefs--PROCEDURE;

Resolution: --AltoDisplay, AltoHardware--TYPE = {high, low};

ResumeError: --TrapDefs--SIGNAL;

Rubout: --IODefs--SIGNAL;

RunConfig: --FrameDefs--PROCEDURE [name: STRING];

RunImage: --ImageDefs--PROCEDURE [file: FileSegmentHandle];

Seconds: --ProcessDefs, Process--TYPE = CARDINAL;

SecondsToTicks: --ProcessDefs, Process--PROCEDURE [Seconds] RETURNS [Ticks];

SectorInterrupts: --AltoHardware--POINTER TO WORD;

SegCount: --SegmentDefs--TYPE = [0..177777B];

SegLockCount: --SegmentDefs--TYPE = [0..15];

SegmentAddress: --SegmentDefs--PROCEDURE [seg: SegmentHandle] RETURNS [POINTER];

SegmentClass: --SegmentDefs--TYPE = {frame, table, code, other};

SegmentFault: --SegmentDefs--SIGNAL [seg: FileSegmentHandle, pages: PageCount];

SegmentHandle: --SegmentDefs--TYPE = POINTER TO SegmentObject;

SegmentLocation: --SegmentDefs--TYPE = {disk, remote};

SegmentObject: --SegmentDefs--TYPE = segment Object;

SegmentSize: --SystemDefs--PROCEDURE [base: POINTER] RETURNS [nwords: CARDINAL];

SegmentType: --SegmentDefs--TYPE = {data, file};

SelfDestruct: --FrameDefs--PROCEDURE;

SendMsgSignal: --TrapDefs--SIGNAL
RETURNS [msg: UNSPECIFIED, signal: UNSPECIFIED];

SetBlock: --MiscDefs--PROCEDURE [p: POINTER, v: UNSPECIFIED, l: CARDINAL];

SetDummyDisplaySize: --DisplayDefs--PROCEDURE [nScanLines: CARDINAL];

SetEcho: --IODefs--PROCEDURE [new: BOOLEAN] RETURNS [old: BOOLEAN];

SetEndOfFile: --SegmentDefs--PROCEDURE [
file: FileHandle, page: PageNumber, byte: CARDINAL];

SetFileAccess: --SegmentDefs--PROCEDURE [
file: FileHandle, access: AccessOptions];

SetFileLength: --SegmentDefs--PROCEDURE [file: FileHandle, fa: POINTER TO FA];

SetFileSegmentDA: --SegmentDefs--PROCEDURE [seg: FileSegmentHandle, da: vDA];

SetFileTimes: --SegmentDefs--PROCEDURE [
file: FileHandle, read: LONG CARDINAL, write: LONG CARDINAL,
create: LONG CARDINAL];

SetFont: --DisplayDefs--PROCEDURE [FontHandle];

SetIndex: --StreamDefs--PROCEDURE [stream: StreamHandle, index: StreamIndex];

SetInputStream: --IODefs--PROCEDURE [StreamHandle];

SetOutputStream: --IODefs--PROCEDURE [StreamHandle];

SetPosition: --StreamDefs--PROCEDURE [
stream: StreamHandle, pos: StreamPosition];

SetPriority: --ProcessDefs, Process--PROCEDURE [Priority];

SetSystemDisplaySize: --DisplayDefs--PROCEDURE [
nTextLines: CARDINAL, nPages: CARDINAL];

SetSystemDisplayWidth: --DisplayDefs--PROCEDURE [
indent: CARDINAL, width: CARDINAL];

SetTimeout: --ProcessDefs, Process--PROCEDURE [
condition: POINTER TO CONDITION, ticks: Ticks];

SetTypeScript: --DisplayDefs--PROCEDURE [DiskHandle];

SetWorkingDir: --DirectoryDefs--PROCEDURE [dir: FileHandle];

SN: --AltoFileDefs--TYPE = MACHINE DEPENDENT RECORD [
bits: SNBits, part1: [0..17777B], part2: CARDINAL];

SNBits: --AltoFileDefs--TYPE = MACHINE DEPENDENT RECORD [
directory: [0..1], random: [0..1], nolog: [0..1]];

SP: --Ascii, CharIO, IODefs--CHARACTER = 40C;

SplitNode: --FSPDefs--PROCEDURE [z: ZonePointer, p: POINTER, n: BlockSize];

StackError: --TrapDefs--ERROR;

StartCursor: --DisplayDefs--PROCEDURE;

StartFault: --TrapDefs--SIGNAL [dest: GlobalFrameHandle];

StartKeyHandler: --StreamDefs--PROCEDURE;

StartTrace: --TrapDefs--PROCEDURE [
loc: POINTER, val: UNSPECIFIED, mask: WORD, equal: BOOLEAN];

StopCursor: --DisplayDefs--PROCEDURE;

StopKeyHandler: --StreamDefs--PROCEDURE;

StopMesa: --ImageDefs--PROCEDURE;

StopTrace: --TrapDefs--PROCEDURE;

StreamBufferDS: --SegmentDefs--DataSegmentType = 6;

StreamError: --StreamDefs--SIGNAL [
stream: StreamHandle, error: StreamErrorCode];

StreamErrorCode: --StreamDefs--TYPE = {
StreamType, StreamAccess, StreamOperation, StreamPosition, StreamEnd,
StreamBug};

StreamHandle: --StreamDefs--TYPE = POINTER TO StreamObject;

StreamIndex: --StreamDefs--TYPE = RECORD [page: PageNumber, byte: CARDINAL];

StreamIO: --IODefs--PROGRAM;

StreamObject: --StreamDefs--TYPE = RECORD [
reset: PROCEDURE [StreamHandle],
get: PROCEDURE [StreamHandle] RETURNS [UNSPECIFIED],
putback: PROCEDURE [StreamHandle, UNSPECIFIED],
put: PROCEDURE [StreamHandle, UNSPECIFIED],
endof: PROCEDURE [StreamHandle] RETURNS [BOOLEAN],
destroy: PROCEDURE [StreamHandle],
link: StreamHandle,
body:
SELECT type: * FROM
Keyboard => [
in: CARDINAL, out: CARDINAL, buffer: PACKED ARRAY [0..79] OF CHARACTER],
Display => [
clearCurrentLine: PROCEDURE [stream: StreamHandle],
clearLine: PROCEDURE [stream: StreamHandle, line: CARDINAL],
clearChar: PROCEDURE [stream: StreamHandle, char: CHARACTER],
type: UNSPECIFIED,
data: POINTER],
Disk => [
eof: BOOLEAN,
dirty: BOOLEAN,
read: BOOLEAN,
write: BOOLEAN,
append: BOOLEAN,
unit: [1..2],
index: CARDINAL,
size: CARDINAL,
page: PageNumber,
char: CARDINAL,
buffer: RECORD [
SELECT OVERLAID * FROM
byte => [byte: POINTER TO PACKED ARRAY [0..0] OF BYTE],
word => [word: POINTER TO ARRAY [0..0] OF WORD]
ENDCASE],

file: FileHandle,
das: ARRAY {last, current, next} OF vDA,
getOverflow: PROCEDURE [StreamHandle],
savedGet: PROCEDURE [StreamHandle] RETURNS [UNSPECIFIED],
putOverflow: PROCEDURE [StreamHandle],
savedPut: PROCEDURE [StreamHandle, UNSPECIFIED]],
Other => [type: UNSPECIFIED, data: POINTER]
ENDCASE];

StreamPosition: --StreamDefs--TYPE = LONG CARDINAL;

String: --Storage--PROCEDURE [nchars: CARDINAL] RETURNS [s: STRING];

StringBoundsFault: --StringDefs, String--SIGNAL [s: STRING]
RETURNS [ns: STRING];

StringHeaderSize: --StringDefs, String--CARDINAL = 2;

StringLength: --Storage--PROCEDURE [s: STRING] RETURNS [CARDINAL];

StringProc: --Format--TYPE = PROCEDURE [s: STRING];

StringToDecimal: --StringDefs, String--PROCEDURE [s: STRING] RETURNS [INTEGER];

StringToLongNumber: --StringDefs, String--PROCEDURE [s: STRING, radix: CARDINAL]
RETURNS [LONG UNSPECIFIED];

StringToNumber: --StringDefs, String--PROCEDURE [s: STRING, radix: CARDINAL]
RETURNS [UNSPECIFIED];

StringToOctal: --StringDefs, String--PROCEDURE [s: STRING]
RETURNS [UNSPECIFIED];

SubString: --Format--PROCEDURE [ss: SubString, proc: StringProc];

SubString: --StringDefs--TYPE = POINTER TO SubStringDescriptor;

SubString: --String--TYPE = SubString;

SubStringDescriptor: --StringDefs--TYPE = RECORD [
base: STRING, offset: CARDINAL, length: CARDINAL];

SubStringDescriptor: --String--TYPE = SubStringDescriptor;

SwapError: --SegmentDefs--SIGNAL [seg: FileSegmentHandle];

SwapErrorDuringMakeCheck: --ImageDefs--SIGNAL;

SwapErrorDuringMakeImage: --ImageDefs--SIGNAL;

SwapIn: --SegmentDefs--PROCEDURE [seg: FileSegmentHandle];

SwapInCode: --FrameDefs--PROCEDURE [f: GlobalFrameHandle];

SwapOut: --SegmentDefs--PROCEDURE [seg: FileSegmentHandle];

SwapOutCode: --FrameDefs--PROCEDURE [f: GlobalFrameHandle];

SwapOutDuringMakeCheck: --ImageDefs--SIGNAL;

SwapOutDuringMakeImage: --ImageDefs--SIGNAL;

SwappingProcedure: --AllocDefs--TYPE = PROCEDURE [
needed: PageCount, info: AllocInfo, seg: SegmentHandle] RETURNS [BOOLEAN];

SwapStrategy: --AllocDefs--TYPE = RECORD [
link: POINTER TO SwapStrategy, proc: SwappingProcedure];

SwapTrapDuringMakeCheck: --ImageDefs--SIGNAL;

SwapTrapDuringMakeImage: --ImageDefs--SIGNAL;

SwapUp: --SegmentDefs--PROCEDURE [seg: FileSegmentHandle];

SwatLevel: --ProcessDefs--InterruptLevel = 3;

SystemDS: --SegmentDefs--DataSegmentType = 4;

TAB: --Ascii, CharIO, IODefs--CHARACTER = 11C;

TableDS: --SegmentDefs--DataSegmentType = 2;

Task: --AltoHardware--TYPE = {
Emulator, OrbitSlot, unused2, Trident3, KSEC, Tape5, Tape6, ETHER, MRT, DWT,
CURT, DHT, DVT, PART, KWD, Trident17};

Ticks: --ProcessDefs, Process--TYPE = CARDINAL;

TicksToMsec: --ProcessDefs, Process--PROCEDURE [Ticks] RETURNS [Milliseconds];

TIME: --AltoFileDefs--TYPE = MACHINE DEPENDENT RECORD [
high: CARDINAL, low: CARDINAL];

TimeoutLevel: --ProcessDefs--InterruptLevel = 4;

TooManyProcesses: --ProcessDefs, Process--ERROR;

trackCursor: --StreamDefs--BOOLEAN;

TruncateDiskStream: --StreamDefs--PROCEDURE [stream: StreamHandle];

TryCodeSwapping: --AllocDefs--SwappingProcedure;

UnboundProcedure: --TrapDefs--SIGNAL [dest: UNSPECIFIED] RETURNS [ControlLink];

UnimplementedInst: --TrapDefs--SIGNAL;

UnknownDS: --SegmentDefs--DataSegmentType = 0;

Unlock: --SegmentDefs--PROCEDURE [seg: FileSegmentHandle];

UnlockCode: --FrameDefs--PROCEDURE [link: UNSPECIFIED];

UnlockFile: --SegmentDefs--PROCEDURE [file: FileHandle];

UnNew: --FrameDefs--PROCEDURE [frame: GlobalFrameHandle];

UnNewConfig: --FrameDefs--PROCEDURE [link: UNSPECIFIED];

Unpack: --Time--PROCEDURE [time: LONG CARDINAL] RETURNS [unpacked: Unpacked];

UnpackDT: --TimeDefs--PROCEDURE [p: PackedTime] RETURNS [time: UnpackedTime];

Unpacked: --Time--TYPE = UnpackedTime;

UnpackedTime: --TimeDefs--TYPE = RECORD [
year: [0..4002B],
month: [0..11],
day: [0..31],
hour: [0..23],
minute: [0..59],
second: [0..59],
weekday: [0..6],
zone: [177764B..12],
dst: BOOLEAN];

UnusableLevel: --ProcessDefs--InterruptLevel = 15;

UpdateFileLength: --SegmentDefs--PROCEDURE [
file: FileHandle, fa: POINTER TO FA];

UpDown: --AltoHardware--TYPE = {down, up};

updown: --KeyDefs--TYPE = {down, up};

UpperCase: --StringDefs, String--PROCEDURE [c: CHARACTER] RETURNS [CHARACTER];

userAbort: --StreamDefs--BOOLEAN;

UserCleanupProc: --ImageDefs--CleanupProcedure;

UtilIn: --AltoHardware--POINTER TO UtilInBits;

UtilInBits: --AltoHardware--TYPE = MACHINE DEPENDENT RECORD [
util: [0..255],
key0: UpDown,
key1: UpDown,
key2: UpDown,
key3: UpDown,
key4: UpDown,
redMouse: UpDown,
blueMouse: UpDown,
yellowMouse: UpDown];

UtilOut: --AltoHardware--POINTER TO WORD;

ValidateFrame: --FrameDefs--PROCEDURE [UNSPECIFIED];

ValidateGlobalFrame: --FrameDefs--PROCEDURE [UNSPECIFIED];

ValidateLongPointer: --SegmentDefs--PROCEDURE [a: LONG UNSPECIFIED];

ValidateProcess: --ProcessDefs, Process--PROCEDURE [UNSPECIFIED];

ValidateVMPage: --SegmentDefs--PROCEDURE [page: UNSPECIFIED];

vDA: --AltoFileDefs--TYPE = RECORD [CARDINAL];

vDC: --AltoFileDefs--TYPE = {
ReadHLD, ReadLD, ReadD, WriteHLD, WriteLD, WriteD, SeekOnly, DoNothing};

VersionOptions: --SegmentDefs--TYPE = [0..3];

VMLimit: --AltoDefs--CARDINAL = 177777B;

VMnotFree: --SegmentDefs--SIGNAL [base: PageNumber, pages: PageCount];

VMtoDataSegment: --SegmentDefs--PROCEDURE [a: POINTER]
RETURNS [DataSegmentHandle];

VMtoFileSegment: --SegmentDefs--PROCEDURE [a: POINTER]
RETURNS [FileSegmentHandle];

VMtoSegment: --SegmentDefs--PROCEDURE [a: POINTER] RETURNS [SegmentHandle];

WakeupError: --TrapDefs--SIGNAL;

WestEast: --TimeDefs--TYPE = {west, east};

WordBlockDescriptor: --AltoHardware--TYPE = MACHINE DEPENDENT RECORD [
count: CARDINAL, pointer: POINTER];

wordlength: --AltoDefs--CARDINAL = 16;

WordLength: --AltoHardware--CARDINAL = 16;

Words: --Storage--PROCEDURE [nwords: CARDINAL] RETURNS [base: POINTER];

WordsForBcplString: --StringDefs--PROCEDURE [nchars: CARDINAL]
RETURNS [CARDINAL];

WordsForString: --StringDefs, String--PROCEDURE [nchars: CARDINAL]
RETURNS [CARDINAL];

WorryCallDebugger: --MiscDefs--PROCEDURE [STRING];

Write: --SegmentDefs, StreamDefs--AccessOptions = 2;

WriteAppend: --SegmentDefs, StreamDefs--AccessOptions = 6;

WriteBlock: --StreamDefs--PROCEDURE [
stream: StreamHandle, address: POINTER, words: CARDINAL] RETURNS [CARDINAL];

WriteChar: --IODefs--PROCEDURE [CHARACTER];

WriteDecimal: --IODefs--PROCEDURE [INTEGER];

WriteLine: --IODefs--PROCEDURE [STRING];

WriteNumber: --IODefs--PROCEDURE [UNSPECIFIED, NumberFormat];

WriteOctal: --IODefs--PROCEDURE [UNSPECIFIED];

WriteProtectFault: --TrapDefs--SIGNAL [page: CARDINAL];

WriteString: --IODefs--PROCEDURE [STRING];

WriteSubString: --IODefs--PROCEDURE [SubString];

Yield: --ProcessDefs, Process--PROCEDURE;

Zero: --MiscDefs--PROCEDURE [p: POINTER, l: CARDINAL];

ZeroDivisor: --TrapDefs--SIGNAL;

zeroLengthBuffer: --AltoHardware--EthernetMicrocodeStatus;

ZoneHeader: --FSPDefs--TYPE = RECORD [
node: free NodeHeader,
rover: FreeNodePointer,
lock: MONITORLOCK,
restOfZone: ZonePointer,
length: BlockSize,
deallocate: Deallocator,
threshold: BlockSize,
checking: BOOLEAN];

ZoneOverhead: --FSPDefs--CARDINAL = 10;

ZonePointer: --FSPDefs--TYPE = POINTER TO ZoneHeader;

ZoneTooLarge: --FSPDefs--ERROR [POINTER];

ZoneTooSmall: --FSPDefs, Storage--ERROR [POINTER];