SAIL.XGP[DOC,AIL]4 - www.SailDart.org

perm filename SAIL.XGP[DOC,AIL]4 blob sn#144372 filedate 1975-02-12 generic text, type T, neo UTF8
/LMAR=0/XLINE=4/FONT#0=BDR30/FONT#1=BDR40/FONT#2=BDR30/FONT#3=LPT



␈↓ α∧␈↓STANFORD ARTIFICIAL INTELLIGENCE LABORATORY␈↓ 
;FEBRUARY 1975






␈↓ α∧␈↓↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈αλSAIL USER MANUAL

␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∃UPDATE



␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α7James R. Low
␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α3John F. Reiser
␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α0Hanan J. Samet
␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α)Robert L. Smith
␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α Robert F. Sproull
␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∂Daniel C. Swinehart
␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α Russell H. Taylor
␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α"Kurt A. VanLehn










␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧ABSTRACT

␈↓ α∧␈↓This␈α
document␈α
describes␈α
recent␈α
changes␈α
to␈α
the␈α
SAIL␈α
language␈α
since␈α
the␈α
"new"␈α∞manual␈α
(AIM-204)
␈↓ α∧␈↓was␈α∞published␈α∞in␈α∞July␈α∞1973.␈α
 It␈α∞reflects␈α∞the␈α∞various␈α∞new␈α
features␈α∞implemented␈α∞as␈α∞of␈α∞24␈α
October,
␈↓ α∧␈↓1974 for SAIL version 18 and corrects a number of minor errors in the earlier manual.
␈↓ α∧␈↓SAIL Addendum  1␈↓ 	ZTABLE OF CONTENTS


␈↓ α∧␈↓  
␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α0␈↓↓T A B L E   O F   C O N T E N T S␈↓



␈↓ α∧␈↓␈↓ βtSECTION␈↓ 	XPAGE



␈↓ α∧␈↓␈↓ βt1␈↓ ∧DINTRODUCTION␈↓ 
⊗1



␈↓ α∧␈↓␈↓ βt2␈↓ ∧DNUMERICAL ROUTINES␈↓ 
⊗2

␈↓ α∧␈↓␈↓ βt␈↓ ∧D1␈↓ ¬∀OVERFLOW␈↓ 
⊗3
␈↓ α∧␈↓␈↓ βt␈↓ ∧D2␈↓ ¬∀ENTRY POINTS␈↓ 
⊗3


␈↓ α∧␈↓␈↓ βt3␈↓ ∧DNEW PROCESS FEATURES␈↓ 
⊗4

␈↓ α∧␈↓␈↓ βt␈↓ ∧D1␈↓ ¬∀SPROUT APPLY␈↓ 
⊗4
␈↓ α∧␈↓␈↓ βt␈↓ ∧D2␈↓ ¬∀SPROUT_DEFAULTS␈↓ 
⊗4
␈↓ α∧␈↓␈↓ βt␈↓ ∧D3␈↓ ¬∀SUSPEND␈↓ 
⊗6
␈↓ α∧␈↓␈↓ βt␈↓ ∧D4␈↓ ¬∀FAIL AND SUCCEED␈↓ 
⊗6


␈↓ α∧␈↓␈↓ βt4␈↓ ∧DERROR HANDLING␈↓ 
⊗7

␈↓ α∧␈↓␈↓ βt␈↓ ∧D1␈↓ ¬∀ERROR MODES␈↓ 
⊗7
␈↓ α∧␈↓␈↓ βt␈↓ ∧D2␈↓ ¬∀USER ERROR PROCEDURES␈↓ 
⊗7


␈↓ α∧␈↓␈↓ βt5␈↓ ∧DINEXHAUSTIBLE STRING SPACE␈↓ 
⊗9
␈↓ α∧␈↓SAIL Addendum  1␈↓ 	ZTABLE OF CONTENTS


␈↓ α∧␈↓␈↓ βt6␈↓ ∧DRECORD STRUCTURES␈↓ 
λ11

␈↓ α∧␈↓␈↓ βt␈↓ ∧D1␈↓ ¬∀INTRODUCTORY REMARKS␈↓ 
λ11
␈↓ α∧␈↓␈↓ βt␈↓ ∧D2␈↓ ¬∀RECORD CLASS DECLARATIONS␈↓ 
λ12
␈↓ α∧␈↓␈↓ βt␈↓ ∧D3␈↓ ¬∀RECORD POINTER DECLARATIONS␈↓ 
λ12
␈↓ α∧␈↓␈↓ βt␈↓ ∧D4␈↓ ¬∀ALLOCATION␈↓ 
λ13
␈↓ α∧␈↓␈↓ βt␈↓ ∧D5␈↓ ¬∀SUBFIELDS␈↓ 
λ14
␈↓ α∧␈↓␈↓ βt␈↓ ∧D6␈↓ ¬∀INTERNAL REPRESENTATIONS AND
␈↓ α∧␈↓␈↓ ¬tIMPLEMENTATION NOTES␈↓ 
λ15


␈↓ α∧␈↓␈↓ βt7␈↓ ∧DMISCELLANEOUS NEW FEATURES␈↓ 
λ17

␈↓ α∧␈↓␈↓ βt␈↓ ∧D1␈↓ ¬∀NEW MTAPE OPTIONS␈↓ 
λ17
␈↓ α∧␈↓␈↓ βt␈↓ ∧D2␈↓ ¬∀INITIALIZATION PHASES␈↓ 
λ17
␈↓ α∧␈↓␈↓ βt␈↓ ∧D3␈↓ ¬∀CHNCDB␈↓ 
λ18
␈↓ α∧␈↓␈↓ βt␈↓ ∧D4␈↓ ¬∀ARRCLR␈↓ 
λ18
␈↓ α∧␈↓␈↓ βt␈↓ ∧D5␈↓ ¬∀SETPL␈↓ 
λ19
␈↓ α∧␈↓␈↓ βt␈↓ ∧D6␈↓ ¬∀EVALREDEFINE␈↓ 
λ19
␈↓ α∧␈↓␈↓ βt␈↓ ∧D7␈↓ ¬∀CVPS␈↓ 
λ19
␈↓ α∧␈↓␈↓ βt␈↓ ∧D8␈↓ ¬∀EXPRESSIONS IN REQUIRES␈↓ 
λ19
␈↓ α∧␈↓␈↓ βt␈↓ ∧D9␈↓ ¬∀RELEASE␈↓ 
λ20
␈↓ α∧␈↓␈↓ βt␈↓ ∧D10␈↓ ¬∀TTYUP␈↓ 
λ20
␈↓ α∧␈↓␈↓ βt␈↓ ∧D11␈↓ ¬∀BREAKSET MODES "K" AND "F"␈↓ 
λ20
␈↓ α∧␈↓␈↓ βt␈↓ ∧D12␈↓ ¬∀INOUT␈↓ 
λ21
␈↓ α∧␈↓␈↓ βt␈↓ ∧D13␈↓ ¬∀GETSTS & SETSTS␈↓ 
λ21
␈↓ α∧␈↓␈↓ βt␈↓ ∧D14␈↓ ¬∀CHANGES TO "OPEN" ERROR HANDLING␈↓ 
λ21
␈↓ α∧␈↓␈↓ βt␈↓ ∧D15␈↓ ¬∀ASH␈↓ 
λ22
␈↓ α∧␈↓␈↓ βt␈↓ ∧D16␈↓ ¬∀ARG_LIST␈↓ 
λ22
␈↓ α∧␈↓␈↓ βt␈↓ ∧D17␈↓ ¬∀CLOSE␈↓ 
λ22
␈↓ α∧␈↓␈↓ βt␈↓ ∧D18␈↓ ¬∀TYPEIT␈↓ 
λ23
␈↓ α∧␈↓␈↓ βt␈↓ ∧D19␈↓ ¬∀COMPARISON OF .REL FILES␈↓ 
λ23
␈↓ α∧␈↓␈↓ βt␈↓ ∧D20␈↓ ¬∀SCAN Optimizations␈↓ 
λ23
␈↓ α∧␈↓␈↓ βt␈↓ ∧D21␈↓ ¬∀BREAK TABLES␈↓ 
λ23
␈↓ α∧␈↓␈↓ βt␈↓ ∧D22␈↓ ¬∀CV6STR␈↓ 
λ24
␈↓ α∧␈↓␈↓ βt␈↓ ∧D23␈↓ ¬∀TENEX RUNTIMES␈↓ 
λ24
␈↓ α∧␈↓␈↓ βt␈↓ ∧D24␈↓ ¬∀CVASTR␈↓ 
λ25


␈↓ α∧␈↓␈↓ βt8␈↓ ∧DMINOR CORRECTIONS TO AIM-204␈↓ 
λ26
␈↓ α∧␈↓SAIL Addendum  1␈↓ 
1INTRODUCTION


␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α≡␈↓↓SECTION  1␈↓

␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α0␈↓↓INTRODUCTION␈↓





␈↓ α∧␈↓The␈αfollowing␈αshort␈αmanual␈αdescribes␈αthe␈αchanges␈αthat␈αhave␈αhappened␈αto␈αSAIL␈αsince␈αthe␈αpublishing
␈↓ α∧␈↓of␈αthe␈αManual␈αin␈αJuly␈α1973.␈αIt␈αaccurately␈αreflects␈αthe␈αstate␈αof␈αSAIL,␈αversion␈α18,␈αwhich␈αwas␈α
put␈αup
␈↓ α∧␈↓on␈α∩October␈α∩24,␈α∩1973.␈α∩ The␈α∩reader␈α∩should␈α⊃be␈α∩warned␈α∩that␈α∩many␈α∩of␈α∩these␈α∩new␈α∩features␈α⊃were
␈↓ α∧␈↓designed for veteran SAIL hackers.

␈↓ α∧␈↓The reader may also want to refer to the following documents, which are usually kept updated.

␈↓ α∧␈↓MACLIE.WRU[DOC,AIL]␈↓ ∧DA␈α
summary␈α
of␈α
commonly␈αmade␈α
errors␈α
when␈α
using␈αmacros␈α
and␈α
what␈α
to␈αdo
␈↓ α∧␈↓␈↓ ∧Dabout them.

␈↓ α∧␈↓TUTOR.DOC[DOC,AIL]␈↓ ∧DIn introduction to LEAP.

␈↓ α∧␈↓LEAP.WRU[DOC,AIL]␈↓ ∧DA␈αdetailed␈αdescription␈αof␈αthe␈αruntime␈αenvironment␈αof␈αLEAP␈αfor␈αthe␈αhardy
␈↓ α∧␈↓␈↓ ∧Dfew who want to interface to LEAP in assembly language.

␈↓ α∧␈↓SAIL.DOC[AIM,DOC]␈↓ ∧DThe␈α
July␈α
'73␈α∞manual␈α
(AIM-204)␈α
in␈α
LPT␈α∞form.␈α
Warning:␈α
this␈α
version␈α∞is␈α
the
␈↓ α∧␈↓␈↓ ∧DStanford␈α∞character␈α∞set.␈α∞ It␈α∂is␈α∞also␈α∞almost␈α∞300␈α∂pages␈α∞long.␈α∞ You␈α∞can␈α∂get␈α∞a
␈↓ α∧␈↓␈↓ ∧D120␈α∩page␈α∩version,␈α∩set␈α∩in␈α∩two␈α∩columns␈α∩of␈α∩nice␈α∩type␈α∩from␈α∩the␈α⊃National
␈↓ α∧␈↓␈↓ ∧DTechnical Information Service, Springfield, Virginia 22151.

␈↓ α∧␈↓LIES[DOC,AIL]␈↓ ∧DThis␈α∩file␈α⊃contains␈α∩the␈α⊃know␈α∩mistakes␈α⊃in␈α∩the␈α⊃Manual.␈α∩Soon␈α⊃it␈α∩will␈α⊃also
␈↓ α∧␈↓␈↓ ∧Dcontain the known mistakes in this document.















␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α1␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ 	NNUMERICAL ROUTINES


␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α≡␈↓↓SECTION  2␈↓

␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α'␈↓↓NUMERICAL ROUTINES␈↓





␈↓ α∧␈↓A␈α∪collection␈α∪of␈α∩numerical␈α∪routines␈α∪has␈α∪been␈α∩added␈α∪to␈α∪SAIL.␈α∩ These␈α∪are␈α∪pre-declared␈α∪in␈α∩the
␈↓ α∧␈↓compiler,␈α∪and␈α∪are␈α∪loaded␈α∪from␈α∪the␈α∩standard␈α∪SAIL␈α∪library.␈α∪ The␈α∪functions␈α∪are␈α∪quite␈α∩standard;
␈↓ α∧␈↓following are the equivalent definitions:

␈↓ α∧␈↓1.␈↓ αDThe␈α⊂standard␈α⊂trigonometric␈α⊃functions.␈α⊂ ASIN,␈α⊂ACOS,␈α⊂ATAN␈α⊃and␈α⊂ATAN2␈α⊂return␈α⊃results␈α⊂in
␈↓ α∧␈↓␈↓ αDradians.␈α
 The␈α
ATAN2␈αcall␈α
takes␈α
arc-tangent␈αof␈α
the␈α
quotient␈αof␈α
its␈α
arguments;␈αin␈α
this␈α
way,␈αit
␈↓ α∧␈↓␈↓ αDcorrectly preserves sign information.

␈↓ α∧␈↓        REAL PROCEDURE SIN (REAL RADIANS);
␈↓ α∧␈↓        REAL PROCEDURE COS (REAL RADIANS);
␈↓ α∧␈↓        REAL PROCEDURE SIND (REAL DEGREES);
␈↓ α∧␈↓        REAL PROCEDURE COSD (REAL DEGREES);

