Changeset 972 for specdomain/trunk


Ignore:
Timestamp:
Jun 24, 2012 11:39:20 PM (10 years ago)
Author:
jemian
Message:

cleanups

File:
1 edited

Legend:

Unmodified
Added
Removed
  • specdomain/trunk/src/specdomain/sphinxcontrib/specmacrofileparser.py

    r966 r972  
    3737extended_comment_match      = r'(' + extended_comment_marker + r')'
    3838
    39 macro_sig_re = re.compile(
    40                                r'''^ ([a-zA-Z_]\w*)         # macro name
    41                                ''', re.VERBOSE)
    42 
    43 func_sig_re = re.compile(word_match + r'\('
    44                       + r'(' + match_all + r')'
    45                       + r'\)',
    46                       re.IGNORECASE|re.DOTALL)
    47 
    48 cdef_name_sig_re = re.compile(double_quote_string_match,
    49                                    re.IGNORECASE|re.DOTALL)
    50 
    51 
    52 extended_comment_flag_sig_re = re.compile(extended_comment_marker,
    53                                                re.IGNORECASE|re.DOTALL)
    54 extended_comment_start_sig_re = re.compile(string_start
    55                                                 + non_greedy_whitespace
    56                                                 + extended_comment_match,
    57                                                 re.IGNORECASE|re.VERBOSE)
    58 extended_comment_end_sig_re = re.compile(non_greedy_whitespace
    59                                                 + extended_comment_match
    60                                                 + non_greedy_whitespace
    61                                                 + r'#' + non_greedy_filler
    62                                                 + string_end,
    63                                                 re.IGNORECASE|re.VERBOSE)
    64 extended_comment_block_sig_re = re.compile(string_start
    65                                                 + non_greedy_whitespace
    66                                                 + extended_comment_marker
    67                                                 + r'(' + non_greedy_filler + r')'
    68                                                 + extended_comment_marker
    69                                                 + non_greedy_filler
    70                                                 + string_end,
    71                                                 re.IGNORECASE|re.DOTALL|re.MULTILINE)
    72 lgc_variable_sig_re = re.compile(string_start
    73                                     + non_greedy_whitespace
    74                                     + r'(local|global|constant)'
    75                                     + r'((?:,?\s*@?[\w.eE+-]+\[?\]?)*)'
    76                                     + non_greedy_whitespace
    77                                     + r'#' + non_greedy_filler
    78                                     + string_end,
    79                                     re.VERBOSE)
     39#    macro_sig_re = re.compile(
     40#                                   r'''^ ([a-zA-Z_]\w*)         # macro name
     41#                                   ''', re.VERBOSE)
     42#   
     43#    func_sig_re = re.compile(word_match + r'\('
     44#                          + r'(' + match_all + r')'
     45#                          + r'\)',
     46#                          re.IGNORECASE|re.DOTALL)
     47#   
     48#    cdef_name_sig_re = re.compile(double_quote_string_match,
     49#                                       re.IGNORECASE|re.DOTALL)
     50#   
     51#   
     52#    extended_comment_flag_sig_re = re.compile(extended_comment_marker,
     53#                                                   re.IGNORECASE|re.DOTALL)
    8054
    8155# TODO: handle "#: " indicating a description of a variable on the preceding line
     
    9266        The first and simplest thing to do is to read the .mac file and only extract
    9367        all the extended comments and add them as nodes to the current document.
     68   
     69    Assume macro definitions are not nested (but test for this).
    9470       
    9571    An additional step would be to parse for:
     
    11187        'rdef macro',           # inside a multiline rdef macro definition
    11288        'cdef macro',           # inside a multiline cdef macro definition
     89        'parsed',               # parsing of file is complete
    11390    )
    11491
     
    143120        self.state_stack = []
    144121        for line in self.buf.split('\n'):
    145             m = None
     122
     123            line_number += 1
    146124            if self.state not in self.states:
    147                 raise RuntimeError, "unexpected parser state: " + self.state
    148             line_number += 1
     125                # this quickly points out a programmer error
     126                msg = "unexpected parser state: %s, line %s" % (self.state, line_number)
     127                raise RuntimeError, msg
     128
    149129            if self.state == 'global':
    150 
    151130                if self._is_lgc_variable(line, line_number):
    152131                    continue
    153 
    154132                if self._is_one_line_extended_comment(line, line_number):
    155133                    continue
    156 
    157134                if self._is_multiline_start_extended_comment(line, line_number):
    158135                    continue
    159 
    160136            elif self.state == 'extended comment':
    161 
    162137                if not self._is_multiline_end_extended_comment(line, line_number):
    163138                    # multiline extended comment continues
    164139                    self.ec['text'].append(line)
    165140                continue
    166 
    167141            elif self.state == 'def macro':
    168142                pass
    169 
    170143            elif self.state == 'cdef macro':
    171144                pass
    172 
    173145            elif self.state == 'rdef macro':
    174146                pass
    175    
     147       
     148        if len(self.state_stack) > 0:
     149            fmt = "encountered EOF while parsing %s, line %d, in state %s, stack=%s"
     150            msg = fmt % (self.filename, line_number, self.state, self.state_stack)
     151            raise RuntimeWarning, msg
     152
     153        self.state = 'parsed'
     154       
     155    lgc_variable_sig_re = re.compile(string_start
     156                                        + non_greedy_whitespace
     157                                        + r'(local|global|constant)'
     158                                        + r'((?:,?\s*@?[\w.eE+-]+\[?\]?)*)'
     159                                        + non_greedy_whitespace
     160                                        + r'#' + non_greedy_filler
     161                                        + string_end,
     162                                        re.VERBOSE)
     163
    176164    def _is_lgc_variable(self, line, line_number):
    177165        ''' local, global, or constant variable declaration '''
    178         m = self._match(lgc_variable_sig_re, line)
     166        m = self._search(self.lgc_variable_sig_re, line)
    179167        if m is None:
    180168            return False
    181         objtype, args = lgc_variable_sig_re.match(line).groups()
     169       
     170        objtype, args = self.lgc_variable_sig_re.match(line).groups()
    182171        pos = args.find('#')
    183172        if pos > -1:
     
    193182            # TODO: consider not indexing "global" inside a def
    194183            # TODO: consider not indexing "local" at global level
     184            #      or leave these decisions for later, including some kind of analyzer
    195185            for var in args.split():
    196186                m['text'] = var.rstrip(',')
     
    199189        return True
    200190   
     191    extended_comment_block_sig_re = re.compile(string_start
     192                                                + non_greedy_whitespace
     193                                                + extended_comment_marker
     194                                                + r'(' + non_greedy_filler + r')'
     195                                                + extended_comment_marker
     196                                                + non_greedy_filler
     197                                                + string_end,
     198                                                re.IGNORECASE|re.DOTALL|re.MULTILINE)
     199
    201200    def _is_one_line_extended_comment(self, line, line_number):
    202         m = self._match(extended_comment_block_sig_re, line)
     201        m = self._search(self.extended_comment_block_sig_re, line)
    203202        if m is None:
    204203            return False
     
    209208        self.findings.append(dict(m))
    210209        return True
     210    extended_comment_start_sig_re = re.compile(string_start
     211                                                + non_greedy_whitespace
     212                                                + extended_comment_match,
     213                                                re.IGNORECASE|re.VERBOSE)
    211214   
    212215    def _is_multiline_start_extended_comment(self, line, line_number):
    213         m = self._match(extended_comment_start_sig_re, line)
     216        m = self._search(self.extended_comment_start_sig_re, line)
    214217        if m is None:
    215218            return False
     
    224227        return True
    225228
     229    extended_comment_end_sig_re = re.compile(non_greedy_whitespace
     230                                                + extended_comment_match
     231                                                + non_greedy_whitespace
     232                                                + r'#' + non_greedy_filler
     233                                                + string_end,
     234                                                re.IGNORECASE|re.VERBOSE)
     235
    226236    def _is_multiline_end_extended_comment(self, line, line_number):
    227         m = self._match(extended_comment_end_sig_re, line)
     237        m = self._search(self.extended_comment_end_sig_re, line)
    228238        if m is None:
    229239            return False
     
    237247        return True
    238248   
    239     def _match(self, regexp, line):
     249    def _search(self, regexp, line):
     250        '''regular expression search of line, returns a match as a dictionary or None'''
    240251        m = regexp.search(line)
    241252        if m is None:
    242253            return None
     254        # TODO: define a parent key somehow
    243255        d = {
    244256            'start': m.start(1),
     
    266278    def ReST(self):
    267279        """create the ReStructured Text from what has been found"""
     280        if self.state == 'parsed':
     281            raise RuntimeWarning, "state = %s, should be 'parsed'" % self.filename
     282           
    268283        s = []
    269284        declarations = []
     
    282297        if len(declarations) > 0:
    283298            col_keys = ('text', 'objtype', 'start_line', 'end_line', )
    284             widths = {}
    285             for key in col_keys:
    286                 widths[key] = len( str(key) )
     299            widths = dict([( key, len(str(key)) ) for key in col_keys])
    287300            for d in declarations:
    288                 for key, w in widths.items():
    289                     widths[key] = max(w, len( str(d[key]) ) )
     301                widths = dict([( key, max(w, len(str(d[key])))) for key, w in widths.items()])
    290302            separator = " ".join( ["="*widths[key] for key in col_keys] )
    291             format = " ".join( ["%%-%ds"%widths[key] for key in col_keys] )
     303            fmt = " ".join( ["%%-%ds"%widths[key] for key in col_keys] )
    292304            s.append( '' )
    293             s.append( '.. rubric:: Variable Declarations:' )
     305#            s.append( '.. rubric:: Variable Declarations:' )
     306            s.append( 'Variable Declarations' )
     307            s.append( '=====================' )
    294308            s.append( '' )
    295309            s.append( separator )
    296             #s.append( " ".join( [str(key) for key in col_keys]) )
    297             s.append( format % tuple([str(key) for key in col_keys]) )
     310            s.append( fmt % tuple([str(key) for key in col_keys]) )
    298311            s.append( separator )
    299312            for d in declarations:
    300                 s.append( format % tuple([str(d[key]) for key in col_keys]) )
     313                s.append( fmt % tuple([str(d[key]) for key in col_keys]) )
    301314            s.append( separator )
    302315        return '\n'.join(s)
Note: See TracChangeset for help on using the changeset viewer.