nexus_parser 1.0.0 → 1.1.0

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.1.0

data/lib/lexer.rb

@@ -1,6 +1,6 @@
 
 
-class NexusFile::Lexer
+class NexusParser::Lexer
 
   def initialize(input)
     @input = input
@@ -21,7 +21,7 @@ class NexusFile::Lexer
     token = read_next_token(token_class)
     @next_token = nil
     if token.class != token_class
-        raise(NexusFile::ParseError,"expected #{token_class.to_s} but received #{token.class.to_s} at #{@input[0..10]}...", caller)
+        raise(NexusParser::ParseError,"expected #{token_class.to_s} but received #{token.class.to_s} at #{@input[0..10]}...", caller)
     else
         return token
     end
@@ -38,13 +38,13 @@ class NexusFile::Lexer
         return @next_token
       else
         # now check all the tokens for a match
-        NexusFile::Tokens.nexus_file_token_list.each {|t|
+        NexusParser::Tokens.nexus_file_token_list.each {|t|
           return @next_token if match(t)
         }
       end
          # no match, either end of string or lex-error
          if @input != ''
-             raise( NexusFile::ParseError, "Lex Error, unknown token at #{@input[0..10]}...", caller)
+             raise( NexusParser::ParseError, "Lex Error, unknown token at #{@input[0..10]}...", caller)
          else
             return nil
       end

data/lib/{nexus_file.rb → nexus_parser.rb}

@@ -7,13 +7,13 @@
 # outstanding issues:
 ## need to resolve Tokens Labels, ValuePair, IDs
 
-module NexusFile
+module NexusParser
 
   require File.expand_path(File.join(File.dirname(__FILE__), 'tokens'))
   require File.expand_path(File.join(File.dirname(__FILE__), 'parser'))
   require File.expand_path(File.join(File.dirname(__FILE__), 'lexer'))
  
-class NexusFile 
+class NexusParser 
   
   attr_accessor :taxa, :characters, :sets, :codings, :vars, :notes
 
@@ -117,20 +117,20 @@ class NexusFile
 end
 
 
-# constructs the NexusFile
+# constructs the NexusParser
 class Builder
 
   def initialize
-    @nf = NexusFile.new 
+    @nf = NexusParser.new 
   end
 
   def stub_taxon
-    @nf.taxa.push(NexusFile::Taxon.new) 
+    @nf.taxa.push(NexusParser::Taxon.new) 
     return @nf.taxa.size
   end
 
   def stub_chr
-    @nf.characters.push(NexusFile::Character.new)
+    @nf.characters.push(NexusParser::Character.new)
     return @nf.characters.size
   end
 
@@ -138,7 +138,7 @@ class Builder
 
     @nf.characters.each_with_index do |c, i|
       @nf.codings[taxon_index.to_i] = [] if !@nf.codings[taxon_index.to_i]
-      @nf.codings[taxon_index.to_i][i] = NexusFile::Coding.new(:states => rowvector[i])
+      @nf.codings[taxon_index.to_i][i] = NexusParser::Coding.new(:states => rowvector[i])
     
       # !! we must update states for a given character if the state isn't found (not all states are referenced in description !! 
 
@@ -183,7 +183,7 @@ class Builder
     
     # need to create the characters
     
-    raise(NexusFile::ParseError, "Can't update character of index #{@index}, it doesn't exist! This is a problem parsing the character state labels. Check the indices. It may be for this character \"#{@opt[:name]}\".") if !@nf.characters[@index]
+    raise(NexusParser::ParseError, "Can't update character of index #{@index}, it doesn't exist! This is a problem parsing the character state labels. Check the indices. It may be for this character \"#{@opt[:name]}\".") if !@nf.characters[@index]
 
     (@nf.characters[@index].name = @opt[:name]) if @opt[:name]
   
@@ -223,28 +223,28 @@ class Builder
     # Why does mesquite differentiate b/w footnotes and annotations?!, apparently same data structure?
     when 'TEXT' # a footnote 
       if @opt[:file]
-       @nf.notes << NexusFile::Note.new(@opt)
+       @nf.notes << NexusParser::Note.new(@opt)
         
       elsif  @opt[:taxon] && @opt[:character] # its a cell, parse this case         
         @nf.codings[@opt[:taxon].to_i - 1][@opt[:character].to_i - 1].notes = [] if !@nf.codings[@opt[:taxon].to_i - 1][@opt[:character].to_i - 1].notes
-        @nf.codings[@opt[:taxon].to_i - 1][@opt[:character].to_i - 1].notes << NexusFile::Note.new(@opt)
+        @nf.codings[@opt[:taxon].to_i - 1][@opt[:character].to_i - 1].notes << NexusParser::Note.new(@opt)
 
       elsif @opt[:taxon] && !@opt[:character]
-        @nf.taxa[@opt[:taxon].to_i - 1].notes << NexusFile::Note.new(@opt)
+        @nf.taxa[@opt[:taxon].to_i - 1].notes << NexusParser::Note.new(@opt)
 
       elsif @opt[:character] && !@opt[:taxon]
         
-        @nf.characters[@opt[:character].to_i - 1].notes << NexusFile::Note.new(@opt)
+        @nf.characters[@opt[:character].to_i - 1].notes << NexusParser::Note.new(@opt)
       end
 
     when 'AN' # an annotation, rather than a footnote, same dif
       if @opt[:t] && @opt[:c]
         @nf.codings[@opt[:t].to_i - 1][@opt[:c].to_i - 1].notes = [] if !@nf.codings[@opt[:t].to_i - 1][@opt[:c].to_i - 1].notes
-        @nf.codings[@opt[:t].to_i - 1][@opt[:c].to_i - 1].notes << NexusFile::Note.new(@opt)
+        @nf.codings[@opt[:t].to_i - 1][@opt[:c].to_i - 1].notes << NexusParser::Note.new(@opt)
       elsif @opt[:t]
-        @nf.taxa[@opt[:t].to_i - 1].notes << NexusFile::Note.new(@opt)
+        @nf.taxa[@opt[:t].to_i - 1].notes << NexusParser::Note.new(@opt)
       elsif @opt[:c]
-        @nf.characters[@opt[:c].to_i - 1].notes << NexusFile::Note.new(@opt)
+        @nf.characters[@opt[:c].to_i - 1].notes << NexusParser::Note.new(@opt)
       end
     end
     
@@ -256,7 +256,7 @@ class Builder
 
 end # end file
 
-  # NexusFile::ParseError
+  # NexusParser::ParseError
   class ParseError < StandardError
   end
 
@@ -267,15 +267,14 @@ end # end module
 def parse_nexus_file(input)
   @input = input
   @input.gsub!(/\[[^\]]*\]/,'')  # strip out all comments BEFORE we parse the file
