-- file CommandPack.Mesa
-- last modified by Satterthwaite, September 5, 1982 2:50 pm
-- last modified by Russ Atkinson, 24-Nov-80 14:40:48

DIRECTORY
  Ascii: TYPE USING [CR, SP],
  CharIO: TYPE USING [PutChar, PutString],
  CommandUtil: TYPE USING [CommandObject, CommandPtr],
  Heap: TYPE USING [systemZone],
  Stream: TYPE USING [Handle],
  Strings: TYPE USING [
    String, SubString, SubStringDescriptor,
    AppendChar, AppendString, EquivalentSubStrings];

CommandPack: PROGRAM
    IMPORTS CharIO, Heap, Strings
    EXPORTS CommandUtil = {
  OPEN CommandUtil;

  String: TYPE = Strings.String;

  Pair: TYPE = RECORD [key, val: String, next: PairList];
  PairList: PUBLIC TYPE = LONG POINTER TO Pair;

  TokenClass: TYPE = CHAR;
    id: TokenClass = 'I;
    eom: TokenClass = 03c;	-- ControlC

  State: TYPE = [0..17];
    --  0:
    --  1:    id
    --  2:    id _
    --  3:    [ ?{id : id},
    --  4:    [ ?{id : id}, id
    --  5:    [ ?{id : id}, id :
    --  6:    [ ?{id : id}, id : id
    --  7:    [ ?{id : id}, ]
    --  8:    [ ?{id : id}, ] _
    --  9:    LHS _ id
    -- 10:    ?(LHS _) id [ ?{id : id},
    -- 11:    ?(LHS _) id [ ?{id : id}, id
    -- 12:    ?(LHS _) id [ ?{id : id}, id :
    -- 13:    ?(LHS _) id [ ?{id : id}, id : id
    -- 14:    ?(LHS _) id [ ?{id : id}, ]
    -- 15:    ?(LHS) id ?([ ?{id : id}, ])) /
    -- 16:    ?(?(LHS) id ?([ ?{id : id}, ])) / id
    -- 17:    ?(?(LHS) id ?([ ?{id : id}, ])) ?(/ ?id) (;|eom) | eom
    --            where LHS = id | [ ?{id : id}, ]


  Failed: PUBLIC ERROR = CODE;


 -- stream-like utilities

  GetChar: PROC [p: CommandPtr] RETURNS [c: CHAR] = {
    IF p.pos >= p.len THEN RETURN [eom];
    c _ p.data[p.pos];
    p.pos _ p.pos + 1};

  GetIndex: PROC [p: CommandPtr, delta: INTEGER_0] RETURNS [CARDINAL] = {
     pos: CARDINAL _ p.pos + delta;
     IF delta < 0 AND pos > p.pos THEN pos _ 0;
     RETURN [pos]};

  SetIndex: PROC [p: CommandPtr, index: CARDINAL] = {p.pos _ index};


  -- external parsing routine

  Parse: PUBLIC PROC [s: CommandPtr, opX, argX, resultX: CARDINAL]
      RETURNS [operator: String, argList, resultList: PairList, switches: String] = {
    token: TokenClass;
    state: State;

    idString: STRING _ [100];
    tIndex: CARDINAL;

    c: CHAR;

    NextToken: PROC = INLINE {
      WHILE c = Ascii.SP OR c = Ascii.CR DO c _ GetChar[s] ENDLOOP;
      tIndex _ GetIndex[s] - 1;
      SELECT c FROM
	IN ['a..'z], IN ['A..'Z], IN ['0..'9], '<, '., '+, '-, '~, '!, '$ => {
	  idString.length _ 0;
	  DO
	    SELECT c FROM
	      IN ['a..'z], IN ['A..'Z], IN ['0..'9],
	      '<, '>, '., '+, '-, '~, '!, '$ => {
		Strings.AppendChar[idString, c]; c _ GetChar[s]};
	      ENDCASE => EXIT;
	    ENDLOOP;
	  token _ id};
	'_, '[, '], ':, '/ => {token _ c; c _ GetChar[s]};
	',, ';, eom => token _ c;
	ENDCASE => BadCommand[]};

    CopyId: PROC [extra: CARDINAL] RETURNS [String] = INLINE {
      RETURN [CopyString[idString, extra]]};

    pair: ARRAY [0..1] OF String;

    PushArg: PROC = INLINE {argList _ AddPair[argList, pair[0], pair[1]]};
    PushResult: PROC = INLINE {resultList _ AddPair[resultList, pair[0], pair[1]]};

    RestoreToken: PROC = {SetIndex[s, tIndex]};

    BadCommand: PROC = {
      operator _ FreeString[operator];
      resultList _ FreePairList[resultList]; argList _ FreePairList[argList];
      switches _ FreeString[switches];
      ERROR Failed};

    c _ ' ;  state _ 0;  operator _ switches _ NIL;
    argList _ resultList _ NIL;

    UNTIL state = 17 DO
      NextToken[];
      SELECT token FROM
	id =>
	  SELECT state FROM
	    0 =>    {operator _ CopyId[MAX[resultX, opX]]; state _ 1};
	    2, 8 => {operator _ CopyId[opX]; state _ 9};
	    3 =>    {pair[0] _ CopyId[0]; state _ 4};
	    5 =>    {pair[1] _ CopyId[resultX]; PushResult[]; state _ 6};
	    10 =>   {pair[0] _ CopyId[0]; state _ 11};
	    12 =>   {pair[1] _ CopyId[argX]; PushArg[]; state _ 13};
	    15 =>   {switches _ CopyId[0]; state _ 16};
	    1, 9, 14, 16 => {RestoreToken[]; state _ 17};
	    ENDCASE =>  BadCommand[];
	'_ =>
	  SELECT state FROM
	    1 => {
	      pair[0] _ NIL; pair[1] _ operator;  operator _ NIL;
	      PushResult[];  state _ 2};
	    7 => state _ 8;
	    ENDCASE => BadCommand[];
	'[ =>
	  SELECT state FROM
	    0 => state _ 3;
	    1, 9 => state _ 10;
	    14 => {RestoreToken[]; state _ 17};
	    ENDCASE => BadCommand[];
	'] =>
	  SELECT state FROM
	    3, 6 => state _ 7;
	    10, 13 => state _ 14;
	    ENDCASE => BadCommand[];
	': =>
	  SELECT state FROM
	    4 => state _ 5;
	    11 => state _ 12;
	    ENDCASE => BadCommand[];
	', =>
	  SELECT state FROM
	    6 => {state _ 3; c _ GetChar[s]};
	    13 => {state _ 10; c _ GetChar[s]};
	    1, 9, 14, 15, 16 => state _ 17;
	    ENDCASE => BadCommand[];
	'/ =>
	  SELECT state FROM
	    0, 1, 9, 14 => state _ 15;
	    ENDCASE => BadCommand[];
	'; =>
	  SELECT state FROM
	    1, 9, 14, 15, 16 => state _ 17;
	    ENDCASE => BadCommand[];
	eom =>
	  SELECT state FROM
	    0, 1, 9, 14, 15, 16 => state _ 17;
	    ENDCASE => BadCommand[];
	ENDCASE;
      ENDLOOP;

    RETURN};


  Echo: PUBLIC PROC [
      d: Stream.Handle,
      operator: String, argList, resultList: PairList, switches: String] = {
    OPEN CharIO;

    EchoList: PROC [list: PairList] = {
      PutChar[d, '[];
      FOR p: PairList _ list, p.next UNTIL p = NIL DO
	IF p.key # NIL THEN {PutString[d, p.key];  PutString[d, ": "L]};
	PutString[d, p.val];
	IF p.next # NIL THEN PutString[d, ", "L];
	ENDLOOP;
      PutChar[d, ']]};

    IF resultList # NIL THEN {
      IF resultList.next = NIL AND resultList.key = NIL THEN PutString[d, resultList.val]
      ELSE EchoList[resultList];
      PutString[d, " _ "L]};
    PutString[d, operator];
    IF argList # NIL THEN EchoList[argList];
    IF switches # NIL AND switches.length > 0 THEN {
      PutString[d, "/"L]; PutString[d, switches]}};


 -- string utilities

  CopyString: PUBLIC PROC [s: String, extra: CARDINAL_0] RETURNS [String] = {
    copy: String = (Heap.systemZone).NEW[StringBody[(IF s=NIL THEN 0 ELSE s.length) + extra]];
    IF s # NIL THEN Strings.AppendString[copy, s];  RETURN [copy]};

  FreeString: PUBLIC PROC [s: String] RETURNS [String] = {
    IF s # NIL THEN (Heap.systemZone).FREE[@s];  RETURN [NIL]};


 -- PairList utilities

  AddPair: PUBLIC PROC [list: PairList, key,val: String] RETURNS [PairList] = {
    new: PairList _ (Heap.systemZone).NEW[Pair];
    new^ _ [key: key, val: val, next: list];
    RETURN [new]};

  GetNthPair: PUBLIC PROC [list: PairList, n: CARDINAL, delete: BOOL_FALSE]
      RETURNS [key, value: String_NIL] = {
    i: CARDINAL _ 0;
    FOR p: PairList _ list, p.next UNTIL p = NIL DO
      IF i = n THEN {key _ p.key; value _ p.val; IF delete THEN p.key _ p.val _ NIL; EXIT};
      i _ i+1;
      ENDLOOP;
    RETURN};

  ListLength: PUBLIC PROC [list: PairList] RETURNS [n: CARDINAL_0] = {
    FOR p: PairList _ list, p.next UNTIL p = NIL DO n _ n+1 ENDLOOP;
    RETURN};

  KeyValue: PUBLIC PROC [key: Strings.SubString, list: PairList, delete: BOOL_FALSE]
      RETURNS [s: String_NIL] = {
    FOR p: PairList _ list, p.next UNTIL p = NIL DO
      ss: Strings.SubStringDescriptor _ [base: p.key, offset: 0, length: p.key.length];
      IF Strings.EquivalentSubStrings[@ss, key] THEN {
	s _ p.val; IF delete THEN p.val _ NIL; EXIT};
      ENDLOOP;
    RETURN};

  FreePairList: PUBLIC PROC [list: PairList] RETURNS [PairList] = {
    next: PairList;
    p: PairList _ list;
    UNTIL p = NIL DO 
      next _ p.next;
      [] _ FreeString[p.key]; [] _ FreeString[p.val];
      (Heap.systemZone).FREE[@p];  p _ next;
      ENDLOOP;
    RETURN [NIL]};


 -- file naming utilities

  SetExtension: PUBLIC PROC [root, defaultExt: String] RETURNS [name: String] = {
    SELECT TRUE FROM
      ~Dotted[root] => {
	name _ AdjustString[root, defaultExt.length + 2];
	Strings.AppendChar[name, '.];
	Strings.AppendString[name, defaultExt]};
      ENDCASE => name _ root;
    RETURN};

  Dotted: PROC [s: String] RETURNS [BOOL] = INLINE {
    FOR i: CARDINAL IN [0..s.length) DO IF s[i] = '. THEN RETURN [TRUE] ENDLOOP;
    RETURN [FALSE]};


 -- storage allocation

  AdjustString: PROC [old: String, extra: CARDINAL] RETURNS [new: String] = {
    IF old.length + extra <= old.maxlength THEN new _ old
    ELSE {
      new _ (Heap.systemZone).NEW[StringBody[old.length + extra]];
      Strings.AppendString[new, old];
      (Heap.systemZone).FREE[@old]};
    RETURN};

  }.