Merge pull request #436 from boriel/feature/allow_disabling_enabling_warnings

Feature/allow disabling enabling warnings

Author: boriel

examples/pong.bas

@@ -1,4 +1,4 @@
-10 REM Pong! Game
+ccvfcxbnbnm10 REM Pong! Game
 
 14 REM Digit data
    REM 128 => "\  "

src/api/config.py

@@ -70,6 +70,7 @@ def init():
     OPTIONS.add_option('zxnext', bool, False)  # True to enable ZX Next ASM opcodes
     OPTIONS.add_option('architecture', str, None)  # Architecture
     OPTIONS.add_option('expect_warnings', int, 0)  # Expected Warnings that will be silenced
+    OPTIONS.add_option('hide_warning_codes', bool, False)  # Whether to show WXXX warning codes or not
 
 
 init()

src/api/errmsg.py

@@ -10,13 +10,26 @@
 # ----------------------------------------------------------------------
 
 import sys
+from functools import wraps
+
+from typing import Callable
 from typing import Optional
 
 from . import global_
 from .config import OPTIONS
 
+
 # Exports only these functions. Others
-__all__ = ['error', 'warning']
+__all__ = [
+    'error',
+    'is_valid_warning_code',
+    'warning',
+    'warning_not_used'
+]
+
+
+WARNING_PREFIX: str = ''  # will be prepended to warning messages
+ERROR_PREFIX: str = ''  # will be prepended to error messages
 
 
 def msg_output(msg: str) -> None:
@@ -42,7 +55,7 @@ def error(lineno: int, msg: str, fname: Optional[str] = None) -> None:
     if global_.has_errors > OPTIONS.max_syntax_errors:
         msg = 'Too many errors. Giving up!'
 
-    msg = "%s:%i: error: %s" % (fname, lineno, msg)
+    msg = "%s:%i: error:%s %s" % (fname, lineno, ERROR_PREFIX, msg)
     msg_output(msg)
 
     if global_.has_errors > OPTIONS.max_syntax_errors:
@@ -61,10 +74,48 @@ def warning(lineno: int, msg: str, fname: Optional[str] = None) -> None:
     if fname is None:
         fname = global_.FILENAME
 
-    msg = "%s:%i: warning: %s" % (fname, lineno, msg)
+    msg = "%s:%i: %s %s" % (fname, lineno, WARNING_PREFIX or 'warning:', msg)
     msg_output(msg)
 
 
+def is_valid_warning_code(code: str) -> bool:
+    return code in global_.ENABLED_WARNINGS
+
+
+def assert_is_valid_warning_code(code: str):
+    assert is_valid_warning_code(code), f"Invalid warning code '{code}'"
+
+
+def enable_warning(code: str):
+    assert_is_valid_warning_code(code)
+    global_.ENABLED_WARNINGS[code] = True
+
+
+def disable_warning(code: str):
+    assert_is_valid_warning_code(code)
+    global_.ENABLED_WARNINGS[code] = False
+
+
+def register_warning(code: str) -> Callable:
+    assert code not in global_.ENABLED_WARNINGS, f"Duplicated warning code '{code}'"
+    global_.ENABLED_WARNINGS[code] = True
+
+    def decorator(func: Callable) -> Callable:
+        def wrapper(*args, **kwargs):
+            global WARNING_PREFIX
+            if global_.ENABLED_WARNINGS.get(code, True):
+                if not OPTIONS.hide_warning_codes:
+                    WARNING_PREFIX = f'warning: [W{code}]'
+                func(*args, **kwargs)
+                WARNING_PREFIX = ''
+
+        return wraps(func)(wrapper)
+
+    return decorator
+
+
+# region [Warnings]
+@register_warning('100')
 def warning_implicit_type(lineno: int, id_: str, type_: str = None):
     """ Warning: Using default implicit type 'x'
     """
@@ -78,49 +129,59 @@ def warning_implicit_type(lineno: int, id_: str, type_: str = None):
     warning(lineno, "Using default implicit type '%s' for '%s'" % (type_, id_))
 
 
+@register_warning('110')
 def warning_condition_is_always(lineno: int, cond: bool = False):
     """ Warning: Condition is always false/true
     """
     warning(lineno, "Condition is always %s" % cond)
 
 
+@register_warning('120')
 def warning_conversion_lose_digits(lineno: int):
     """ Warning: Conversion may lose significant digits
     """
     warning(lineno, 'Conversion may lose significant digits')
 
 
+@register_warning('130')
 def warning_empty_loop(lineno: int):
     """ Warning: Empty loop
     """
     warning(lineno, 'Empty loop')
 
 
+@register_warning('140')
 def warning_empty_if(lineno):
     """ Warning: Useless empty IF ignored
     """
     warning(lineno, 'Useless empty IF ignored')
 
 
-# Emits an optimization warning
+@register_warning('150')
 def warning_not_used(lineno, id_, kind='Variable'):
+    """ Emits an optimization warning
+    """
     if OPTIONS.optimization > 0:
         warning(lineno, "%s '%s' is never used" % (kind, id_))
 
