[copilot edited] Allow macro calls to use line return around parenthesis

Author: Krusty/Benediction

cpclib-asm/src/parser/common.rs

@@ -616,9 +616,14 @@ pub fn parse_line_component_standard(
 
         // otherwise this is a normal stuff
 
-        // we must have an instruction if label is missing; otherwise it is optional
+        // We speculatively parse an instruction first; on failure, restore input so
+        // the macro-call fallback sees the original span (e.g. NAME(args)).
+        let before_instruction = input.checkpoint();
         let instruction =
             opt(alt((parse_z80_directive_with_block, parse_single_token))).parse_next(input)?;
+        if instruction.is_none() {
+            input.reset(&before_instruction);
+        }
 
         if label.is_some() && instruction.is_none() {
             if let Ok(call) = parse_macro_or_struct_call_inner(false, label.take().unwrap()) // label is eaten

cpclib-asm/src/parser/directives.rs

@@ -27,8 +27,9 @@ use cpclib_tokens::macro_segment::tokenize_macro_body;
 use cpclib_tokens::{Expr, ExprFormat, FormattedExpr};
 
 use super::common::{
-    inner_code, inner_code_with_state, my_line_ending, my_many0_nocollect, my_space0, my_space1,
-    parse_argname_and_value, parse_comma, parse_comment, parse_convertible_word,
+    inner_code, inner_code_with_state, my_line_ending, my_many0_nocollect, my_space0,
+    my_space0_with_newlines, my_space1, parse_argname_and_value, parse_comma,
+    parse_comma_multiline, parse_comment, parse_convertible_word,
     parse_optional_argname_and_value, parse_word
 };
 use super::context;
@@ -2926,63 +2927,112 @@ pub fn parse_macro_or_struct_call_inner(
 
         let has_parenthesis = opt((
             '(',
-            my_space0,
-            not(alt((("void", my_space0).value(()), ')'.value(()))))
+            my_space0_with_newlines,
+            not(alt((("void", my_space0_with_newlines).value(()), ')'.value(()))))
         ))
         .parse_next(input)?
         .is_some();
-        let args: Vec<(LocatedMacroParam, &[u8])> = if peek(alt((
-            eof.value(()),
-            parse_comment.value(()),
-            line_ending.value(()),
-            ':'.value(())
-        )))
-        .parse_next(input)
-        .is_ok()
+        let args: Vec<(LocatedMacroParam, &[u8])> = if !has_parenthesis
+            && peek(alt((
+                eof.value(()),
+                parse_comment.value(()),
+                line_ending.value(()),
+                ':'.value(())
+            )))
+            .parse_next(input)
+            .is_ok()
+            || (has_parenthesis
+                && peek(alt((eof.value(()), parse_comment.value(()), ':'.value(()))))
+                    .parse_next(input)
+                    .is_ok())
         {
             vec![]
         }
         else {
-            cut_err(
-                alt((
-                    delimited(
-                        my_space0,
+            if has_parenthesis {
+                cut_err(
+                    alt((
+                        delimited(
+                            my_space0,
+                            alt((
+                                "()".value(()),
+                                Caseless("(void)").value(()),
+                                parse_comment.value(())
+                            )),
+                            my_space0
+                        )
+                        .value(Default::default()),
                         alt((
-                            "()".value(()),
-                            Caseless("(void)").value(()),
-                            parse_comment.value(())
-                        )),
-                        my_space0
-                    )
-                    .value(Default::default()),
+                            alt((Caseless("(void)"), "()")).value(Vec::new()),
+                            delimited(
+                                my_space0_with_newlines,
+                                separated(
+                                    1..,
+                                    alt((
+                                        parse_macro_arg.with_taken(),
+                                        my_space1
+                                            .map(|space: InnerZ80Span| {
+                                                LocatedMacroParam::RawArgument(space.into())
+                                            })
+                                            .with_taken()
+                                    )),
+                                    parse_comma_multiline
+                                ),
+                                my_space0_with_newlines
+                            )
+                        ))
+                    ))
+                    .context(if for_struct {
+                        "STRUCT: error in arguments list"
+                    }
+                    else {
+                        "MACRO or STRUCT: forbidden name"
+                    })
+                )
+                .parse_next(input)?
+            }
+            else {
+                cut_err(
                     alt((
-                        alt((Caseless("(void)"), "()")).value(Vec::new()),
-                        separated(
-                            1..,
+                        delimited(
+                            my_space0,
                             alt((
-                                parse_macro_arg.with_taken(),
-                                my_space1
-                                    .map(|space: InnerZ80Span| {
-                                        LocatedMacroParam::RawArgument(space.into())
-                                    })
-                                    .with_taken()
+                                "()".value(()),
+                                Caseless("(void)").value(()),
+                                parse_comment.value(())
                             )),
-                            parse_comma
+                            my_space0
                         )
+                        .value(Default::default()),
+                        alt((
+                            alt((Caseless("(void)"), "()")).value(Vec::new()),
+                            separated(
+                                1..,
+                                alt((
+                                    parse_macro_arg.with_taken(),
+                                    my_space1
+                                        .map(|space: InnerZ80Span| {
+                                            LocatedMacroParam::RawArgument(space.into())
+                                        })
+                                        .with_taken()
+                                )),
+                                parse_comma
+                            )
+                        ))
                     ))
-                ))
-                .context(if for_struct {
-                    "STRUCT: error in arguments list"
-                }
-                else {
-                    "MACRO or STRUCT: forbidden name"
-                })
-            )
-            .parse_next(input)?
+                    .context(if for_struct {
+                        "STRUCT: error in arguments list"
+                    }
+                    else {
+                        "MACRO or STRUCT: forbidden name"
+                    })
+                )
+                .parse_next(input)?
+            }
         };
 
         if has_parenthesis {
-            (my_space0, ')', my_space0).parse_next(input)?;
+            (my_space0_with_newlines, ')', my_space0).parse_next(input)?;
         }
 
         if args.len() == 1 && args.first().unwrap().0.is_empty() {
@@ -3251,4 +3301,39 @@ mod tests {
             assert!(res.res.is_ok(), "Should parse successfully: {}", input);
         }
     }
+
+
+    #[test]
+    fn test_parse_macro_call() {
+        let cases = [
+            ("MACRO1", "MACRO1()", 0),
+            ("MACRO2", "MACRO2(void)", 0),
+            ("MACRO3", "MACRO3(42)", 1),
+            ("MACRO4", "MACRO4(arg1, arg2, arg3)", 3),
+            ("MACRO5", "MACRO5([nested, list], {eval} evaluated_arg, raw_arg)", 3),
+            ("SWITCH_VALUES", "SWITCH_VALUES(scroller_configuration_table.current_generating_code_table,scroller_configuration_table.next_generating_code_table)", 2),
+            ("SWITCH_VALUES", "SWITCH_VALUES(\nscroller_configuration_table.current_generating_code_table,\nscroller_configuration_table.next_generating_code_table\n)", 2),
+            ("add_to_a", "add_to_a(10)", 1)
+        ];
+
+        for (name, call, expected_args) in cases {
+            let res = dbg!(parse_test(parse_macro_or_struct_call(false, false), call));
+            assert!(
+                res.res.is_ok(),
+                "Should parse successfully: {} (error: {:?})",
+                call,
+                res.res.err()
+            );
+
+            let token = dbg!(res.res.unwrap().inner.left().unwrap());
+            if let LocatedTokenInner::MacroCall(call_name, args) = token {
+                assert_eq!(call_name.as_bstr(), name.as_bytes(), "Macro name should match");
+                assert_eq!(args.len(), expected_args, "Expected {} arguments, got {}", expected_args, args.len());
+                println!("Parsed macro call: {} with args: {:?}", call_name, args);
+            }
+            else {
+                panic!("Expected a MacroCall token");
+            }
+        }
+    }
 }

cpclib-asm/src/parser/parser.rs

@@ -987,6 +987,20 @@ MEND";
     #[test]
     fn test_parse_macro_call() {
         assert!(dbg!(parse_test(parse_line_component, "empty     (void)")).is_ok());
+        assert!(dbg!(parse_test(parse_line_component, "add_to_a(10)")).is_ok());
+        assert!(dbg!(parse_test(
+            inner_code,
+            "\
+macro add_to_a value\n\
+    add a, {value}\n\
+endm\n\
+\n\
+ld a, 5\n\
+add_to_a(10)\n\
+add_to_a(3)\n\
+"
+        ))
+        .is_ok());
 
         let res = dbg!(parse_test(
             (parse_line_component, ':', parse_line_component),