Changeset 1166 for proto/RE2PBS/bin


Ignore:
Timestamp:
Apr 26, 2011, 7:56:33 PM (8 years ago)
Author:
ksherdy
Message:

Add compilable template.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/RE2PBS/bin/re2pbs.py

    r1165 r1166  
    183183     
    184184     
    185 class PostValidator(Generator):
    186    
    187     """ Regular expression stream generator utilizing a post-validation strategy,
    188         i.e. Advance cursor(s). Validate.
    189        
    190         This approach requires regular expression symbol lookahead to
    191         determine 'Follow' lexical item streams for the identification of errors.
     185
     186class PreValidator(Generator):
     187   
     188    """ Regular expression stream generator using a pre-validation strategy,
     189        i.e. Validate. Advance cursor(s).
     190
     191        Create multiple instances via the FactoryGenerator class.
    192192    """
    193        
    194 #       TODO
    195 #
    196 #       (1) Implemeent method definition: make_follow_set_strm .
    197 #       (2) Add post validation error handling & deletion of cursor positions in error.
    198 #       (3) Add debug code.
    199 #
    200 
    201     def __init__(self, level=0, cursor='cursor', error='error'):
    202      
    203       print self.__class__.__name__ + ' not implemented.'
    204       sys.exit(1)
    205      
     193
     194    def __init__(self, level=0, cursor='cursor', error='error', debug=True):
    206195      Generator.__init__(self, level, cursor, error)
     196           
     197      self.debug = debug
     198      if (self.debug):
     199        self.re2pbs_debug_generator = DebugGenerator(level)
    207200   
    208201    def make_init_stmts(self, strm):
    209       code = self.indent_level  + PabloCode.Assign(self.error, '0') + '\n'
    210       code += self.indent_level + PabloCode.Assign(self.cursor, PabloCode.Nand(strm, PabloCode.Advance(strm)))  + '\n'
    211       return code
     202      code = []
     203
     204      #----- op 1 -----
     205      op = self.indent_level  + PabloCode.Assign(self.error, '0')
     206      code.append(op)
     207
     208      if (self.debug):
     209                label = self.indent_level + 'Init'
     210                self.re2pbs_debug_generator.add_stmt(label)
     211                label = self.indent_level + self.error
     212                self.re2pbs_debug_generator.add_stmt(label, self.error)
     213
     214      #----- op 2 -----
     215      op = self.indent_level + PabloCode.Assign(self.cursor, PabloCode.Nand(strm, PabloCode.Advance(strm)))
     216      code.append(op)
     217
     218      if (self.debug):
     219                label = self.indent_level + strm
     220                self.re2pbs_debug_generator.add_stmt(label, strm)
     221                self.re2pbs_debug_generator.add_stmt(op, self.cursor)
     222
     223      return '\n'.join(code) + '\n'
    212224   
    213225    def make_match_stmts(self, strm, quantifier=None, follow_set_strm=None):
     
    221233        return self.make_single_stmts(strm, follow_set_strm)
    222234       
    223     def make_single_stmts(self, strm, follow_set_strm=None):
    224       """ Cursor = Advance(Cursor)                      # C = C + C
    225           Error  = Cursor &~ FollowSet(Strm)            # E = C &~ F
    226           Cursor = Cursor &~ Error                      # C = C &~ E
    227       """
    228       code = self.indent_level + PabloCode.Assign(self.cursor, PabloCode.Advance(self.cursor)) + '\n'
    229       if(follow_set_strm != None):
    230             code += self.indent_level + PabloCode.OrEq(self.error, PabloCode.Nand(self.cursor, follow_set_strm)) + '\n'
    231       return code
    232 
    233     def make_optional_stmts(self, strm, follow_set_strm=None):
    234       """ Temp   = Cursor                                       # T = C
    235           Cursor = ScanThru(Cursor, (Strm & Cursor))            # C = ScanThru(C,(S & C)) OR C = C | Advance(C&S), this eliminates internal ScanThru addition.
    236           Error  = Cursor1 &~ Temp &~ FollowSet(Strm)           # E = C &~ T &~ F, since C &~ (T | F)
    237       """
    238       code = self.indent_level + PabloCode.Assign(self.cursor, PabloCode.ScanThru(self.cursor, PabloCode.And(self.cursor, strm))) + '\n'
    239       if(follow_set_strm != None):
    240             code += self.indent_level + PabloCode.OrEq(self.error, PabloCode.Nand(self.cursor, follow_set_strm)) + '\n'
    241       return code
    242    
    243     def make_kleene_star_stmts(self, strm, follow_set_strm=None):
    244       """ Temp   = Cursor                                       # T  = C
    245           Cursor = ScanThru(Cursor, Strm)                       # C  = ScanThru(C,S)         
    246           Error  = Cursor1 &~ Temp &~ FollowSet(Strm)           # E  = C &~ T &~ F, since C &~ (T | F)
    247       """
    248       code = self.indent_level + PabloCode.Assign(self.cursor, PabloCode.ScanThru(self.cursor, strm)) + '\n'
    249       if(follow_set_strm != None):
    250             code += self.indent_level + PabloCode.OrEq(self.error, PabloCode.Nand(self.cursor, follow_set_strm)) + '\n'
    251       return code
    252    
    253     def make_kleene_cross_stmts(self, strm, follow_set_strm=None):
    254       #code = self.make_single_stmts(strm)
    255       code = self.make_kleene_star_stmts(strm, follow_set_strm)
    256       return code
    257 
    258 class PreValidator(Generator):
    259    
    260     """ Regular expression stream generator using a pre-validation strategy,
    261         i.e. Validate. Advance cursor(s). """
    262 
    263     def __init__(self, level=0, cursor='cursor', error='error', debug=True):
    264       Generator.__init__(self, level, cursor, error)
    265            
    266       self.debug = debug
    267       if (self.debug):
    268         self.re2pbs_debug_generator = DebugGenerator(level)
    269    
    270     def make_init_stmts(self, strm):
     235    def make_single_stmts(self, strm, follow_set_strm=None):     
     236      # E = C &~ S
     237      # C = C &~ E
     238      # C = Advance(C)
     239
    271240      code = []
    272 
     241     
    273242      #----- op 1 -----
    274       op = self.indent_level  + PabloCode.Assign(self.error, '0')
    275       code.append(op)
    276 
    277       if (self.debug):
    278                 label = self.indent_level + 'Init'
     243      if (self.debug):
     244                label = self.indent_level + 'Single Character'
    279245                self.re2pbs_debug_generator.add_stmt(label)
    280                 label = self.indent_level + self.error
    281                 self.re2pbs_debug_generator.add_stmt(label, self.error)
    282 
    283       #----- op 2 -----
    284       op = self.indent_level + PabloCode.Assign(self.cursor, PabloCode.Nand(strm, PabloCode.Advance(strm)))
    285       code.append(op)
    286 
    287       if (self.debug):
     246                label = self.indent_level + self.cursor
     247                self.re2pbs_debug_generator.add_stmt(label, self.cursor)
    288248                label = self.indent_level + strm
    289249                self.re2pbs_debug_generator.add_stmt(label, strm)
     250     
     251      cursor = self.cursor
     252      op = self.indent_level + PabloCode.Assign(self.next_error(), PabloCode.Nand(cursor, strm))
     253      code.append(op)
     254
     255      if (self.debug):
     256                self.re2pbs_debug_generator.add_stmt(op, self.error)
     257
     258
     259      #----- op 2 -----
     260      cursor = self.cursor
     261      op = self.indent_level + PabloCode.Assign(self.next_cursor(), PabloCode.Nand(cursor, self.error))
     262      code.append(op)
     263
     264      if (self.debug):
    290265                self.re2pbs_debug_generator.add_stmt(op, self.cursor)
    291266
     267      #----- op 3 -----
     268      cursor = self.cursor
     269      op = self.indent_level + PabloCode.Assign(self.next_cursor(), PabloCode.Advance(cursor))
     270      code.append(op)
     271
     272      if (self.debug):
     273                self.re2pbs_debug_generator.add_stmt(op, self.cursor)
     274
     275
    292276      return '\n'.join(code) + '\n'
     277
     278    def make_optional_stmts(self, strm, follow_set_strm=None):
     279      # C = ScanThru(C, (C & S))
     280      code = []     
     281
     282      #----- op 1 -----
     283      if (self.debug):
     284                label = self.indent_level + 'Optional Character'
     285                self.re2pbs_debug_generator.add_stmt(label)
     286                label = self.indent_level + self.cursor
     287                self.re2pbs_debug_generator.add_stmt(label, self.cursor)
     288                label = self.indent_level + strm
     289                self.re2pbs_debug_generator.add_stmt(label, strm)
     290
     291      cursor = self.cursor
     292      op = self.indent_level + PabloCode.Assign(self.next_cursor(), PabloCode.ScanThru(self.cursor, PabloCode.And(cursor, strm)))
     293      code.append(op)
     294
     295      if (self.debug):
     296                self.re2pbs_debug_generator.add_stmt(op, self.cursor)
     297
     298      return '\n'.join(code) + '\n'
     299   
     300    def make_kleene_star_stmts(self, strm, follow_set_strm=None):
     301      # C = ScanThru(C, S)
     302      code = []
     303
     304      #----- op 1 -----
     305      if (self.debug):
     306                label = self.indent_level + 'Kleene Star'
     307                self.re2pbs_debug_generator.add_stmt(label)
     308                label = self.indent_level + self.cursor
     309                self.re2pbs_debug_generator.add_stmt(label, self.cursor)
     310                label = self.indent_level + strm
     311                self.re2pbs_debug_generator.add_stmt(label, strm)
     312
     313      cursor = self.cursor
     314      op = self.indent_level + PabloCode.Assign(self.next_cursor(), PabloCode.ScanThru(cursor, strm))
     315      code.append(op)
     316
     317      if (self.debug):
     318                self.re2pbs_debug_generator.add_stmt(op, self.cursor)
     319
     320      return '\n'.join(code) + '\n'
     321   
     322    def make_kleene_cross_stmts(self, strm, follow_set_strm=None):
     323      # E = C &~ S
     324      # C = C &~ E
     325      # C = Advance(C)
     326      # C = ScanThru(C, S)
     327      code = ''     
     328
     329      if (self.debug):
     330                label = self.indent_level + 'Kleene Cross'
     331                self.re2pbs_debug_generator.add_stmt(label)
     332
     333      code = self.make_single_stmts(strm)
     334      code += self.make_kleene_star_stmts(strm, follow_set_strm)
     335     
     336      return code
     337     
     338    def make_finalization_stmts(self):
     339     
     340      code = []
     341       
     342      if self.error_count > 0:
     343              label = self.indent_level + 'Finalize'
     344              self.re2pbs_debug_generator.add_stmt(label)
     345
     346              op = self.indent_level + PabloCode.Assign(self.next_error(), self.error_base + '_' + str(0))
     347              code.append(op)
     348
     349              if (self.debug):
     350                        self.re2pbs_debug_generator.add_stmt(op, self.error)
     351
     352
     353      for i in range(1, self.error_count):
     354              op = self.indent_level + PabloCode.OrEq(self.error, self.error_base + '_' + str(i))
     355              code.append(op)
     356
     357              if (self.debug):
     358                        self.re2pbs_debug_generator.add_stmt(op, self.error)
     359             
     360      return '\n'.join(code) + '\n'
     361
     362
     363    def make_debug_stmts(self):     
     364      code = ""
     365      if(self.debug):
     366        code = self.indent_level + self.re2pbs_debug_generator.make_debug_stmts()
     367
     368      return code
     369
     370class PostValidator(Generator):
     371   
     372    """ Regular expression stream generator utilizing a post-validation strategy,
     373        i.e. Advance cursor(s). Validate.
     374       
     375        This approach requires regular expression symbol lookahead to
     376        determine 'Follow' lexical item streams for the identification of errors.
     377       
     378        Create multiple instances via the FactoryGenerator class.
     379    """
     380       
     381#       TODO
     382#
     383#       (1) Implemeent method definition: make_follow_set_strm .
     384#       (2) Add post validation error handling & deletion of cursor positions in error.
     385#       (3) Add debug code.
     386#
     387
     388    def __init__(self, level=0, cursor='cursor', error='error'):
     389     
     390      print self.__class__.__name__ + ' not implemented.'
     391      sys.exit(1)
     392     
     393      Generator.__init__(self, level, cursor, error)
     394   
     395    def make_init_stmts(self, strm):
     396      code = self.indent_level  + PabloCode.Assign(self.error, '0') + '\n'
     397      code += self.indent_level + PabloCode.Assign(self.cursor, PabloCode.Nand(strm, PabloCode.Advance(strm)))  + '\n'
     398      return code
    293399   
    294400    def make_match_stmts(self, strm, quantifier=None, follow_set_strm=None):
     
    302408        return self.make_single_stmts(strm, follow_set_strm)
    303409       
    304     def make_single_stmts(self, strm, follow_set_strm=None):     
    305       # E = C &~ S
    306       # C = C &~ E
    307       # C = Advance(C)
    308 
    309       code = []
    310      
    311       #----- op 1 -----
    312       if (self.debug):
    313                 label = self.indent_level + 'Single Character'
    314                 self.re2pbs_debug_generator.add_stmt(label)
    315                 label = self.indent_level + self.cursor
    316                 self.re2pbs_debug_generator.add_stmt(label, self.cursor)
    317                 label = self.indent_level + strm
    318                 self.re2pbs_debug_generator.add_stmt(label, strm)
    319      
    320       cursor = self.cursor
    321       op = self.indent_level + PabloCode.Assign(self.next_error(), PabloCode.Nand(cursor, strm))
    322       code.append(op)
    323 
    324       if (self.debug):
    325                 self.re2pbs_debug_generator.add_stmt(op, self.error)
    326 
    327 
    328       #----- op 2 -----
    329       cursor = self.cursor
    330       op = self.indent_level + PabloCode.Assign(self.next_cursor(), PabloCode.Nand(cursor, self.error))
    331       code.append(op)
    332 
    333       if (self.debug):
    334                 self.re2pbs_debug_generator.add_stmt(op, self.cursor)
    335 
    336       #----- op 3 -----
    337       cursor = self.cursor
    338       op = self.indent_level + PabloCode.Assign(self.next_cursor(), PabloCode.Advance(cursor))
    339       code.append(op)
    340 
    341       if (self.debug):
    342                 self.re2pbs_debug_generator.add_stmt(op, self.cursor)
    343 
    344 
    345       return '\n'.join(code) + '\n'
     410    def make_single_stmts(self, strm, follow_set_strm=None):
     411      """ Cursor = Advance(Cursor)                      # C = C + C
     412          Error  = Cursor &~ FollowSet(Strm)            # E = C &~ F
     413          Cursor = Cursor &~ Error                      # C = C &~ E
     414      """
     415      code = self.indent_level + PabloCode.Assign(self.cursor, PabloCode.Advance(self.cursor)) + '\n'
     416      if(follow_set_strm != None):
     417            code += self.indent_level + PabloCode.OrEq(self.error, PabloCode.Nand(self.cursor, follow_set_strm)) + '\n'
     418      return code
    346419
    347420    def make_optional_stmts(self, strm, follow_set_strm=None):
    348       # C = ScanThru(C, (C & S))
    349       code = []     
    350 
    351       #----- op 1 -----
    352       if (self.debug):
    353                 label = self.indent_level + 'Optional Character'
    354                 self.re2pbs_debug_generator.add_stmt(label)
    355                 label = self.indent_level + self.cursor
    356                 self.re2pbs_debug_generator.add_stmt(label, self.cursor)
    357                 label = self.indent_level + strm
    358                 self.re2pbs_debug_generator.add_stmt(label, strm)
    359 
    360       cursor = self.cursor
    361       op = self.indent_level + PabloCode.Assign(self.next_cursor(), PabloCode.ScanThru(self.cursor, PabloCode.And(cursor, strm)))
    362       code.append(op)
    363 
    364       if (self.debug):
    365                 self.re2pbs_debug_generator.add_stmt(op, self.cursor)
    366 
    367       return '\n'.join(code) + '\n'
     421      """ Temp   = Cursor                                       # T = C
     422          Cursor = ScanThru(Cursor, (Strm & Cursor))            # C = ScanThru(C,(S & C)) OR C = C | Advance(C&S), this eliminates internal ScanThru addition.
     423          Error  = Cursor1 &~ Temp &~ FollowSet(Strm)           # E = C &~ T &~ F, since C &~ (T | F)
     424      """
     425      code = self.indent_level + PabloCode.Assign(self.cursor, PabloCode.ScanThru(self.cursor, PabloCode.And(self.cursor, strm))) + '\n'
     426      if(follow_set_strm != None):
     427            code += self.indent_level + PabloCode.OrEq(self.error, PabloCode.Nand(self.cursor, follow_set_strm)) + '\n'
     428      return code
    368429   
    369430    def make_kleene_star_stmts(self, strm, follow_set_strm=None):
    370       # C = ScanThru(C, S)
    371       code = []
    372 
    373       #----- op 1 -----
    374       if (self.debug):
    375                 label = self.indent_level + 'Kleene Star'
    376                 self.re2pbs_debug_generator.add_stmt(label)
    377                 label = self.indent_level + self.cursor
    378                 self.re2pbs_debug_generator.add_stmt(label, self.cursor)
    379                 label = self.indent_level + strm
    380                 self.re2pbs_debug_generator.add_stmt(label, strm)
    381 
    382       cursor = self.cursor
    383       op = self.indent_level + PabloCode.Assign(self.next_cursor(), PabloCode.ScanThru(cursor, strm))
    384       code.append(op)
    385 
    386       if (self.debug):
    387                 self.re2pbs_debug_generator.add_stmt(op, self.cursor)
    388 
    389       return '\n'.join(code) + '\n'
     431      """ Temp   = Cursor                                       # T  = C
     432          Cursor = ScanThru(Cursor, Strm)                       # C  = ScanThru(C,S)         
     433          Error  = Cursor1 &~ Temp &~ FollowSet(Strm)           # E  = C &~ T &~ F, since C &~ (T | F)
     434      """
     435      code = self.indent_level + PabloCode.Assign(self.cursor, PabloCode.ScanThru(self.cursor, strm)) + '\n'
     436      if(follow_set_strm != None):
     437            code += self.indent_level + PabloCode.OrEq(self.error, PabloCode.Nand(self.cursor, follow_set_strm)) + '\n'
     438      return code
    390439   
    391440    def make_kleene_cross_stmts(self, strm, follow_set_strm=None):
    392       # E = C &~ S
    393       # C = C &~ E
    394       # C = Advance(C)
    395       # C = ScanThru(C, S)
    396       code = ''     
    397 
    398       if (self.debug):
    399                 label = self.indent_level + 'Kleene Cross'
    400                 self.re2pbs_debug_generator.add_stmt(label)
    401 
    402       code = self.make_single_stmts(strm)
    403       code += self.make_kleene_star_stmts(strm, follow_set_strm)
    404      
    405       return code
    406      
    407     def make_finalization_stmts(self):
    408      
    409       code = []
    410        
    411       if self.error_count > 0:
    412               label = self.indent_level + 'Finalize'
    413               self.re2pbs_debug_generator.add_stmt(label)
    414 
    415               op = self.indent_level + PabloCode.Assign(self.next_error(), self.error_base + '_' + str(0))
    416               code.append(op)
    417 
    418               if (self.debug):
    419                         self.re2pbs_debug_generator.add_stmt(op, self.error)
    420 
    421 
    422       for i in range(1, self.error_count):
    423               op = self.indent_level + PabloCode.OrEq(self.error, self.error_base + '_' + str(i))
    424               code.append(op)
    425 
    426               if (self.debug):
    427                         self.re2pbs_debug_generator.add_stmt(op, self.error)
    428              
    429       return '\n'.join(code) + '\n'
    430 
    431 
    432     def make_debug_stmts(self):     
    433       code = ""
    434       if(self.debug):
    435         code = self.indent_level + self.re2pbs_debug_generator.make_debug_stmts()
    436 
    437       return code
    438        
     441      #code = self.make_single_stmts(strm)
     442      code = self.make_kleene_star_stmts(strm, follow_set_strm)
     443      return code
     444
     445# --------------------------------------------------------------------------------
    439446class DebugGenerator:
    440447    def __init__(self, level=0):
     448      """ Object to accumulate and generate 'bitutil.print_aligned_streams' debug statements. """
    441449      self.indent_level = PabloCode.indent(level)
    442450      self.header = 'bitutil.print_aligned_streams([(\''+ self.indent_level + 'Input Data\', u8data), \n'
     
    451459      return self.header + ',\n'.join(self.stmts) + self.footer + '\n'
    452460
     461# --------------------------------------------------------------------------------
     462import string     
     463     
     464class Program:
     465  def __init__(self, template = "template.py",  out_file='out.py'):
     466      """ Object to generates Python parallel bit stream template code via search and replace of template labels '@label_name' """
     467      self.template = template
     468      self.out_file = out_file
     469      self.contents = readfile(template)     
     470   
     471  def generate(self, lex_strms, cc_code, pbs_code, pbs_debug=''):   
     472      self.contents = string.replace(self.contents, '@lex_strms', lex_strms)
     473      self.contents = string.replace(self.contents, '@cc_code', cc_code)
     474      self.contents = string.replace(self.contents, '@pbs_code', pbs_code)
     475      self.contents = string.replace(self.contents, '@pbs_debug', pbs_debug)
     476      writefile(self.out_file, self.contents)
     477
     478# --------------------------------------------------------------------------------
    453479def readfile(filename):
    454480      f = open(filename, 'r')
     
    461487      f.write(contents)
    462488      f.close()
    463      
    464 import string     
    465      
    466 class Program:
    467   def __init__(self, prototype='prototype.py', template = "prototype_template.py"):
    468       self.prototype = prototype
    469       self.template = template
    470       self.contents = readfile(template)     
    471    
    472   def generate(self, lex_strms, cc_code, pbs_code, pbs_debug=''):   
    473       self.contents = string.replace(self.contents, '@lex_strms', lex_strms)
    474       self.contents = string.replace(self.contents, '@cc_code', cc_code)
    475       self.contents = string.replace(self.contents, '@pbs_code', pbs_code)
    476       self.contents = string.replace(self.contents, '@pbs_debug', pbs_debug)
    477       writefile(self.prototype, self.contents)
     489
    478490
    479491def test():
Note: See TracChangeset for help on using the changeset viewer.