+# endregion
+
+# region [Syntax Errors]
+
 
 # ----------------------------------------
 # Syntax error: Expected string instead of
 #               numeric expression.
 # ----------------------------------------
-def syntax_error_expected_string(lineno: str, _type: str):
+def syntax_error_expected_string(lineno: int, _type: str):
     error(lineno, "Expected a 'string' type expression, got '%s' instead" % _type)
 
 
 # ----------------------------------------
 # Syntax error: FOR variable should be X
 #               instead of Y
 # ----------------------------------------
-def syntax_error_wrong_for_var(lineno: str, x: str, y: str):
+def syntax_error_wrong_for_var(lineno: int, x: str, y: str):
     error(lineno, "FOR variable should be '%s' instead of '%s'" % (x, y))
 
 
@@ -205,3 +266,5 @@ def syntax_error_address_must_be_constant(lineno: int):
 # ----------------------------------------
 def syntax_error_cannot_pass_array_by_value(lineno: int, id_: str):
     error(lineno, "Array parameter '%s' must be passed ByRef" % id_)
+
+# endregion

src/api/global_.py

@@ -16,6 +16,7 @@
 #
 # Don't touch unless you know what are you doing
 # ----------------------------------------------------------------------
+from typing import Dict
 
 from .opcodestemps import OpcodesTemps
 from .constants import TYPE
@@ -156,3 +157,9 @@
 # Cache of Message errors to avoid repetition
 # ----------------------------------------------------------------------
 error_msg_cache = set()
+
+
+# ----------------------------------------------------------------------
+# Warning codes and whether they're enabled or not
+# ----------------------------------------------------------------------
+ENABLED_WARNINGS: Dict[str, bool] = {}

src/api/optimize.py

@@ -1,19 +1,24 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+import types
+
 from typing import NamedTuple
+from typing import Set
+
+import src.api.global_ as gl
+import src.api.utils
+import src.api.symboltable
+import src.api.check as chk
+
+from src import symbols
 from src.ast import NodeVisitor
-from .config import OPTIONS
 from src.api.errmsg import warning
-import src.api.check as chk
 from src.api.constants import TYPE, SCOPE, CLASS
-import src.api.global_ as gl
-from .. import symbols
-import types
 from src.api.debug import __DEBUG__
 from src.api.errmsg import warning_not_used
-import src.api.utils
-import src.api.symboltable
+
+from .config import OPTIONS
 
 
 class ToVisit(object):
@@ -327,7 +332,7 @@ def has_circular_dependency(self, var_dependency: VarDependency) -> bool:
         return False
 
     def get_var_dependencies(self, var_entry: symbols.VAR):
-        visited = set()
+        visited: Set[symbols.Var] = set()
         result = set()
 
         def visit_var(entry):

src/api/options.py

@@ -96,7 +96,16 @@ def value(self, value):
         if value is not None and self.type is not None and not isinstance(value, self.type):
             try:
                 if isinstance(value, str) and self.type == bool:
-                    value = {'false': False, 'true': True}[value.lower()]
+                    value = {
+                        'false': False,
+                        'true': True,
+                        'off': False,
+                        'on': True,
+                        '-': False,
+                        '+': True,
+                        'no': False,
+                        'yes': True
+                    }[value.lower()]
                 else:
                     value = self.type(value)
             except TypeError:

src/api/utils.py

@@ -25,15 +25,15 @@
 from .. import symbols
 
 __all__ = [
-    'read_txt_file',
+    'flatten_list',
     'open_file',
+    'read_txt_file',
     'sanitize_filename',
-    'flatten_list',
     'timeout'
 ]
 
-__doc__ = """Utils module contains many helpers for several task, like reading files
-or path management"""
+__doc__ = """Utils module contains many helpers for several task,
+like reading files or path management"""
 
 SHELVE_PATH = os.path.join(constants.ZXBASIC_ROOT, 'parsetab', 'tabs.dbm')
 SHELVE = shelve.open(SHELVE_PATH)