-    
   # quickly peek at the input, does this look like a Nexus file? 
   if !(@input =~ /\#Nexus/i) || !(@input =~ /Begin/i) || !(@input =~ /Matrix/i) || !(@input =~ /end\;/i)
-    raise(NexusFile::ParseError, "File is missing at least some required headers, check formatting.", caller)
+    raise(NexusParser::ParseError, "File is missing at least some required headers, check formatting.", caller)
   end
 
-  builder = NexusFile::Builder.new
-  lexer = NexusFile::Lexer.new(@input)
-  NexusFile::Parser.new(lexer, builder).parse_file
+  builder = NexusParser::Builder.new
+  lexer = NexusParser::Lexer.new(@input)
+  NexusParser::Parser.new(lexer, builder).parse_file
   
   return builder.nexus_file  
 end

data/lib/parser.rb

@@ -1,5 +1,5 @@
 
-class NexusFile::Parser
+class NexusParser::Parser
  
   def initialize(lexer, builder)
     @lexer = lexer
@@ -7,50 +7,50 @@ class NexusFile::Parser
   end
 
   def parse_file
-    # nf = @builder.new_nexus_file # create new local NexusFile instance, nf
+    # nf = @builder.new_nexus_file # create new local NexusParser instance, nf
     blks = []
-    @lexer.pop(NexusFile::Tokens::NexusStart)
+    @lexer.pop(NexusParser::Tokens::NexusStart)
      
-    while @lexer.peek(NexusFile::Tokens::BeginBlk)
+    while @lexer.peek(NexusParser::Tokens::BeginBlk)
        
-      @lexer.pop(NexusFile::Tokens::BeginBlk) # pop it
+      @lexer.pop(NexusParser::Tokens::BeginBlk) # pop it
       
-      if @lexer.peek(NexusFile::Tokens::AuthorsBlk)
+      if @lexer.peek(NexusParser::Tokens::AuthorsBlk)
         parse_authors_blk
         
       # we parse these below 
-      elsif @lexer.peek(NexusFile::Tokens::TaxaBlk)
+      elsif @lexer.peek(NexusParser::Tokens::TaxaBlk)
         
-        @lexer.pop(NexusFile::Tokens::TaxaBlk )
+        @lexer.pop(NexusParser::Tokens::TaxaBlk )
         parse_taxa_blk
            
-      elsif @lexer.peek(NexusFile::Tokens::ChrsBlk)
-        @lexer.pop(NexusFile::Tokens::ChrsBlk)
+      elsif @lexer.peek(NexusParser::Tokens::ChrsBlk)
+        @lexer.pop(NexusParser::Tokens::ChrsBlk)
         parse_characters_blk
 
-      elsif @lexer.peek(NexusFile::Tokens::NotesBlk)
-        @lexer.pop(NexusFile::Tokens::NotesBlk)  
+      elsif @lexer.peek(NexusParser::Tokens::NotesBlk)
+        @lexer.pop(NexusParser::Tokens::NotesBlk)  
         parse_notes_blk
 
       # we should parse this
-      elsif @lexer.peek(NexusFile::Tokens::SetsBlk)
-        @lexer.pop(NexusFile::Tokens::SetsBlk)
+      elsif @lexer.peek(NexusParser::Tokens::SetsBlk)
+        @lexer.pop(NexusParser::Tokens::SetsBlk)
 
       # we don't parse these 
-      elsif @lexer.peek(NexusFile::Tokens::TreesBlk)
-        @foo =  @lexer.pop(NexusFile::Tokens::TreesBlk).value
+      elsif @lexer.peek(NexusParser::Tokens::TreesBlk)
+        @foo =  @lexer.pop(NexusParser::Tokens::TreesBlk).value
  
-      elsif @lexer.peek(NexusFile::Tokens::LabelsBlk)
-        @lexer.pop(NexusFile::Tokens::LabelsBlk)
+      elsif @lexer.peek(NexusParser::Tokens::LabelsBlk)
+        @lexer.pop(NexusParser::Tokens::LabelsBlk)
    
-      elsif @lexer.peek(NexusFile::Tokens::MqCharModelsBlk)
-        @lexer.pop(NexusFile::Tokens::MqCharModelsBlk) 
+      elsif @lexer.peek(NexusParser::Tokens::MqCharModelsBlk)
+        @lexer.pop(NexusParser::Tokens::MqCharModelsBlk) 
 
-      elsif @lexer.peek(NexusFile::Tokens::AssumptionsBlk)
-        @lexer.pop(NexusFile::Tokens::AssumptionsBlk)
+      elsif @lexer.peek(NexusParser::Tokens::AssumptionsBlk)
+        @lexer.pop(NexusParser::Tokens::AssumptionsBlk)
 
-      elsif @lexer.peek(NexusFile::Tokens::CodonsBlk)
-        @lexer.pop(NexusFile::Tokens::CodonsBlk)
+      elsif @lexer.peek(NexusParser::Tokens::CodonsBlk)
+        @lexer.pop(NexusParser::Tokens::CodonsBlk)
       end
       
     end
@@ -60,50 +60,50 @@ class NexusFile::Parser
   def parse_authors_blk
     # thing has non single word key/value pairs, like "AUTHOR NAME", SIGH
     # for now just slurp it all up.
-    @lexer.pop(NexusFile::Tokens::AuthorsBlk )
+    @lexer.pop(NexusParser::Tokens::AuthorsBlk )
 
     #while true
-    #  if @lexer.peek(NexusFile::Tokens::EndBlk)
-    #    @lexer.pop(NexusFile::Tokens::EndBlk)
+    #  if @lexer.peek(NexusParser::Tokens::EndBlk)
+    #    @lexer.pop(NexusParser::Tokens::EndBlk)
     #    break
     #  else
 
-     #   while @lexer.peek(NexusFile::Tokens::ValuePair)
+     #   while @lexer.peek(NexusParser::Tokens::ValuePair)
      #     # IMPORTANT, these are going to a general hash, there may ultimately be overlap of keys used in different blocks, this is ignored at present
-     #     @builder.add_var(@lexer.pop(NexusFile::Tokens::ValuePair).value) 
+     #     @builder.add_var(@lexer.pop(NexusParser::Tokens::ValuePair).value) 
      #   end
         
-        #@lexer.pop(NexusFile::Tokens::ID) if @lexer.peek(NexusFile::Tokens::ID)
+        #@lexer.pop(NexusParser::Tokens::ID) if @lexer.peek(NexusParser::Tokens::ID)
      # end
     #end
   end
 
   def parse_taxa_blk 
-    @lexer.pop(NexusFile::Tokens::Title) if @lexer.peek(NexusFile::Tokens::Title)
+    @lexer.pop(NexusParser::Tokens::Title) if @lexer.peek(NexusParser::Tokens::Title)
 
     # need to not ignore to test against
-    parse_dimensions if @lexer.peek(NexusFile::Tokens::Dimensions)
+    parse_dimensions if @lexer.peek(NexusParser::Tokens::Dimensions)
 
     while true
-      if @lexer.peek(NexusFile::Tokens::EndBlk)
-        @lexer.pop(NexusFile::Tokens::EndBlk)
+      if @lexer.peek(NexusParser::Tokens::EndBlk)
+        @lexer.pop(NexusParser::Tokens::EndBlk)
         break
       else
 
-        if @lexer.peek(NexusFile::Tokens::Taxlabels)
-          @lexer.pop(NexusFile::Tokens::Taxlabels) if @lexer.peek(NexusFile::Tokens::Taxlabels)
+        if @lexer.peek(NexusParser::Tokens::Taxlabels)
+          @lexer.pop(NexusParser::Tokens::Taxlabels) if @lexer.peek(NexusParser::Tokens::Taxlabels)
           i = 0
-          while @lexer.peek(NexusFile::Tokens::Label)
-            @builder.update_taxon(:index => i, :name => @lexer.pop(NexusFile::Tokens::Label).value) 
+          while @lexer.peek(NexusParser::Tokens::Label)
+            @builder.update_taxon(:index => i, :name => @lexer.pop(NexusParser::Tokens::Label).value) 
             i += 1
           end 
-          @lexer.pop(NexusFile::Tokens::SemiColon) if @lexer.peek(NexusFile::Tokens::SemiColon) # close of tax labels, placement of this seems dubious... but tests are working
+          @lexer.pop(NexusParser::Tokens::SemiColon) if @lexer.peek(NexusParser::Tokens::SemiColon) # close of tax labels, placement of this seems dubious... but tests are working
         
-        elsif  @lexer.peek(NexusFile::Tokens::MesquiteIDs)
+        elsif  @lexer.peek(NexusParser::Tokens::MesquiteIDs)
 
-          @lexer.pop(NexusFile::Tokens::MesquiteIDs) # trashing these for now
-        elsif  @lexer.peek(NexusFile::Tokens::MesquiteBlockID)
-          @lexer.pop(NexusFile::Tokens::MesquiteBlockID) 
+          @lexer.pop(NexusParser::Tokens::MesquiteIDs) # trashing these for now
+        elsif  @lexer.peek(NexusParser::Tokens::MesquiteBlockID)
+          @lexer.pop(NexusParser::Tokens::MesquiteBlockID) 
         end
         
       end
@@ -114,43 +114,43 @@ class NexusFile::Parser
 
   def parse_characters_blk 
     while true
-      if @lexer.peek(NexusFile::Tokens::EndBlk) # we're at the end of the block, exit after geting rid of the semi-colon
+      if @lexer.peek(NexusParser::Tokens::EndBlk) # we're at the end of the block, exit after geting rid of the semi-colon
         break 
       else
-        @lexer.pop(NexusFile::Tokens::Title) if @lexer.peek(NexusFile::Tokens::Title) # not used at present
+        @lexer.pop(NexusParser::Tokens::Title) if @lexer.peek(NexusParser::Tokens::Title) # not used at present
 
-        parse_dimensions if @lexer.peek(NexusFile::Tokens::Dimensions)
-        parse_format if @lexer.peek(NexusFile::Tokens::Format) 
+        parse_dimensions if @lexer.peek(NexusParser::Tokens::Dimensions)
+        parse_format if @lexer.peek(NexusParser::Tokens::Format) 
         
-        parse_chr_state_labels if @lexer.peek(NexusFile::Tokens::CharStateLabels)
+        parse_chr_state_labels if @lexer.peek(NexusParser::Tokens::CharStateLabels)
 
-        parse_matrix if @lexer.peek(NexusFile::Tokens::Matrix) 
+        parse_matrix if @lexer.peek(NexusParser::Tokens::Matrix) 
     
         # handle "\s*OPTIONS MSTAXA = UNCERTAIN;\s\n" within a characters block (sticks in an infinite loop right now)
 
-        @lexer.pop(NexusFile::Tokens::MesquiteIDs) if @lexer.peek(NexusFile::Tokens::MesquiteIDs) # trashing these for now
-        @lexer.pop(NexusFile::Tokens::MesquiteBlockID) if @lexer.peek(NexusFile::Tokens::MesquiteBlockID) # trashing these for now
+        @lexer.pop(NexusParser::Tokens::MesquiteIDs) if @lexer.peek(NexusParser::Tokens::MesquiteIDs) # trashing these for now
+        @lexer.pop(NexusParser::Tokens::MesquiteBlockID) if @lexer.peek(NexusParser::Tokens::MesquiteBlockID) # trashing these for now
     
         false
       end
     end
-    @lexer.pop(NexusFile::Tokens::EndBlk)
+    @lexer.pop(NexusParser::Tokens::EndBlk)
   end
 
   # prolly pop header then fuse with parse_dimensions
   def parse_format
-    @lexer.pop(NexusFile::Tokens::Format) 
-    while @lexer.peek(NexusFile::Tokens::ValuePair)
-      @builder.add_var(@lexer.pop(NexusFile::Tokens::ValuePair).value)
+    @lexer.pop(NexusParser::Tokens::Format) 
+    while @lexer.peek(NexusParser::Tokens::ValuePair)
+      @builder.add_var(@lexer.pop(NexusParser::Tokens::ValuePair).value)
     end
 
     check_initialization_of_ntax_nchar
   end
 
   def parse_dimensions  
-    @lexer.pop(NexusFile::Tokens::Dimensions)
-    while @lexer.peek(NexusFile::Tokens::ValuePair)
-      @builder.add_var(@lexer.pop(NexusFile::Tokens::ValuePair).value)
+    @lexer.pop(NexusParser::Tokens::Dimensions)
+    while @lexer.peek(NexusParser::Tokens::ValuePair)
+      @builder.add_var(@lexer.pop(NexusParser::Tokens::ValuePair).value)
     end
     # the last value pair with a ; is automagically handled, don't try popping it again
     
@@ -170,33 +170,33 @@ class NexusFile::Parser
   end
 
   def parse_chr_state_labels
-    @lexer.pop(NexusFile::Tokens::CharStateLabels)
+    @lexer.pop(NexusParser::Tokens::CharStateLabels)
   
     while true
-      if @lexer.peek(NexusFile::Tokens::SemiColon)    
+      if @lexer.peek(NexusParser::Tokens::SemiColon)    
         break 
       else
         opts = {}
         
         name = ""
-        index = @lexer.pop(NexusFile::Tokens::Number).value.to_i
-        (name = @lexer.pop(NexusFile::Tokens::Label).value) if @lexer.peek(NexusFile::Tokens::Label) # not always given a letter
+        index = @lexer.pop(NexusParser::Tokens::Number).value.to_i
+        (name = @lexer.pop(NexusParser::Tokens::Label).value) if @lexer.peek(NexusParser::Tokens::Label) # not always given a letter
 
-        @lexer.pop(NexusFile::Tokens::BckSlash) if @lexer.peek(NexusFile::Tokens::BckSlash)
+        @lexer.pop(NexusParser::Tokens::BckSlash) if @lexer.peek(NexusParser::Tokens::BckSlash)
 
-        if !@lexer.peek(NexusFile::Tokens::Comma) || !@lexer.peek(NexusFile::Tokens::SemiColon)
+        if !@lexer.peek(NexusParser::Tokens::Comma) || !@lexer.peek(NexusParser::Tokens::SemiColon)
           i = 0
 
           # three kludge lines, need to figure out the label/number priority, could be issue in list order w/in tokens
-          while @lexer.peek(NexusFile::Tokens::Label) || @lexer.peek(NexusFile::Tokens::Number)
-            opts.update({i.to_s => @lexer.pop(NexusFile::Tokens::Label).value}) if @lexer.peek(NexusFile::Tokens::Label)
-            opts.update({i.to_s => @lexer.pop(NexusFile::Tokens::Number).value.to_s}) if @lexer.peek(NexusFile::Tokens::Number)
+          while @lexer.peek(NexusParser::Tokens::Label) || @lexer.peek(NexusParser::Tokens::Number)
+            opts.update({i.to_s => @lexer.pop(NexusParser::Tokens::Label).value}) if @lexer.peek(NexusParser::Tokens::Label)
+            opts.update({i.to_s => @lexer.pop(NexusParser::Tokens::Number).value.to_s}) if @lexer.peek(NexusParser::Tokens::Number)
 
             i += 1
           end  
         end
 
-        @lexer.pop(NexusFile::Tokens::Comma) if @lexer.peek(NexusFile::Tokens::Comma) # we may also have hit semicolon
+        @lexer.pop(NexusParser::Tokens::Comma) if @lexer.peek(NexusParser::Tokens::Comma) # we may also have hit semicolon
         
         opts.update({:index => (index - 1), :name => name})
        
@@ -205,56 +205,56 @@ class NexusFile::Parser
       end     
 
     end
-    @lexer.pop(NexusFile::Tokens::SemiColon) 
+    @lexer.pop(NexusParser::Tokens::SemiColon) 
   end
 
   def parse_matrix
-    @lexer.pop(NexusFile::Tokens::Matrix)
+    @lexer.pop(NexusParser::Tokens::Matrix)
     i = 0
       while true
-        if @lexer.peek(NexusFile::Tokens::SemiColon)
+        if @lexer.peek(NexusParser::Tokens::SemiColon)
          break 
         else
-          t = @lexer.pop(NexusFile::Tokens::Label).value
+          t = @lexer.pop(NexusParser::Tokens::Label).value
 
           @builder.update_taxon(:index => i, :name => t) # if it exists its not re-added
 
-          @builder.code_row(i, @lexer.pop(NexusFile::Tokens::RowVec).value)
+          @builder.code_row(i, @lexer.pop(NexusParser::Tokens::RowVec).value)
       
           i += 1
         end
       end
-    @lexer.pop(NexusFile::Tokens::SemiColon) # pop the semicolon 
+    @lexer.pop(NexusParser::Tokens::SemiColon) # pop the semicolon 
   end
 
   # this suck(s/ed), it needs work when a better API for Mesquite comes out
   def parse_notes_blk
-    # IMPORTANT - we don't parse the (CM <note>), we just strip the "(CM" ... ")" bit for now in NexusFile::Note
+    # IMPORTANT - we don't parse the (CM <note>), we just strip the "(CM" ... ")" bit for now in NexusParser::Note
 
     @vars = {} 
     inf = 0
     while true
       inf += 1
       raise "Either you have a gazillion notes or more likely parser is caught in an infinite loop inside parse_notes_block" if inf > 100000
-      if @lexer.peek(NexusFile::Tokens::EndBlk)
-        @lexer.pop(NexusFile::Tokens::EndBlk)
+      if @lexer.peek(NexusParser::Tokens::EndBlk)
+        @lexer.pop(NexusParser::Tokens::EndBlk)
         @builder.add_note(@vars) # one still left to add
         break
       else
 
-        if @lexer.peek(NexusFile::Tokens::ValuePair)
-          @vars.update(@lexer.pop(NexusFile::Tokens::ValuePair).value)
+        if @lexer.peek(NexusParser::Tokens::ValuePair)
+          @vars.update(@lexer.pop(NexusParser::Tokens::ValuePair).value)
       
-        elsif @lexer.peek(NexusFile::Tokens::Label)
+        elsif @lexer.peek(NexusParser::Tokens::Label)
           if @vars[:type] # we have the data for this row write it, and start a new one    
             
             @builder.add_note(@vars)
             @vars = {}
           else
-            @vars.update(:type => @lexer.pop(NexusFile::Tokens::Label).value)
+            @vars.update(:type => @lexer.pop(NexusParser::Tokens::Label).value)
           end
-        elsif @lexer.peek(NexusFile::Tokens::FileLbl)  
-          @lexer.pop(NexusFile::Tokens::FileLbl)
+        elsif @lexer.peek(NexusParser::Tokens::FileLbl)  
+          @lexer.pop(NexusParser::Tokens::FileLbl)
           @vars.update(:file => 'file') # we check for whether :file key is present and handle conditionally
         end
       end
@@ -264,27 +264,27 @@ class NexusFile::Parser
     #@vars = {}
     #while true
       
-    #  break if  @lexer.peek(NexusFile::Tokens::EndBlk)   
+    #  break if  @lexer.peek(NexusParser::Tokens::EndBlk)   
       
-    #  @vars.update(:type => @lexer.pop(NexusFile::Tokens::Label).value)
+    #  @vars.update(:type => @lexer.pop(NexusParser::Tokens::Label).value)
 
       # kludge to get around the funny construct that references file
-     # if @lexer.peek(NexusFile::Tokens::FileLbl)
-    #    @lexer.pop(NexusFile::Tokens::FileLbl)
+     # if @lexer.peek(NexusParser::Tokens::FileLbl)
+    #    @lexer.pop(NexusParser::Tokens::FileLbl)
     #      vars.update(:file => 'file') # we check for whether :file key is present and handle conditionally
      #   end
 
      #   while true
 
-     #     meh = @lexer.pop(NexusFile::Tokens::ValuePair)          
+     #     meh = @lexer.pop(NexusParser::Tokens::ValuePair)          
      #     @vars.update(meh.value)
-     #     break if !@lexer.peek(NexusFile::Tokens::ValuePair)
+     #     break if !@lexer.peek(NexusParser::Tokens::ValuePair)
      #   end
      #   
      #   @builder.add_note(@vars)
      #   @vars = {}
     #end
-   # @lexer.pop(NexusFile::Tokens::EndBlk)
+   # @lexer.pop(NexusParser::Tokens::EndBlk)
 
 
   def parse_trees_blk
@@ -320,8 +320,8 @@ class NexusFile::Parser
   # parse a comma-separated list of nodes
   #  while true 
   #    parse_node(parent)
-  #    if @lexer.peek(NexusFile::Tokens::Comma)
-  #      @lexer.pop(NexusFile::Tokens::Comma)
+  #    if @lexer.peek(NexusParser::Tokens::Comma)
+  #      @lexer.pop(NexusParser::Tokens::Comma)
   #    else
   #      break
   #    end