feat: allow optional parameters!

Author: boriel

src/api/check.py

@@ -112,6 +112,12 @@ def check_call_arguments(lineno: int, id_: str, args):
 
     entry = global_.SYMBOL_TABLE.get_entry(id_)
 
+    if len(args) < len(entry.params):  # try filling default params
+        for param in entry.params[len(args) :]:
+            if param.default_value is None:
+                break
+            symbols.ARGLIST.make_node(args, symbols.ARGUMENT(param.default_value, lineno=lineno, byref=False))
+
     if len(args) != len(entry.params):
         c = "s" if len(entry.params) != 1 else ""
         errmsg.error(

src/api/errmsg.py

@@ -303,6 +303,13 @@ def syntax_error_cannot_initialize_array_of_type(lineno: int, type_name: str):
     error(lineno, f"Cannot initialize array of type {type_name}")
 
 
+# ----------------------------------------
+#  Cannot define a default array argument
+# ----------------------------------------
+def syntax_error_cannot_define_default_array_argument(lineno: int):
+    error(lineno, "Cannot define default array argument")
+
+
 # ----------------------------------------
 #  Error, ID is a ... not a ...
 # ----------------------------------------
@@ -319,4 +326,11 @@ def syntax_error_already_declared(lineno: int, id_name: str, as_class: CLASS, at
     error(lineno, f"'{id_name}' already declared as {as_class} at {at_lineno}")
 
 
+# ----------------------------------------
+#  Can't declare a mandatory parameter after an optional one
+# ----------------------------------------
+def syntax_error_mandatory_param_after_optional(lineno: int, param1: str, param2: str):
+    error(lineno, f"Can't declare mandatory param '{param2}' after optional param '{param1}'")
+
+
 # endregion

src/api/symboltable.py

@@ -35,6 +35,7 @@
 from .errmsg import warning_not_used
 from .errmsg import syntax_error_func_type_mismatch
 from .errmsg import syntax_error_not_array_nor_func
+from .errmsg import syntax_error_cannot_define_default_array_argument
 
 from .constants import DEPRECATED_SUFFIXES
 from .constants import SUFFIX_TYPE
@@ -695,26 +696,33 @@ def declare_label(self, id_: str, lineno: int) -> Optional[SymbolLABEL]:
         entry.type_ = self.basic_types[global_.PTR_TYPE]
         return entry
 
-    def declare_param(self, id_: str, lineno: int, type_=None, is_array=False) -> Optional[SymbolVAR]:
+    def declare_param(
+        self, id_: str, lineno: int, type_=None, is_array=False, default_value: Optional[Symbol] = None
+    ) -> Optional[SymbolVAR]:
         """Declares a parameter
         Check if entry.declared is False. Otherwise raises an error.
         """
         if not self.check_is_undeclared(id_, lineno, classname="parameter", scope=self.current_scope, show_error=True):
             return None
 
         if is_array:
+            if default_value is not None:
+                syntax_error_cannot_define_default_array_argument(lineno)
+                return None
+
             entry = self.declare(id_, lineno, symbols.VARARRAY(id_, symbols.BOUNDLIST(), lineno, None, type_))
             entry.callable = True
             entry.scope = SCOPE.parameter
         else:
-            entry = self.declare(id_, lineno, symbols.PARAMDECL(id_, lineno, type_))
+            entry = self.declare(id_, lineno, symbols.PARAMDECL(id_, lineno, type_, default_value))
 
         if entry is None:
             return None
 
         entry.declared = True
         if entry.type_.implicit:
             warning_implicit_type(lineno, id_, type_)
+
         return entry
 
     def declare_array(self, id_: str, lineno: int, type_, bounds, default_value=None, addr=None):

src/arch/z80/translator.py

@@ -1447,7 +1447,7 @@ def visit_FUNCTION(self, node):
                 if local_var.default_value is not None:
                     r.extend(self.array_default_value(local_var.type_, local_var.default_value))
                 self.ic_larrd(local_var.offset, q, local_var.size, r, bound_ptrs)  # Initializes array bounds
-            elif local_var.class_ == CLASS.const:
+            elif local_var.class_ == CLASS.const or local_var.scope == SCOPE.parameter:
                 continue
             else:  # Local vars always defaults to 0, so if 0 we do nothing
                 if local_var.default_value is not None and local_var.default_value != 0:

src/parsetab/tabs.dbm.bak

@@ -1,4 +1,4 @@
 'zxbpp', (0, 76970)
 'asmparse', (77312, 268394)
 'zxnext_asmparse', (346112, 298411)
-'zxbparser', (644608, 703160)
+'zxbparser', (644608, 704752)

src/parsetab/tabs.dbm.dat

@@ -1,4 +1,4 @@
 'zxbpp', (0, 76970)
 'asmparse', (77312, 268394)
 'zxnext_asmparse', (346112, 298411)
-'zxbparser', (644608, 703160)
+'zxbparser', (644608, 704752)

src/parsetab/tabs.dbm.dir

@@ -8,23 +8,27 @@
 # This program is Free Software and is released under the terms of
 #                    the GNU General License
 # ----------------------------------------------------------------------
+from typing import Optional
+
+import src.api.global_ as gl
 
 from src.api.constants import CLASS
 from src.api.constants import SCOPE
 from src.api.config import OPTIONS
-import src.api.global_ as gl
-from .type_ import SymbolBASICTYPE as BasicType
-from .var import SymbolVAR
+from src.symbols.type_ import SymbolBASICTYPE as BasicType
+from src.symbols.var import SymbolVAR
+from src.symbols.symbol_ import Symbol
 
 
 class SymbolPARAMDECL(SymbolVAR):
     """Defines a parameter declaration"""
 
-    def __init__(self, varname, lineno, type_=None):
-        super(SymbolPARAMDECL, self).__init__(varname, lineno, type_=type_, class_=CLASS.var)
+    def __init__(self, varname: str, lineno: int, type_=None, default_value: Optional[Symbol] = None):
+        super().__init__(varname, lineno, type_=type_, class_=CLASS.var)
         self.byref = OPTIONS.default_byref  # By default all params By value (false)
         self.offset = None  # Set by PARAMLIST, contains positive offset from top of the stack
         self.scope = SCOPE.parameter
+        self.default_value = default_value
 
     @property
     def size(self):

src/symbols/paramdecl.py

@@ -411,9 +411,9 @@ def make_call(id_: str, lineno: int, args: symbols.ARGLIST):
     return make_func_call(id_, lineno, args)
 
 
-def make_param_decl(id_: str, lineno: int, typedef, is_array=False):
+def make_param_decl(id_: str, lineno: int, typedef, is_array: bool, default_value: Optional[symbols.SYMBOL] = None):
     """Wrapper that creates a param declaration"""
-    return SYMBOL_TABLE.declare_param(id_, lineno, typedef, is_array)
+    return SYMBOL_TABLE.declare_param(id_, lineno, typedef, is_array, default_value)
 
 
 def make_type(typename, lineno, implicit=False):
@@ -2931,6 +2931,10 @@ def p_param_decl_list(p):
 
 def p_param_decl_list2(p):
     """param_decl_list : param_decl_list COMMA param_definition"""
+    if p[1] is not None and p[3] is not None:  # No errors in parsing
+        if p[3].default_value is None and p[1][-1].default_value is not None:
+            src.api.errmsg.syntax_error_mandatory_param_after_optional(p[3].lineno, p[1][-1].name, p[3].name)
+
     p[0] = make_param_list(p[1], p[3])
 
 
@@ -2981,13 +2985,32 @@ def p_param_def_array(p):
 
 
 def p_param_def_type(p):
-    """param_def : singleid typedef"""
+    """param_def : singleid typedef default_arg_value"""
     id_: Id = p[1]
     typedef = p[2]
     if typedef is not None:
         src.api.check.check_type_is_explicit(id_.lineno, id_.name, typedef)
 
-    p[0] = make_param_decl(id_.name, id_.lineno, typedef)
+    default_value = make_typecast(typedef, p[3], id_.lineno)
+    p[0] = make_param_decl(
+        id_.name,
+        id_.lineno,
+        typedef,
+        is_array=False,
+        default_value=default_value,
+    )
+
+
+def p_param_def_default_arg_value(p):
+    """default_arg_value :
+    | EQ expr
+    """
+    if len(p) == 1:
+        p[0] = None
+        return
+
+    p[0] = p[2]
+    return
 
 
 def p_function_body(p):

src/zxbc/zxbparser.py

@@ -0,0 +1,53 @@
+	org 32768
+.core.__START_PROGRAM:
+	di
+	push ix
+	push iy
+	exx
+	push hl
+	exx
+	ld hl, 0
+	add hl, sp
+	ld (.core.__CALL_BACK__), hl
+	ei
+	jp .core.__MAIN_PROGRAM__
+.core.__CALL_BACK__:
+	DEFW 0
+.core.ZXBASIC_USER_DATA:
+	; Defines USER DATA Length in bytes
+.core.ZXBASIC_USER_DATA_LEN EQU .core.ZXBASIC_USER_DATA_END - .core.ZXBASIC_USER_DATA
+	.core.__LABEL__.ZXBASIC_USER_DATA_LEN EQU .core.ZXBASIC_USER_DATA_LEN
+	.core.__LABEL__.ZXBASIC_USER_DATA EQU .core.ZXBASIC_USER_DATA
+.core.ZXBASIC_USER_DATA_END:
+.core.__MAIN_PROGRAM__:
+	ld hl, 0
+	push hl
+	call _test
+	ld hl, 0
+	ld b, h
+	ld c, l
+.core.__END_PROGRAM:
+	di
+	ld hl, (.core.__CALL_BACK__)
+	ld sp, hl
+	exx
+	pop hl
+	exx
+	pop iy
+	pop ix
+	ei
+	ret
+_test:
+	push ix
+	ld ix, 0
+	add ix, sp
+_test__leave:
+	ld sp, ix
+	pop ix
+	exx
+	pop hl
+	ex (sp), hl
+	exx
+	ret
+	;; --- end of user code ---
+	END