COMMENT ⊗   VALID 00005 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	{$NOMAIN	Editor: part of the Initialization routine }
C00004 00003	(* routine to make reserved words: initReswords *)
C00006 00004	(* Aux routines (not external) used by initResWords *)
C00018 00005	(* initResWords: main part *)
C00021 ENDMK
C⊗;
{$NOMAIN	Editor: part of the Initialization routine }

%include einit.hdr;

{ Externally defined routines from elsewhere: }

	(* From ALLOC *)
function newStrng: strngp;					external;

	(* From EAUX1A *)
function hash(ch: ascii): integer;				external;

(* routine to make reserved words: initReswords *)

{ This guy is NOT external }
function makeResword(t: reswdtypes; s: cstring): reswordp;
 var res: reswordp; str: strngp; i: integer;
 begin
 new(res);
 with res↑ do
   begin
   rtype := t;
   str := newStrng;
   str↑.ch := s;
   name := str;
   length := 10;
   while s[length] = ' ' do length := length - 1;
   end;
 i := hash(s[1]);		(* find proper bucket *)
 res↑.next := reswords[i];	(* link us onto list of reserved words *)
 reswords[i] := res;
 makeResword := res;
end;


(* I had to cut up initResWords since the compiler couldn't deal with it *)

(* Aux routines (not external) used by initResWords *)

procedure makeallst;

 procedure stmake(st: stmntypes; s: cstring);
  var res: reswordp;
  begin
  res := makeResword(stmnttype,s);
  res↑.stmnt := st;
  end;

 begin {makeallst}
 stmake(progtype,'PROGRAM   ');
 stmake(blocktype,'BEGIN     ');
 stmake(coblocktype,'COBEGIN   ');
 stmake(coendtype,'COEND     ');
 stmake(endtype,'END       ');
 stmake(assigntype,':=        ');
 stmake(fortype,'FOR       ');
 stmake(iftype,'IF        ');
 stmake(whiletype,'WHILE     ');
 stmake(casetype,'CASE      ');
 stmake(returntype,'RETURN    ');
 stmake(printtype,'PRINT     ');
 stmake(prompttype,'PROMPT    ');
 stmake(pausetype,'PAUSE     ');
 stmake(aborttype,'ABORT     ');
 stmake(signaltype,'SIGNAL    ');
 stmake(waittype,'WAIT      ');
 stmake(enabletype,'ENABLE    ');
 stmake(disabletype,'DISABLE   ');
 stmake(cmtype,'ON        ');
 stmake(affixtype,'AFFIX     ');
 stmake(unfixtype,'UNFIX     ');
 stmake(movetype,'MOVE      ');
 stmake(operatetype,'OPERATE   ');
 stmake(opentype,'OPEN      ');
 stmake(closetype,'CLOSE     ');
 stmake(centertype,'CENTER    ');
 stmake(floattype,'FLOAT     ');
 stmake(stoptype,'STOP      ');
 stmake(retrytype,'RETRY     ');
 stmake(requiretype,'REQUIRE   ');
 stmake(definetype,'DEFINE    ');
 stmake(dimdeftype,'DIMENSION ');
 stmake(commenttype,'COMMENT   ');
 stmake(setbasetype,'SETBASE   ');
 stmake(wristtype,'WRIST     ');
 stmake(saytype,'SAY       ');
 stmake(armmagictype,'ARM_MAGIC ');
 end {makeallst};


procedure makeallfil (var Estr: strngp);
 var res: reswordp;

 procedure filmake(fil: filtypes; s: cstring);
  var res: reswordp;
  begin
  res := makeResword(filtype,s);
  res↑.filler := fil;
  end;

 begin
 filmake(abouttype,'ABOUT     ');
 filmake(alongtype,'ALONG     ');
 filmake(attype,'AT        ');
 filmake(bytype,'BY        ');
 filmake(defertype,'DEFER     ');
 filmake(dotype,'DO        ');
 filmake(elsetype,'ELSE      ');
 res := makeResword(filtype,'ERROR_MODE');
 res↑.name↑.next := newStrng;
 res↑.name↑.next↑.ch := 'S         '; 
 res↑.length := 11; 
 res↑.filler := errmodestype;
 filmake(fromtype,'FROM      ');
 filmake(handtype,'HAND      ');
 filmake(intype,'IN        ');
 filmake(nonrigidlytype,'NONRIGIDLY');
 filmake(rigidlytype,'RIGIDLY   ');
 res := makeResword(filtype,'SOURCE_FIL');
 Estr := newStrng;
 Estr↑.ch := 'E         '; 
 res↑.name↑.next := Estr;
 res↑.length := 11; 
 res↑.filler := sourcefiletype;
 filmake(steptype,'STEP      ');
 filmake(thentype,'THEN      ');
 filmake(totype,'TO        ');
 filmake(untltype,'UNTIL     ');
 filmake(viatype,'VIA       ');
 filmake(withtype,'WITH      ');
 filmake(worldtype,'WORLD     ');
 filmake(zeroedtype,'ZEROED    ');
 filmake(oftype,'OF        ');
 filmake(wheretype,'WHERE     ');
 filmake(nowaittype,'NOWAIT    ');
 filmake(notype,'NO        ');
 filmake(righttype,'RIGHT     ');
 filmake(lefttype,'LEFT      ');
 filmake(uptype,'UP        ');
 filmake(downtype,'DOWN      ');
 filmake(motiontype,'MOTION    ');
 filmake(offtype,'OFF       ');
 filmake(ppsizetype,'BOTSIZE   ');
 filmake(collecttype,'COLLECT   ');
 filmake(alltype,'ALL       ');
 filmake(lextype,'LEX       ');
 end {makeallfil};


procedure makeallcl (Estr: strngp);
 var res: reswordp;

 procedure clmake(cl: clsetypes; s: cstring);
  var res: reswordp;
  begin
  res := makeResword(clsetype,s);
  res↑.clause := cl;
  end;

 begin
 clmake(approachtype,'APPROACH  ');
 clmake(arrivaltype,'ARRIVAL   ');
 clmake(departuretype,'DEPARTURE ');
 clmake(departingtype,'DEPARTING ');
 clmake(durationtype,'DURATION  ');
 clmake(errortype,'ERROR     ');
 clmake(forcetype,'FORCE     ');
 res := makeResword(clsetype,'FORCE_FRAM');
 res↑.name↑.next := Estr;
 res↑.length := 11; 
 res↑.clause := forceframetype;
 res := makeResword(clsetype,'FORCE_WRIS');
 res↑.name↑.next := newStrng;
 res↑.name↑.next↑.ch := 'T         '; 
 res↑.length := 11; 
 res↑.clause := forcewristtype;
 clmake(gathertype,'GATHER    ');
 res := makeResword(clsetype,'NILDEPROAC');
 res↑.name↑.next := newStrng;
 res↑.name↑.next↑.ch := 'H         '; 
 res↑.length := 11; 
 res↑.clause := nildeproachtype;
 clmake(nullingtype,'NULLING   ');
 clmake(stiffnesstype,'STIFFNESS ');
 clmake(torquetype,'TORQUE    ');
 clmake(velocitytype,'VELOCITY  ');
 clmake(wobbletype,'WOBBLE    ');
 clmake(cwtype,'CW        ');
 clmake(cwtype,'CLOCKWISE ');
 clmake(ccwtype,'CCW       ');
 res := makeResword(clsetype,'COUNTER_CL');
 res↑.name↑.next := newStrng;
 res↑.name↑.next↑.ch := 'OCKWISE   '; 
 res↑.length := 17; 
 res↑.clause := ccwtype;
 res := makeResword(clsetype,'ANGULAR_VE');
 res↑.name↑.next := newStrng;
 res↑.name↑.next↑.ch := 'LOCITY    '; 
 res↑.length := 16; 
 res↑.clause := angularvelocitytype;
 res := makeResword(clsetype,'STOP_WAIT_');
 res↑.name↑.next := newStrng;
 res↑.name↑.next↑.ch := 'TIME      '; 
 res↑.length := 14; 
 res↑.clause := stopwaittimetype;
 clmake(respecttype,'RESPECT   ');
 clmake(elbowtype,'ELBOW     ');
 clmake(shouldertype,'SHOULDER  ');
 clmake(fliptype,'FLIP      ');
 clmake(lineartype,'LINEAR    ');
 res := makeResword(clsetype,'JOINT_SPAC');
 res↑.name↑.next := newStrng;
 res↑.name↑.next↑.ch := 'E         '; 
 res↑.length := 11; 
 res↑.clause := jointspacetype;
 clmake(loadtype,'LOAD      ');
 end {makeallcl};


procedure makeallop;

 procedure opmake(opr: exprtypes; s: cstring);
  var res: reswordp;
  begin
  res := makeResword(optype,s);
  res↑.op := opr;
  end;

 begin
 opmake(sltop,'<         ');
 opmake(sleop,'<=        ');
 opmake(sleop,'=<        ');
 opmake(seqop,'=         ');
 opmake(sgeop,'>=        ');
 opmake(sgeop,'=>        ');
 opmake(sgtop,'>         ');
 opmake(sneop,'<>        ');
 opmake(notop,'NOT       ');
 opmake(orop,'OR        ');
 opmake(xorop,'XOR       ');
 opmake(andop,'AND       ');
 opmake(eqvop,'EQV       ');
 opmake(sexpop,'↑         ');
 opmake(maxop,'MAX       ');
 opmake(minop,'MIN       ');
 opmake(intop,'INT       ');
 opmake(idivop,'DIV       ');
 opmake(modop,'MOD       ');
 opmake(sqrtop,'SQRT      ');
 opmake(logop,'LOG       ');
 opmake(expop,'EXP       ');
 opmake(timeop,'RUNTIME   ');
 opmake(sinop,'SIN       ');
 opmake(cosop,'COS       ');
 opmake(tanop,'TAN       ');
 opmake(asinop,'ASIN      ');
 opmake(acosop,'ACOS      ');
 opmake(atan2op,'ATAN2     ');
 opmake(vdotop,'.         ');
 opmake(unitvop,'UNIT      ');
 opmake(vmakeop,'VECTOR    ');
 opmake(wrtop,'WRT       ');
 opmake(tposop,'POS       ');
 opmake(taxisop,'AXIS      ');
 opmake(tmakeop,'TRANS     ');
 opmake(fmakeop,'FRAME     ');
 opmake(torientop,'ORIENT    ');
 opmake(tinvrtop,'INV       ');
 opmake(vsaxwrop,'ROT       ');
 opmake(constrop,'CONSTRUCT ');
 opmake(deproachop,'DEPROACH  ');
 opmake(ftofop,'->        ');
 opmake(queryop,'QUERY     ');
 opmake(inscalarop,'INSCALAR  ');
 opmake(adcop,'ADC       ');
 opmake(dacop,'DAC       ');
 opmake(addop,'+         ');
 opmake(subop,'-         ');
 opmake(mulop,'*         ');
 opmake(divop,'/         ');
 opmake(absop,'|         ');	
 opmake(grinchop,'#         ');
 end {makeallop};

(* initResWords: main part *)

procedure initReswords; external;
procedure initReswords;
 var i: integer; res: reswordp;  Estr: strngp;

 procedure dcmake(dc: datatypes; s: cstring);
  var res: reswordp;
  begin
  res := makeResword(decltype,s);
  res↑.decl := dc;
  end;

 procedure editmake(ed: edittypes; s: cstring);
  var res: reswordp;
  begin
  res := makeResword(edittype,s);
  res↑.ed := ed;
  end;

 begin
 for i := 0 to 26 do reswords[i] := nil;

 makeallst;		(* Make all the statements *)

 makeallfil(Estr);	(* and all the fillers *)

 makeallcl(Estr);	(* and all the clauses *)

 makeallop;		(* all the operators *)

 dcmake(arraytype,'ARRAY     ');
 dcmake(eventtype,'EVENT     ');
 dcmake(labeltype,'LABEL     ');
 dcmake(proctype,'PROCEDURE ');
 dcmake(reftype,'REFERENCE ');
 dcmake(svaltype,'SCALAR    ');
 dcmake(valtype,'VALUE     ');

 editmake(getcmd,'GET       ');		(* for use by the editor/debugger *)
 editmake(savecmd,'SAVE      ');
 editmake(insertcmd,'INSERT    ');
 editmake(renamecmd,'RENAME    ');
 editmake(startcmd,'START     ');
 editmake(startcmd,'RUN       ');
 editmake(gocmd,'GO        ');
 editmake(proceedcmd,'PROCEED   ');
 editmake(sstepcmd,'SSTEP     ');
 editmake(nstepcmd,'NSTEP     ');
 editmake(gstepcmd,'GSTEP     ');
 editmake(executecmd,'EXECUTE   ');
 editmake(setcmd,'SET       ');
 editmake(tracecmd,'TRACE     ');
 editmake(breakcmd,'BREAK     ');
 editmake(unbreakcmd,'UNBREAK   ');
 editmake(tbreakcmd,'TBREAK    ');
 editmake(markcmd,'MARK      ');
 editmake(unmarkcmd,'UNMARK    ');
 editmake(popcmd,'POP       ');
 editmake(calibratecmd,'CALIBRATE ');
 end;