␈↓ α∧␈↓        REAL PROCEDURE ASIN (REAL ARGUMENT);
␈↓ α∧␈↓        REAL PROCEDURE ACOS (REAL ARGUMENT);
␈↓ α∧␈↓        REAL PROCEDURE ATAN (REAL ARGUMENT);
␈↓ α∧␈↓        REAL PROCEDURE ATAN2 (REAL NUMERATOR,DENOMINATOR);


␈↓ α∧␈↓2.␈↓ αDThe hyperbolic trigonometric functions.

␈↓ α∧␈↓        REAL PROCEDURE SINH (REAL ARGUMENT);
␈↓ α∧␈↓        REAL PROCEDURE COSH (REAL ARGUMENT);
␈↓ α∧␈↓        REAL PROCEDURE TANH (REAL ARGUMENT);

␈↓ α∧␈↓3. ␈↓ αDThe square-root function:

␈↓ α∧␈↓        REAL PROCEDURE SQRT (REAL ARGUMENT);

␈↓ α∧␈↓4.␈↓ αDA␈αpseudo-random␈αnumber␈αgenerator.␈α The␈αargument␈αspecifies␈αa␈αnew␈αvalue␈αfor␈αthe␈αseed␈α(If␈αthe
␈↓ α∧␈↓␈↓ αDargument␈α∩is␈α∩0,␈α∩the␈α∪old␈α∩seed␈α∩value␈α∩is␈α∩used.␈α∪ Thus␈α∩to␈α∩get␈α∩differing␈α∩random␈α∪numbers,␈α∩this
␈↓ α∧␈↓␈↓ αDargument should be zero.)  Results are normalized to lie in the range [0,1].

␈↓ α∧␈↓        REAL PROCEDURE RAN (INTEGER SEED);



␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α2␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ 	NNUMERICAL ROUTINES


␈↓ α∧␈↓5.␈↓ αDLogarithm␈α⊃and␈α⊃exponentiation␈α⊃functions.␈α⊃ These␈α⊃functions␈α⊃are␈α⊃the␈α⊃same␈α⊃ones␈α⊃used␈α⊃by␈α⊂the
␈↓ α∧␈↓␈↓ αDSAIL␈α
exponentiation␈α∞operator.␈α
 The␈α
base␈α∞is␈α
e␈α
(2.71828182845904).␈α∞ The␈α
logarithm␈α
to␈α∞the␈α
base
␈↓ α∧␈↓␈↓ αD10 of e is .4342944819.

␈↓ α∧␈↓        REAL PROCEDURE LOG (REAL ARGUMENT);
␈↓ α∧␈↓        REAL PROCEDURE EXP (REAL ARGUMENT);

␈↓ α∧␈↓These␈αfunctions␈αmay␈αoccasionally␈αbe␈αasked␈αto␈αcompute␈αnumbers␈αthat␈αlie␈αoutside␈αthe␈αrange␈αof␈αlegal
␈↓ α∧␈↓floating-point␈αnumbers␈αon␈αthe␈αPDP-10.␈α In␈αthese␈αcases,␈αthe␈αroutines␈αissue␈αsprightly␈αerror␈αmessages
␈↓ α∧␈↓that are continuable.



␈↓ α∧␈↓2.1 - ␈↓↓OVERFLOW␈↓


␈↓ α∧␈↓In␈α∂order␈α∂to␈α∂better␈α⊂perform␈α∂their␈α∂tasks,␈α∂these␈α∂routines␈α⊂enable␈α∂the␈α∂system␈α∂interrupt␈α⊂facility␈α∂for
␈↓ α∧␈↓floating-point␈αoverflow␈αand␈αunderflow␈αerrors.␈α If␈αan␈αunderflow␈αis␈αdetected,␈αthe␈αresults␈αare␈αset␈αto
␈↓ α∧␈↓0␈α∞(a␈α
feat␈α∞not␈α∞done␈α
by␈α∞the␈α∞PDP-10␈α
hardware,␈α∞alas).␈α∞ Be␈α
aware␈α∞that␈α∞such␈α
underflow␈α∞fixups␈α∞will␈α
be
␈↓ α∧␈↓done to every underflow that occurs in your program.

␈↓ α∧␈↓If you would like to be informed of any numerical exceptions, you can call the runtime:

␈↓ α∧␈↓        TRIGINI ( LOCATION(simple-procedure-name) );

␈↓ α∧␈↓Every␈α∪floating-point␈α∪exception␈α∪that␈α∪is␈α∪not␈α∪expected␈α∪by␈α∪the␈α∪interrupt␈α∪handler␈α∀(the␈α∪numerical
␈↓ α∧␈↓routines␈α∞use␈α∞a␈α∞special␈α∞convention␈α∞to␈α
indicate␈α∞that␈α∞arithmetic␈α∞exception␈α∞was␈α∞expected)␈α∞will␈α
cause
␈↓ α∧␈↓the␈α∪specified␈α∪simple␈α∩procedure␈α∪to␈α∪be␈α∪called.␈α∩ This␈α∪procedure␈α∪may␈α∩look␈α∪around␈α∪the␈α∪world␈α∩as
␈↓ α∧␈↓described␈α∞in␈α
the␈α∞Manual␈α∞for␈α
'export'␈α∞interrupt␈α∞handlers,␈α
page␈α∞79.␈α
 If␈α∞no␈α∞TRIGINI␈α
call␈α∞is␈α∞done,␈α
the
␈↓ α∧␈↓interrupt routine will simply dismiss unexpected floating-point interrupts.



␈↓ α∧␈↓2.2 - ␈↓↓ENTRY POINTS␈↓


␈↓ α∧␈↓In␈αorder␈αto␈αavoid␈αconfusion␈α(by␈αthe␈αloader)␈αwith␈αolder␈αtrig␈αpackages,␈αthe␈αentry␈αpoints␈αof␈αthe␈αSAIL
␈↓ α∧␈↓arithmetic␈α
routines␈α
all␈α
have␈α
a␈α
"$"␈α
appended␈α
to␈α
the␈α
end.␈α
 Thus,␈α
SIN␈α
has␈α
the␈α
entry␈α
point␈α∞SIN$,␈α
etc.
␈↓ α∧␈↓WARNING:␈αIf␈αa␈αprogram␈αplans␈αto␈αuse␈αthe␈αSAIL␈αintrinsic␈αnumerical␈αroutines,␈αit␈αshould␈αNOT␈αinclude
␈↓ α∧␈↓external␈αdeclarations␈αto␈αthem,␈αsince␈αthis␈αwill␈αprobably␈αcause␈αthe␈αFORTRAN␈αlibrary␈αroutines␈αto␈αbe
␈↓ α∧␈↓loaded.




␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α3␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ 	*NEW PROCESS FEATURES


␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α≡␈↓↓SECTION  3␈↓

␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α∞␈↓↓NEW PROCESS FEATURES␈↓







␈↓ α∧␈↓3.1 - ␈↓↓SPROUT APPLY␈↓


␈↓ α∧␈↓The␈α<procedure␈αcall>␈αin␈αa␈αSPROUT␈αstatement␈αmay␈αbe␈αan␈αAPPLY␈αconstruct.␈α In␈α this␈αcase␈αSPROUT
␈↓ α∧␈↓will␈α∂ do␈α∂the␈α⊂"right"␈α∂thing␈α∂ about␈α∂setting␈α⊂up␈α∂the␈α∂static␈α∂link␈α⊂for␈α∂ the␈α∂APPLY.␈α∂That␈α⊂is,␈α∂"up-level"
␈↓ α∧␈↓references␈α
by␈α
the␈αprocess␈α
will␈α
be␈αmade␈α
to␈α
the␈α
same␈αvariable␈α
instances␈α
that␈αwould␈α
be␈α
used␈α
if␈αthe
␈↓ α∧␈↓APPLY did not occur in a SPROUT statement. (See page 77 of the manual.)

␈↓ α∧␈↓However,␈α
there␈α
is␈α
a␈α
glitch.␈α
The␈α
sprout␈α
mechanism␈α∞is␈α
not␈α
yet␈α
smart␈α
enough␈α
to␈α
find␈α
out␈α∞the␈α
block
␈↓ α∧␈↓of␈αthe␈α
declaration␈αof␈αthe␈α
procedure␈αused␈α
to␈αdefine␈αthe␈α
procedure␈αitem.␈α
It␈αwould␈αbe␈α
nice␈αif␈α
it␈αdid,
␈↓ α∧␈↓since␈αthen␈αit␈αcould␈αwarn␈αthe␈αuser␈αwhen␈αthat␈αblock␈αwas␈αexited␈αand␈αyet␈αthe␈αprocess␈αwas␈αstill␈αalive,
␈↓ α∧␈↓and␈α
thus␈α
potentially␈α
able␈α
to␈α
refer␈α
to␈α
deallocated␈α
arrays␈α
and␈α
etc.␈α
What␈α
the␈α
sprout␈α
does␈α∞instead␈α
is
␈↓ α∧␈↓assume␈α
the␈α
procedure␈α
was␈α
declared␈α
in␈α
the␈α
outer␈α
block.␈α
This␈α
may␈α
be␈α
fixed␈α
 eventually,␈α
but␈α
in␈α
the
␈↓ α∧␈↓meantime␈α⊂ some␈α⊂extra␈α⊂care␈α⊂should␈α∂be␈α⊂taken␈α⊂ when␈α⊂using␈α⊂ apply␈α∂in␈α⊂sprouts␈α⊂to␈α⊂ avoid␈α⊂ exiting␈α∂a
␈↓ α∧␈↓block␈α∞ with␈α∞dependents.␈α∞   Similarly,␈α∞be␈α∞warned␈α∞ that␈α∞the␈α∞"DEPENDENTS␈α∞(<blockid>)"␈α∞construct
␈↓ α∧␈↓may␈α∪ not␈α∪give␈α∪ the␈α∪ "right"␈α∪result␈α∪ for␈α∩ sprout␈α∪applies.␈α∪Page␈α∪68␈α∪of␈α∪the␈α∪Manual␈α∪contains␈α∩the
␈↓ α∧␈↓description of this protection mechanism for non-APPLY Sprouts.



␈↓ α∧␈↓3.2 - ␈↓↓SPROUT_DEFAULTS␈↓


␈↓ α∧␈↓SAIL␈α
 now␈α∞provides␈α
 a␈α∞mechanism␈α
 by␈α
which␈α∞ the␈α
user␈α∞ may␈α
specify␈α
 the␈α∞"default"␈α
options␈α∞to␈α
be
␈↓ α∧␈↓used when individual procedures are sprouted.










␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α4␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ 	*NEW PROCESS FEATURES



␈↓ α∧␈↓αSyntax:
␈↓ α∧␈↓α        PROCEDURE <procid> ...
␈↓ α∧␈↓α         BEGIN
␈↓ α∧␈↓α         <some declarations>;
␈↓ α∧␈↓α         SPROUT_DEFAULTS <integer constant>;
␈↓ α∧␈↓α         <perhaps some more declarations>;
␈↓ α∧␈↓α         :
␈↓ α∧␈↓α         :
␈↓ α∧␈↓α         <statements>
␈↓ α∧␈↓α         :
␈↓ α∧␈↓α         END;


␈↓ α∧␈↓In other words, SPROUT_DEFAULTS is a declaration.

␈↓ α∧␈↓Semantics:

␈↓ α∧␈↓If␈α⊃ one␈α⊂of␈α⊃the␈α⊃"allocation"␈α⊂fields␈α⊃of␈α⊃ the␈α⊂options␈α⊃word␈α⊂passed␈α⊃to␈α⊃the␈α⊂SPROUT␈α⊃routine␈α⊃--␈α⊂i.e.
␈↓ α∧␈↓QUANTUM,STRINGSTACK,PSTACK,␈α⊃or␈α⊃ PRIORITY␈α⊃--␈α⊃is␈α⊃zero,␈α⊃  then␈α⊃ SPROUT␈α⊃ will␈α∩look␈α⊃ at
␈↓ α∧␈↓the␈αcorresponding␈α field␈αof␈α the␈αspecified␈α<integer␈αconstant>␈αfor␈αthe␈αprocedure␈αbeing␈αsprouted.␈αIf
␈↓ α∧␈↓the␈α
field␈α
is␈α
 non-zero,␈α
  then␈α
 that␈α
value␈α
 will␈α
be␈α
 used;␈α
otherwise␈α
 the␈α
current␈α
"system"␈αdefault
␈↓ α∧␈↓will be used.

␈↓ α∧␈↓NOTE:␈α SPROUT_DEFAULTS␈α only␈αapplies␈α to␈α "allocations",␈αi.e.␈α  the␈αprocess␈αstatus␈αcontrol␈αbits
␈↓ α∧␈↓(e.g. SUSPME) are not affected.
␈↓ α∧␈↓αExample:

␈↓ α∧␈↓α        RECURSIVE PROCEDURE FOO;
␈↓ α∧␈↓α         BEGIN
␈↓ α∧␈↓α         SPROUT_DEFAULTS STRINGSTACK(10);
␈↓ α∧␈↓α         INTEGER XXX;
␈↓ α∧␈↓α         :
␈↓ α∧␈↓α         :
␈↓ α∧␈↓α         END;
␈↓ α∧␈↓α        :
␈↓ α∧␈↓α        SPROUT(P1,FOO,STRINGSTACK(3));
␈↓ α∧␈↓α        SPROUT(P2,FOO);
␈↓ α∧␈↓α        COMMENT P1 will have a string stack of 3*32 words.
␈↓ α∧␈↓α         P2 will have a string stack of 10*32 words;





␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α5␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ 	*NEW PROCESS FEATURES


␈↓ α∧␈↓3.3 - ␈↓↓SUSPEND␈↓


␈↓ α∧␈↓SUSPEND now behaves like RESUME in that it returns an item.

␈↓ α∧␈↓        itm ← SUSPEND(<process item>)

␈↓ α∧␈↓Frequently,␈α∂one␈α∞is␈α∂suspending␈α∞some␈α∂other␈α∞process␈α∂than␈α∞the␈α∂one␈α∞that␈α∂is␈α∞executing␈α∂the␈α∞SUSPEND
␈↓ α∧␈↓statement. In this case, the item returned is ANY.   However, in cases like:

␈↓ α∧␈↓        X ← SUSPEND(MYPROC);

␈↓ α∧␈↓where␈α∪the␈α∀process␈α∪suspends␈α∪itself,␈α∀it␈α∪might␈α∪happen␈α∀that␈α∪this␈α∪process␈α∀is␈α∪made␈α∪running␈α∀by␈α∪a
␈↓ α∧␈↓RESUME␈α
from␈α
another␈α
process.␈α
If␈α
so,␈α
then␈α
X␈α
receives␈α
the␈α
<return_item>␈α
 that␈α
was␈α∞an␈α
argument
␈↓ α∧␈↓to the RESUME.



␈↓ α∧␈↓3.4 - ␈↓↓FAIL AND SUCCEED␈↓


␈↓ α∧␈↓FAIL␈α∂and␈α∂SUCCEED␈α∂now␈α∂behave␈α∂like␈α∂RESUME␈α∞and␈α∂SUSPEND␈α∂in␈α∂that␈α∂they␈α∂also␈α∂return␈α∂an␈α∞item.
␈↓ α∧␈↓The␈α
item␈αreturned␈α
is␈α
ANY␈αunless␈α
the␈α
Matching␈αProcedure␈α
containing␈α
the␈αFAIL␈α
or␈α
SUCCEED␈αwas
␈↓ α∧␈↓(1)␈α
sprouted␈α
as␈α∞a␈α
process,␈α
and␈α∞(2)␈α
made␈α
running␈α
by␈α∞a␈α
RESUME␈α
construct.␈α∞ In␈α
the␈α
latter␈α∞case,␈α
the
␈↓ α∧␈↓item␈α
returned␈α∞is␈α
the␈α∞<return_item>␈α
that␈α∞was␈α
an␈α∞argument␈α
to␈α∞the␈α
RESUME.␈α∞ [Note␈α
that␈α∞the␈α
only
␈↓ α∧␈↓case in which a Matching Procedure can be reactivated at a FAIL is by being RESUMEd.]



















␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α6␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ 
∀ERROR HANDLING


␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α≡␈↓↓SECTION  4␈↓

␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α↔␈↓↓ERROR HANDLING␈↓







␈↓ α∧␈↓4.1 - ␈↓↓ERROR MODES␈↓


␈↓ α∧␈↓SAIL's␈αerror␈α handler␈αhas␈αat␈α long␈αlast␈αbeen␈α modified␈αto␈αdo␈α what␈αis␈αclaimed␈αit␈αwill␈αdo␈α in␈αSection
␈↓ α∧␈↓20␈αof␈αthe␈αmanual␈α(pgs␈α95␈α-␈α97),␈αand␈αin␈αthe␈αdescription␈αof␈αUSERERR␈α(pg␈α42).␈α In␈αbrief,␈αit␈αallows␈αone
␈↓ α∧␈↓to␈α have␈αerror␈α messages␈αautomatically␈α sent␈α to␈α a␈α"log"␈α file␈α while␈αone␈α is␈αcompiling,␈αand␈αto␈αuse
␈↓ α∧␈↓USERERR as a trace statement.

␈↓ α∧␈↓The␈αdescription␈αgiven␈αin␈αthe␈α
manual␈αdiffers␈αfrom␈αreality␈αin␈α
two␈αways:␈α"Keep"␈αmode␈αhas␈α
not␈α been
␈↓ α∧␈↓implemented␈α(the␈αerror␈αhandler␈α will␈αflush␈αall␈αtype-ahead␈αexcept␈αa␈α<lf>);␈α  all␈αof␈αthe␈α other␈αmodes
␈↓ α∧␈↓("Quiet",␈α "Logging",␈αand␈α"Numbers")␈αare␈αimplemented␈αONLY␈α IN␈αTHE␈αCOMPILER.␈α  However,␈αone
␈↓ α∧␈↓can␈α⊂get␈α∂the␈α⊂effect␈α⊂of␈α∂error␈α⊂modes␈α⊂at␈α∂runtime␈α⊂by␈α⊂using␈α∂a␈α⊂brand␈α⊂new␈α∂feature␈α⊂called␈α⊂user␈α∂error
␈↓ α∧␈↓procedures.



␈↓ α∧␈↓4.2 - ␈↓↓USER ERROR PROCEDURES␈↓


␈↓ α∧␈↓A␈α user␈αerror␈α procedure␈αis␈αa␈α user␈αprocedure␈α that␈αis␈αrun␈α before␈αor␈αinstead␈αof␈α the␈α SAIL␈αerror
␈↓ α∧␈↓handler␈α⊂ everytime␈α⊂ an␈α⊃error␈α⊂ occurs␈α⊂ at␈α⊃runtime.␈α⊂ This␈α⊂ includes␈α⊃all␈α⊂array␈α⊂errors,␈α⊃IO␈α⊂ errors,
␈↓ α∧␈↓Leapish␈α∞errors␈α
and␈α∞all␈α
USERERRs.␈α∞ It␈α
does␈α∞not␈α
include␈α∞system␈α
errors,␈α∞such␈α
as␈α∞Ill␈α
Mem␈α∞Ref␈α∞or␈α
Ill
␈↓ α∧␈↓UUO.

␈↓ α∧␈↓The  procedure one uses  for a  user error procedure  must be  of the following type:

␈↓ α∧␈↓␈α?␈α?␈α5SIMPLE INTEGER PROCEDURE proc (INTEGER loc; STRING msg, rsp);


␈↓ α∧␈↓Only␈α∞the␈α∞names␈α∞ proc,␈α∞loc,␈α∞ msg,␈α∞and␈α∞rsp␈α∞ may␈α∞vary␈α∞ from␈α∞the␈α∞ example␈α∞above,␈α∞except␈α∞ that␈α∞one
␈↓ α∧␈↓may declare  the procedure  INTERNAL if  one wishes to use it across files.

␈↓ α∧␈↓Whenever␈α the␈α
external␈αinteger␈α
_ERRP_␈α is␈αloaded␈α
with␈αLOCATION(proc),␈α
the␈αerror␈α
handler␈αwill


␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α7␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ 
∀ERROR HANDLING


␈↓ α∧␈↓call␈α
proc␈α∞before␈α
it␈α
 does␈α∞anything␈α
else.␈α
  It␈α∞will␈α
set␈α∞loc␈α
to␈α
 the␈α∞core␈α
location␈α
of␈α∞the␈α
call␈α∞ to␈α
the
␈↓ α∧␈↓error␈α∞handler.␈α∞ Msg␈α∞ will␈α∞be␈α∞ the␈α∞message␈α∞ that␈α∞it␈α∞ would␈α∞have␈α∞ printed.␈α∞ Rsp␈α∞will␈α∂be␈α∞non-NULL
␈↓ α∧␈↓only␈αif␈αthe␈αerror␈αwas␈αfrom␈αa␈αUSERERR␈αwhich␈αhad␈αresponse␈αstring␈αargument.␈α Proc␈αcan␈αdo␈αanything
␈↓ α∧␈↓that␈α⊂ a␈α∂simple␈α⊂procedure␈α∂can␈α⊂do.␈α∂ When␈α⊂it␈α∂exits,␈α⊂it␈α∂should␈α⊂ return␈α∂an␈α⊂ integer␈α∂which␈α⊂ tells␈α∂the
␈↓ α∧␈↓error␈αhandler␈α if␈α it␈αshould␈αdo␈αanything␈αmore.␈α If␈αthe␈αinteger␈αis␈α0,␈αthe␈αerror␈αhandler␈αwill␈α(1)␈α print
␈↓ α∧␈↓the␈α message,␈α(2)␈α print␈αthe␈αlocation,␈αand␈α(3)␈αquery␈αthe␈αtty␈αand␈αdispatch␈αon␈αthe␈αresponse␈αcharacter
␈↓ α∧␈↓(i.e␈αask␈αfor␈αa␈α<cr>,␈α<lf>,␈αetc.).␈α If␈αthe␈αright␈αhalf␈αof␈αthe␈αinteger␈αis␈αnon-zero,␈αit␈αis␈αtaken␈αas␈αthe␈αascii
␈↓ α∧␈↓for␈α
a␈α
character␈αto␈α
dispatch␈α
upon.␈α
 The␈αleft␈α
half␈α
may␈αhave␈α
two␈α
bits␈α
to␈αcontrol␈α
printing.␈α
  If␈α
bit␈α17
␈↓ α∧␈↓in␈α∂the␈α∂integer␈α∞is␈α∂on,␈α∂message␈α∂printing␈α∞is␈α∂inhibited.␈α∂ If␈α∞bit␈α∂16␈α∂is␈α∂on,␈α∞then␈α∂the␈α∂location␈α∂printing␈α∞is
␈↓ α∧␈↓inhibited.␈α⊃For␈α⊃example,␈α⊃"X"+(1␈α⊃LSH␈α⊂18)␈α⊃will␈α⊃cause␈α⊃the␈α⊃location␈α⊂to␈α⊃be␈α⊃printed␈α⊃and␈α⊃the␈α⊂program
␈↓ α∧␈↓exited. "C"+(3 LSH 18) will cause the error handler to continue without printing anything.

␈↓ α∧␈↓Note␈α∞that␈α∞simple␈α∞ procedures␈α∞can␈α
not␈α∞do␈α∞ a␈α∞non-local␈α∞GOTO.␈α
  However,␈α∞the␈α∞ effect␈α∞of␈α∞ a␈α
non-
␈↓ α∧␈↓local␈α∪ GOTO␈α∩ can␈α∪be␈α∩ achieved␈α∪in␈α∩ a␈α∪ user␈α∩error␈α∪procedure␈α∩by␈α∪loading␈α∩the␈α∪external␈α∩integer
␈↓ α∧␈↓_ERRJ_␈αwith␈αthe␈αLOCATION␈αof␈αa␈αlabel.␈αThe␈αlabel␈αshould␈αbe␈αa␈αon␈αa␈αcall␈αto␈αa␈αnon-simple␈αprocedure
␈↓ α∧␈↓which␈αdoes␈α
the␈αdesired␈α
GOTO.␈α The␈α
error␈αhandler␈αclears␈α
_ERRJ_␈αbefore␈α
calling␈αthe␈α
procedure␈αin
␈↓ α∧␈↓_ERRP_.␈α If␈α_ERRJ_␈α is␈αnon-zero␈αwhen␈α
the␈α user␈αprocedure␈αreturns,␈αand␈αcontinuing␈α
was␈αspecified,
␈↓ α∧␈↓then␈α
the␈α
error␈α
handler's␈α
exit␈α∞ consists␈α
of␈α
a␈α
simple␈α
transfer␈α∞to␈α
 that␈α
location.␈α
 Note␈α
that␈α∞for␈α
this
␈↓ α∧␈↓simple␈α
transfer␈α
to␈α
work␈α∞properly,␈α
the␈α
place␈α
where␈α
the␈α∞error␈α
occurred␈α
(or␈α
the␈α
call␈α∞to␈α
USERERR)
␈↓ α∧␈↓must␈αbe␈αin␈α
the␈αsame␈αstatic␈α(lexical)␈α
scope␈αas␈αthe␈α
label␈αwhose␈αLOCATION␈αis␈α
in␈α_ERRJ_.␈α If␈α
this␈αis
␈↓ α∧␈↓really important to you, see a SAIL hacker.

␈↓ α∧␈↓WARNING!␈α⊂Handling␈α⊂errors␈α⊂from␈α⊂strange␈α⊂places␈α⊂like␈α⊂the␈α⊂string␈α⊂garbage␈α⊂collector␈α⊂and␈α⊃the␈α⊂core
␈↓ α∧␈↓management routines will get you into deep trouble.





















␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α8␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ λ\INEXHAUSTIBLE STRING SPACE


␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α≡␈↓↓SECTION  5␈↓

␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α
␈↓↓INEXHAUSTIBLE STRING SPACE␈↓





␈↓ α∧␈↓The␈αstring␈αgarbage␈αcollector␈αhas␈αbeen␈αmodified␈αto␈αexpand␈αstring␈αspace␈α(using␈αdiscontiguous␈αblocks)
␈↓ α∧␈↓whenever␈α
necessary␈α
to␈α
satisfy␈α
the␈α
demand␈α
for␈α∞places␈α
to␈α
put␈α
strings.␈α
To␈α
take␈α
advantage␈α∞ of␈α
 this
␈↓ α∧␈↓feature,  one need not change his programs.

␈↓ α∧␈↓Here are some points which might be of interest, however:

␈↓ α∧␈↓1)␈↓ αDAlthough␈α⊃ we␈α⊃ are␈α∩ going␈α⊃ to␈α⊃ provide␈α⊃ user␈α∩control␈α⊃over␈α⊃all␈α⊃size␈α∩parameters␈α⊃eventually,
␈↓ α∧␈↓␈↓ αDcurrently␈α∃only␈α∃ the␈α∃ initial␈α∃ string␈α∃ space␈α∃size␈α∃ is␈α∃ settable␈α∃ by␈α∃ the␈α∃ user,␈α⊗either␈α∃via
␈↓ α∧␈↓␈↓ αDREQUIRE␈α
or␈α
the␈α
ALLOC␈α
sequence,␈α
as␈α
before.␈α
 The␈α
