Changeset 441


Ignore:
Timestamp:
08/25/2011 05:05:49 PM (11 years ago)
Author:
marcus
Message:

doctests for parsing functions pass again

Location:
SHX/trunk
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed
  • SHX/trunk/SeismicHandler/basics/command.py

    r439 r441  
    9191            pass 
    9292 
    93         msgs.sendMessage("log.debug.command", msg=self.__class__.__name__) 
     93        msgs.sendMessage("log.debug.command", message=self.__class__.__name__) 
    9494 
    9595        if hasattr(self, "run"): 
  • SHX/trunk/SeismicHandler/basics/error.py

    r437 r441  
    11# -*- coding: utf-8 -*- 
    22# 
    3 # Copyright (C) 2008-2010 Marcus Walther (walther@szgrf.bgr.de) 
     3# Copyright (C) 2008-2011 Marcus Walther (walther@szgrf.bgr.de) 
    44# 
    55# This file is part of Seismic Handler eXtended (SHX) 
     
    2323 
    2424from SeismicHandler.modules.messages import MessageSystem as msgs 
    25 from SeismicHandler.basics import Singleton 
    2625 
    27 __all__ = ['ShxError', 'ShxWarning'] 
     26__all__ = ['ShxError'] 
    2827 
    2928class Error(Exception): 
     
    3231    """ 
    3332 
    34     __metaclass__ = Singleton 
    35      
    3633    def __init__(self): 
    37         try: 
    38             level = self.level 
    39         except AttributeError: 
    40             level = "debug" 
    41  
    4234        # log message 
    43         msgs.sendMessage("log.%s" % level, msg=str(self)) 
     35        msgs.sendMessage("log.error", message=str(self)) 
    4436 
    4537    def __str__(self): 
     
    5547    def __init__(self, value): 
    5648        self.value = value 
    57         self.level = "error" 
    5849        Error.__init__(self) 
    5950     
    6051 
    61 class ShxWarning(Error): 
    62     """ 
    63     Standard warning. 
    64     """ 
    65  
    66     def __init__(self, value): 
    67         self.value = value 
    68         self.level = "warning" 
    69         Error.__init__(self) 
    70  
    71  
    7252if __name__ == "__main__": 
    7353    try: 
    74         raise ShxWarning("test") 
     54        raise ShxError("test") 
    7555    except: 
    7656        pass 
  • SHX/trunk/SeismicHandler/modules/parse.py

    r435 r441  
    3535from SeismicHandler.basics.error import ShxError 
    3636from SeismicHandler.config import Settings 
    37  
    38 class parse(object): 
     37from SeismicHandler.modules.messages import MessageSystem as msgs 
     38 
     39 
     40class Parse(object): 
    3941    """ 
    4042    Parse SH scripting language. 
     
    5355    The parser analyses the command string: 
    5456    >>> cmd = 'COMMAND /SWITCH1 PARAMETER1 /SWITCH2=4 PARAMETER2' 
    55     >>> x = parse(cmd).parsed 
     57    >>> x = Parse(cmd).parsed 
    5658 
    5759    The parsed command name is always lower case. It's used for comparision with 
     
    7779    the command name! 
    7880    >>> cmd = 'DELAY+SUM/BLA/FOO=1 BAR /tmp/test /SW FOO' 
    79     >>> x = parse(cmd).parsed 
     81    >>> x = Parse(cmd).parsed 
    8082    >>> x["shx_parameter"] 
    8183    ['BAR', 'FOO'] 
     
    9193    If more than one "possible filename is given, only the first one is 
    9294    recognized. All following are only processed as qualifiers. 
    93     >>> x = parse('COMMAND /tmp/x /tmp/y').parsed 
     95    >>> x = Parse('COMMAND /tmp/x /tmp/y').parsed 
    9496    >>> x["shx_suspectedFilename"] 
    9597    '/TMP/X' 
     
    9799    The semicolon is an alternative separator that is mostly used to skip 
    98100    parameters: 
    99     >>> x = parse("ECHO;;2 3 4 ;; 6 7").parsed 
     101    >>> x = Parse("ECHO;;2 3 4 ;; 6 7").parsed 
    100102    >>> x["shx_parameter"] 
    101103    ['', '2', '3', '4', '', '6', '7'] 
    102104 
    103     >>> x = parse('ECHO;;;;foo;bar;;').parsed 
     105    >>> x = Parse('ECHO;;;;foo;bar;;').parsed 
    104106    >>> x["shx_parameter"] 
    105107    ['', '', '', 'FOO', 'BAR', ''] 
     
    193195            raise ShxError(name) 
    194196 
    195 class script(object): 
     197 
     198class Script(object): 
    196199    """ 
    197200    Read commands from stream. 
     
    209212    >>> from StringIO import StringIO 
    210213    >>> strm = StringIO("echo line1\\necho line2\\n") 
    211     >>> symb = symbol() 
     214    >>> symb = Symbol() 
    212215    >>> Settings.swEcho = True 
    213     >>> x = script(strm, symb) 
     216    >>> x = Script(strm, symb) 
    214217    >>> x.run() 
    215218    echo line1 
     
    330333 
    331334        if Settings.swCmderrstop: 
    332             raise ShxError(error, msg) 
     335            raise ShxError(msg) 
    333336 
    334337        if not Settings.swNoerrmsg: 
    335             import warnings 
    336             warnings.warn((error, msg)) 
     338            msgs.sendMessage("log.error.traceback", message=msg) 
    337339 
    338340    def run(self): 
     
    344346                    print cmd 
    345347 
    346                 cmd = parse(cmd).parsed 
     348                cmd = Parse(cmd).parsed 
    347349 
    348350                # translate variables 
    349                 _ = translate(cmd, self) 
     351                _ = Translate(cmd, self) 
    350352 
    351353                # Check for internal command ... 
     
    374376                # .. or start script. 
    375377                else: 
    376                     symb = symbol() 
     378                    symb = Symbol() 
    377379                    try: 
    378380                        ns = script( 
     
    502504            self.Goto(cmd.p[5].value) 
    503505 
    504 class translate(object): 
     506 
     507class Translate(object): 
    505508    """ 
    506509    Translate variables in command. If a script class is used as second 
     
    528531    ...    'shx_qualifiers': {'FOO': '$DOLLAR', 'BAR': True}, 
    529532    ... } 
    530     >>> _ = translate(cmd) 
     533    >>> _ = Translate(cmd) 
    531534    >>> cmd['shx_translated'] 
    532535    'ECHO 3.1415926535897931 ! /FOO=$ /BAR' 
     
    726729            raise ShxError("Line %d not found in file '%s'!" % (lineno, f)) 
    727730 
    728 class symbol(object): 
     731 
     732class Symbol(object): 
    729733    """ 
    730734    This class holds locals symbols. Access to global symbols is granted. 
     
    732736    Important note: All symbol names are converted into upper case! 
    733737 
    734     >>> s = symbol() 
     738    >>> s = Symbol() 
    735739    >>> s.foo = 1 
    736740    >>> s.foo 
     
    753757    Traceback (most recent call last): 
    754758    ... 
    755     ShxError: Symbol BAR not found! 
     759    ShxError: Symbol 'BAR' not found! 
    756760 
    757761    If one wants to delete a global symbol but keep the local symbol: 
     
    766770 
    767771    def __init__(self): 
    768         self.__dict__["__globals"] = Settings.Globals 
     772        # this is a singleton 
     773        self.__dict__["_globals"] = Settings.Globals 
    769774 
    770775    def __getattr__(self, name): 
     776        """ 
     777        This method is called only, if the requested name was not found in 
     778        __dict__ 
     779        """ 
    771780        name = name.upper() 
     781 
     782        # local vars (but changed case) 
    772783        try: 
    773784            return self.__dict__[name] 
     
    775786            pass 
    776787 
    777         try: 
    778             return self.__dict__["__globals"][name] 
     788        # next try inside globals 
     789        try: 
     790            return self._globals[name] 
    779791        except KeyError: 
    780             pass 
    781  
    782         raise ShxError("Symbol %s not found!" % name) 
    783  
    784     def __setattr__(self, name, value=None): 
    785         name = name.upper() 
    786  
    787         self.__dict__[name] = value 
     792            raise ShxError("Symbol '%s' not found!" % name) 
     793 
     794    def __setattr__(self, name, value): 
     795        self.__dict__[name.upper()] = value 
    788796 
    789797    def __delattr__(self, name): 
     
    798806            return 
    799807 
    800         try: 
    801             del self.__dict__["__globals"][name] 
     808        self.deleteGlobal(name) 
     809 
     810    def setGlobal(self, name, value=None): 
     811        self._globals[name.upper()] = value 
     812 
     813    def deleteGlobal(self, name): 
     814        try: 
     815            del self._globals[name.upper()] 
    802816        except KeyError: 
    803             pass 
    804         else: 
    805             return 
    806  
    807         raise ShxError("Symbol %s not found!" % name) 
    808  
    809     def setGlobal(self, name, value=None): 
    810         name = name.upper() 
    811  
    812         self.__dict__["__globals"][name] = value 
    813  
    814     def deleteGlobal(self, name): 
    815         name = name.upper() 
    816  
    817         del self.__dict__["__globals"][name] 
     817            raise ShxError("Symbol %s not found!" % name) 
    818818 
    819819def getVar(name, symbolset = None): 
     
    825825 
    826826    if not symbolset: 
    827         s = translate() 
     827        s = Translate() 
    828828    else: 
    829829        x = AttribDict() 
    830830        x.symbols = symbolset 
    831         s = translate(None, x) 
     831        s = Translate(None, x) 
    832832 
    833833    return s._translate(name) 
     834 
    834835 
    835836if __name__ == "__main__": 
    836837    import doctest 
     838#    doctest.testmod(exclude_empty=True, verbose=True) 
    837839    doctest.testmod(exclude_empty=True) 
  • SHX/trunk/sandbox

    • Property svn:ignore
      •  

        old new  
        44access 
        55sscanf 
         6.getset.py.swp 
Note: See TracChangeset for help on using the changeset viewer.