Added support for <...[math]> variadic arg syntax

Author: RPGHacker

docs/changelog/index.html

@@ -61,6 +61,7 @@ <h3>New features:</h3>
 			<li>Static labels (i.e. labels that don't move between passes) can now be used in more places, including if statements. (RPG Hacker)</li>
 			<li>Asar can be built as a static library. (Atari2)</li>
 			<li>Asar now uses named warnings and errors instead of magic numbers as identifiers. (p4plus2, RPG Hacker)</li>
+			<li>Variadic macro parameters now use the syntax <code class="65c816_asar">&lt;...[math]&gt;</code>, which makes them less ambiguous and helps prevent syntax parsing bugs. (RPG Hacker)</li>
 		</ul>
 
 		<h3>Bug fixes:</h3>
@@ -96,6 +97,7 @@ <h3>Deprecated features:</h3>
 			<li><code>;@command</code> and <code>@command</code> notation: Use <code>command</code> instead.</li>
 			<li>Wrapping defines to resolve in quotes (e.g. <code>db "!define"</code>): The quotes aren't needed (<code>db !define</code>).</li>
 			<li>Single-line/inline if statements: Use full if blocks with an <code>if</code>/<code>endif</code> pair instead.</li>
+			<li><code class="65c816_asar">&lt;math&gt;</code> syntax for variadic macro parameters: Use <code class="65c816_asar">&lt;...[math]&gt;</code> insread.</li>
 		</ul></div>
 
 		<hr />

docs/manual/index.html

@@ -2439,26 +2439,26 @@ <h4 id="built-in-defines">Built-in Defines</h4>
 </code></pre>
 
 In addition to named substitutions if the variadic token <code class="65c816_asar">...</code> is specified as the last parameter asar will allow an arbitrary number of parameters after all prior parameters have been satisfied.
-To access unnamed arguments of a variadic function they are declared numerically starting from 0 up to the number of provided parameters. To access the number of provided variadic arguments one may use <code class="65c816_asar">sizeof(...)</code>.
+To access unnamed parameters of a variadic macro, use the syntax <code class="65c816_asar">&lt;...[{math}]&gt;</code>, where <code class="65c816_asar">math</code> is any math expression evaluating to the index of a variadic parameter. These are declared numerically starting from 0 up to the number of provided parameters. To access the number of provided variadic arguments one may use <code class="65c816_asar">sizeof(...)</code>.
 Lastly, it is important to note that while traditionally macros do not parse defines at their creation variadic macros will.  This is to allow iteration of arguments by using defines.
 
 <pre><code class="65c816_asar">
 macro example0(...)
-	db sizeof(...), &lt;0&gt;	;04 01
+	db sizeof(...), &lt;...[0]&gt;	;04 01
 endmacro
 
 macro example1(...)
 	!a #= 0
 	while !a &lt; sizeof(...)
-		db &lt;!a&gt;		;01 02 03
+		db &lt;...[!a]&gt;		;01 02 03
 		!a #= !a+1
 	endif
 endmacro
 
 macro example2(named_parameter, ...)
 	!a #= 0
 	while !a &lt; sizeof(...)
-		db &lt;!a&gt;		;02 03 04 05 06 07
+		db &lt;...[!a]&gt;		;02 03 04 05 06 07
 		!a #= !a+1
 	endif
 	db &lt;named_parameter&gt;	;01
@@ -2467,7 +2467,7 @@ <h4 id="built-in-defines">Built-in Defines</h4>
 macro macro_with_optional_arguments(required, ...)
 	db &lt;required&gt;
 	if sizeof(...) &gt; 0
-		db &lt;0&gt;
+		db &lt;...[0]&gt;
 	end
 end
 

src/asar-tests/test.cpp

@@ -1073,6 +1073,10 @@ int main(int argc, char * argv[])
 
 	free(smwrom);
 
+#if defined(ASAR_TEST_DLL)
+	asar_close();
+#endif
+
 	printf("%u out of %u performed tests succeeded.\n", (unsigned int)(input_files.size() - (size_t)numfailed), (unsigned int)input_files.size());
 
 	if (numfailed > 0)
@@ -1081,9 +1085,5 @@ int main(int argc, char * argv[])
 		return 1;
 	}
 
-#if defined(ASAR_TEST_DLL)
-	asar_close();
-#endif
-
 	return 0;
 }

src/asar/errors.cpp

@@ -284,7 +284,10 @@ static asar_error_mapping asar_errors[] =
 	{ ERR(pushns_without_pullns), "pushns without matching pullns." },
 	{ ERR(pullns_without_pushns), "pullns without matching pushns." },
 
-	{ ERR(label_forward), "The use of forward labels is not allowed in this context" },
+	{ ERR(label_forward), "The use of forward labels is not allowed in this context." },
+
+	{ ERR(unclosed_vararg), "Variadic macro parameter wasn't closed properly." },
+	{ ERR(invalid_vararg), "Trying to use variadic macro parameter syntax to resolve a non variadic argument." },
 };
 // RPG Hacker: Sanity check. This makes sure that the element count of asar_warnings
 // matches with the number of constants in asar_warning_id. This is important, because

src/asar/errors.h

@@ -259,6 +259,9 @@ enum asar_error_id : int
 	error_id_pullns_without_pushns,
 
 	error_id_label_forward,