size␈α
of␈α
each␈α
string␈α
space␈α
increment␈αwill
␈↓ α∧␈↓␈↓ αDbe␈α
 the␈α
same␈α
as␈α
the␈α
original␈α
size,␈α
which␈α
need␈α
not␈α
be␈α
monstrous␈α
any␈α
more␈α
unless␈α∞you␈α
 know
␈↓ α∧␈↓␈↓ αDthat␈α∃all␈α∃runs␈α∃of␈α∃your␈α∃program␈α⊗will␈α∃ need␈α∃ a␈α∃monstrous␈α∃ string␈α∃ space␈α⊗ anyhow.␈α∃  The
␈↓ α∧␈↓␈↓ αDthreshold␈α
(see␈α∞below)␈α
for␈α
expanding␈α∞will␈α
be␈α
set␈α∞at␈α
1/8␈α
 the␈α∞ string␈α
 space␈α∞ size␈α
 (increment
␈↓ α∧␈↓␈↓ αDsize).

␈↓ α∧␈↓2)␈↓ αDOne␈α∩can,␈α∩in␈α∩his␈α∩program,␈α∩modify␈α∩these␈α∩values␈α∩independently,␈α∩if␈α∩he␈α∩is␈α∩willing␈α∩to␈α∩use␈α∩the
␈↓ α∧␈↓␈↓ αDUSERCON function, and to follow this format:

␈↓ α∧␈↓β     USER TABLE ENTRY NAME              VALUE
␈↓ α∧␈↓β        STINCR          lh: number of chars. in increment
␈↓ α∧␈↓β                        rh: number of words in increment + 4

␈↓ α∧␈↓β        STREQD          lh: number of chars. in threshold
␈↓ α∧␈↓β                        rh: number of words in threshold.


␈↓ α∧␈↓3)␈↓ αDThe␈αthreshold.␈α After␈αgarbage␈αcollection,␈αlet␈αus␈αsay␈αthat␈αM-1␈αdiscontiguous␈αstring␈αspaces␈α are
␈↓ α∧␈↓␈↓ αDfull,␈α
 and␈α the␈α
 M'th␈α
 has␈α n␈α
 free␈α characters␈α
in␈α
it␈α(available␈α
for␈αnew␈α
strings).␈α
 The␈α garbage
␈↓ α∧␈↓␈↓ αDcollector␈α was␈α called␈αbecause␈α some␈αroutine␈αwanted␈αto␈αcreate␈αa␈αstring␈αR␈αcharacters␈αlong,␈αand
␈↓ α∧␈↓␈↓ αDthere␈α
were␈α
not␈αthat␈α
many␈α
 available␈α(free).␈α
    After␈α
 garbage␈αcollection,␈α
 the␈α
new␈αalgorithm
␈↓ α∧␈↓␈↓ αDrequires␈α
that␈α
N␈α
be␈α
greater␈α
than␈α
R+LH(STREQD).␈α If␈α
it␈α
is␈α
not,␈α
expansion␈α
takes␈α
place␈α
(to␈αM+1
␈↓ α∧␈↓␈↓ αDspaces),␈α∞to␈α∞ satisfy␈α
 this␈α∞requirement.␈α∞   In␈α∞other␈α
words,␈α∞if␈α∞STREQD␈α∞is␈α
1/8␈α∞the␈α∞size␈α∞of␈α
the
␈↓ α∧␈↓␈↓ αDcurrent␈α⊃space,␈α⊂that␈α⊃space␈α⊂will␈α⊃not␈α⊃be␈α⊂ allowed␈α⊃ to␈α⊂become␈α⊃ more␈α⊂ than␈α⊃ about␈α⊃ 7/8␈α⊂ full.
␈↓ α∧␈↓␈↓ αDThis␈αhelps␈αavoid␈α
frequent,␈αnearly␈αuseless␈α
calls␈αon␈αthe␈αgarbage␈α
collector␈αwhen␈α space␈α
is␈αabout
␈↓ α∧␈↓␈↓ αDgone.   All but the current space are allowed to become as full as possible, however.



␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α9␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ λ\INEXHAUSTIBLE STRING SPACE


␈↓ α∧␈↓4)␈↓ αDNew␈α∞statistics␈α∞are␈α∞maintained␈α∞by␈α∞the␈α∞ garbage␈α∞ collector.␈α∞    Soon␈α∞there␈α∞ will␈α∞ be␈α∂a␈α∞built-in
␈↓ α∧␈↓␈↓ αDroutine␈α∪you␈α∪can␈α∩use␈α∪to␈α∪print␈α∩them.␈α∪ For␈α∪now,␈α∩you␈α∪may␈α∪look␈α∩at␈α∪them␈α∪using␈α∩USERCON,
␈↓ α∧␈↓␈↓ αDalthough␈α
this␈α∞ document␈α
 does␈α∞not␈α
 say␈α∞ what␈α
 they␈α
 are.␈α∞    In␈α
 order␈α∞to␈α
activate␈α∞timing␈α
of
␈↓ α∧␈↓␈↓ αDthe garbage collector (slows it down), set SGCTIME in the  user  table to -1.

␈↓ α∧␈↓5)␈↓ αDFuture␈α∂plans.␈α∂ The␈α∂ new␈α∂ structure␈α∂ not␈α∂only␈α∂allows␈α∂expansion␈α∂of␈α∂string␈α∂space,␈α∂it␈α∂also␈α∞will
␈↓ α∧␈↓␈↓ αDallow␈α
 for␈α
 partial␈α
 garbage␈α
 collections␈α (no␈α
 visible␈α
benefits␈α
 except␈α
 increased␈α
speed,␈αsince
␈↓ α∧␈↓␈↓ αDa␈αpartial␈αcollection␈αwill␈αbe␈αalmost␈αas␈αeffective␈αas␈αa␈αcomplete␈αone,␈αand␈α much␈α faster),␈α and␈αthe
␈↓ α∧␈↓␈↓ αDability␈α∂ to␈α∂ move␈α∂ string␈α⊂ space␈α∂ blocks,␈α∂in␈α∂order␈α∂to␈α⊂compact␈α∂memory.␈α∂ Push␈α∂on␈α⊂your␈α∂local
␈↓ α∧␈↓␈↓ αDrepresentative  to  get  these  things done.



































␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧10␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ 	WRECORD STRUCTURES


␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α≡␈↓↓SECTION  6␈↓

␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α/␈↓↓RECORD STRUCTURES␈↓







␈↓ α∧␈↓6.1 - ␈↓↓INTRODUCTORY REMARKS␈↓


␈↓ α∧␈↓Record␈α⊃structures␈α⊂are␈α⊃a␈α⊂fairly␈α⊃recent␈α⊂addition␈α⊃to␈α⊂SAIL.␈α⊃ Essentially,␈α⊂they␈α⊃provide␈α⊂a␈α⊃means␈α⊂by
␈↓ α∧␈↓which␈α∞a␈α∞number␈α∞of␈α∞closely␈α∞related␈α∞variables␈α∞may␈α∞be␈α∞allocated␈α∞and␈α∞manipulated␈α∞as␈α∞a␈α∞unit,␈α
without
␈↓ α∧␈↓the␈α∞overhead␈α∞or␈α∞limitations␈α
associated␈α∞with␈α∞using␈α∞parallel␈α
arrays.␈α∞ In␈α∞the␈α∞current␈α
implementation,
␈↓ α∧␈↓each␈αrecord␈αis␈αan␈αinstance␈αof␈αa␈αuser-defined␈α"record␈αclass",␈αwhich␈αserves␈αas␈αa␈αtemplate␈αdescribing
␈↓ α∧␈↓the␈αvarious␈αsubfields␈αof␈αthe␈αrecord.␈α Internally,␈αrecords␈αare␈αsmall␈αblocks␈αof␈αstorage␈αwhich␈αcontain
␈↓ α∧␈↓space␈αfor␈αthe␈αvarious␈αsubfields␈αand␈αa␈αpointer␈αto␈αa␈αclass␈αdescriptor.␈α Subfields␈αare␈αallocated␈αone␈αper
␈↓ α∧␈↓word␈α
and␈αare␈α
accessed␈α
by␈αconstant␈α
indexing␈α
off␈αthe␈α
record␈α
pointer.␈α Deallocation␈α
is␈α
perormed␈αby
␈↓ α∧␈↓a garbage collector.

␈↓ α∧␈↓Records␈αwere␈αoriginally␈αadded␈αto␈αSAIL␈αto␈αfullfill␈αa␈αnumber␈αof␈αvery␈αspecific␈αneeds␈αat␈αStanford,␈αand
␈↓ α∧␈↓were␈α∞subsequently␈α∞generalized␈α∞to␈α∞the␈α∞form␈α∞seen␈α∞here.␈α∞ The␈α∞structures␈α∞described␈α∞in␈α∂this␈α∞section
␈↓ α∧␈↓are␈αimplemented␈αand,␈αso␈αfar␈αas␈αis␈αknown,␈αwork␈αcorrectly.␈α (They␈αhave␈αbeen␈αused␈αsuccessfully␈αover
␈↓ α∧␈↓the␈α∃past␈α∃3␈α∃months␈α∃by␈α∃several␈α∃different␈α∀people␈α∃to␈α∃produce␈α∃a␈α∃number␈α∃of␈α∃sizable␈α∀programs).
␈↓ α∧␈↓However,␈α∪a␈α∪number␈α∀of␈α∪fine␈α∪points␈α∪have␈α∀yet␈α∪to␈α∪be␈α∪cleaned␈α∀up␈α∪before␈α∪SAIL␈α∪records␈α∀can␈α∪be
␈↓ α∧␈↓considered␈α∞to␈α∂be␈α∞"finished".␈α∞ Also,␈α∂several␈α∞aspects␈α∂of␈α∞the␈α∞existing␈α∂implementation␈α∞are␈α∂still␈α∞quite
␈↓ α∧␈↓ugly,␈αand␈αmay␈αbe␈αsubstantially␈αmodified␈αin␈αthe␈αfuture,␈αalthough␈αthe␈αlanguage␈αconstructs␈αseen␈αby␈αthe
␈↓ α∧␈↓user␈αare␈αapt␈αto␈αstay␈αabout␈αthe␈αsame.␈α The␈αmaterial␈αpresented␈αhere␈αshould␈αtherefore␈αbe␈αconsidered
␈↓ α∧␈↓to␈α∃be␈α∃PRELIMINARY␈α∃DOCUMENTATION␈α∃ONLY.␈α⊗ It␈α∃is␈α∃being␈α∃supplied␈α∃only␈α∃in␈α⊗response␈α∃to
␈↓ α∧␈↓numerous␈αrequests␈αfor␈αsuch␈αdocumentation,␈αand␈αwith␈αthe␈αunderstanding␈αthat␈αthe␈αsystem␈αdescribed
␈↓ α∧␈↓is␈αstill␈αin␈αan␈αadolescent␈α--␈αthough␈αusable␈α
--␈αstage.␈α Readers␈αare␈αstrongly␈αurged␈αto␈αlook␈αat␈α
the␈αfile
␈↓ α∧␈↓RECAUX.SAI[CSP,SYS], which contains a number of useful examples and auxilliary functions.











␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧11␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ 	WRECORD STRUCTURES


␈↓ α∧␈↓6.2 - ␈↓↓RECORD CLASS DECLARATIONS␈↓


␈↓ α∧␈↓        RECORD_CLASS <classid> (<subfield declarations>)

␈↓ α∧␈↓For instance,

␈↓ α∧␈↓        RECORD_CLASS VECTOR (REAL X,Y,Z);
␈↓ α∧␈↓        RECORD_CLASS CELL (RECORD_POINTER(ANY_CLASS) CAR,CDR);
␈↓ α∧␈↓        RECORD_CLASS TABLEAU (REAL ARRAY A,B,C;INTEGER N,M);
␈↓ α∧␈↓        RECORD_CLASS FOO(LIST L;ITEMVAR A);


␈↓ α∧␈↓Generally,␈α
the␈α∞<subfield␈α
declarations>␈α
have␈α∞the␈α
same␈α∞form␈α
as␈α
a␈α∞procedure's␈α
formal␈α∞paramter␈α
list,
␈↓ α∧␈↓except␈α
that␈α
the␈αwords␈α
VALUE␈α
and␈α
REFERENCE␈αshould␈α
not␈α
be␈αused.␈α
 Also,␈α
STRING␈α
subfields␈αare
␈↓ α∧␈↓not␈α
yet␈α
implemented.␈α
 Each␈α
record␈α
class␈α
declaration␈α
is␈α
compiled␈α
into␈α
a␈α
"record␈α
descriptor"␈α
which
␈↓ α∧␈↓is used by the runtime system for allocation, deallocation, garbage collection, etc.



␈↓ α∧␈↓6.3 - ␈↓↓RECORD POINTER DECLARATIONS␈↓


␈↓ α∧␈↓        RECORD_POINTER(<classid list>) <id list>
␈↓ α∧␈↓        RECORD_POINTER(ANY_CLASS) <id list>

␈↓ α∧␈↓For instance,

␈↓ α∧␈↓        RECORD_POINTER(VECTOR) V1,V2;
␈↓ α∧␈↓        RECORD_POINTER(VECTOR,TABLEAU) T1,T2;
␈↓ α∧␈↓        RECORD_POINTER(ANY_CLASS) R;


