Parser.py

#-------------------------------------------------------------------------
#Parser.py -- ATG file parser
#Compiler Generator Coco/R,
#Copyright (c) 1990, 2004 Hanspeter Moessenboeck, University of Linz
#extended by M. Loeberbauer & A. Woess, Univ. of Linz
#ported from Java to Python by Ronald Longo
#
#This program is free software; you can redistribute it and/or modify it
#under the terms of the GNU General Public License as published by the
#Free Software Foundation; either version 2, or (at your option) any
#later version.
#
#This program is distributed in the hope that it will be useful, but
#WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
#or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
#for more details.
#
#You should have received a copy of the GNU General Public License along
#with this program; if not, write to the Free Software Foundation, Inc.,
#59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
#As an exception, it is allowed to write an extension of Coco/R that is
#used as a plugin in non-free software.
#
#If not otherwise stated, any source code generated by Coco/R (other than
#Coco/R itself) does not fall under the GNU General Public License.
#-------------------------------------------------------------------------*/

from frothcompiler2 import *


import sys

from Scanner import Token
from Scanner import Scanner
from Scanner import Position

class ErrorRec( object ):
   def __init__( self, l, c, s ):
      self.line   = l
      self.col    = c
      self.num    = 0
      self.str    = s


class Errors( object ):
   errMsgFormat = "file %(file)s : (%(line)d, %(col)d) %(text)s\n"
   eof          = False
   count        = 0         # number of errors detected
   fileName     = ''
   listName     = ''
   mergeErrors  = False
   mergedList   = None      # PrintWriter
   errors       = [ ]
   minErrDist   = 2
   errDist      = minErrDist
      # A function with prototype: f( errorNum=None ) where errorNum is a
      # predefined error number.  f returns a tuple, ( line, column, message )
      # such that line and column refer to the location in the
      # source file most recently parsed.  message is the error
      # message corresponging to errorNum.

   @staticmethod
   def Init( fn, dir, merge, getParsingPos, errorMessages ):
      Errors.theErrors = [ ]
      Errors.getParsingPos = getParsingPos
      Errors.errorMessages = errorMessages
      Errors.fileName = fn
      listName = dir + 'listing.txt'
      Errors.listName = listName
      Errors.mergeErrors = merge
      if Errors.mergeErrors:
         try:
            Errors.mergedList = open( listName, 'w' )
         except IOError:
            raise RuntimeError( '-- Compiler Error: could not open ' + listName )

   @staticmethod
   def storeError( line, col, s ):
      if Errors.mergeErrors:
         Errors.errors.append( ErrorRec( line, col, s ) )
      else:
         Errors.printMsg( Errors.fileName, line, col, s )

   @staticmethod
   def SynErr( errNum, errPos=None ):
      line,col = errPos if errPos else Errors.getParsingPos( )
      msg = Errors.errorMessages[ errNum ]
      Errors.storeError( line, col, msg )
      Errors.count += 1

   @staticmethod
   def SemErr( errMsg, errPos=None ):
      line,col = errPos if errPos else Errors.getParsingPos( )
      Errors.storeError( line, col, errMsg )
      Errors.count += 1

   @staticmethod
   def Warn( errMsg, errPos=None ):
      line,col = errPos if errPos else Errors.getParsingPos( )
      Errors.storeError( line, col, errMsg )

   @staticmethod
   def Exception( errMsg ):
      print(errMsg)
      sys.exit( 1 )

   @staticmethod
   def printMsg( fileName, line, column, msg ):
      vals = { 'file':fileName, 'line':line, 'col':column, 'text':msg }
      sys.stdout.write( Errors.errMsgFormat % vals )

   @staticmethod
   def display( s, e ):
      Errors.mergedList.write('**** ')
      for c in range( 1, e.col ):
         if s[c-1] == '\t':
            Errors.mergedList.write( '\t' )
         else:
            Errors.mergedList.write( ' ' )
      Errors.mergedList.write( '^ ' + e.str + '\n')

   @staticmethod
   def Summarize( sourceBuffer ):
      if Errors.mergeErrors and Errors.count:
        errs = list(Errors.errors)
        for (srcLineNum, srcLineStr) in enumerate(iter(sourceBuffer), start=1):
          Errors.mergedList.write( '%4d %s\n' % (srcLineNum, srcLineStr.rstrip()) )
          while errs and (errs[0].line == srcLineNum):
            err = errs.pop(0)
            Errors.display( srcLineStr, err )

        if errs:
          # Still some errors left.
          for i in errs:
            Errors.display( " "*i.col, i)

        

      if Errors.count == 1:
        sys.stdout.write( '%d error detected.\n' % Errors.count )
      if Errors.count != 1:
        sys.stdout.write( '%d errors detected.\n' % Errors.count )

      if Errors.mergeErrors and Errors.count:
        sys.stdout.write( f"see {Errors.listName} for a listing showing the errors.\n")