+	
+	error_id_unclosed_vararg,
+	error_id_invalid_vararg,
 
 	error_id_end,
 	error_id_count = error_id_end - error_id_start - 1,

src/asar/macro.cpp

@@ -6,6 +6,7 @@
 #include "assembleblock.h"
 #include "macro.h"
 #include "asar_math.h"
+#include "warnings.h"
 
 assocarr<macrodata*> macros;
 static string thisname;
@@ -169,6 +170,17 @@ void callmacro(const char * data)
 						out+=*(in++);
 						continue;
 					}
+					
+					bool proper_variadic = false;
+					if (in[1] == '.' && in[2] == '.' && in[3] == '.' && in[4] == '[')
+					{
+						if (end[-1] != ']')
+							asar_throw_error(0, error_type_block, error_id_unclosed_vararg);
+							
+						proper_variadic = true;
+						in += 4;
+						end[-1]=0;
+					}
 
 					*end=0;
 					in++;
@@ -178,7 +190,7 @@ void callmacro(const char * data)
 					bool valid_named_param = confirmname(in);
 					if (!valid_named_param && !thismacro->variadic) asar_throw_error(0, error_type_block, error_id_invalid_macro_param_name);
 					bool found=false;
-					for (int j=0;thismacro->arguments[j];j++)
+					for (int j=0;thismacro->arguments[j]&&!proper_variadic;j++)
 					{
 						if (!strcmp(in, thismacro->arguments[j]))
 						{
@@ -195,8 +207,17 @@ void callmacro(const char * data)
 					if (!found)
 					{
 						snes_label ret;
-						if(valid_named_param  && !thismacro->variadic) asar_throw_error(0, error_type_block, error_id_macro_param_not_found, in);
-						if(thismacro->variadic && valid_named_param && !labelval(in, &ret, false))  asar_throw_error(0, error_type_block, error_id_macro_param_not_found, in);
+						if(valid_named_param && !thismacro->variadic)
+						{
+							if (proper_variadic) asar_throw_error(0, error_type_block, error_id_invalid_vararg, in);
+							else asar_throw_error(0, error_type_block, error_id_macro_param_not_found, in);
+						}
+						if(thismacro->variadic && valid_named_param && !labelval(in, &ret, false))
+						{
+							if (proper_variadic) asar_throw_error(0, error_type_block, error_id_invalid_vararg, in);
+							else asar_throw_error(0, error_type_block, error_id_macro_param_not_found, in);
+						}
+						if(!proper_variadic) asar_throw_warning(0, warning_id_feature_deprecated, "'<math>' syntax for variadic macro parameters", "Use '<...[math]>' instead.");
 						int arg_num = getnum(in);
 
 						if(forwardlabel) asar_throw_error(0, error_type_block, error_id_label_forward);

tests/variadic_errors.asm

@@ -1,5 +1,9 @@
 ;`errEvararg_must_be_last
 ;`errEinvalid_macro_param_name
+;`warnWfeature_deprecated
+;`errEunclosed_vararg
+;`errEinvalid_vararg
+;`errEinvalid_vararg
 ;`errEvararg_sizeof_nomacro
 ;`errEmacro_not_varadic
 ;`errEvararg_out_of_bounds
@@ -19,11 +23,11 @@ macro asd(..., dfg)
 endmacro
 
 macro sorry(...)
-	db <-1>
+	db <...[-1]>
 endmacro
 
 macro sorry2(asd, ...)
-	db <10>
+	db <...[10]>
 endmacro
 
 macro normal()
@@ -46,3 +50,24 @@ db $FF, $FF
 %sorry2(0)
 %sorry3()
 
+
+macro deprecated(...)
+	db <0>
+endmacro
+
+macro unclosed(...)
+	db <...[0>
+endmacro
+
+macro invalid(named, ...)
+	db <...[named]>
+endmacro
+
+macro invalid_2(named)
+	db <...[named]>
+endmacro
+
+%deprecated($01)
+%unclosed($01)
+%invalid($01, $01)
+%invalid_2($01)

tests/variadic_syntax.asm

@@ -1,25 +1,27 @@
 ;`01 01 01 FF FF 05 01 01 FF FF 01 02 03 04 05 06 07 FF FF 02 03 04 05 06 07 01 01 02 03
+;`warnWfeature_deprecated
+;`warnWfeature_deprecated
 lorom
 org $008000
 
 !a = 0
 macro asd(...)
-	db sizeof(...), <0>, <!a>
+	db sizeof(...), <...[0]>, <!a> ; Intentionally uses deprecated syntax, to make sure it still works
 endmacro
 
 macro sorry(...)
 	!a = 0
 	while !a < sizeof(...)
-		db <!a>
+		db <...[!a]>
 		!a #= !a+1
 	endwhile
 endmacro
 
 macro sorry2(asd, ...)
 	!a = 0
-	db <0>
+	db <...[0]>
 	while !a < sizeof(...)-1
-		db <!a+1>
+		db <...[!a+1]>
 		!a #= !a+1
 	endwhile
 	db <asd>
@@ -28,7 +30,7 @@ endmacro
 macro optional(required, ...)
 	db <required>
 	if sizeof(...) > 0
-		db <0>
+		db <...[0]>
 	endif
 endmacro