␈↓ α∧␈↓At␈α⊂runtime,␈α⊂these␈α⊂variables␈α⊂either␈α⊃contain␈α⊂the␈α⊂value␈α⊂NULL_RECORD␈α⊂(internally,␈α⊂zero)␈α⊃or␈α⊂else
␈↓ α∧␈↓contains␈α⊃a␈α⊃pointer␈α⊃to␈α⊃a␈α⊃record.␈α⊃ The␈α⊃<classid␈α⊃list>␈α⊃is␈α⊃used␈α⊃to␈α⊃make␈α⊃a␈α⊃compile-time␈α⊃check␈α⊂on
␈↓ α∧␈↓assignments␈α∀and␈α∪subfield␈α∀references.␈α∀ The␈α∪pseudo-class␈α∀ANY_CLASS␈α∪matches␈α∀all␈α∀classes,␈α∪and
␈↓ α∧␈↓effectively disables this compile-time check.  For instance:

␈↓ α∧␈↓        RECORD_POINTER(FOO,BAR) FB1,FB2;
␈↓ α∧␈↓        RECORD_POINTER(FOO) FB3;
␈↓ α∧␈↓        RECORD_POINTER(CELL) C;
␈↓ α∧␈↓        RECORD_POINTER(ANY_CLASS) RP;
␈↓ α∧␈↓        :
␈↓ α∧␈↓        COMMENT the following are all ok syntactically;

␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧12␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ 	WRECORD STRUCTURES


␈↓ α∧␈↓        C←NEW_RECORD(CELL);
␈↓ α∧␈↓        RP←C;
␈↓ α∧␈↓        FB2←NEW_RECORD(FOO);
␈↓ α∧␈↓        FB1←FB3;
␈↓ α∧␈↓        FB3←RP; COMMENT Note that this is most likely a runtime bug
␈↓ α∧␈↓                        Since RP will contain a cell record.  SAIL
␈↓ α∧␈↓                        won't catch it, however;
␈↓ α∧␈↓        CELL:CAR[RP]←FB1;

␈↓ α∧␈↓        COMMENT The compiler will complain about these: ;
␈↓ α∧␈↓        FB1←C;
␈↓ α∧␈↓        FB3←NEW_RECORD(CELL);
␈↓ α∧␈↓        RP←CELL:CAR[FB3];

␈↓ α∧␈↓NO␈α
runtime␈αclass␈α
information␈αis␈α
kept␈αwith␈α
the␈α
variable,␈αand␈α
no␈αruntime␈α
class␈αchecks␈α
are␈α
made␈αon
␈↓ α∧␈↓record␈αassignment␈αor␈αsubfield␈αaccess.␈α Record␈αpointer␈αvariables␈αare␈αallocated␈αquantities,␈αand␈αshould
␈↓ α∧␈↓not␈αappear␈αinside␈αSIMPLE␈αprocedures.␈α  They␈αresemble␈αlists␈αin␈αthat␈αthey␈αare␈αnot␈αgiven␈αany␈αspecial
␈↓ α∧␈↓value␈α⊂upon␈α⊂block␈α⊃entry␈α⊂and␈α⊂they␈α⊃are␈α⊂set␈α⊂to␈α⊃a␈α⊂null␈α⊂value␈α⊃(NULL_RECORD)␈α⊂when␈α⊂the␈α⊃block␈α⊂in
␈↓ α∧␈↓which␈αthey␈αare␈αdeclared␈αis␈αexited.␈α (This␈αis␈αso␈αthat␈αany␈αrecords␈αreferred␈αto␈αonly␈αin␈αthat␈αblock␈αcan
␈↓ α∧␈↓be reclaimed by the garbage collector.)



␈↓ α∧␈↓6.4 - ␈↓↓ALLOCATION␈↓


␈↓ α∧␈↓Records are allocated by means of the construct

␈↓ α∧␈↓        NEW_RECORD(<classid>)


␈↓ α∧␈↓which␈αreturns␈αa␈αnew␈αrecord␈αof␈αthe␈αspecified␈αclass.␈α All␈αsubfields␈αof␈αthe␈αnew␈αrecord␈αare␈αset␈αto␈αthe
␈↓ α∧␈↓"null"␈α
or␈α∞"zero"␈α
value␈α∞for␈α
that␈α∞subfield␈α
--␈α∞i.e.,␈α
real␈α
&␈α∞integer␈α
subfields␈α∞will␈α
be␈α∞set␈α
to␈α∞0,␈α
itemvar
␈↓ α∧␈↓subfields␈α∞will␈α∞be␈α∞set␈α∞to␈α∞ANY,␈α∂lists␈α∞will␈α∞be␈α∞set␈α∞to␈α∞PHI,␈α∂etc.␈α∞ Again,␈α∞note␈α∞that␈α∞entry␈α∞into␈α∂a␈α∞block
␈↓ α∧␈↓with␈αlocal␈αrecord␈αpointer␈αvariables␈αdoes␈αNOT␈αcause␈αrecords␈αto␈αbe␈αallocated␈αand␈αassigned␈αto␈αthose
␈↓ α∧␈↓variables.









␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧13␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ 	WRECORD STRUCTURES


␈↓ α∧␈↓6.5 - ␈↓↓SUBFIELDS␈↓


␈↓ α∧␈↓Record subfields are referenced by means of the construct

␈↓ α∧␈↓        <classid>:<fieldid>[<record pointer expression>]


␈↓ α∧␈↓and may be used wherever an array element may be used.  For example

␈↓ α∧␈↓        RECORD_POINTER(VECTOR) V;
␈↓ α∧␈↓        RECORD_POINTER(CELL) C;
␈↓ α∧␈↓        RECORD_POINTER(FOO) F;

␈↓ α∧␈↓        :
␈↓ α∧␈↓        VECTOR:X[V]←VECTOR:Y[V];
␈↓ α∧␈↓        CELL:CAR[C←NEW_RECORD(CELL)]←V;
␈↓ α∧␈↓        VECTOR:Z[V]←VECTOR:X[CELL:CAR[C]];
␈↓ α∧␈↓        SUBLIS ← FOO:L[F][1 TO 3];
␈↓ α∧␈↓        :


␈↓ α∧␈↓If␈α⊂the␈α⊂<record␈α⊂pointer␈α⊂expression>␈α⊂gives␈α⊂a␈α⊃null␈α⊂record,␈α⊂then␈α⊂a␈α⊂runtime␈α⊂error␈α⊂message␈α⊃will␈α⊂be
␈↓ α∧␈↓generated.␈α∞ This␈α∞is␈α∂the␈α∞only␈α∞runtime␈α∞check␈α∂that␈α∞is␈α∞made␈α∞at␈α∂present.␈α∞ I.e.,␈α∞no␈α∞runtime␈α∂checks␈α∞are
␈↓ α∧␈↓made␈α⊃to␈α⊃verify␈α⊃that␈α⊃the␈α⊃<classid>␈α⊃in␈α⊃the␈α⊃subfield␈α⊃statement␈α⊃matches␈α⊃the␈α⊃class␈α⊃of␈α⊃the␈α⊃record
␈↓ α∧␈↓whose subfield is being extracted.

␈↓ α∧␈↓An array subfield may be used as an array name, as in

␈↓ α∧␈↓        RECORD_POINTER(TABLEAU) T;
␈↓ α∧␈↓        :
␈↓ α∧␈↓        TABLEAU:A[T][I,J] ← 2.5;


␈↓ α∧␈↓provided␈α⊂that␈α⊂you␈α⊂have␈α⊂stored␈α⊂a␈α∂valid␈α⊂array␈α⊂descriptor␈α⊂into␈α⊂the␈α⊂subfield.␈α⊂ Unfortunately,␈α∂SAIL
␈↓ α∧␈↓does not provide any clean way to do this.  One unclean way is
␈↓ α∧␈↓        INTEGER PROCEDURE NEWARY(INTEGER LB,UB);
␈↓ α∧␈↓                BEGIN
␈↓ α∧␈↓                INTEGER ARRAY A[LB:UB];
␈↓ α∧␈↓                INTEGER AA;
␈↓ α∧␈↓                AA←MEMORY[LOCATION(A)];
␈↓ α∧␈↓                MEMORY[LOCATION(A)]←0;
␈↓ α∧␈↓                         COMMENT defeats deallocation;
␈↓ α∧␈↓                RETURN(AA);

␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧14␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ 	WRECORD STRUCTURES


␈↓ α∧␈↓                END;
␈↓ α∧␈↓        :
␈↓ α∧␈↓        RECORD_CLASS FUBAR(INTEGER ARRAY A);
␈↓ α∧␈↓        RECORD_POINTER(FUBAR) FB;
␈↓ α∧␈↓        :
␈↓ α∧␈↓        MEMORY[LOCATION(FUBAR:A[FB])]←NEWARY(1,100);

␈↓ α∧␈↓(Warning:␈αthe␈αabove␈α"advice"␈αis␈αprimarily␈αintended␈αfor␈αhackers;␈αwe␈αmake␈αno␈αpromisses␈αthat␈αit␈αwill
␈↓ α∧␈↓never␈α∞get␈α∞you␈α∞into␈α∞trouble,␈α
although␈α∞this␈α∞particular␈α∞trick␈α∞is␈α
unlikely␈α∞to␈α∞be␈α∞made␈α∞obsolete␈α∞in␈α
the
␈↓ α∧␈↓forseeable future).



␈↓ α∧␈↓6.6␈α$-␈α$␈↓↓INTERNAL␈α$REPRESENTATIONS␈α%AND␈α$IMPLEMENTATION
␈↓ α∧␈↓↓NOTES␈↓


␈↓ α∧␈↓Records␈α⊂are␈α∂allocated␈α⊂by␈α⊂a␈α∂"small␈α⊂block"␈α∂allocator␈α⊂that␈α⊂gets␈α∂large␈α⊂buffers␈α∂of␈α⊂storage␈α⊂from␈α∂the
␈↓ α∧␈↓normal SAIL free storage system.  Each record currently has the following form:

␈↓ α∧␈↓        -1:     <used by garbage collector & free storage system>
␈↓ α∧␈↓         0:     20,,<record class descriptor>
␈↓ α∧␈↓        +1:     <first subfield>
␈↓ α∧␈↓                      :
␈↓ α∧␈↓        +n:     <last subfield>

␈↓ α∧␈↓Record␈αpointer␈αvariables␈αpoint␈αat␈αword␈α0␈αof␈αsuch␈αrecords.␈α Eventually,␈αwe␈αmay␈αdo␈αaway␈αwith␈α"-1"
␈↓ α∧␈↓word altogether.

␈↓ α∧␈↓Record class descriptors currently have the form:

␈↓ α∧␈↓        0:      byte(13)length(5)0(18)<record handler procedure>
␈↓ α∧␈↓        1:      <descriptor for first field>
␈↓ α∧␈↓                :
␈↓ α∧␈↓        n:      <descriptor for last field>
␈↓ α∧␈↓      n+1:      <SAIL-format string descriptor
␈↓ α∧␈↓      n+2:       for class name>
␈↓ α∧␈↓      n+3:      ascii text for class name


␈↓ α∧␈↓The␈α
normal␈α
value␈α∞for␈α
the␈α
handler␈α
procedure␈α∞is␈α
$REC$,␈α
which␈α
is␈α∞the␈α
standard␈α
procedure␈α∞for␈α
such
␈↓ α∧␈↓functions␈α
as␈α
allocation,␈αdeallocation,␈α
etc.␈α
 Currently,␈αthis␈α
procedure␈α
is␈αusually␈α
called␈α
as␈α
the␈αresult
␈↓ α∧␈↓of user uuo RECUUO (=8).  which, in turn, does a pushj p,@<effective address>.  Thus:


␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧15␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ 	WRECORD STRUCTURES


␈↓ α∧␈↓        RECUUO  OP,RV   ;OP = minor op code.  RV = record variable

␈↓ α∧␈↓goes (roughly to)

␈↓ α∧␈↓        <save acs>
␈↓ α∧␈↓        PUSH    P,[OP]
␈↓ α∧␈↓        PUSH    P,RV
␈↓ α∧␈↓        PUSH    P,[0]   ;this extra argument is sort of random.
␈↓ α∧␈↓                        ;It was intended for expansions.  Instead,
␈↓ α∧␈↓                        ;it may eventually be flushed.
␈↓ α∧␈↓        PUSHJ   P,@RV
␈↓ α∧␈↓        < restore acs (except ac1) >


␈↓ α∧␈↓It␈α
is␈α
possible␈α
for␈α
a␈α
user␈α
to␈α
substitute␈α
his␈αown␈α
handler␈α
procedure␈α
for␈α
a␈α
given␈α
class␈α
of␈α
records␈αby
␈↓ α∧␈↓including the procedure name in brackets after the record class declaration:

␈↓ α∧␈↓        RECORD_CLASS <id> (<subfields>) [<handler>]

␈↓ α∧␈↓This handler must have the form

␈↓ α∧␈↓        RECORD_POINTER(ANY_CLASS) PROCEDURE <procid>
␈↓ α∧␈↓                        (INTEGER OP;RECORD_POINTER(ANY_CLASS) R1,R2);


␈↓ α∧␈↓Where OP will be a small integer saying what is to be done.  The current assignments for OP are:

␈↓ α∧␈↓        OP value        meaning

␈↓ α∧␈↓        0               invalid
␈↓ α∧␈↓        1               allocate a new record with same type as R1
␈↓ α∧␈↓        2               not used
␈↓ α∧␈↓        3               not used
␈↓ α∧␈↓        4               Mark all subfields of record R1
␈↓ α∧␈↓        5               Delete all space for record R1