class Parser( object ):
   _EOF = 0
   _identifier = 1
   _number = 2
   _hexnumber = 3
   _negnumber = 4
   _string = 5
   _float = 6
   _negfloat = 7
   maxT = 36

   T          = True
   x          = False
   minErrDist = 2

   def init(self):
    self.C = FrothCompiler(self)

   def writeResults(self, filetoparse, filebase):
    return self.C.writeResults(filetoparse, filebase)


   def __init__( self ):
      self.scanner     = None
      self.token       = None           # last recognized token
      self.la          = None           # lookahead token
      self.genScanner  = False
      self.tokenString = ''             # used in declarations of literal tokens
      self.noString    = '-none-'       # used in declarations of literal tokens
      self.errDist     = Parser.minErrDist

   def getParsingPos( self ):
      return self.la.line, self.la.col

   def SynErr( self, errNum ):
      if self.errDist >= Parser.minErrDist:
         Errors.SynErr( errNum )

      self.errDist = 0

   def SemErr( self, msg ):
      if self.errDist >= Parser.minErrDist:
         Errors.SemErr( msg )

      self.errDist = 0

   def Warning( self, msg ):
      if self.errDist >= Parser.minErrDist:
         Errors.Warn( msg )

      self.errDist = 0

   def Successful( self ):
      return Errors.count == 0;

   def LexString( self ):
      return self.token.val

   def LookAheadString( self ):
      return self.la.val

   def Get( self ):
      while True:
         self.token = self.la
         self.la = self.scanner.Scan( )
         if self.la.kind <= Parser.maxT:
            self.errDist += 1
            break
         
         self.la = self.token

   def Expect( self, n ):
      if self.la.kind == n:
         self.Get( )
      else:
         self.SynErr( n )

   def StartOf( self, s ):
      return self.set[s][self.la.kind]

   def ExpectWeak( self, n, follow ):
      if self.la.kind == n:
         self.Get( )
      else:
         self.SynErr( n )
         while not self.StartOf(follow):
            self.Get( )

   def WeakSeparator( self, n, syFol, repFol ):
      s = [ False for i in range( Parser.maxT+1 ) ]
      if self.la.kind == n:
         self.Get( )
         return True
      elif self.StartOf(repFol):
         return False
      else:
         for i in range( Parser.maxT ):
            s[i] = self.set[syFol][i] or self.set[repFol][i] or self.set[0][i]
         self.SynErr( n )
         while not s[self.la.kind]:
            self.Get( )
         return self.StartOf( syFol )

   def EFroth( self ):
      self.init() 
      self.Expect(8)
      self.Expect(5)
      name = self.token.val 
      self.Expect(9)
      self.Expect(2)
      maxvol = int(self.token.val) 
      self.Expect(9)
      self.Expect(2)
      maxsec = int(self.token.val) 
      self.Expect(10)
      self.C.qHeader(name, maxvol, maxsec) 
      self.Program()
      self.C.checkWords() 

   def Program( self ):
      while self.la.kind == 11:
         self.Global()

      while self.la.kind == 12 or self.la.kind == 14:
         self.Word()


   def Global( self ):
      self.Expect(11)
      self.Expect(1)
      self.C.addGlobal(self.token.val) 

   def Word( self ):
      if self.la.kind == 12:
         while not (self.la.kind == 0 or self.la.kind == 12):
            self.SynErr(37)
            self.Get()
         self.AnnotatedWord()
      elif self.la.kind == 14:
         self.SimpleWord()
      else:
         self.SynErr(38)

   def AnnotatedWord( self ):
      self.Expect(12)
      before = []; after = []                     
      while self.la.kind == 1:
         self.Get( )
         before.append(self.token.val)               

      self.ExpectWeak(13, 1)
      while self.la.kind == 1:
         self.Get( )
         after.append(self.token.val)                

      self.Expect(10)
      ids = [before, after]                       
      self.RestOfWord(ids)

   def SimpleWord( self ):
      self.Expect(14)
      ids = [[], []]                              
      self.RestOfWord(ids)

   def RestOfWord( self, stackids ):
      name = self.WordDef()
      print(f"// {name} : {stackids[0]} -- {stackids[1]}") 
      while self.StartOf(2):
         self.CompoundStatement()

      self.EndOfWord()
      self.C.registerWord(name, stackids)         

   def WordDef( self ):
      self.Expect(1)
      name = self.C.addWord(self.token.val)        
      return name

   def CompoundStatement( self ):
      if self.la.kind == 15:
         self.If()
      elif self.la.kind == 18:
         self.For()
      elif self.la.kind == 20:
         self.Repeat()
      elif self.la.kind == 22:
         self.While()
      elif self.StartOf(3):
         self.Statement()
      else:
         self.SynErr(39)

   def EndOfWord( self ):
      self.C.qWord(";"); self.C.showWord()         
      self.Expect(31)

   def If( self ):
      self.Expect(15)
      ifhandle = self.C.qBranch("BZ"); noelse=True  
      stackbeforeif = self.C.StackUse               
      while self.StartOf(2):
         self.CompoundStatement()

      while self.la.kind == 16:
         elsehandle = self.C.qBranch("BRA")            
         stackbeforeelse = self.C.StackUse             
         self.Get( )
         noelse = False                                
         self.C.setBranchTargetToHere(ifhandle)        
         self.C.StackUse = stackbeforeif               
         while self.StartOf(2):
            self.CompoundStatement()

         self.C.checkPathsEqual(stackbeforeelse, self.C.StackUse) 
         self.C.setBranchTargetToHere(elsehandle)      

      self.Expect(17)
      if noelse: self.C.setBranchTargetToHere(ifhandle) 
      self.C.StackUse = stackbeforeif               

   def For( self ):
      self.Expect(18)
      self.C.startFor(); addr = self.C.Addr-1         
      while self.StartOf(2):
         self.CompoundStatement()

      self.Expect(19)
      self.C.endFor(addr)                           

   def Repeat( self ):
      self.Expect(20)
      while self.StartOf(2):
         self.CompoundStatement()

      self.Expect(21)

   def While( self ):
      self.Expect(22)
      while self.StartOf(2):
         self.CompoundStatement()

      self.Expect(23)

   def Statement( self ):
      if self.la.kind == 1:
         self.WordName()
      elif self.StartOf(4):
         self.Number()
      elif self.la.kind == 32:
         self.Label()
      elif self.StartOf(5):
         self.MathOp()
      elif self.la.kind == 34:
         self.Tag()
      elif self.la.kind == 24:
         self.StackCopy()
      elif self.la.kind == 26:
         self.StackDiscard()
      elif self.la.kind == 25:
         self.StackKeep()
      else:
         self.SynErr(40)

   def WordName( self ):
      self.Expect(1)
      self.C.qWord(self.token.val)                 

   def Number( self ):
      val = self.IntOrFloat()
      self.C.qVal(val, comment="%s" % self.token.val) 

   def Label( self ):
      self.Expect(32)
      self.Expect(1)
      self.C.addLabel(self.token.val)              
      self.Expect(33)

   def MathOp( self ):
      if self.la.kind == 27:
         self.Get( )
      elif self.la.kind == 28:
         self.Get( )
      elif self.la.kind == 29:
         self.Get( )
      elif self.la.kind == 30:
         self.Get( )
      else:
         self.SynErr(41)
      self.C.qWord(self.token.val)                 

   def Tag( self ):
      self.Expect(34)
      self.Expect(1)
      self.C.addTag(self.token.val)                
      self.Expect(35)

   def StackCopy( self ):
      self.Expect(24)
      while self.la.kind == 1:
         self.Get( )
         self.C.qCopy(self.token.val)                 

      self.Expect(10)

   def StackDiscard( self ):
      self.Expect(26)
      while self.la.kind == 1:
         self.Get( )
         self.C.qDiscard(self.token.val)              

      self.Expect(10)

   def StackKeep( self ):
      self.Expect(25)
      while self.la.kind == 1:
         self.Get( )

      self.Expect(10)

   def IntOrFloat( self ):
      if self.la.kind == 2:
         self.Get( )
         val = int(self.token.val, 10)              
      elif self.la.kind == 3:
         self.Get( )
         val = int(self.token.val, 16)              
      elif self.la.kind == 6:
         self.Get( )
         val = float(self.token.val)                
      elif self.la.kind == 4:
         self.Get( )
         val = int(self.token.val, 10)              
      elif self.la.kind == 7:
         self.Get( )
         val = float(self.token.val)                
      else:
         self.SynErr(42)
      return val



   def Parse( self, scanner ):
      self.scanner = scanner
      self.la = Token( )
      self.la.val = ''
      self.Get( )
      self.EFroth()
      self.Expect(0)


   set = [
      [T,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x],
      [T,T,x,x, x,x,x,x, x,x,T,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x],
      [x,T,T,T, T,x,T,T, x,x,x,x, x,x,x,T, x,x,T,x, T,x,T,x, T,T,T,T, T,T,T,x, T,x,T,x, x,x],
      [x,T,T,T, T,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,T,T,T, T,T,T,x, T,x,T,x, x,x],
      [x,x,T,T, T,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x],
      [x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,T,T,x, x,x,x,x, x,x]

      ]

   errorMessages = {
      
      0 : "EOF expected",
      1 : "identifier expected",
      2 : "number expected",
      3 : "hexnumber expected",
      4 : "negnumber expected",
      5 : "string expected",
      6 : "float expected",
      7 : "negfloat expected",
      8 : "\"Program(\" expected",
      9 : "\",\" expected",
      10 : "\")\" expected",
      11 : "\"Global\" expected",
      12 : "\":(\" expected",
      13 : "\"--\" expected",
      14 : "\":\" expected",
      15 : "\"IF\" expected",
      16 : "\"ELSE\" expected",
      17 : "\"ENDIF\" expected",
      18 : "\"FOR\" expected",
      19 : "\"ENDFOR\" expected",
      20 : "\"REPEAT\" expected",
      21 : "\"ENDREPEAT\" expected",
      22 : "\"WHILE\" expected",
      23 : "\"ENDWHILE\" expected",
      24 : "\"COPY(\" expected",
      25 : "\"KEEP(\" expected",
      26 : "\"DISCARD(\" expected",
      27 : "\"-\" expected",
      28 : "\"+\" expected",
      29 : "\"*\" expected",
      30 : "\"/\" expected",
      31 : "\";\" expected",
      32 : "\"{\" expected",
      33 : "\"}\" expected",
      34 : "\"<\" expected",
      35 : "\">\" expected",
      36 : "??? expected",
      37 : "this symbol not expected in Word",
      38 : "invalid Word",
      39 : "invalid CompoundStatement",
      40 : "invalid Statement",
      41 : "invalid MathOp",
      42 : "invalid IntOrFloat",
      }