merge preprocessor from pokecrystal c0a01c99

That version was better anyway.

1 files changed, 96 insertions, 83 deletions

diff --git a/pokemontools/preprocessor.py b/pokemontools/preprocessor.py
index e33cda7..87faefd 100644
--- a/pokemontools/preprocessor.py
+++ b/pokemontools/preprocessor.py
@@ -13,9 +13,6 @@ default_macros = [
     DataByteWordMacro,
 ]
 
-class SkippableMacro(object):
-    macro_name = "db"
-
 chars = {
 "ガ": 0x05,
 "ギ": 0x06,
@@ -281,6 +278,16 @@ chars = {
 "9": 0xFF
 }
 
+class PreprocessorException(Exception):
+    """
+    There was a problem in the preprocessor.
+    """
+
+class MacroException(PreprocessorException):
+    """
+    There was a problem with a macro.
+    """
+
 def separate_comment(l):
     """
     Separates asm and comments on a single line.
@@ -392,8 +399,9 @@ def macro_test(asm, macro_table):
     """
     # macros are determined by the first symbol on the line
     token = extract_token(asm)
-    # check against all names
-    if token in macro_table:
+
+    # skip db and dw since rgbasm handles those and they aren't macros
+    if token is not None and token not in ["db", "dw"] and token in macro_table:
         return (macro_table[token], token)
     else:
         return (None, None)
@@ -410,15 +418,69 @@ def is_based_on(something, base):
     options += [something.__name__]
     return (base in options)
 
-def macro_translator(macro, token, line, skippable_macros, show_original_lines=False, do_macro_sanity_check=False):
+def check_macro_sanity(params, macro, original_line):
+    """
+    Checks whether or not the correct number of arguments are being passed to a
+    certain macro. There are a number of possibilities based on the types of
+    parameters that define the macro.
+
+    @param params: a list of parameters given to the macro
+    @param macro: macro klass
+    @param original_line: the line being preprocessed
+    """
+    allowed_length = 0
+
+    for (index, param_type) in macro.param_types.items():
+        param_klass = param_type["class"]
+
+        if param_klass.byte_type == "db":
+            allowed_length += 1 # just one value
+        elif param_klass.byte_type == "dw":
+            if param_klass.size == 2:
+                allowed_length += 1 # just label
+            elif param_klass.size == 3:
+                allowed_length += 2 # bank and label
+            else:
+                raise MacroException(
+                    "dunno what to do with a macro param with a size > 3 (size={size})"
+                    .format(size=param_klass.size)
+                )
+        else:
+            raise MacroException(
+                "dunno what to do with this non db/dw macro param: {klass} in line {line}"
+                .format(klass=param_klass, line=original_line)
+            )
+
+    # sometimes the allowed length can vary
+    if hasattr(macro, "allowed_lengths"):
+        allowed_lengths = macro.allowed_lengths + [allowed_length]
+    else:
+        allowed_lengths = [allowed_length]
+
+    # used twice, so precompute once
+    params_len = len(params)
+
+    if params_len not in allowed_lengths:
+        raise PreprocessorException(
+            "mismatched number of parameters ({count}, instead of any of {allowed}) on this line: {line}"
+            .format(
+                count=params_len,
+                allowed=allowed_lengths,
+                line=original_line,
+            )
+        )
+
+    return True
+
+def macro_translator(macro, token, line, show_original_lines=False, do_macro_sanity_check=False):
     """
     Converts a line with a macro into a rgbasm-compatible line.
 
     @param show_original_lines: show lines before preprocessing in stdout
     @param do_macro_sanity_check: helpful for debugging macros
     """
-
-    assert macro.macro_name == token, "macro/token mismatch"
+    if macro.macro_name != token:
+        raise MacroException("macro/token mismatch")
 
     original_line = line
 
@@ -446,16 +508,15 @@ def macro_translator(macro, token, line, skippable_macros, show_original_lines=F
 
         # check if there are no params (redundant)
         if len(params) == 1 and params[0] == "":
-            raise Exception, "macro has no params?"
+            raise MacroException("macro has no params?")
 
     # write out a comment showing the original line
     if show_original_lines:
         sys.stdout.write("; original_line: " + original_line)
 
-    # "db" is a macro because of SkippableMacro
-    # rgbasm can handle "db" so no preprocessing is required
-    # (don't check its param count)
-    if macro.__name__ in skippable_macros or (macro.macro_name == "db" and macro in skippable_macros):
+    # rgbasm can handle "db" so no preprocessing is required, plus this wont be
+    # reached because of earlier checks in macro_test.
+    if macro.macro_name in ["db", "dw"]:
         sys.stdout.write(original_line)
         return
 
@@ -465,45 +526,10 @@ def macro_translator(macro, token, line, skippable_macros, show_original_lines=F
     if not macro.override_byte_check:
         sys.stdout.write("db ${0:02X}\n".format(macro.id))
 
-    # --- long-winded sanity check goes here ---
-
+    # Does the number of parameters on this line match any allowed number of
+    # parameters that the macro expects?
     if do_macro_sanity_check:
-
-        # sanity check... this won't work because PointerLabelBeforeBank shows
-        # up as two params, so these two lengths will always be different.
-        #assert len(params) == len(macro.param_types), \
-        #       "mismatched number of parameters on this line: " + \
-        #       original_line
-
-        # v2 sanity check :) although it sorta sucks that this loop happens twice?
-        allowed_length = 0
-        for (index, param_type) in macro.param_types.items():
-            param_klass = param_type["class"]
-
-            if param_klass.byte_type == "db":
-                allowed_length += 1 # just one value
-            elif param_klass.byte_type == "dw":
-                if param_klass.size == 2:
-                    allowed_length += 1 # just label
-                elif param_klass.size == 3:
-                    allowed_length += 2 # bank and label
-                else:
-                    raise Exception, "dunno what to do with a macro param with a size > 3"
-            else:
-                raise Exception, "dunno what to do with this non db/dw macro param: " + \
-                                 str(param_klass) + " in line: " + original_line
-
-        # sometimes the allowed length can vary
-        if hasattr(macro, "allowed_lengths"):
-            allowed_lengths = macro.allowed_lengths + [allowed_length]
-        else:
-            allowed_lengths = [allowed_length]
-
-        assert len(params) in allowed_lengths, \
-               "mismatched number of parameters on this line: " + \
-               original_line
-
-    # --- end of ridiculously long sanity check ---
+        check_macro_sanity(params, macro, original_line)
 
     # used for storetext
     correction = 0
@@ -512,22 +538,7 @@ def macro_translator(macro, token, line, skippable_macros, show_original_lines=F
 
     index = 0
     while index < len(params):
-        try:
-            param_type  = macro.param_types[index - correction]
-        except KeyError as exception:
-            raise Exception(
-                "Got a KeyError on param_types. This usually happens when a " \
-                "macro should have been skipped but wasn't. But there are also " \
-                "other sources of this error.\n\n" \
-                "line is: {line}\n" \
-                "macro is: {macro}\n" \
-                "error is: {error}\n"
-                .format(
-                    line=line,
-                    macro=macro,
-                    error=exception,
-                )
-            )
+        param_type  = macro.param_types[index - correction]
         description = param_type["name"]
         param_klass = param_type["class"]
         byte_type   = param_klass.byte_type # db or dw
@@ -561,9 +572,13 @@ def macro_translator(macro, token, line, skippable_macros, show_original_lines=F
                 output += ("db " + param_klass.from_asm(param) + "\n")
                 index += 1
             else:
-                raise Exception, "dunno what to do with this macro " + \
-                "param (" + str(param_klass) + ") " + "on this line: " + \
-                original_line
+                raise MacroException(
+                    "dunno what to do with this macro param ({klass}) in line: {line}"
+                    .format(
+                        klass=param_klass,
+                        line=original_line,
+                    )
+                )
 
         # or just print out the byte
         else:
@@ -573,9 +588,13 @@ def macro_translator(macro, token, line, skippable_macros, show_original_lines=F
 
     sys.stdout.write(output)
 
-def read_line(l, skippable_macros, macro_table):
+def read_line(l, macro_table):
     """Preprocesses a given line of asm."""
 
+    if l in ["\n", ""] or l[0] == ";":
+        sys.stdout.write(l)
+        return # jump out early
+
     # strip comments from asm
     asm, comment = separate_comment(l)
 
@@ -589,7 +608,7 @@ def read_line(l, skippable_macros, macro_table):
         sys.stdout.write(asm)
 
     # ascii string macro preserves the bytes as ascii (skip the translator)
-    elif len(asm) > 6 and "ascii " == asm[:6] or "\tascii " == asm[:7]:
+    elif len(asm) > 6 and ("ascii " == asm[:6] or "\tascii " == asm[:7]):
         asm = asm.replace("ascii", "db", 1)
         sys.stdout.write(asm)
 
@@ -601,21 +620,15 @@ def read_line(l, skippable_macros, macro_table):
     else:
         macro, token = macro_test(asm, macro_table)
         if macro:
-            macro_translator(macro, token, asm, skippable_macros)
+            macro_translator(macro, token, asm)
         else:
             sys.stdout.write(asm)
 
-    if comment: sys.stdout.write(comment)
+    if comment:
+        sys.stdout.write(comment)
 
-def preprocess(macros, skippable_macros=None, lines=None):
+def preprocess(macro_table, lines=None):
     """Main entry point for the preprocessor."""
-    if skippable_macros == None:
-        skippable_macros = [SkippableMacro]
-
-    macro_table = make_macro_table(list(set(macros + skippable_macros)))
-
-    # HACK for pokecrystal. Must be after make_macro_table call.
-    skippable_macros += ["TextEndingCommand"]
 
     if not lines:
         # read each line from stdin
@@ -625,4 +638,4 @@ def preprocess(macros, skippable_macros=None, lines=None):
         lines = lines.split("\n")
 
     for l in lines:
-        read_line(l, skippable_macros, macro_table)
+        read_line(l, macro_table)