예제 #1
0
파일: database.py 프로젝트: prjemian/iocdoc
    def _parse_record(self, tokenLog):
        tok = tokenLog.nextActionable()
        ref = self._make_ref(tok)
        rtype, rname = tokenLog.tokens_to_list()
        # just parsing, no need for macros now
        record_object = record.Record(self, rtype, rname, ref)
        self.record_list.append(record_object)

        tok = tokenLog.nextActionable()
        if token_key(tok) == 'OP {':
            tok = tokenLog.nextActionable()
            # get record's field definitions
            while token_key(tok) != 'OP }':
                ref = self._make_ref(tok, tok['tokStr'])
                tk = token_key(tok)
                if tk == 'NAME field':
                    tok = tokenLog.nextActionable()
                    ref = self._make_ref(tok)
                    field, value = parse_bracketed_macro_definitions(tokenLog)
                    record_object.addFieldPattern(field, value.strip('"'), self, ref)
                    #tok = tokenLog.previous()   # backup before advancing below
                elif tk == 'NAME alias':
                    self._parse_alias(tokenLog, record_object, ref)
                elif tk == 'NAME info':
                    self._parse_info(tokenLog, record_object, ref)
                else:
                    tok = tokenLog.getCurrentToken()
                    msg = str(ref)
                    msg += ' unexpected content: |%s|' % str(tok['tokStr'])
                    msg += ' in file: ' + str(ref)
                    raise RuntimeError(msg)
                tok = tokenLog.nextActionable()
예제 #2
0
파일: database.py 프로젝트: prjemian/iocdoc
 def parse(self):
     '''interpret records for PV declarations'''
     tokenLog = TokenLog()
     tokenLog.processFile(self.filename_expanded)
     tok = tokenLog.nextActionable()
     actions = {
                #'NAME alias': self._parse_alias,
                #'NAME info': self._parse_info,
                'NAME grecord': self._parse_record,
                'NAME record': self._parse_record,
                }
     while tok is not None:
         tk = token_key(tok)
         if tk in actions:
             actions[tk](tokenLog)
         tok = tokenLog.nextActionable()
예제 #3
0
파일: template.py 프로젝트: prjemian/iocdoc
 def parse(self):
     '''
     interpret the template file for database declarations
     
     The Python tokenizer makes simple work of parsing database files.
     The TokenLog class interprets the contents according to a few simple terms
     such as NAME, OP, COMMENT, NEWLINE.
     '''
     tokenLog = TokenLog()
     tokenLog.processFile(self.filename_expanded)
     tok = tokenLog.nextActionable()
     actions = {
                'NAME file': self._parse_file_statement,
                'NAME global': self._parse_globals_statement,
                }
     while tok is not None:
         tk = token_key(tok)
         if tk in actions:
             actions[tk](tokenLog)
         tok = tokenLog.nextActionable()
예제 #4
0
 def parse(self):
     '''analyze this command file'''
     tokenLog = TokenLog()
     tokenLog.processFile(self.filename_absolute)
     lines = tokenLog.lineAnalysis()
     del lines['numbers']
     for _lineNumber, line in sorted(lines.items()):
         isNamePattern = line['pattern'].startswith( 'NAME' )
         tk = token_key(line['tokens'][0])
         if isNamePattern or tk == 'OP <':
             arg0 = line['tokens'][0]['tokStr']
             ref = self._make_ref(line['tokens'][0], arg0)
             if line['tokens'][1]['tokStr'] == '=':
                 # this is a symbol assignment
                 handler = self.kh_symbol
                 handler(arg0, line['tokens'], ref)
             elif arg0 in self.knownHandlers:
                 # command arg0 has a known handler, call it
                 handler = self.knownHandlers[arg0]
                 handler(arg0, line['tokens'], ref)
             else:
                 self.kh_shell_command(arg0, line['tokens'], ref)
예제 #5
0
파일: template.py 프로젝트: prjemian/iocdoc
 def _parse_globals_statement(self, tokenLog):
     '''
     support the *globals* statement in a template file
     
     This statement was new starting with EPICS base 3.15
     
     example::
     
         global { P=12ida1:,SCANREC=12ida1:scan1 }
     
     '''
     ref = self._make_ref(tokenLog.getCurrentToken(), 'global macros')
     # TODO: How to remember where the globals were defined?
     tok = tokenLog.nextActionable()
     if token_key(tok) == 'OP {':
         kv = parse_bracketed_macro_definitions(tokenLog)
         ref = self._make_ref(tok, kv)
         # TODO: Do something with ref
         self.macros.setMany(**kv)
     else:
         msg = '(%s,%d,%d) ' % (self.filename, tok['start'][0], tok['start'][1])
         msg += 'missing "{" in globals statement'
         raise DatabaseTemplateException(msg)
예제 #6
0
파일: template.py 프로젝트: prjemian/iocdoc
    def _parse_file_statement(self, tokenLog):
        '''
        support the *file* statement in a template file
        
        example::
        
            file "$(SSCAN)/sscanApp/Db/scanParms.db"
        
        '''
        ref = self._make_ref(tokenLog.getCurrentToken(), 'database file')
        # TODO: Do something with ref
        
        # if no enclosing quotes, '$" is an ERRORTOKEN
        skip_list = 'COMMENT NEWLINE ENDMARKER INDENT DEDENT'.split()
        tok = tokenLog.nextActionable(skip_list)   # move past the "file" command
        tk = token_key(tok)
        text = ''
        while tk != 'OP {':
            text += tok['tokStr']
            tok = tokenLog.nextActionable(skip_list)
            tk = token_key(tok)
        dbFileName = utils.strip_outer_quotes(text.strip())
        fname = self.macros.replace(dbFileName)

        tok = tokenLog.nextActionable()

        # When there is a "pattern" statement, 
        # the macro labels are given first, 
        # then (later) values in each declaration (usually multiple sets)
        pattern_keys = []
        if token_key(tok) == 'NAME pattern':
            tok = tokenLog.nextActionable()
            pattern_keys = tokenLog.tokens_to_list()
            tok = tokenLog.nextActionable()     # skip past the closing }
        
        while token_key(tok) != 'OP }':
            # define the macros for this set
            pattern_macros = macros.Macros()
            if len(pattern_keys) > 0:
                # The macro labels were defined in a pattern statement
                value_list = tokenLog.tokens_to_list()
                kv = dict(zip(pattern_keys, value_list))
                pattern_macros.setMany(**kv)
                tok = tokenLog.nextActionable()
            else:
                # No pattern statement, macro labels are defined with the values
                tok = tokenLog.getCurrentToken()
                kv = tokenLog.getKeyValueSet()
                pattern_macros.setMany(**kv)
                tok = tokenLog.nextActionable()
            
            ref = self._make_ref(tokenLog.getCurrentToken())
            # TODO: work out how to get the path into the next statement
            arg_text = '("' + dbFileName + '")'
            if len(pattern_macros) > 0:
                arg_text = '("' + dbFileName
                arg_text += ', "'
                arg_text += ','.join([k+'='+v for k, v in sorted(pattern_macros.items())])
                arg_text += '")'
            pattern_macros.setMany(**self.macros.db)
            cmd = command_file.Command(self, 
                                       '(dbLoadRecords)', 
                                       'path unknown', 
                                       arg_text, 
                                       ref, 
                                       **pattern_macros.db)
            self.commands.append(cmd)
            dbg = database.Database(self, fname, ref, **pattern_macros.db)
            self.database_list.append(dbg)