Java-语义分析：使用键和多个值实现哈希表

Question

In semantic analysis one of the most popular method or data structure used is Hash Table. Implementing hash table is relatively easy however reading this peresentation made it complex for me - I don't know if Im right. Based from the presentation, how do you implement a symbol table with a token ( key ) that has multiple values?

My idea is to create a table below:

Given input string:
VAR abc, b, c AS INT

   | symbol | datatype | value |
   -----------------------------
   | VAR    | keyword  | null  |
   | abc    | INT      | null  |
   | b      | INT      | null  |
   | c      | INT      | null  |
   | AS     | keyword  | null  |
   | CHAR   | keyword  | null  |

VAR x, w_23='w' AS CHAR

   | symbol | datatype | value |
   -----------------------------
   | VAR    | keyword  | null  |
   | x      | CHAR     | null  |
   | w_23   | CHAR     | 'w'   |
   | AS     | keyword  | null  |
   | CHAR   | keyword  | null  |

So, lets say I have a variable a if I lookup (a) then it should be error because looking at the table key a doesn't exist. Also, if w_23=10 should also be an error because w_23 is of type CHAR generally it's just a type checking.

My question is, is it possible to create a symbol table like that of above?, if so how do I implement a symbol table with symbol as key and datatype & value as values?.

Answer 1

You can implement it something like this:

  public class SymbolEntry {
      private String symbol;
      private DataType datatype;
      private Value value;
      ...
  }

where DataType and Value are custom classes that represent the types and values as appropriate. Then the symbol table is simply this:

  HashMap<String, SymbolEntry> symtab = new HashMap<>();

where the String key is the symbol.

In short, you need a custom class to represent the values that comprise a symbol table entry. The rest is left as "an exercise for the reader".

Answer 2

I would use an approach based on the Generics.

First you define a generic class like this:

public abstract class GenericEntry<T> {
    protected T value;

    @SuppressWarnings("unchecked")
    public Class<? extends T> getDatatype() {
        return (Class<? extends T>) value.getClass();
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

and then you define a material classes. One for the character, for example:

public class CharacterEntry extends GenericEntry<Character> { }

and another one for integers:

public class IntegerEntry extends GenericEntry<Integer> { }

and a main with some tests:

public class Main {
    public static void main(String[] args) {
        HashMap<String, GenericEntry<?>> myMap = new HashMap<>();

        CharacterEntry characterEntry = new CharacterEntry();
        characterEntry.setValue('c');
        myMap.put("key1", characterEntry);

        IntegerEntry integerEntry = new IntegerEntry();
        integerEntry.setValue(3);
        myMap.put("key2", integerEntry);

        GenericEntry<?> entry1 = myMap.get("key1");
        System.out.println(entry1.getDatatype());
        System.out.println(entry1.getValue());

        GenericEntry<?> entry2 = myMap.get("key2");
        System.out.println(entry2.getDatatype());   
        System.out.println(entry2.getValue());
    }
}

whose output is:

class java.lang.Character
c
class java.lang.Integer
3

as you can see from @stephen-c's answer, the approaches may be differents, but in any case you have to define a class that containts the datatype and the value.