-- SymTabImpl - implementation of symbol table abstraction
-- last change: Russ Atkinson - 16-Sep-81 21:01:24
-- last change: Nori Suzuki - 11-Oct-81 20:35:31
-- filed on: [Indigo]<Sakura>Parser>SymTabImpl.mesa

DIRECTORY
   Inline USING [LowHalf],
   Rope USING [Compare, Ref],
   RopeInline USING [InlineFetch, InlineSize, Lower],
   SymTab;

SymTabImpl: MONITOR LOCKS x USING x: Ref
      IMPORTS Inline, Rope, RopeInline
      EXPORTS SymTab
      = BEGIN

  Int: TYPE = LONG INTEGER;
  Ref: TYPE = REF SymTabRep;
  SymTabRep: PUBLIC TYPE =
    MONITORED RECORD [mod,size: CARDINAL, case: BOOLEAN, data: REF Array];
  NodeRep: TYPE = RECORD [key: Key, val: Val, next: Node];
  Node: TYPE = REF NodeRep;
  String: TYPE = Rope.Ref;
  Key: TYPE = SymTab.Key; 
  Val: TYPE = SymTab.Val;
  EachPairAction: TYPE = SymTab.EachPairAction; 

  Array: TYPE = RECORD[nodes: SEQUENCE max: CARDINAL OF Node];

  -- Private Operations

  Hash: PROCEDURE [s: String, mod: CARDINAL] RETURNS [CARDINAL] = BEGIN
    size: LONG INTEGER _ RopeInline.InlineSize[s];
    IF size = 0 THEN RETURN [0];
    {c0: CARDINAL = RopeInline.Lower[RopeInline.InlineFetch[s, 0]] - 0C;
     c1: CARDINAL = RopeInline.Lower[RopeInline.InlineFetch[s, size-1]] - 0C;
     RETURN [(Inline.LowHalf[size] + c0 + c1) MOD mod]};
    END;

  -- public operations

  Create: PUBLIC PROCEDURE [mod: CARDINAL _ 17, case: BOOLEAN _ TRUE]
          RETURNS [Ref]
    = BEGIN
    index: CARDINAL _ 0;
    data: REF Array _ NIL;
    IF mod < 1 THEN mod _ 1;
    IF mod > 4095 THEN mod _ 4095;
    data _ NEW[Array[mod]];
    RETURN[NEW[SymTabRep _ [mod: mod, size: 0, case: case, data: data]]];
    END;

  GetSize: PUBLIC PROCEDURE [x: Ref] RETURNS [CARDINAL] =
    {RETURN [x^.size]};

  Fetch: PUBLIC ENTRY PROCEDURE [x: Ref, key: Key]
         RETURNS [found: BOOLEAN, storedKey: Key, val: Val] = BEGIN
    hash: CARDINAL _ Hash[key, x.mod];
    node: Node _ x.data[hash];
    case: BOOLEAN _ x.case;
    WHILE node # NIL DO
      nkey: Key _ node.key;
      IF Rope.Compare[key, node.key, case] = 0
         THEN RETURN [TRUE, node.key, node.val];
      node _ node.next;
      ENDLOOP;
    RETURN [FALSE, NIL, NIL];
    END;

  Store: PUBLIC ENTRY PROCEDURE [x: Ref, key: Key, val: Val]
         RETURNS [BOOLEAN]
    = BEGIN
    hash: CARDINAL _ Hash[key, x.mod];
    node: Node _ x.data[hash];
    head: Node _ node;
    case: BOOLEAN _ x.case;
    WHILE node # NIL DO
      nkey: Key _ node.key;
      IF Rope.Compare[key, node.key, case] = 0
         THEN {node.val _ val; RETURN [FALSE]};
      node _ node.next;
      ENDLOOP;
    x.data[hash] _ NEW[NodeRep _ [key: key, val: val, next: head]];
    x.size _ x.size + 1;
    RETURN [TRUE];
    END;

  Insert: PUBLIC ENTRY PROCEDURE [x: Ref, key: Key, val: Val]
          RETURNS [BOOLEAN]
    = BEGIN
    hash: CARDINAL _ Hash[key, x.mod];
    node: Node _ x.data[hash];
    head: Node _ node;
    case: BOOLEAN _ x.case;
    WHILE node # NIL DO
      nkey: Key _ node.key;
      IF Rope.Compare[key, node.key, case] = 0
         THEN RETURN [FALSE];
      node _ node.next;
      ENDLOOP;
    x.data[hash] _ NEW[NodeRep _ [key: key, val: val, next: head]];
    x.size _ x.size + 1;
    RETURN [TRUE];
    END;

  Delete: PUBLIC ENTRY PROCEDURE [x: Ref, key: Key] RETURNS [BOOLEAN]
    = BEGIN
    hash: CARDINAL _ Hash[key, x.mod];
    node: Node _ x.data[hash];
    head: Node _ node;
    case: BOOLEAN _ x.case;
    lag: Node _ NIL;
    WHILE node # NIL DO
      nkey: Key _ node.key;
      IF Rope.Compare[key, node.key, case] = 0
         THEN {IF lag = NIL THEN x.data[hash] _ node.next
                            ELSE lag.next _ node.next;
               x.size _ x.size - 1;
               RETURN [TRUE]};
      lag _ node;
      node _ node.next;
      ENDLOOP;
    RETURN [FALSE];
    END;

  Pairs: PUBLIC PROCEDURE [x: Ref, action: EachPairAction]
           RETURNS [quit: BOOLEAN] = BEGIN
    node: Node _ NIL;
    index: CARDINAL _ 0;
    DO
        [node, index] _ GetNext[x, node, index];
        IF node = NIL THEN RETURN [FALSE];
        IF action[node.key, node.val] THEN RETURN [TRUE];
        ENDLOOP;
    END;

  GetNext: ENTRY PROCEDURE [x: Ref, node: Node, index: CARDINAL]
             RETURNS [Node, CARDINAL] = {
    mod: CARDINAL _ x.mod;
    IF node # NIL THEN {
       node _ node.next;
       IF node # NIL THEN RETURN [node, index];
       index _ index + 1}
       ELSE index _ 0;
    WHILE index < mod DO
      node _ x.data[index];
      IF node = NIL THEN {index _ index + 1; LOOP};
      RETURN [node, index];
      ENDLOOP;
    RETURN [NIL, mod];
    };

  END.
  
  Change log:
  
  Fetch returns  stored Key as well as Value