␈↓ α∧␈↓However,␈α∀NO␈α∀promisses␈α∀are␈α∀made␈α∪concerning␈α∀future␈α∀assignments␈α∀or,␈α∀indeed,␈α∀concerning␈α∪the
␈↓ α∧␈↓general␈α⊂structure.␈α∂ This␈α⊂feature␈α⊂is␈α∂primarily␈α⊂intended␈α∂for␈α⊂use␈α⊂by␈α∂wizards,␈α⊂and␈α∂others␈α⊂use␈α⊂it␈α∂at
␈↓ α∧␈↓their peril.





␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧16␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ λ7MISCELLANEOUS NEW FEATURES


␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α≡␈↓↓SECTION  7␈↓

␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α<␈↓↓MISCELLANEOUS NEW FEATURES␈↓







␈↓ α∧␈↓7.1 - ␈↓↓NEW MTAPE OPTIONS␈↓


␈↓ α∧␈↓        MTAPE(chan,NULL)


␈↓ α∧␈↓will␈αcause␈αan␈αMTAPE␈α0␈αto␈αbe␈αissued␈αfor␈αchannel␈αchan.␈α For␈αmag.␈αtapes,␈αthis␈αwill␈αcause␈αyou␈αto␈αwait
␈↓ α∧␈↓until␈α∞all␈α∞activity␈α
ceases.␈α∞ For␈α∞other␈α∞devices,␈α
various␈α∞random␈α∞things␈α
can␈α∞happen,␈α∞depending␈α∞on␈α
the
␈↓ α∧␈↓device and system.

␈↓ α∧␈↓In␈α∂export␈α⊂SAIL,␈α∂MTAPE(chnl,"I")␈α∂sets␈α⊂the␈α∂'IBM␈α∂compatible'␈α⊂mode␈α∂for␈α∂a␈α⊂tape␈α∂drive.␈α∂ (It␈α⊂does␈α∂an
␈↓ α∧␈↓MTAPE chnl,101.)

␈↓ α∧␈↓These␈αfeatures␈αdo␈αnot␈αwork␈αin␈αTENEX␈αSAIL.␈α Full␈αaccess␈αto␈αTENEX␈αmagtapes␈αis␈αobtained␈αthrough
␈↓ α∧␈↓the MTOPR, GDSTS and SDSTS routines, which are TENEX-only runtimes.



␈↓ α∧␈↓7.2 - ␈↓↓INITIALIZATION PHASES␈↓


␈↓ α∧␈↓User␈α
initializations␈α
 are␈α
 now␈αdone␈α
 in␈α
successive␈α
 phases,␈αwith␈α
 all␈α
initializations␈α
  required␈α  for
␈↓ α∧␈↓one   phase   being  done   before initializations required for the next phase.

␈↓ α∧␈↓Syntax:

␈↓ α∧␈↓        REQUIRE <procid> INITIALIZATION;
␈↓ α∧␈↓        REQUIRE <procid> INITIALIZATION [<phase no>];

␈↓ α∧␈↓where <phase no> is an integer constant.

␈↓ α∧␈↓Semantics:



␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧17␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ λ7MISCELLANEOUS NEW FEATURES


␈↓ α∧␈↓<phase␈αno>␈αspecifies␈α the␈αnumber␈α of␈αthe␈αuser␈α initialization␈αphase.␈α If␈α it␈αis␈αleft␈αout,␈α then␈αone␈αis
␈↓ α∧␈↓used.␈α  Currently,␈αthere␈αare␈αthree␈α phases,␈αnumbered␈α0,␈α1,␈αand␈α 2.␈α If␈αthe␈α demand␈αis␈αgreat␈αenough,
␈↓ α∧␈↓additional␈α⊃phases␈α⊂may␈α⊃ be␈α⊂added␈α⊃later.␈α⊃  (Note␈α⊂for␈α⊃assembly␈α⊂ language␈α⊃hackers:␈α⊃internally,␈α⊂user
␈↓ α∧␈↓phases are numbered '400000, '400001, etc.)



␈↓ α∧␈↓7.3 - ␈↓↓CHNCDB␈↓


␈↓ α∧␈↓        val←CHNCDB(channel)

␈↓ α∧␈↓This␈α∂integer␈α∂procedure␈α∂returns␈α⊂a␈α∂pointer␈α∂to␈α∂the␈α∂three␈α⊂word␈α∂block␈α∂used␈α∂to␈α∂open␈α⊂the␈α∂ specified
␈↓ α∧␈↓channel.␈α∞  It␈α∞is␈α∞provided␈α∞ for␈α∞the␈α∞benefit␈α∞ of␈α∞assembly␈α∞language␈α∞procedures␈α∞that␈α∞may␈α∞want␈α∞to␈α
do
␈↓ α∧␈↓I/O␈αinside␈αsome␈αfast␈αinner␈αloop,␈αbut␈αwhich␈αmay␈αwant␈αto␈αlive␈αin␈αa␈αSAIL␈αcore␈αimage␈α&␈αuse␈αthe␈αSAIL
␈↓ α∧␈↓OPEN, etc.

␈↓ α∧␈↓This feature does not work in TENEX SAIL.  See a hacker if you want these features.



␈↓ α∧␈↓7.4 - ␈↓↓ARRCLR␈↓


␈↓ α∧␈↓        ARRCLR(arry)

␈↓ α∧␈↓This␈αnew␈αruntime␈αroutine␈αclears␈αany␈αkind␈αof␈αarray.␈αThat␈αis,␈αarthmetic␈αarrays␈αget␈αfilled␈αwith␈αzeros,
␈↓ α∧␈↓string␈α∞arrays␈α∂with␈α∞NULLs,␈α∞and␈α∂itemvar␈α∞arrays␈α∞with␈α∂ANYs.␈α∞ One␈α∞may␈α∂use␈α∞ARRCLR␈α∞with␈α∂set␈α∞and
␈↓ α∧␈↓list␈α⊂arrays,␈α⊂but␈α∂the␈α⊂set␈α⊂and␈α⊂list␈α∂space␈α⊂will␈α⊂be␈α∂lost␈α⊂(i.e.␈α⊂un-garbage-collectable).␈α⊂The␈α∂alternative
␈↓ α∧␈↓form:

␈↓ α∧␈↓        ARRCLR(arry,val)


␈↓ α∧␈↓where␈αval␈α
is␈αeither␈α
an␈αinteger␈αor␈α
a␈αreal␈α
number,␈αwill␈αfill␈α
arry␈αwith␈α
that␈αvalue.␈α Do␈α
not␈αdo␈α
this␈αto
␈↓ α∧␈↓string␈α∞or␈α∞list␈α∞arrays␈α∞unless␈α∞you␈α∞do␈α∞not␈α
care␈α∞whether␈α∞or␈α∞not␈α∞your␈α∞program␈α∞works.␈α∞ Also␈α∞using␈α
a
␈↓ α∧␈↓real␈α
val␈α
for␈α
an␈α
itemvar␈α
array␈α
is␈α
apt␈α
to␈α∞cause␈α
strange␈α
results.␈α
(If␈α
you␈α
use␈α
an␈α
integer,␈α
arry␈α∞will␈α
be
␈↓ α∧␈↓filled with CVI(val).)







␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧18␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ λ7MISCELLANEOUS NEW FEATURES


␈↓ α∧␈↓7.5 - ␈↓↓SETPL␈↓


␈↓ α∧␈↓        SETPL(channel, @linnum, @pagnum, @sosnum)

␈↓ α∧␈↓This␈α∃new␈α⊗runtime␈α∃routine␈α⊗allows␈α∃one␈α⊗to␈α∃keep␈α∃track␈α⊗of␈α∃the␈α⊗string␈α∃input␈α⊗from␈α∃CHANNEL.
␈↓ α∧␈↓Whenever␈α∃a␈α∃'12␈α∃is␈α∃encountered,␈α⊗LINNUM␈α∃is␈α∃incremented.␈α∃ Whenever␈α∃a␈α∃'14␈α⊗is␈α∃encountered,
␈↓ α∧␈↓PAGNUM␈α
is␈αincremented,␈α
and␈α
LINNUM␈αis␈α
zeroed.␈α Whenever␈α
an␈α
SOS␈αline␈α
number␈α
is␈αencountered,
␈↓ α∧␈↓it␈α
is␈α
placed␈α
into␈α∞SOSNUM.␈α
 When␈α
fully␈α
implemented␈α
(soon),␈α∞this␈α
will␈α
work␈α
on␈α
the␈α∞INPUT,␈α
INTIN,
␈↓ α∧␈↓and REALIN functions as well.



␈↓ α∧␈↓7.6 - ␈↓↓EVALREDEFINE␈↓


␈↓ α∧␈↓EVALREDEFINE␈α⊃bears␈α⊂the␈α⊃same␈α⊂relationship␈α⊃to␈α⊂REDEFINE␈α⊃as␈α⊂EVALDEFINE␈α⊃does␈α⊃to␈α⊂DEFINE.
␈↓ α∧␈↓See pages 47 and 50 of the Manual.



␈↓ α∧␈↓7.7 - ␈↓↓CVPS␈↓


␈↓ α∧␈↓CVPS(<macro_parameter>)␈α∂converts␈α∂<macro_parameter>␈α∂to␈α∂a␈α∂string␈α∂and␈α∂returns␈α∂the␈α∂string.␈α∞See
␈↓ α∧␈↓about macro parameters on page 48 of the manual.



␈↓ α∧␈↓7.8 - ␈↓↓EXPRESSIONS IN REQUIRES␈↓


␈↓ α∧␈↓Previously,␈αall␈αREQUIRE␈αconstructs␈αhad␈αto␈αhave␈αonly␈αconstants␈αin␈αthem.␈αNow␈αSAIL␈αallows␈αcompile
␈↓ α∧␈↓time expressions as well. See about compile time expressions on page 47 of the Manual.











␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧19␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ λ7MISCELLANEOUS NEW FEATURES


␈↓ α∧␈↓7.9 - ␈↓↓RELEASE␈↓


␈↓ α∧␈↓RELEASE␈αnow␈αtakes␈αan␈αoptional␈αsecond␈αargument,␈αthe␈αCLOSE␈αinhibit␈αbits.␈α These␈αare␈αdescribed␈αin
␈↓ α∧␈↓the␈α∞UUO␈α∞manual␈α∞(Stanford␈α∞System).␈α
These␈α∞are␈α∞defaulted␈α∞to␈α∞zero␈α
when␈α∞not␈α∞specified␈α∞so␈α∞that␈α
old
␈↓ α∧␈↓programs which did not specify them will work as before.

␈↓ α∧␈↓The CLOSE inhibit feature only works at SU-AI.



␈↓ α∧␈↓7.10 - ␈↓↓TTYUP␈↓


␈↓ α∧␈↓        oldval←TTYUP(newval)


␈↓ α∧␈↓This␈αroutine␈αcasuse␈αconversion␈αof␈αlower␈αcase␈αcharacters␈α(a-z)␈αto␈αtheir␈αupper␈αcase␈αequivalents␈αfor
␈↓ α∧␈↓strings␈α⊂read␈α∂by␈α⊂any␈α⊂of␈α∂the␈α⊂SAIL␈α⊂teletype␈α∂routines␈α⊂that␈α⊂do␈α∂not␈α⊂use␈α⊂break␈α∂tables.␈α⊂ If␈α⊂newval␈α∂is
␈↓ α∧␈↓TRUE,␈αthen␈αconversion␈αwill␈αtake␈αplace␈αon␈αall␈αsubsequent␈αinputs␈αuntil␈αTTYUP␈αis␈αcalled␈αwith␈αnewval
␈↓ α∧␈↓FALSE.␈α∞ Oldval␈α
will␈α∞always␈α
get␈α∞set␈α
to␈α∞the␈α
value␈α∞of␈α
newval␈α∞used␈α
in␈α∞the␈α
previous␈α∞call.␈α∞(If␈α
TTYUP
␈↓ α∧␈↓has␈α⊃never␈α⊃been␈α⊃called,␈α⊃then␈α⊂no␈α⊃conversions␈α⊃will␈α⊃take␈α⊃place,␈α⊂and␈α⊃the␈α⊃first␈α⊃call␈α⊃to␈α⊃TTYUP␈α⊂will
␈↓ α∧␈↓return FALSE).

␈↓ α∧␈↓In TENEX, TTYUP sets the system parameter using the STPAR jsys to convert to upper case.



␈↓ α∧␈↓7.11 - ␈↓↓BREAKSET MODES "K" AND "F"␈↓


␈↓ α∧␈↓A␈α∞"K"␈α∞specification␈α∞as␈α∞a␈α∞BREAKSET␈α∞mode␈α
will␈α∞cause␈α∞lower␈α∞to␈α∞upper␈α∞case␈α∞conversion␈α∞when␈α
that
␈↓ α∧␈↓break␈α⊂table␈α∂is␈α⊂used.␈α∂ Conversion␈α⊂takes␈α⊂place␈α∂before␈α⊂each␈α∂character␈α⊂is␈α∂checked␈α⊂for␈α⊂breaking␈α∂or
␈↓ α∧␈↓omission.  An "F" specification turns off the conversion -- i.e. it undoes the effects of "K".











␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧20␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ λ7MISCELLANEOUS NEW FEATURES


␈↓ α∧␈↓7.12 - ␈↓↓INOUT␈↓


␈↓ α∧␈↓        INOUT(inchan,outchan,howmany)


