Changeset 237


Ignore:
Timestamp:
07/27/2010 05:44:15 PM (12 years ago)
Author:
marcus
Message:

Concat operator for command procedures.

Location:
SHX/trunk/src/SeismicHandler
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • SHX/trunk/src/SeismicHandler/core/parser.py

    r236 r237  
    257257                    inputdata = inputdata.upper() 
    258258 
     259                self.filename = inputdata 
     260                 
    259261                # look for file in search path 
    260262                for folder in self.searchpath: 
     
    315317        self.targets = targets 
    316318 
     319    def traceBack(self): 
     320        pass 
     321     
    317322    def run(self): 
    318323        while True: 
     
    324329 
    325330                cmd = parse(cmd).parsed 
     331 
     332                # translate variables 
     333                _ = translate(cmd, self) 
    326334 
    327335                # Check for internal command ... 
     
    335343                # or execute command... 
    336344                elif cmd["shx_command"] in commands.list: 
    337                     # translate variables 
    338                     _ = translate(cmd, self) 
    339  
    340345                    if Settings.swVerify: 
    341346                        print cmd["shx_translated"] 
     
    521526        # translate parameters 
    522527        for i, p in enumerate(cmd["shx_parameter"]): 
    523             if p[0] not in '"$^#%': 
    524                 continue 
    525  
    526             id = p[0] 
    527             # system 
    528             if id == "$": 
    529                 cmd["shx_parameter"][i] = self.handleSystem(p[1:]) 
    530             # symbols 
    531             elif id == '"': 
    532                 cmd["shx_parameter"][i] = self.handleSymbol(p[1:]) 
    533             # trace XXX 
    534             elif id == '^': 
    535                 cmd["shx_parameter"][i] = self.handleTrace(p[1:]) 
    536             # options at startup XXX 
    537             elif id == '#': 
    538                 cmd["shx_parameter"][i] = self.handleOption(p[1:]) 
    539             # file XXX 
    540             elif id == '%': 
    541                 cmd["shx_parameter"][i] = self.handleFile(p[1:]) 
     528            cmd["shx_parameter"][i] = self.__translate(p) 
    542529 
    543530        # translate qualifiers 
     
    549536                continue 
    550537 
    551             id = p[0] 
    552  
    553             if id == "$": 
    554                 cmd["shx_qualifiers"][q] = self.handleSystem(p[1:]) 
    555             elif id == '"': 
    556                 cmd["shx_qualifiers"][q] = self.handleSymbol(p[1:]) 
    557             elif id == '^': 
    558                 cmd["shx_qualifiers"][q] = self.handleTrace(p[1:]) 
    559             elif id == '#': 
    560                 cmd["shx_qualifiers"][q] = self.handleOption(p[1:]) 
    561             elif id == '%': 
    562                 cmd["shx_qualifiers"][q] = self.handleFile(p[1:]) 
     538            cmd["shx_qualifiers"][q] = self.__translate(p) 
    563539 
    564540        # Actually this is only for debugging purposes. 
     
    580556        ]) 
    581557 
     558    def __translate(self, value): 
     559        idmap = { 
     560            '$': self.handleSystem, 
     561            '"': self.handleSymbol, 
     562            '^': self.handleTrace, 
     563            '#': self.handleOption, 
     564            '%': self.handleFile, 
     565        } 
     566 
     567        id = value[0] 
     568 
     569        # concat operator 
     570        if id == "|": 
     571            parts = filter(None, value.split("|")) 
     572            newparts = [self.__translate(i) for i in parts] 
     573            return "".join(newparts) 
     574 
     575        if id not in idmap.keys(): 
     576            return value 
     577 
     578        value = value[1:] 
     579 
     580        return idmap[id](value) 
     581 
    582582    def handleSystem(self, name): 
    583583        try: 
  • SHX/trunk/src/SeismicHandler/tests/test_parser.py

    r236 r237  
    3333 
    3434    def tearDown(self): 
     35        """ 
     36        Remove left-overs. 
     37        """ 
     38 
    3539        try: 
    3640            os.unlink(self.outfile + ".STX") 
     
    3943 
    4044    def addEchoChannel(self, data): 
     45        """ 
     46        Add envelope to commands in order to catch output. 
     47        """ 
    4148        data.insert(0, "echo_ch %s" % self.outfile) 
    4249        data.append("echo_ch") 
     
    4552 
    4653    def callScript(self, data): 
     54        """ 
     55        Take a list of commands, execute them and return output produced. 
     56        """ 
    4757        data = "\n".join(self.addEchoChannel(data.splitlines())) 
    4858 
     
    5666 
    5767    def getResults(self): 
     68        """ 
     69        Read and return output. 
     70        """ 
    5871        return open(self.outfile + ".STX").read() 
    5972 
    6073    def testEcho1(self): 
     74        """ 
     75        Text output with/out newline and case conversion. 
     76        """ 
    6177        script = """ 
    6278        echo foo /NO_CRLF 
     
    6985 
    7086    def testEcho2(self): 
     87        """ 
     88        Non-existing symbol. 
     89        """ 
    7190        script = """ 
    7291        echo "foo 
     
    7594        self.assertRaises(Exception, self.callScript, script) 
    7695 
     96    def testEcho3(self): 
     97        """ 
     98        Concat operator. 
     99        """ 
     100        script = """ 
     101        echo |foo|bar|$DOLLAR| /NO_CRLF 
     102        """ 
     103        expect = "FOOBAR$" 
     104 
     105        res = self.callScript(script) 
     106        self.assertEqual(res, expect) 
     107 
    77108    def testSdef(self): 
     109        """ 
     110        Define and delete user symbols. Local symbols mask global ones. 
     111        """ 
    78112        script = """ 
    79113        sdef foo 1 
     
    90124        self.assertEqual(res, expect) 
    91125 
    92  
    93126    def testSystem(self): 
     127        """ 
     128        Some system variables. 
     129        """ 
    94130        script = """ 
    95131        echo $DOLLAR /NO_CRLF 
     
    105141 
    106142    def testSwitch1(self): 
     143        """ 
     144        Stop on error or just a warning. 
     145        """ 
    107146        script = """ 
    108147        switch cmderrstop off 
     
    119158 
    120159    def testSwitch2(self): 
     160        """ 
     161        Global case conversion. 
     162        """ 
    121163        script = """ 
    122164        switch capconv off 
     
    131173 
    132174    def testSwitch3(self): 
     175        """ 
     176        Unknown switch. 
     177        """ 
    133178        script = """ 
    134179        switch foo on 
     
    138183 
    139184    def testReturn(self): 
     185        """ 
     186        Return from script. 
     187        """ 
    140188        # the explicit "echo_ch" closes output stream in order to flush contents 
    141189        script = """ 
Note: See TracChangeset for help on using the changeset viewer.