add more eval tests and comments; undo change that caused failing tests

Author: linuxlizard

pymake/pymake.py

@@ -370,10 +370,10 @@ def _is_recipe_comment(tok):
             except Exception as err:
                 # My code crashed. For shame!
                 logger.exception(err)
-                logger.error("INTERNAL ERROR eval exception during token makefile=\"\"\"\n%s\n\"\"\"", statement.makefile())
-                logger.error("INTERNAL ERROR eval exception during token string=%s", str(statement))
+                logger.error("INTERNAL ERROR exception during token makefile=\"\"\"\n%s\n\"\"\"", statement.makefile())
+                logger.error("INTERNAL ERROR exception during token string=%s", str(statement))
                 filename,pos = statement.get_pos()
-                logger.error("eval failed statement=%r file=%s pos=%s", statement, filename, pos)
+                logger.error("execute failed pos=%r file=%s statement=%r", pos, filename, statement)
                 exit_code = 1
 
         # leave early on error
@@ -580,7 +580,20 @@ def execute(makefile, args):
     # Basically, we have context sensitive evaluation.
     curr_rules = []
 
-    # XXX experimental for handling $(eval)
+    # For handling $(eval)  This is not my proudest moment.  I originally
+    # designed my make function implementations to be truly functional (no side
+    # effects). My plan was for $(eval) to return a string of Make code that
+    # would be re-interpretted. But now I'm deep enough into implementation to
+    # understand that won't work.  The $(eval) function is entirely a side
+    # effect. The $(eval) function can add rules, execute other functions,
+    # anything.  And the $(eval) has to happen exactly in the place where it's
+    # called. 
+    # $(info $(eval foo:bar))  # add a rule; $(info) would consume the string
+    # if I simply returned "foo:bar" from $(eval)
+    #
+    # I need a way to send down the current state of the make (specifically,
+    # rules). The symbol table is the only argument passed between make
+    # functions.
     symtable.curr_rules = curr_rules
     symtable.rulesdb = rulesdb
 

pymake/symbol.py

@@ -381,11 +381,25 @@ def eval(self, symbol_table):
         # pyfiles := $(wildcard foo*.py) $(wildcard bar*.py) $(wildcard baz*.py)
         assert len(self.token_list) == 3
 
-        lhs = self.token_list[0]
-        assign_op = self.token_list[1]
-        rhs = self.token_list[2]
+        return self.assign(self.lhs, self.assign_op, self.rhs, symbol_table, self.modifier_flags)
+
+    @property 
+    def lhs(self):
+        # convenience method to get the LHS (left hand side)
+        assert isinstance(self.token_list[0], Expression), type(self.token_list[0])
+        return self.token_list[0]
 
-        return self.assign(lhs, assign_op, rhs, symbol_table, self.modifier_flags)
+    @property
+    def assign_op(self):
+        # convenience method to get the assignment operator
+        assert isinstance(self.token_list[1], AssignOp), type(self.token_list[1])
+        return self.token_list[1]
+ 
+    @property 
+    def rhs(self):
+        # convenience method to get the RHS (right hand side)
+        assert isinstance(self.token_list[2], Expression), type(self.token_list[2])
+        return self.token_list[2]
 
     def sanity(self):
         # AssignmentExpression :=  Expression AssignOp Expression

tests/eval.mk

@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (C) 2024-2025 David Poole david.poole@ericsson.com
+#
 # test the eval function
 
 $(eval FOO:=foo)

tests/test_define.py

@@ -227,13 +227,14 @@ def test_nested_define():
     with pytest.raises(StopIteration):
         s = next(vline_iter)
 
+@pytest.mark.skip(reason="spaces handling in multi-line shell assign is broken")
 def test_shell_define():
     makefile = """
 define shell_example !=
     echo foo
     echo bar
 endef
-$(info $(shell_example))
+$(info >>$(shell_example)<<)
 @:;@:
 """
     s1 = run.gnumake_string(makefile)

tests/test_eval.py

@@ -1,10 +1,49 @@
 # SPDX-License-Identifier: GPL-2.0
-# Copyright (C) 2024 David Poole david.poole@ericsson.com
+# Copyright (C) 2024-2025 David Poole david.poole@ericsson.com
 #
 # test the $(eval) function
 
+import run
 
 def test1():
-    pass
+    makefile="""
+$(eval FOO:=foo)
+ifndef FOO
+$(error FOO is missing
+endif
+ifneq ($(FOO),foo)
+$(error FOO is wrong)
+endif
+@:;@:
+"""
+    run.simple_test(makefile)
 
+def test_rule():
+    makefile="""
+$(eval @:;@:)
+"""
+    run.simple_test(makefile)
 
+def test_two_eval():
+    makefile="""
+$(eval BAR:=bar)
+$(eval FOO:=$(BAR))
+ifndef FOO
+$(error FOO is missing)
+endif
+ifneq ($(FOO),bar)
+$(error foo is wrong)
+endif
+@:;@:
+"""
+    run.simple_test(makefile)
+
+def test_eval_return():
+    makefile="""
+$(info >>$(eval FOO:=foo)<<)
+ifneq ($(FOO),foo)
+$(error foo is wrong)
+endif
+@:;@:
+"""
+    run.simple_test(makefile)

tests/test_makefile.py

@@ -93,7 +93,7 @@ def _run_pymake(infilename):
     # "file.mk",
     "call.mk",
 #        "value.mk",  # FIXME my .makefile() surrounds single letter varrefs with () even if not in the original
-    # "eval.mk",
+    "eval.mk",
     # "origin.mk",
     # "flavor.mk",
     # "shell.mk",