Symbol Table Design and Implementation in Ruby

I am building a lexical analyzer in Ruby and am about to start gathering
and storing symbols in the symbol table. My main question about the
design of the symbol and as to whether it should be static table
(meaning that all of the data will be held at the class level) or
whether it should be on an instance to instance basis.

**Option 1: Class level data structure**

    require 'SymbolTableEntry.rb'

    class SymbolTable
      @sym_table = Array.new(500)
      def initialize()
      end

      def SymbolTable.add(element, index)
        @sym_table[index] = element if element.is_a? SymbolTableEntry
      end

      def SymbolTable.to_s
        pp @sym_table
      end
    end

With this scheme, the SymbolTable class has a sort of 'static'
functionality, meaning that I don't actually create an instance of a
SymbolTable, the only object that exists is the class level one.

(Assume that `SymbolTableEntry` is a valid object even though I don't
define it here)

Ex:

    irb(main):002:0> require 'SymbolTable.rb'
    => true

    irb(main):003:0> ste = SymbolTableEntry.new
    => #<SymbolTableEntry:0x7ef36884>

    irb(main):004:0> SymbolTable.add(ste, 10)
    => #<SymbolTableEntry:0x7ef36884>

    irb(main):005:0> SymbolTable.to_s
    [nil,
     nil,
     nil,
     nil,
     nil,
     nil,
     nil,
     nil,
     nil,
     nil,
     #<SymbolTableEntry:0x7ef36884>]
    => nil

**Option 2: Instance level data structure**

    require 'rubygems'
    require 'backports'
    require 'SymbolTableEntry.rb'

    class SymbolTable
      def initialize()
        @sym_table = Array.new(10)
      end

      def add(element, index)
        @sym_table[index] = element if element.is_a? SymbolTableEntry
      end

      def to_s
        pp @sym_table
      end
    end

With this scheme I would actually need to instantiate an instance of the
SymbolTable class in order to add values to the symbol table.


    irb(main):001:0> require 'SymbolTable.rb'
    => true

    irb(main):002:0> st = SymbolTable.new
    => #<SymbolTable:0x7eeb6c9c @sym_table=[nil, nil, nil, nil, nil,
                                            nil, nil, nil, nil, nil]>

    irb(main):003:0> ste=SymbolTableEntry.new
    => #<SymbolTableEntry:0x7eeb4d5c>

    irb(main):004:0> st.add(ste,10)
    => #<SymbolTableEntry:0x7eeb4d5c>

    irb(main):007:0> st.to_s
    [nil,
     nil,
     nil,
     nil,
     nil,
     nil,
     nil,
     nil,
     nil,
     nil,
     #<SymbolTableEntry:0x7eeb4d5c>]
    => nil


I would love to hear any and all input on which design you would use or
prefer to use, as well any comments on the ruby code in general.

Thanks
Hunter McMillen

Please note that I have also posted this on Stack Overflow:
http://stackoverflow.com/questions/9012854/symbol-table-design-and-implementation-in-ruby

-- 
Posted via http://www.ruby-forum.com/.