Add ability to use constants

Author: prkrtg

wdl/wavgen.py

@@ -133,8 +133,8 @@ def loadWDL(infile, outfile="/dev/null", verbose=1):
                 pval = int(match.group(2))
                 Parameters.update({pname: pval})
                 continue
-            # look for constants
-            match = re.search(r"^constant\s+(\w+)\s*=\s*([+-]?\d+(?:\.\d*)?)\s*$", line)
+            # look 'const' or 'constant' (case-insensitive), value may be float
+            match = re.search(r"(?i)^(?:const(?:ant)?)\s+(\w+)\s*=\s*([+-]?\d+(?:\.\d*)?)\s*$", line)
             if match is not None:
                 cname = match.group(1)
                 cval = float(match.group(2))

wdl/wdlParser.py

@@ -56,6 +56,11 @@
 import Lexer
 from Symbols import *
 import sys
+# Access constants collected by wavgen.py (fallback to empty if not present)
+try:
+    from wavgen import Constants
+except Exception:
+    Constants = {}
 
 sys.dont_write_bytecode = True
 
@@ -254,18 +259,23 @@ def lvds(slot_number):
 
     lvds_chan = None
 
-    if found(NUMBER):
+    if found(IDENTIFIER) and token.cargo in Constants:
+        lvds_chan = str(int(float(Constants[token.cargo])))
+        consume(IDENTIFIER)
+    elif found(NUMBER):
         lvds_chan = token.cargo
-        if module_name.upper() in {"LVDS"}:
-            if not (1 <= int(lvds_chan) <= 16):
-                error(
-                    f"LVDS channel {dq(lvds_chan)} outside range {{1:16}} for module: "
-                    f"{module_name.upper()}"
-                )
-        else:
-            error(f"LVDSL is an invalid keyword for module: {module_name.upper()}")
+        consume(NUMBER)
+    else:
+        error("Expected number or constant for LVDS channel")
 
-    consume(NUMBER)
+    if module_name.upper() in {"LVDS"}:
+        if not (1 <= int(lvds_chan) <= 16):
+            error(
+                f"LVDS channel {dq(lvds_chan)} outside range {{1:16}} for module: "
+                f"{module_name.upper()}"
+            )
+    else:
+        error(f"LVDSL is an invalid keyword for module: {module_name.upper()}")
 
     # there can be an optional label, specified as token type=STRING
     if found(STRING):
@@ -1909,17 +1919,22 @@ def to():
     global setLevel
 
     consume("TO")
-    # could be a negative number...
+    # optional leading minus sign
     if found("-"):
-        # if so, consume the sign and remember it
         consume("-")
         sign = -1.0
     else:
         sign = 1.0
-    if found(NUMBER):
-        # multiply the value by the sign from above (hehe)
+
+    # level can be a NUMBER or a defined constant
+    if found(IDENTIFIER) and token.cargo in Constants:
+        setLevel = str(sign * float(Constants[token.cargo]))
+        consume(IDENTIFIER)
+    elif found(NUMBER):
         setLevel = str(sign * float(token.cargo))
-    consume(NUMBER)
+        consume(NUMBER)
+    else:
+        error("Expected level as number or defined constant after TO")
 
 
 # -----------------------------------------------------------------------------
@@ -2191,6 +2206,7 @@ def generic_sequence(*sequenceName):
                 (found(IDENTIFIER))
                 and (token.cargo not in subroutines)
                 and (token.cargo not in paramNames)
+                and (token.cargo not in Constants)
             ):
                 error(
                     "(wdlParser.py::generic_sequence) undefined symbol "
@@ -2222,14 +2238,18 @@ def generic_sequence(*sequenceName):
                 consume(IDENTIFIER)
                 consume("(")
                 # if next token isn't a closing paren then assume
-                # it's a number or param
+                # it's a number, param, or constant
                 if not found(")"):
-                    sequence_line += "(" + token.cargo  # + ")"
-                    # and if it's not a number then it must be a defined param
-                    if not found(NUMBER) and token.cargo not in paramNames:
+                    sequence_line += "(" + token.cargo  # keep the name; const is emitted earlier
+                    # validate: allow NUMBER, defined param, or defined constant
+                    if (
+                            not found(NUMBER)
+                            and token.cargo not in paramNames
+                            and token.cargo not in constNames
+                    ):
                         error(
                             "(wdlParser.py::generic_sequence) undefined "
-                            "param " + token.show(align=False)
+                            "param or constant " + token.show(align=False)
                         )
             elif found("RETURN"):
                 consume("RETURN")