␈↓ α∧␈↓INOUT␈αreads␈αhowmany␈αwords␈αfrom␈αchannel␈αinchan␈αand␈αwrites␈αthem␈αout␈αon␈αchannel␈αoutchan.␈α Each
␈↓ α∧␈↓channel␈α∂must␈α∂be␈α∂open␈α∞in␈α∂a␈α∂mode␈α∂between␈α∂8␈α∞and␈α∂12.␈α∂ on␈α∂return,␈α∞the␈α∂EOF␈α∂variables␈α∂for␈α∂the␈α∞two
␈↓ α∧␈↓channels␈α∂will␈α∂be␈α∞the␈α∂same␈α∂as␈α∞if␈α∂ARRYIN␈α∂&␈α∂ARRYOUT␈α∞had␈α∂been␈α∂used.␈α∞ If␈α∂howmany␈α∂is␈α∂less␈α∞than
␈↓ α∧␈↓zero, then transfer of data will cease only upon end of file or a device error.

␈↓ α∧␈↓(note: INOUT uses BLTs to transfer data directly from one set of buffers to the other)

␈↓ α∧␈↓INOUT is not available in TENEX SAIL.



␈↓ α∧␈↓7.13 - ␈↓↓GETSTS & SETSTS␈↓


␈↓ α∧␈↓        SETSTS(chan,new_status)

␈↓ α∧␈↓issues a SETSTS uuo on channel chan with the status value new_status.

␈↓ α∧␈↓        status←GETSTS(chan)


␈↓ α∧␈↓returns the results of a GETSTS uuo on channel chan.

␈↓ α∧␈↓These␈α∂functions␈α∞do␈α∂not␈α∞exist␈α∂in␈α∞TENEX␈α∂SAIL.␈α∞ Instead,␈α∂see␈α∞GTSTS,␈α∂GDSTS,␈α∞STSTS,␈α∂and␈α∞SDSTS
␈↓ α∧␈↓for analogous features.



␈↓ α∧␈↓7.14 - ␈↓↓CHANGES TO "OPEN" ERROR HANDLING␈↓


␈↓ α∧␈↓If␈αthe␈αEOF␈αvariable␈αsupplied␈αto␈αOPEN␈αis␈αnon-zero␈αand␈αthe␈αdevice␈αname␈αis␈αinvalid,␈αthen␈αOPEN␈αwill
␈↓ α∧␈↓fail␈αwithout␈αgiving␈αthe␈αerror␈αmessage␈α
"INVALID␈αDEVICE␈αNAME␈αFOR␈αOPEN",␈αand␈αthe␈α
EOF␈αvalue
␈↓ α∧␈↓will␈α
be␈α
unchanged.␈α
 If␈αa␈α
device␈α
is␈α
unavailable,␈αand␈α
EOF=0,␈α
then␈α
the␈αuser␈α
is␈α
now␈α
given␈α
the␈αoptions
␈↓ α∧␈↓of␈α∞trying␈α∞again␈α∞or␈α∞going␈α∞on␈α∞without␈α∞opening␈α∂the␈α∞device,␈α∞in␈α∞which␈α∞case␈α∞EOF␈α∞will␈α∞be␈α∞set␈α∂to␈α∞non-
␈↓ α∧␈↓zero as usual.



␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧21␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ λ7MISCELLANEOUS NEW FEATURES


␈↓ α∧␈↓7.15 - ␈↓↓ASH␈↓


␈↓ α∧␈↓ASH␈α∪has␈α∩been␈α∪added␈α∩as␈α∪an␈α∪arithmetic␈α∩operator.␈α∪ Its␈α∩syntax␈α∪is␈α∪just␈α∩like␈α∪that␈α∩of␈α∪LSH,␈α∪and␈α∩it
␈↓ α∧␈↓generates similar code (except for putting out a PDP-10 ASH instruction instead of a LSH).



␈↓ α∧␈↓7.16 - ␈↓↓ARG_LIST␈↓


␈↓ α∧␈↓        ARG_LIST(<arg1>,...,<argn>)


␈↓ α∧␈↓where␈α∂each␈α⊂<arg>␈α∂may␈α∂be␈α⊂any␈α∂valid␈α∂argument␈α⊂to␈α∂the␈α∂REF_ITEM␈α⊂construct,␈α∂assembles␈α∂a␈α⊂list␈α∂of
␈↓ α∧␈↓"temporary"␈α
reference␈α
items␈α
that␈α∞will␈α
be␈α
deleted␈α
by␈α∞APPLY␈α
after␈α
the␈α
applied␈α∞procedure␈α
returns.
␈↓ α∧␈↓Thus

␈↓ α∧␈↓        APPLY(proc,ARG_LIST(foo,bar,VALUE baz))

␈↓ α∧␈↓is roughly equivalent to

␈↓ α∧␈↓        tmplst←{{REF_ITEM(foo),REF_ITEM(bar),REF_ITEM(VALUE baz)}};
␈↓ α∧␈↓        APPLY(proc,tmplst);
␈↓ α∧␈↓        WHILE LENGTH(tmplst) DO DELETE(LOP(tmplst));


␈↓ α∧␈↓but␈α∂is␈α∞somewhat␈α∂easier␈α∂to␈α∞type.␈α∂ Note␈α∞that␈α∂the␈α∂reference␈α∞items␈α∂created␈α∞by␈α∂ARG_LIST␈α∂are␈α∞just
␈↓ α∧␈↓like␈α∞those␈α
created␈α∞by␈α∞REF_ITEM,␈α
except␈α∞that␈α∞they␈α
are␈α∞marked␈α
so␈α∞that␈α∞APPLY␈α
will␈α∞know␈α∞to␈α
kill
␈↓ α∧␈↓them.



␈↓ α∧␈↓7.17 - ␈↓↓CLOSE␈↓


␈↓ α∧␈↓The␈α
CLOSE␈α
function␈α
now␈α
has␈α
an␈α
additional␈α
optional␈α
argument␈α
that␈α
allows␈α
the␈α
CLOSE␈α
inhibit␈α
bits
␈↓ α∧␈↓to␈α
be␈αturned␈α
on.␈α The␈α
second␈αargument␈α
is␈αthe␈α
bit␈αpattern␈α
for␈αthe␈α
inhibition,␈αand␈α
it␈αis␈α
defaulted␈α0.
␈↓ α∧␈↓See the UUO manual for details.

␈↓ α∧␈↓This feature is available only at SU-AI, and is not available in the TENEX version of SAIL.




␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧22␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ λ7MISCELLANEOUS NEW FEATURES


␈↓ α∧␈↓7.18 - ␈↓↓TYPEIT␈↓


␈↓ α∧␈↓The␈α∂number␈α∂returned␈α∂by␈α∂the␈α∂TYPEIT␈α∂procedure␈α∂(which␈α∂identifies␈α∂the␈α∂type␈α∂of␈α∂the␈α∂datum␈α∂of␈α∂its
␈↓ α∧␈↓item␈α
expression␈α
argument)␈α
is␈α
now␈α∞changed␈α
for␈α
arrays.␈α
 Now␈α
it␈α
is␈α∞'24␈α
plus␈α
the␈α
scalar␈α
value␈α∞of␈α
the
␈↓ α∧␈↓type (e.g., INTEGER), whereas before it was '15 plus the scalar value.

␈↓ α∧␈↓Additional types added to TYPEIT are:  '16 for labels, '17 for record classes.



␈↓ α∧␈↓7.19 - ␈↓↓COMPARISON OF .REL FILES␈↓


␈↓ α∧␈↓Starting␈αwith␈αversion␈α18,␈αthe␈αcompiler␈αemits␈αinformation␈αinto␈αeach␈α.REL␈αfile␈αcontaining␈αthe␈αversion
␈↓ α∧␈↓of␈αthe␈αcompiler␈αused.␈α Then,␈αduring␈αthe␈αSAIL␈αinitialization␈αsequence,␈αthese␈αversions␈α
are␈αcompared,
␈↓ α∧␈↓and␈α
a␈α
warning␈αmessage␈α
is␈α
issued␈αif␈α
necessary.␈α
 Thus,␈αthe␈α
problem␈α
of␈αconverting␈α
from␈α
one␈αversion
␈↓ α∧␈↓of␈αthe␈αcompiler␈αto␈αa␈αnew␈αversion␈αis␈αlessened.␈α This␈αfeature␈αmay␈αnot␈αwork␈αas␈αwell␈αin␈α
the␈α current
␈↓ α∧␈↓changeover as it will in the future.



␈↓ α∧␈↓7.20 - ␈↓↓SCAN Optimizations␈↓


␈↓ α∧␈↓The␈α
SCAN␈α
function␈α
has␈α
been␈α
modified␈α
to␈α
return␈α
true␈α
substrings␈α
instead␈α
of␈α
copies␈α
in␈α∞those␈α
cases
␈↓ α∧␈↓that␈αthe␈αbreak␈αtable␈αin␈αquestion␈αwas␈αnot␈αomitting␈αany␈αcharacters.␈α This␈αshould␈αbe␈αan␈αimprovement
␈↓ α∧␈↓in the efficiency of those routines.



␈↓ α∧␈↓7.21 - ␈↓↓BREAK TABLES␈↓


␈↓ α∧␈↓There␈αare␈α
now␈α54␈αuser-setable␈α
break␈αtables␈αavailable␈α
to␈αthe␈αSCAN,␈α
INPUT,␈αTTYINL␈α
functions,␈αas
␈↓ α∧␈↓well as SETBREAK and BREAKSET.  These tables are allocated and deallocated dynamically.

␈↓ α∧␈↓In␈α∃addition,␈α∃GETBREAK␈α∃now␈α∃returns␈α∃the␈α∃value␈α∃of␈α∃the␈α∃smallest␈α∃unallocated␈α∃breaktable,␈α∀and
␈↓ α∧␈↓RELBREAK␈α
releases␈α
its␈α∞table␈α
argument.␈α
 The␈α
implicit␈α∞declarations␈α
of␈α
these␈α
new␈α∞runtime␈α
routines
␈↓ α∧␈↓are:

␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α"INTEGER PROCEDURE GETBREAK
␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α*PROCEDURE RELBREAK(INTEGER TABLE)


␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧23␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ λ7MISCELLANEOUS NEW FEATURES


␈↓ α∧␈↓NOTE:␈α∞ a␈α∞breaktable␈α
is␈α∞allocated␈α∞by␈α
either␈α∞GETBREAK,␈α∞SETBREAK,␈α
BREAKSET␈α∞or␈α∞STDBRK.␈α
 A
␈↓ α∧␈↓breaktable␈α≤is␈α≤de-allocated␈α≤(and␈α≤thereby␈α≤made␈α≤available␈α≤to␈α≤GETBREAK)␈α≥by␈α≤RELBREAK.
␈↓ α∧␈↓Breaktables␈α∂are␈α∂stored␈α∂in␈α∂groups␈α∂of␈α∂18,␈α∂so␈α∂it␈α∂is␈α∂more␈α∂efficient␈α∂to␈α∂use␈α∂all␈α∂the␈α∂tables␈α∂in␈α∂a␈α∂given
␈↓ α∧␈↓group␈α∂before␈α⊂going␈α∂to␈α⊂another␈α∂group.␈α⊂ The␈α∂use␈α⊂of␈α∂GETBREAK␈α⊂is␈α∂particularly␈α⊂recommended␈α∂for
␈↓ α∧␈↓load-modules␈α∂and␈α∂the␈α∂like,␈α∂so␈α∂that␈α∂conflicts␈α∂will␈α∂be␈α∂minimzed.␈α∂ Breaktable␈α∂zero␈α∂is␈α∂special.␈α∂ It␈α∂is
␈↓ α∧␈↓predeclared␈α
to␈αproduce␈α
the␈α
same␈αresults␈α
as␈α
SETBREAK(0,NULL,NULL,"I").␈α This␈α
results␈α
in␈αbreak-
␈↓ α∧␈↓on-count␈α
for␈α
calls␈α
to␈α
INPUT,␈α
and␈α
always␈αreturns␈α
the␈α
whole␈α
string␈α
for␈α
SCAN.␈α
 Breaktable␈α
zero␈αis
␈↓ α∧␈↓stored along with breaktables 1 to 18, and thus takes up no additional space.

␈↓ α∧␈↓HACKERS:␈α∂ Actually␈α∂there␈α∂are␈α∂17␈α∂additional␈α∞system␈α∂breaktables␈α∂which␈α∂are␈α∂reserved␈α∂for␈α∂use␈α∞by
␈↓ α∧␈↓the␈α∩SAIL␈α∩runtime␈α∩system.␈α∩ These␈α∩tables␈α∪are␈α∩numbers␈α∩-17␈α∩through␈α∩-1,␈α∩and␈α∩are␈α∪ordinarily␈α∩not
␈↓ α∧␈↓available to the user.  They will be used by the debugger and by additional SAIL system software.

␈↓ α∧␈↓The␈α∞user␈α∂can␈α∞obtain␈α∂access␈α∞to␈α∂breaktables␈α∞-17␈α∂through␈α∞-1␈α∂by␈α∞setting␈α∂BRKPRV(USER)␈α∞to␈α∂-1,␈α∞for
␈↓ α∧␈↓example␈α∞by␈α∞the␈α∞USERCON␈α∞function␈α∞which␈α∞accesses␈α∞the␈α∞SAIL␈α∞user␈α∞table.␈α∞ WARNING:␈α∞ absolutely
␈↓ α∧␈↓no␈αguarantees␈αare␈αmade␈αto␈αthe␈αuser␈αwho␈αaccesses␈αthese␈αbreaktables.␈α This␈αinformation␈αis␈αintended
␈↓ α∧␈↓for completeness only; the use of these special breaktables by the user is not recommended.



