Changeset 233

Timestamp:

07/21/2010 05:19:53 PM (13 years ago)

Author:

marcus

Message:

Parser work. Translation of system variables (not all covered yet) and symbols work now.

Location:

SHX/trunk/src/SeismicHandler

Files:

• core/parser.py (modified) (6 diffs)
• tests/data/SCRIPT1.SHC (modified) (2 diffs)

SHX/trunk/src/SeismicHandler/core/parser.py

@@ -111 +111 @@
         self.input = input
 
+        converted = False
         if Settings.swCapconv:
-            input = input.upper()
+            # If a command starts with @, no conversion to upper case is
+            # performed but the indicator char is removed.
+            if input.startswith("@"):
+                input = input[1:]
+            else:
+                input = input.upper()
+                converted = True
 
         c = re.compile(self.re_cmd)
@@ -162 +169 @@
                 "shx_input_conv": input,
                 "shx_command": cmd.lower(), # command always in lower case
+                "shx_converted": converted, # indicates cap conversion
                 "shx_parameter": parameter,
                 "shx_qualifiers": qualifiers,
@@ -227 +235 @@
         self.symbols = symbols
 
+        # If a script is initially called there might be parameters and
+        # also qualifiers.
+        if parameters:
+            self.parameters = translate(parameters, self)
+
         try:
             if hasattr(input, "read"):
@@ -293 +306 @@
                 # Execute command...
                 if cmd["shx_command"] in commands.list:
+                    # translate variables
+                    _ = translate(cmd, self)
+
+                    if Settings.swVerify:
+                        print cmd["shx_translated"]
+                    
                     # also supply recent symbolset
                     commands.list[cmd["shx_command"]](shx_symbols=self.symbols, \
@@ -301 +320 @@
                     symb = symbol()
                     try:
-                        ns = script(cmd["shx_command"], symb)
+                        ns = script(cmd["shx_command"], symb, parameters=cmd)
                         ns.run()
                     except Exception, e:
@@ -390 +409 @@
 class translate(object):
     """
-    Translate variables in command.
-    """
-    def __init__(self):
-        pass
+    Translate variables in command. If a script class is used as second
+    parameter, it's symbol set will be used (e.g. for global symbols).
+
+    There are five basic types of variables:
+    1. user-defined symbols start with a quote: "foo
+    2. system variables start with a dollar sign: $DSPTRCS
+    3. trace variables start with a caret: ^delta(3)
+    4. passed options to command procedures start with a hash: #1
+    5. data from file access start with a percent: %filename(1)
+
+    After translation all parameter and qualifiers are replaced.
+    
+    If the global option "Verify" is set the translated command string is saved
+    into "shx_translated". This string is rebuild from the translated parts,
+    so qualifiers may appear not in original order.
+
+    In order to test this class, we define a dummy command object.
+    >>> Settings.swVerify = True
+    >>> cmd = {
+    ...    'shx_command': 'echo',
+    ...    'shx_converted': True,
+    ...    'shx_parameter': ['$PI', '$EXCLAMATION'],
+    ...    'shx_qualifiers': {'FOO': '$DOLLAR', 'BAR': True},
+    ... }
+    >>> _ = translate(cmd)
+    >>> cmd['shx_translated']
+    'ECHO 3.1415926535897931 ! /FOO=$ /BAR'
+    """
+
+    system = {
+        "DOLLAR": "$",
+        "PI": "3.1415926535897931",
+        "SLASH": "/",
+        "HAT": "^",
+        "EXCLAMATION": "!",
+
+        # XXX todo
+        "DSPTRCS": lambda: None,
+        "TOTTRCS": lambda: None,
+    }
+
+    def __init__(self, cmd, script=None):
+        self.script = script
+        
+        # translate parameters
+        for i, p in enumerate(cmd["shx_parameter"]):
+            if p[0] not in '"$^#%':
+                continue
+
+            id = p[0]
+            # system
+            if id == "$":
+                cmd["shx_parameter"][i] = self.handleSystem(p[1:])
+            # symbols
+            elif id == '"':
+                cmd["shx_parameter"][i] = self.handleSymbol(p[1:])
+            # trace XXX
+            elif id == '^':
+                cmd["shx_parameter"][i] = self.handleTrace(p[1:])
+            # options at startup XXX
+            elif id == '#':
+                cmd["shx_parameter"][i] = self.handleOption(p[1:])
+            # file XXX
+            elif id == '%':
+                cmd["shx_parameter"][i] = self.handleFile(p[1:])
+
+        # translate qualifiers
+        for q in cmd["shx_qualifiers"]:
+            p = cmd["shx_qualifiers"][q]
+
+            # Skip qualifiers that act as switches.
+            if type(p) == bool:
+                continue
+
+            id = p[0]
+
+            if id == "$":
+                cmd["shx_qualifiers"][q] = self.handleSystem(p[1:])
+            elif id == '"':
+                cmd["shx_qualifiers"][q] = self.handleSymbol(p[1:])
+            elif id == '^':
+                cmd["shx_qualifiers"][q] = self.handleTrace(p[1:])
+            elif id == '#':
+                cmd["shx_qualifiers"][q] = self.handleOption(p[1:])
+            elif id == '%':
+                cmd["shx_qualifiers"][q] = self.handleFile(p[1:])
+
+        # Actually this is only for debugging purposes.
+        if not Settings.swVerify:
+            return
+        
+        qual = []
+        for q in cmd["shx_qualifiers"]:
+            if type(cmd["shx_qualifiers"][q]) == bool:
+                qual.append(q)
+            else:
+                qual.append("%s=%s" % (q, cmd["shx_qualifiers"][q]))
+            
+        cmd["shx_translated"] = " ".join([
+            cmd["shx_converted"] and cmd["shx_command"].upper() or cmd["shx_command"],
+            " ".join(cmd["shx_parameter"]),
+            len(qual) and "/" + " /".join(qual) or "",
+        ])
+
+    def handleSystem(self, name):
+        try:
+            x = self.system[name.upper()]
+        except KeyError:
+            raise NameError("System variable '%s' not found!" % name)
+
+        if callable(x):
+            return x()
+        else:
+            return x
+
+    def handleSymbol(self, name):
+        try:
+            return getattr(self.script.symbols, name)
+        except:
+            raise NameError("Symbol '%s' not found!" % name)
+
+    def handleTrace(self, name):
+        raise NotImplementedError
+
+    def handleOption(self, name):
+        raise NotImplementedError
+
+    def handleFile(self, name):
+        raise NotImplementedError
 
 class symbol(object):

SHX/trunk/src/SeismicHandler/tests/data/SCRIPT1.SHC

@@ -4 +4 @@
 !
 
-switch echo on
-switch echo off
+sdef/global bar 42
+echo $pi
 switch capconv off
-sdef foo 3
+sdef foo 23
+echo "foo
 switch capconv on
 sdel foo
@@ -14 +15 @@
 echo test2
 echo_ch
+@switch echo on
+switch echo off
+echo "bar