src/libzxbc/args_parser.py

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+
+import argparse
+
+from src import arch
+from src.api import errmsg
+from src.api.config import OPTIONS
+
+from .version import VERSION
+
+
+def parse_warning_option(code: str) -> str:
+    if not errmsg.is_valid_warning_code(code):
+        raise argparse.ArgumentTypeError(f"Invalid warning option 'W{code}'")
+    return code
+
+
+# ------------------------------------------------------------
+# Command line parser
+# ------------------------------------------------------------
+def parser() -> argparse.ArgumentParser:
+    parser_ = argparse.ArgumentParser(
+        prefix_chars='-+'
+    )
+    parser_.add_argument('PROGRAM', type=str,
+                         help='BASIC program file')
+    parser_.add_argument('-d', '--debug', dest='debug', default=OPTIONS.Debug, action='count',
+                         help='Enable verbosity/debugging output. Additional -d increase verbosity/debug level')
+    parser_.add_argument('-O', '--optimize', type=int, default=OPTIONS.optimization,
+                         help='Sets optimization level. '
+                              '0 = None (default level is {0})'.format(OPTIONS.optimization))
+    parser_.add_argument('-o', '--output', type=str, dest='output_file', default=None,
+                         help='Sets output file. Default is input filename with .bin extension')
+    parser_.add_argument('-T', '--tzx', action='store_true',
+                         help="Sets output format to tzx (default is .bin)")
+    parser_.add_argument('-t', '--tap', action='store_true',
+                         help="Sets output format to tap (default is .bin)")
+    parser_.add_argument('-B', '--BASIC', action='store_true', dest='basic',
+                         help="Creates a BASIC loader which loads the rest of the CODE. Requires -T ot -t")
+    parser_.add_argument('-a', '--autorun', action='store_true',
+                         help="Sets the program to be run once loaded")
+    parser_.add_argument('-A', '--asm', action='store_true',
+                         help="Sets output format to asm")
+    parser_.add_argument('-S', '--org', type=str, default=str(OPTIONS.org),
+                         help="Start of machine code. By default %i" % OPTIONS.org)
+    parser_.add_argument('-e', '--errmsg', type=str, dest='stderr', default=OPTIONS.StdErrFileName,
+                         help='Error messages file (standard error console by default)')
+    parser_.add_argument('--array-base', type=int, default=OPTIONS.array_base,
+                         help='Default lower index for arrays ({0} by default)'.format(OPTIONS.array_base))
+    parser_.add_argument('--string-base', type=int, default=OPTIONS.string_base,
+                         help='Default lower index for strings ({0} by default)'.format(OPTIONS.array_base))
+    parser_.add_argument('-Z', '--sinclair', action='store_true',
+                         help='Enable by default some more original ZX Spectrum Sinclair BASIC features:'
+                              ' ATTR, SCREEN$, POINT')
+    parser_.add_argument('-H', '--heap-size', type=int, default=OPTIONS.heap_size,
+                         help='Sets heap size in bytes (default {0} bytes)'.format(OPTIONS.heap_size))
+    parser_.add_argument('--debug-memory', action='store_true',
+                         help='Enables out-of-memory debug')
+    parser_.add_argument('--debug-array', action='store_true',
+                         help='Enables array boundary checking')
+    parser_.add_argument('--strict-bool', action='store_true',
+                         help='Enforce boolean values to be 0 or 1')
+    parser_.add_argument('--enable-break', action='store_true',
+                         help='Enables program execution BREAK detection')
+    parser_.add_argument('-E', '--emit-backend', action='store_true',
+                         help='Emits backend code instead of ASM or binary')
+    parser_.add_argument('--explicit', action='store_true',
+                         help='Requires all variables and functions to be declared before used')
+    parser_.add_argument('-D', '--define', type=str, dest='defines', action='append',
+                         help='Defines de given macro. Eg. -D MYDEBUG or -D NAME=Value')
+    parser_.add_argument('-M', '--mmap', type=str, dest='memory_map', default=None,
+                         help='Generate label memory map')
+    parser_.add_argument('-i', '--ignore-case', action='store_true',
+                         help='Ignore case. Makes variable names are case insensitive')
+    parser_.add_argument('-I', '--include-path', type=str, default='',
+                         help='Add colon separated list of directories to add to include path. e.g. -I dir1:dir2')
+    parser_.add_argument('--strict', action='store_true',
+                         help='Enables strict mode. Force explicit type declaration')
+    parser_.add_argument('--headerless', action='store_true',
+                         help='Header-less mode: omit asm prologue and epilogue')
+    parser_.add_argument('--version', action='version', version='%(prog)s {0}'.format(VERSION))
+    parser_.add_argument('--parse-only', action='store_true',
+                         help='Only parses to check for syntax and semantic errors')
+    parser_.add_argument('--append-binary', default=[], action='append',
+                         help='Appends binary to tape file (only works with -t or -T)')
+    parser_.add_argument('--append-headless-binary', default=[], action='append',
+                         help='Appends binary to tape file (only works with -t or -T)')
+    parser_.add_argument('-N', '--zxnext', action='store_true',
+                         help='Enables ZX Next asm extended opcodes')
+    parser_.add_argument('--arch', type=str, default=arch.AVAILABLE_ARCHITECTURES[0],
+                         help=f"Target architecture (defaults is'{arch.AVAILABLE_ARCHITECTURES[0]}'). "
+                              f"Available architectures: {','.join(arch.AVAILABLE_ARCHITECTURES)}")
+    parser_.add_argument('--expect-warnings', default=OPTIONS.expect_warnings, type=int,
+                         help='Expects N warnings: first N warnings will be silenced')
+    parser_.add_argument('-W', '--disable-warning', type=parse_warning_option, action='append',
+                         help='Disables warning WXXX (i.e. -W100 disables warning with code W100)')
+    parser_.add_argument('+W', '--enable-warning', type=parse_warning_option, action='append',
+                         help='Disables warning WXXX (i.e. -W100 disables warning with code W100)')
+    parser_.add_argument('--hide-warning-codes', action='store_true',
+                         help='Hides WXXX codes')
+    return parser_