␈↓ α∧␈↓7.22 - ␈↓↓CV6STR␈↓


␈↓ α∧␈↓CV6STR␈αdoes␈αwhat␈αyou␈αalways␈αwished␈αCVXSTR␈αdid.␈α I.e.,␈αit␈αstops␈αconverting␈αas␈αsoon␈αas␈αit␈α
sees␈αa
␈↓ α∧␈↓blank rather than always returning a six-character string.  Example:
␈↓ α∧␈↓        CV6STR(CVSIX("XYZ"))="XYZ", not "XYZ   ".

␈↓ α∧␈↓Beware, however, since

␈↓ α∧␈↓        CV6STR(CVSIX("X Y Z")) ="X", not "X Y Z" or "XYZ".

␈↓ α∧␈↓Use some today.



␈↓ α∧␈↓7.23 - ␈↓↓TENEX RUNTIMES␈↓


␈↓ α∧␈↓The␈α∀TENEX␈α∀version␈α∃of␈α∀SAIL␈α∀now␈α∀has␈α∃these␈α∀additional␈α∀teletype-oriented␈α∃routines:␈α∀ STTYP,
␈↓ α∧␈↓GTTYP, STPAR, STI, and DELNF, all named after jsyses.  See TENEX-specific documentation.





␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧24␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ λ7MISCELLANEOUS NEW FEATURES


␈↓ α∧␈↓7.24 - ␈↓↓CVASTR␈↓


␈↓ α∧␈↓CVASTR␈α⊂is␈α⊂the␈α⊃"correct"␈α⊂inverse␈α⊂function␈α⊂to␈α⊃CVASC.␈α⊂ I.e.,␈α⊂it␈α⊂stops␈α⊃on␈α⊂a␈α⊂null␈α⊃character.␈α⊂ For
␈↓ α∧␈↓instance,
␈↓ α∧␈↓        CVASTR(CVASC("ABC")) is "ABC"

␈↓ α∧␈↓whereas

␈↓ α∧␈↓        CVSTR(CVASC("ABC")) is "ABC"&0&0



































␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧25␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ λ)MINOR CORRECTIONS TO AIM-204


␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α≡␈↓↓SECTION  8␈↓

␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α:␈↓↓MINOR CORRECTIONS TO AIM-204␈↓





␈↓ α∧␈↓␈↓βThis␈α∪is␈α∀a␈α∪file␈α∪of␈α∀known␈α∪SAIL␈α∀manual␈α∪defects␈α∪(mainly␈α∀typos)␈α∪that␈α∀are␈α∪not
␈↓ α∧␈↓βalready␈α∨noted␈α≡in␈α∨the␈α∨preface␈α≡or␈α∨covered␈α≡by␈α∨the␈α∨"incremental"␈α≡SAIL
␈↓ α∧␈↓βmanual.␈α∀ It␈α∪is␈α∀primarily␈α∀an␈α∪internal␈α∀document␈α∀for␈α∪the␈α∀SAIL␈α∀hackers,␈α∪put
␈↓ α∧␈↓βis␈α∃being␈α∃provided␈α∃here␈α∃as␈α∃a␈α∃stopgap␈α∃measure␈α∃pending␈α∃a␈α∃full␈α∃new␈α∃edition
␈↓ α∧␈↓βfor␈α∩the␈α∩manual.␈α∩ This␈α∩list␈α∩is,␈α∩however,␈α∩not␈α∩complete␈α∩in␈α∩that␈α∩it␈α∩does␈α∩not
␈↓ α∧␈↓βinclude␈α∀a␈α∪number␈α∀of␈α∪typos␈α∀that␈α∪do␈α∀not␈α∪change␈α∀the␈α∪meaning.␈α∀ If,␈α∪however,
␈↓ α∧␈↓βyou␈α∃discover␈α∃any␈α∃defects␈α∃in␈α∃the␈α∃manual␈α∃or␈α∃in␈α∃the␈α∃update,␈α∃please␈α∃notify
␈↓ α∧␈↓βyour friendly local SAIL representative.

␈↓ α∧␈↓β99R     KVL     The synonym for "SUCH THAT" is "|" and not "␈↓#v"␈↓#

␈↓ α∧␈↓β32R␈α8    KVL␈α8    APPENDIX␈α85␈α8has␈α8nothing␈α8to␈α8do␈α8with␈α8the
␈↓ α∧␈↓βbits for IO errors or mode enablings

␈↓ α∧␈↓β43L     RHT     FILEINFO documentation is a lie.  You usually get:

␈↓ α∧␈↓β                FILENAME␈α?␈α?␈α?␈α?␈α?␈α?␈α$                EXT,,DATE
␈↓ α∧␈↓βprot(9)Mode(4)time(11)date(12)␈α*                negative␈α*swapped␈α*word
␈↓ α∧␈↓βcount␈α⊗(if␈α⊗did␈α⊗a␈α⊗lookup).␈α⊗                 0␈α⊗ (unless␈α⊗you␈α⊗opened␈α⊗device
␈↓ α∧␈↓βin magic mode)                 0

␈↓ α∧␈↓β                The␈α↔whole␈α↔point␈α↔is␈α↔that␈α↔what␈α↔you␈α↔get␈α↔is␈α↔the␈α↔six␈α⊗words
␈↓ α∧␈↓βfrom␈α<the␈α<last␈α<lookup␈α<or␈α<enter.␈α< For␈α<details␈α<see␈α<the
␈↓ α∧␈↓βmonitor manual.

␈↓ α∧␈↓β58R␈α(    JRL␈α(    if␈α(a␈α(designated␈α(bracketed␈α(triple␈α(is␈α(not␈α(found
␈↓ α∧␈↓βthen bindit is returned and no error message is given

␈↓ α∧␈↓β33L␈α~    JRL␈α~    release␈α~now␈α~takes␈α~a␈α~second␈α~defaultable␈α~value␈α~integer
␈↓ α∧␈↓βargument,␈α?␈ααthe␈α?␈ααclose␈α?␈αβinhibit␈α?␈ααbits␈α?␈αα(see␈α?␈ααRELEAS␈α?␈αβin␈α?␈ααUUO
␈↓ α∧␈↓βmanual).  These are defaulted to zero when unspecified.

␈↓ α∧␈↓β72R␈α∨    KVL␈α≡    TELLALL␈α∨does␈α∨not␈α≡do␈α∨an␈α≡implicit␈α∨RESCHEDULE␈α∨as␈α≡the
␈↓ α∧␈↓βdescription␈α_implies␈α_--␈α_it␈α_just␈α_sets␈α_the␈α_status␈α_of␈α_                the
␈↓ α∧␈↓βconcerned processes to "ready".

␈↓ α∧␈↓β102R    RFS     "33 through 36" S/B "33 through 35"

␈↓ α∧␈↓β105R    RFS     ". her are several"    s/b " . There are several"



␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧26␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ λ)MINOR CORRECTIONS TO AIM-204


␈↓ α∧␈↓β79R,L␈α∃  KVL␈α∃    JOBTPC␈α∃should␈α∃be␈α∃loaded␈α∃with␈α∃the␈α∃location␈α∃of␈α∃a␈α∃CALL␈α∃to
␈↓ α∧␈↓βa non-simple procedure.

␈↓ α∧␈↓β92R␈α     JRL␈α     20F␈α will␈α in␈α future␈α surround␈α macro␈α expansions␈α with
␈↓ α∧␈↓β"<>" not "⊂⊃".

␈↓ α∧␈↓β38R␈α≡    RHT␈α≡    The␈α≡description␈α≡of␈α≡INCHWL␈α≡is␈α≡wrong.␈α≡ Actually,␈α≡the
␈↓ α∧␈↓βactivation␈α∩character␈α∩is␈α∩never␈α∩included␈α∩in␈α∩the␈α∩string␈α∩                and
␈↓ α∧␈↓βis␈α~always␈α~put␈α~into␈α~_SKIP_.␈α~ (<crlf>␈α~puts␈α~a␈α~<cr>␈α~                into
␈↓ α∧␈↓β_SKIP_ & throws away the <lf>).

␈↓ α∧␈↓β24L␈α∃    RHT␈α∃    The␈α∃compiler␈α∃will␈α∃not␈α∃in␈α∃fact␈α∃turn␈α∃division␈α∃by␈α∃a␈α∃power
␈↓ α∧␈↓βof two into an ASH.

␈↓ α∧␈↓β90L␈α⊗    REG␈α∃    "...␈α⊗See␈α⊗section␈α∃19␈α⊗about␈α∃these␈α⊗[compilation␈α⊗errors]␈α∃"
␈↓ α∧␈↓βshould be section 20.

␈↓ α∧␈↓β90L     REG     19.1.3 "boundary" is misspelled.

␈↓ α∧␈↓β41R     RHT     CVSIX left-justifies the sixbit value it builds.

␈↓ α∧␈↓β43L     RHT     In POINT, it is "a PDP-10 byte pointer".

␈↓ α∧␈↓β45R     RHT     FORC syntax should be "FORC <identifier> ← ... "

␈↓ α∧␈↓β57R␈α↔    RHT␈α_    "␈α↔...␈α_methods␈α↔of␈α↔searching␈α_the␈α↔associative␈α_store␈α↔..."
␈↓ α∧␈↓βhad "store" missing before.

␈↓ α∧␈↓β105L    RHT     "omaname" should be "the symbolic name"

␈↓ α∧␈↓β110L␈α∩   RHT␈α∩    added␈α∩reference:␈α∩                Harvey,␈α∩Brian␈α∩ "Monitor
␈↓ α∧␈↓βCommand␈α?␈α∀Manual"␈α?␈α∀SAILON␈α?␈α∀54.3␈α?␈α∀                (Dec␈α?␈α∪1973)
␈↓ α∧␈↓βAlso, there is a more current SOS manual: SAILON 50.3

␈↓ α∧␈↓β76L     RHT     Should be "REF_ITEM(VALUE <expression>)"

␈↓ α∧␈↓β43L␈α↔    RFS␈α↔    For␈α↔FILEINFO,␈α↔also␈α↔should␈α↔have␈α↔a␈α↔note␈α↔to␈α↔export␈α⊗users
␈↓ α∧␈↓βlike␈α6"FILEINFO␈α6fills␈α6the␈α6array␈α6with␈α6the␈α6results␈α6of␈α6the
␈↓ α∧␈↓βlast␈α8LOOKUP␈α8or␈α9ENTER␈α8(DEC␈α810-50␈α8systems).␈α9 Consult␈α8your
␈↓ α∧␈↓βlocal monitor manual for the format of these entries."

␈↓ α∧␈↓β28L␈α6    JRL␈α6    CALLING␈α6PROCEDURES␈α6FROM␈α6INSIDE␈α6CODE␈α6BLOCKS
␈↓ α∧␈↓β"...␈α∩procedure␈α∩is␈α∩typed,␈α∩it␈α∩will␈α∩return␈α∩is␈α∩value␈α∩in␈α∩                AC␈α∩1
␈↓ α∧␈↓β(a␈α≠pointer␈α≠to␈α≠the␈α≠second␈α≠word␈α≠if␈α≠the␈α≠procedure␈α≠is␈α≠                a
␈↓ α∧␈↓βstring␈α↔procedure)."␈α⊗should␈α↔be␈α⊗                "␈α↔procedure␈α⊗is␈α↔typed␈α⊗and
␈↓ α∧␈↓βnot␈α∩a␈α∩string␈α∩procedure␈α∩it␈α∩will␈α∩                return␈α∩its␈α∩value␈α∩in␈α∩AC␈α∩1.
␈↓ α∧␈↓βString␈α~procedures␈α~push␈α→the␈α~                two␈α~word␈α~string␈α→descriptor
␈↓ α∧␈↓βcorresponding to the result                 on the SP stack."



␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧27␈↓ ∀
␈↓ α∧␈↓SAIL Addendum  1␈↓ λ)MINOR CORRECTIONS TO AIM-204


␈↓ α∧␈↓β23L␈α∪    RHT␈α∀    The␈α∪table␈α∪of␈α∀precedence␈α∪for␈α∀ ∧␈α∪&␈α∪∨␈α∀is␈α∪misleading.␈α∀∧␈α∪has
␈↓ α∧␈↓βhigher precedence than ∨.

␈↓ α∧␈↓β26R␈α↔    JRL␈α_    ARRYIN.␈α↔No␈α_indication␈α↔of␈α↔how␈α_many␈α↔words␈α_were␈α↔actually
␈↓ α∧␈↓βread␈α∩                is␈α∩given␈α∩if␈α∩EOF␈α∩is␈α∩encountered␈α∩while␈α∩reading␈α∩a␈α∩file
␈↓ α∧␈↓βin                 DUMP mode.

␈↓ α∧␈↓β25L␈α≠    RHT␈α≠    The␈α≠description␈α≠of␈α≠the␈α≠MEMORY[x,<type>]␈α≠construct␈α≠is
␈↓ α∧␈↓βvery␈α∀                misleading.␈α∀ There␈α∀is␈α∀no␈α∀restriction␈α∀on␈α∀the␈α∀use␈α∀of
␈↓ α∧␈↓βthis␈α_                construct␈α_as␈α_the␈α_left␈α_hand␈α_side␈α_of␈α_an␈α_assignment
␈↓ α∧␈↓βstatement.␈α'                 In␈α'fact,␈α'MEMORY[x,<type>]␈α'may␈α'be␈α'used
␈↓ α∧␈↓βanywhere a simple                 variable of type <type> may be used.


































␈↓ α∧␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∧28␈↓ ∀