perm filename EAUX3A.2[EAL,HE]1 blob
sn#676489 filedate 1982-09-27 generic text, type C, neo UTF8
COMMENT ⊗ VALID 00007 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 {$NOMAIN Editor: Plain old aux routines mostly called by Edit }
C00027 00003 { Externally defined routines from elsewhere: }
C00030 00004 (* aux routines: setPPSize, flushOldEnvironments, saveOutermostEnv *)
C00043 00005 (* Aux routine: setUpStmnt *)
C00045 00006 (* aux routines: fileParse, writeProg, readProg *)
C00049 00007 (* Aux routines called by edit: getEcmd, doSetCmd *)
C00055 ENDMK
C⊗;
{$NOMAIN Editor: Plain old aux routines mostly called by Edit }
const
(* Constants from EDIT *)
maxLines = 28; (* smaller on the 11 than on the 10 *)
maxPPLines = 18;
maxBpts = 25;
maxTBpts = 20; (* max could be exceeded by huge case stmnt *)
listinglength = 2000; (* Length of Listingarray *)
(* Random type declarations for OMSI/SAIL compatibility *)
type
byte = 0..255; (* doesn't really belong here, but... *)
ascii = char;
atext = text;
{ Define all the pointer types here }
strngp = ↑strng;
statementp = ↑statement;
varidefp = ↑varidef;
nodep = ↑node;
identp = ↑ident;
tokenp = ↑token;
reswordp = ↑resword;
pdbp = ↑pdb;
envheaderp = ↑envheader;
enventryp = ↑enventry;
environp = ↑environment;
cmoncbp = ↑cmoncb;
linerecp = ↑linerec;
cursorpp = ↑cursorp; {Ron's style, not mine}
(* This one is used whenever a pointer is needed for which the *)
(* definition is missing from this file; naturally, all *)
(* pointers use the same space *)
dump = ↑integer;
(* datatype definitions *)
datatypes = (pconstype, varitype, svaltype, vectype, rottype, transtype,
frametype, eventtype, strngtype, labeltype, proctype, arraytype,
reftype, valtype, cmontype, nulltype, undeftype,
dimensiontype, mactype, macargtype, freevartype);
scalar = real;
cstring = packed array [1..10] of ascii;
c4str = packed array [1..4] of ascii;
c5str = packed array [1..5] of ascii;
c20str = packed array [1..20] of ascii;
linestr = packed array [1..130] of ascii;
strng = record
next: strngp;
ch: cstring;
end;
(* statement definitions *)
stmntypes = (progtype, blocktype, coblocktype, endtype, coendtype,
fortype, iftype, whiletype, untiltype, casetype,
calltype, returntype,
printtype, prompttype, pausetype, aborttype, assigntype,
signaltype, waittype, enabletype, disabletype, cmtype,
affixtype, unfixtype,
movetype, operatetype, opentype, closetype, centertype,
stoptype, retrytype,
requiretype, definetype, macrotype, commenttype, dimdeftype,
setbasetype, wristtype, tovaltype, declaretype, emptytype);
(* more??? *)
statement = packed record
next, last: statementp; (* ↑ to lexical tokens? *)
stlab: varidefp;
exprs: nodep; (* any expressions used by this statement *)
nlines: integer;
bpt: boolean;
case stype: stmntypes of
progtype: (pcode: statementp; errors: integer);
blocktype,
declaretype,
endtype,
coendtype: (bcode, bparent: statementp; blkid: identp;
level, numvars: 0..255; variables: varidefp);
aborttype: (plist: nodep; debugLev: integer);
cmtype: (oncond: nodep; conclusion: statementp;
deferCm, exprCm: boolean; cdef: varidefp);
end;
(* auxiliary definitions: variable, etc. *)
varidef = packed record
next,dnext: varidefp;
name: identp;
level: 0..255; (* environment level *)
offset: 0..255; (* environment offset *)
dtype: varidefp; (* to hold the dimension info *)
tbits: 0..15; (* special type bits: array = 1, proc = 2, ref = 4 & ? *)
dbits: 0..15; (* for use by debugger/interpreter *)
case vtype: datatypes of
arraytype: (a: nodep);
proctype: (p: nodep);
labeltype,
cmontype: (s: statementp);
mactype: (mdef: statementp);
macargtype: (marg: tokenp);
pconstype: (c: nodep);
dimensiontype: (dim: nodep);
end;
(* definition of the ubiquitous NODE record *)
nodetypes = (exprnode, leafnode, listnode, clistnode, colistnode, forvalnode,
deprnode, viaptnode, apprnode, destnode, durnode,
sfacnode, wobblenode, swtnode, nullingnode, wristnode, cwnode,
arrivalnode, departingnode,
ffnode, forcenode, stiffnode, gathernode, cmonnode, errornode,
calcnode, arraydefnode, bnddefnode, bndvalnode,
waitlistnode, procdefnode, tlistnode, dimnode, commentnode);
exprtypes = ( svalop, (* scalar operators *)
sltop, sleop, seqop, sgeop, sgtop, sneop, (* relations *)
notop, orop, xorop, andop, eqvop, (* logical *)
saddop, ssubop, smulop, sdivop, snegop, sabsop, (* scalar ops *)
sexpop, maxop, minop, intop, idivop, modop,
sqrtop, logop, expop, timeop, (* functions *)
sinop, cosop, tanop, asinop, acosop, atan2op, (* trig *)
vdotop, vmagnop, tmagnop,
vecop, (* vector operators *)
vmakeop, unitvop, vaddop, vsubop, crossvop, vnegop,
svmulop, vsmulop, vsdivop, tvmulop, wrtop,
tposop, taxisop,
transop, (* trans operators *)
tmakeop, torientop, ttmulop, tvaddop, tvsubop, tinvrtop,
vsaxwrop, constrop, ftofop, deproachop, fmakeop, vmkfrcop,
ioop, (* i/o operators *)
queryop, inscalarop,
specop, (* special operators *)
arefop, callop, grinchop, macroop, vmop, adcop, dacop,
badop,
addop, subop, negop, mulop, divop, absop); (* for parsing *)
leaftypes = pconstype..strngtype;
reltypes = sltop..sgtop;
forcetypes = (force,absforce,torque,abstorque,angvelocity);
node = record
next: nodep;
case ntype: nodetypes of
exprnode: (op: exprtypes; arg1, arg2, arg3: nodep; elength: integer);
leafnode: (case ltype: leaftypes of
varitype: (vari: varidefp; vid: identp);
pconstype: (cname: varidefp; pcval: nodep);
svaltype: (s: scalar; wid: integer);
vectype: (v: dump);
transtype: (t: dump);
strngtype: (length: integer; str: strngp) ); (* also used by commentnodes *)
errornode: (eexpr: nodep);
bnddefnode: (lower, upper: nodep);
waitlistnode: (who: pdbp; when: integer);
procdefnode:(ptype: datatypes; level: 0..255;
pname, paramlist: varidefp; body: statementp);
end;
(* records for parser: ident, token, resword *)
ident = record
next: identp;
length: integer;
name: strngp;
predefined: varidefp;
end;
tokentypes = (reswdtype, identtype, constype, comnttype, delimtype, labeldeftype,
macpartype);
constypes = svaltype..strngtype;
reswdtypes = (stmnttype, filtype, clsetype, decltype, optype, edittype);
filtypes = (abouttype,alongtype,attype,bytype,defertype,dotype,elsetype,
errmodestype,fromtype,handtype,intype,nonrigidlytype,rigidlytype,
sourcefiletype,steptype,thentype,totype,untltype,viatype,
withtype,worldtype,zeroedtype,oftype,wheretype,nowaittype,
ontype,offtype,ppsizetype,collecttype,alltype,lextype);
clsetypes = (approachtype,arrivaltype,departuretype,departingtype,durationtype,
errortype,forcetype,forceframetype,forcewristtype,gathertype,
nildeproachtype,nonullingtype,nullingtype,stiffnesstype,
torquetype,velocitytype,wobbletype,
cwtype,ccwtype,stopwaittimetype,angularvelocitytype,
fxtype,fytype,fztype,mxtype,mytype,mztype,
t1type,t2type,t3type,t4type,t5type,t6type,tbltype);
edittypes = (getcmd,savecmd,insertcmd,renamecmd,startcmd,gocmd,proceedcmd,
stepcmd,sstepcmd,nstepcmd,gstepcmd,executecmd,setcmd,tracecmd,
breakcmd,unbreakcmd,tbreakcmd,definecmd,markcmd,unmarkcmd,
popcmd);
token = record
next: tokenp;
case ttype: tokentypes of
constype: (cons: nodep);
comnttype: (len: integer; str: strngp);
delimtype: (ch: ascii);
reswdtype: (case rtype: reswdtypes of
stmnttype: (stmnt: stmntypes);
filtype: (filler: filtypes);
clsetype: (clause: clsetypes);
decltype: (decl: datatypes);
optype: (op: exprtypes);
edittype: (ed: edittypes) );
identtype: (id: identp);
labeldeftype: (lab: varidefp);
macpartype: (mpar: varidefp);
end;
resword = record
next: reswordp;
length: integer;
name: strngp;
case rtype: reswdtypes of
stmnttype: (stmnt: stmntypes);
filtype: (filler: filtypes);
clsetype: (clause: clsetypes);
decltype: (decl: datatypes);
optype: (op: exprtypes);
edittype: (ed: edittypes);
end;
(* process descriptor blocks & environment record definitions *)
queuetypes = (nullqueue,nowrunning,runqueue,inputqueue,eventqueue,sleepqueue,
forcewait,devicewait,joinwait,proccall);
pdb = packed record
nextpdb,next: pdbp; (* for list of all/active pdb's *)
level: 0..255; (* lexical level *)
mode: 0..255; (* expression/statement/sub-statement *)
priority: 0..255;
status: queuetypes; (* what are we doing *)
env: envheaderp;
spc: statementp; (* current statement *)
epc: nodep; (* current expression (if any) *)
sp: nodep; (* intermediate value stack *)
cm: cmoncbp; (* if we're a cmon point to our definition *)
mech: dump; (* current device being used *)
linenum: integer; (* used by editor/debugger *)
case procp: boolean of (* true if we're a procedure *)
true: (opdb: pdbp; (* pdb to restore when procedure exits *)
pdef: nodep); (* procedure definition node *)
false: (evt: dump; (* event to signal when process goes away *)
sdef: statementp); (* first statement where process was defined *)
end;
envheader = packed record
parent: envheaderp;
env: array [0..4] of environp;
varcnt: 0..255; (* # of variables in use ??? *)
case procp: boolean of (* true if we're a procedure *)
true: (proc: nodep);
false:(block: statementp);
end;
enventry = record
case etype: datatypes of
svaltype: (s: scalar);
vectype: (v: dump);
transtype: (t: dump);
frametype: (f: dump);
eventtype: (evt: dump);
strngtype: (length: integer; str: strngp);
cmontype: (c: cmoncbp);
proctype: (p: nodep; penv: envheaderp);
reftype: (r: enventryp);
arraytype: (a: envheaderp; bnds: nodep);
end;
environment = record
next: environp;
vals: array [0..9] of enventryp;
end;
cmoncb = record
running, enabled: boolean; (* cmon's status *)
cmon: statementp;
pdb: pdbp;
evt: dump;
fbits: integer; (* bits for force sensing *)
oldcmon: cmoncbp; (* for debugger *)
end;
(* print related records: *)
cursorp = record
cline,ind: integer;
case stmntp: boolean of
true: (st: statementp);
false: (nd: nodep);
end;
linerec = record
next: linerecp;
start,length: integer
end;
listingarray = packed array [0..listinglength] of ascii;
(* Global variables *)
var
(* From ALMAIN *)
b:boolean;
ch:ascii;
ltime: real;
(* From PARSE *)
reswords: array [0..26] of reswordp;
idents: array [0..26] of identp;
macrostack: array [1..10] of tokenp;
curmacstack: array [1..10] of varidefp;
macrodepth: integer;
curchar, maxchar, curline: integer;
curBlock,newDeclarations: statementp;
curProc: varidefp;
pnode: nodep;
nodim, distancedim, timedim, angledim,
forcedim, torquedim, veldim, angveldim: varidefp;
fvstiffdim, mvstiffdim: nodep;
(* filedepth: integer;
curpage: integer;
sysVars,unVars: varidefp;
errcount: integer;
outerBlock: statementp;
curVariable: varidefp;
curMotion: statementp;
endOk,coendOk: integer;
moveLevel: integer;
curErrhandler, curCmon: statementp; *)
d1: array[1..13] of dump;
endOfLine, backup, expandmacros, flushcomments, dimCheck: boolean;
(* semiseen, shownline: boolean;
eofError: boolean;
inMove,inCoblock: boolean; *)
d2,d3,d4,d5,d6: boolean;
curtoken: token;
file1,file2,file3,file4,file5: atext;
line: linestr;
(* From INTERP *)
curInt, activeInts, readQueue, allPdbs: pdbp;
curEnv, sysEnv: envheaderp;
clkQueue: nodep;
allEvents: dump;
STLevel: integer;
etime: integer;
curtime: integer;
stime: integer;
msg: dump;
inputp: integer;
debugLevel: integer;
tSingleThreadMode: boolean;
resched, running, escapeI, singleThreadMode: boolean;
msgp: boolean; (* flag set if any messages pending *)
inputReady: boolean;
inputLine: array [1..20] of ascii;
(* From EDIT *)
lines: array [1..maxLines] of linerecp;
ppLines: array [1..maxPPLines] of linerecp;
marks: array [1..20] of integer;
cursorStack: array [1..15] of cursorp;
bpts: array [1..maxBpts] of statementp;
tbpts: array [1..maxTBpts] of statementp;
debugPdbs: array [0..10] of pdbp;
screenheight,dispHeight: integer;
ppBufp,oppBufp,ppOffset,ppSize,nmarks: integer;
lbufp,cursor,ocur,cursorLine,fieldnum,lineNum,findLine,pcLine: integer;
firstDline,topDline,botDline,firstLine,lastLine: integer;
freeLines,oldLines: linerecp;
findStmnt: statementp;
nbpts,ntbpts: integer;
eCurInt: pdbp;
dProg: statementp;
smartTerminal: boolean;
setUp,setExpr,setCursor,dontPrint,outFilep,newVarOk,collect: boolean;
eBackup: boolean;
eSingleThreadMode: boolean;
listing: packed array [0..listinglength] of ascii;
lbuf: array [1..160] of ascii;
ppBuf: array [1..100] of ascii;
outFile: atext;
eCurToken: token;
(* Various device & variable pointers *)
speedfactor: enventryp;
barm: dump;
(* Various constant pointers *)
xhat,yhat,zhat,nilvect: dump;
niltrans: dump;
bpark, ypark, gpark, rpark: dump; (* arm park positions *)
{ Externally defined routines from elsewhere: }
(* From CALLER *)
procedure e3aFlushAll(p: pdbp; dLev: integer); external;
function e3aParse(fname: c20str; ppn: integer): statementp; external;
(* From FREE *)
procedure freeStatement(s: statementp); external;
(* From IAUX1B *)
procedure swap(newp: pdbp); external;
(* From PAUX2 *)
procedure relExpr(n: nodep); external;
(* From EAUX1A *)
procedure out1Line(line,start,length: integer); external;
procedure clearLine(i: integer); external;
function eUpperCase(c: ascii): ascii; external;
procedure borderLines; external;
procedure adjustDisplay; external;
(* From ETOKEN *)
procedure eGetToken; external;
(* From EAUX2A *)
procedure initOuterBlock (which:integer); external;
(* From EAUX2C *)
procedure displayLines(var pfrom: integer); external;
(* From EPUTST *)
procedure putstmnt(s: statementp; indent, plevel: integer); external;
(* From PP *)
procedure relLine(l: linerecp); external;
procedure ppLine; external;
procedure ppOutNow; external;
procedure ppChar(ch: ascii); external;
procedure pp5(ch: c5str; length: integer); external;
procedure pp10(ch: cstring; length: integer); external;
procedure pp10L(ch: cstring; length: integer); external;
procedure pp20(ch: c20str; length: integer); external;
procedure pp20L(ch: c20str; length: integer); external;
procedure ppInt(i: integer); external;
procedure eAux3aGet; external;
procedure eAux3aGet; begin end;
(* aux routines: setPPSize, flushOldEnvironments, saveOutermostEnv *)
procedure setPPSize(arg: integer); external;
procedure setPPSize;
var delta,i,j,top,bot: integer;
begin (* set page printer size to arg *)
if arg < 3 then arg := 3 (* make sure it's a reasonable request *)
else if arg > screenHeight - 5 then arg := screenHeight - 5;
if arg > maxPPlines then arg := maxPPlines;
delta := arg - ppSize;
if delta > 0 then
begin (* increase page printer size *)
ppOffset := ppOffset + delta;
dispHeight := dispHeight - delta;
adjustDisplay; (* make sure cursor stays on screen *)
displayLines(lineNum); (* shift display if necessary *)
for i := ppSize downto 1 do ppLines[i+delta] := ppLines[i];
for i := 1 to delta do
begin
ppLines[i] := nil; (* we'll roll up later *)
clearLine(dispHeight + 1 + i);
end;
end
else if delta < 0 then
begin (* decrease page printer size *)
delta := - delta;
ppOffset := arg;
for i := 1 to delta do relLine(ppLines[i]);
for i := 1 to arg do ppLines[i] := ppLines[delta + i];
for i := arg + 1 to ppSize do ppLines[i] := nil;
for i := 1 to delta do clearLine(dispHeight + 1 + i);
top := topDline + firstDline + dispHeight - 1; (* top line being added *)
bot := top + delta - 1; (* last line to add *)
if bot <= botDline then j := bot else j := botDline;
for i := top to j do (* show lines already in display *)
with lines[i-topDline+1]↑ do
out1Line(i-topDline-firstDline+2,start,length);
dispHeight := dispHeight + delta;
if j < bot then displayLines(lineNum) (* add new lines *)
else borderLines;
end;
ppSize := arg;
end;
procedure flushOldEnvironments(dLev: integer); external;
procedure flushOldEnvironments;
var i: integer; p: pdbp;
begin (* tell INTERP to flush old program environment *)
for i := debugLevel downto dLev do
begin
if i > 0 then
begin
p := debugPdbs[i];
while p <> nil do
with p↑ do
begin
if sdef↑.last = nil then (* free immediate stmnt & it's abort *)
begin freeStatement(sdef↑.next); freeStatement(sdef) end
else
with sdef↑.next↑ do
if (stype = aborttype) and (debugLev >= i) then
begin
last↑.next := next;
next↑.last := last;
freeStatement(sdef↑.next); (* flush pseudo-abort *)
end;
p := next;
end;
e3aFlushAll(debugPdbs[i],i);
debugPdbs[i] := nil;
end
else e3aFlushAll(nil,0);
end;
if tSingleThreadMode and (STLevel >= dLev) then
begin
STLevel := 0;
tSingleThreadMode := false;
if not esingleThreadMode then singleThreadMode := false;
end;
if dLev > 0 then debugLevel := dlev - 1 else debugLevel := 0;
if curInt = nil then swap(nil); (* see if anyone's active *)
eCurInt := curInt;
if eCurInt <> nil then pcLine := eCurInt↑.linenum;
end;
procedure saveOutermostEnv; external;
procedure saveOutermostEnv;
var menv: envheaderp;
begin
with debugPdbs[0]↑ do (* use main process pdb *)
begin
menv := env; (* save outermost environment *)
level := 2; (* so flushAll won't clobber it *)
end;
while menv↑.parent↑.parent <> nil do
menv := menv↑.parent; (* up to outermost environment *)
flushOldEnvironments(0);
esingleThreadMode := false; (* reset single thread (nowait) mode)
eCurInt := curInt; (* get new main process pdb *)
debugPdbs[0] := eCurInt;
with eCurInt↑ do
begin
spc := dprog↑.pcode↑.bcode;
env := menv; (* restore old environment *)
sdef := dprog;
linenum := 2;
end;
pcLine := 2;
end;
(* Aux routine: setUpStmnt *)
procedure setUpStmnt(which: integer); external;
procedure setUpStmnt;
var i: integer;
begin
lbufp := 0;
cursor := 0;
fieldNum := 1;
firstLine := 0;
lastLine := 0;
curLine := 0;
cursorLine := 1;
setCursor := false;
setUp := true;
setExpr := false;
dontPrint := false;
outFilep := false;
findStmnt := nil;
curProc := nil;
pcLine := 1;
putStmnt(dprog,0,99); (* figure out how long each statement is *)
setUp := false;
topDline := 0;
botDline := -1;
firstDline := 1;
for i := 1 to maxLines do
if lines[i] <> nil then
begin
relLine(lines[i]); (* free up any old lines *)
lines[i] := nil;
end;
for i := 1 to 20 do marks[i] := 0;
nmarks := 0;
for i := 1 to maxBpts do bpts[i] := nil;
for i := 1 to maxTBpts do tbpts[i] := nil;
nbpts := 0;
ntbpts := 0;
debugLevel := 0;
for i := 1 to 10 do debugPdbs[i] := nil;
collect := false;
esingleThreadMode := false;
tSingleThreadMode := false;
SingleThreadMode := false;
initOuterBlock(which);
end;
(* aux routines: fileParse, writeProg, readProg *)
procedure fileParse(var fname: c20str); external;
procedure fileParse;
var ip,i,j,k,prj,prg: integer; ch: char; b: boolean;
function nextchar: char;
begin
if i <= maxChar then nextchar := eUpperCase(listing[i])
else nextchar := ' ';
i := i + 1;
end;
begin (* fileParse *) (* A stripped down version for the 11 *)
fname[1] := ' ';
i := curChar;
k := maxChar + 1;
ip := 1;
repeat (* Skip spaces *)
ch := nextchar
until (ch <> ' ') or (i >= k);
b := true;
while (ch <> ' ') and b do
begin (* parse file name *)
if ip <= 20 then begin fname[ip] := ch; ip := ip + 1 end
else
begin pp20L('Bad file name ',13); ppLine;
b := false;
end;
ch := nextchar;
end;
for j := ip to 20 do fname[j] := ' '; (* Space-fill the rest *)
end;
procedure writeProg; external;
procedure writeProg;
var i: integer; filnam: c20str;
begin
fileParse(filnam);
if filnam[1] = ' ' then
begin pp20L('Need a name for file',20); ppLine end
else
begin
rewrite(outFile,filnam,'.AL'); (* open file for output *)
outFilep := true;
firstLine := 0;
lastLine := dprog↑.nlines + 1;
curLine := 0;
putStmnt(dprog,0,99); (* write program out *)
outFilep := false;
break(outFile); (* Maybe this will write out the stuff at the end.. *)
close(outFile); (* close file *)
end;
end;
procedure readProg; external;
procedure readProg;
var i: integer; filename: c20str; b: boolean;
begin
fileParse(filename);
if filename[1] = ' ' then
begin pp20L('Need a name of file ',19); ppLine end
else
begin
reset(outFile,filename,'.AL',i); (* see if file exists *)
b := (i < 0); (* does it? *)
reset(outFile); (* that's all we needed it for *)
if b then
begin pp20L('File not found ',15); ppLine end
else
begin
flushOldEnvironments(0);
freeStatement(dprog); (* release old program *)
i := ppSize;
setPPSize(55); (* use max pp size *)
dprog := e3aParse(filename,0); (* read in new program *)
setUpStmnt(1); (* Call setUpStmnt and tell it readProg called it *)
setCursor := true;
cursorLine := 2;
lineNum := 1;
topDline := 0;
botDline := 0;
displayLines(lineNum); (* show first window *)
setPPSize(i);
end
end
end;
(* Aux routines called by edit: getEcmd, doSetCmd *)
procedure getEcmd; external;
procedure getEcmd;
begin
eGetToken; (* see what user wants us to do *)
with eCurToken do
if ttype = reswdtype then (* may need to change to edit context *)
if rtype = stmnttype then
begin
if stmnt = definetype then
begin rtype := edittype; ed := definecmd end
else if stmnt = cmtype then
begin rtype := filtype; filler := ontype end
end
else if (rtype = filtype) and (filler = steptype) then
begin rtype := edittype; ed := stepcmd end
end;
procedure doSetcmd; external;
procedure doSetcmd;
var svar: filtypes; b,onoff: boolean; arg: integer;
function getNumericArg(default: integer): boolean;
var b: boolean;
begin
with eCurToken do
begin
if ttype = constype then b := cons↑.ltype = svaltype
else b := false;
if b then arg := round(cons↑.s) (* use specified argument *)
else if endOfLine then
begin arg := default; b := true end (* use default value *)
else begin pp20L('Need a numeric arg ',18); ppLine; end;
end;
getNumericArg := b;
end;
function getOnOff(default: boolean): boolean;
var b: boolean;
begin
with eCurToken do
begin
b := (ttype = reswdtype) and (rtype = filtype) and
((filler = ontype) or (filler = offtype));
if b then onoff := filler = ontype
else if endOfLine then
begin onoff := default; b := true end (* use default value *)
else begin pp20L('Expecting ON or OFF ',19); ppLine; end;
end;
getOnOff := b;
end;
begin (* doSetCmd *)
getEcmd; (* see what we're setting *)
with eCurToken do
begin
arg := 1;
if (ttype = reswdtype) and (rtype = filtype) then svar := filler
else if (ttype = reswdtype) and (rtype = stmnttype) and
(stmnt = waittype) then begin svar := nowaittype; arg := -1 end
else svar := defertype; (* no good *)
getEcmd; (* see what we're setting it to *)
case svar of
ppsizetype: begin
b := getNumericArg(3); (* default size is 3 *)
if b then setPPSize(arg); (* set page printer size *)
end;
collecttype: begin (* see if we're collecting stmnts typed to interpreter *)
b := getOnOff(true); (* default is collect *)
if b then collect := onoff; (* set whether to collect *)
borderLines; (* Redraw top line to show flag *)
end;
lextype: begin
b := getNumericArg(1); (* default is up one level *)
if b then
begin (* *** ??? what do we do ??? *** *) end;
end;
nowaittype: begin (* arg = 1 for nowait, -1 for wait *)
b := getOnOff(true);
if arg < 0 then onoff := not onoff;
if b then
begin
eSingleThreadMode := onoff;
if (debugLevel < STLevel) or not tSingleThreadMode then
singleThreadMode := onoff;
end;
borderLines; (* Redraw top line to show flag *)
end;
otherwise begin pp20L('Bad SET request ',15); ppLine end;
end;
if ttype = constype then relExpr(cons);
end
end (* doSetCmd *);