Switch from parentheses to angle brackets

`\(` is more likely to be a valid escape sequence in the
future (as is `\[`) and `\{` is already taken.

src/asm/lexer.c

@@ -717,19 +717,19 @@ static void freeExpansion(struct Expansion *expansion)
 
 static bool isMacroChar(char c)
 {
-	return c == '@' || c == '#' || c == '(' || (c >= '0' && c <= '9');
+	return c == '@' || c == '#' || c == '<' || (c >= '0' && c <= '9');
 }
 
-/* forward declarations for readParentheticMacroArgNum */
+/* forward declarations for readBracketedMacroArgNum */
 static int peek(void);
 static void shiftChar(void);
 static uint32_t readNumber(int radix, uint32_t baseValue);
 static bool startsIdentifier(int c);
 static bool continuesIdentifier(int c);
 
-static uint32_t readParentheticMacroArgNum(void)
+static uint32_t readBracketedMacroArgNum(void)
 {
-	dbgPrint("Reading parenthetic macro arg\n");
+	dbgPrint("Reading bracketed macro arg\n");
 	bool disableMacroArgs = lexerState->disableMacroArgs;
 	bool disableInterpolation = lexerState->disableInterpolation;
 
@@ -761,9 +761,9 @@ static uint32_t readParentheticMacroArgNum(void)
 		struct Symbol const *sym = sym_FindScopedSymbol(symName);
 
 		if (!sym)
-			fatalerror("Parenthetic symbol \"%s\" does not exist\n", symName);
+			fatalerror("Bracketed symbol \"%s\" does not exist\n", symName);
 		else if (!sym_IsNumeric(sym))
-			fatalerror("Parenthetic symbol \"%s\" is not numeric\n", symName);
+			fatalerror("Bracketed symbol \"%s\" is not numeric\n", symName);
 
 		num = sym_GetConstantSymValue(sym);
 	} else {
@@ -771,12 +771,12 @@ static uint32_t readParentheticMacroArgNum(void)
 	}
 
 	c = peek();
-	if (c != ')')
-		fatalerror("Invalid character in parenthetic macro argument %s\n", printChar(c));
+	if (c != '>')
+		fatalerror("Invalid character in bracketed macro argument %s\n", printChar(c));
 	else if (empty)
-		fatalerror("Empty parenthetic macro argument\n");
+		fatalerror("Empty bracketed macro argument\n");
 	else if (num == 0)
-		fatalerror("Invalid parenthetic macro argument '\\(0)'\n");
+		fatalerror("Invalid bracketed macro argument '\\<0>'\n");
 
 	shiftChar();
 
@@ -793,12 +793,12 @@ static char const *readMacroArg(char name)
 		str = macro_GetUniqueIDStr();
 	} else if (name == '#') {
 		str = macro_GetAllArgs();
-	} else if (name == '(') {
-		uint32_t num = readParentheticMacroArgNum();
+	} else if (name == '<') {
+		uint32_t num = readBracketedMacroArgNum();
 
 		str = macro_GetArg(num);
 		if (!str)
-			fatalerror("Macro argument '\\(%" PRIu32 ")' not defined\n", num);
+			fatalerror("Macro argument '\\<%" PRIu32 ">' not defined\n", num);
 	} else if (name == '0') {
 		fatalerror("Invalid macro argument '\\0'\n");
 	} else {
@@ -1569,7 +1569,7 @@ static void readString(void)
 			case '7':
 			case '8':
 			case '9':
-			case '(':
+			case '<':
 				shiftChar();
 				char const *str = readMacroArg(c);
 
@@ -1715,7 +1715,7 @@ static size_t appendStringLiteral(size_t i)
 			case '7':
 			case '8':
 			case '9':
-			case '(':
+			case '<':
 				shiftChar();
 				char const *str = readMacroArg(c);
 

src/asm/rgbasm.5

@@ -1567,30 +1567,30 @@ The backslash in
 does not need to be escaped because string literals also work as usual inside macro arguments.
 .Pp
 Since there are only nine digits, you can only access the first nine macro arguments like this.
-To use the rest, you need to put the multi-digit argument number in parentheses, like
-.Ql \[rs](10) .
-This parenthetic syntax supports decimal numbers and numeric symbol names.
+To use the rest, you need to put the multi-digit argument number in angle brackets, like
+.Ql \[rs]<10> .
+This bracketed syntax supports decimal numbers and numeric symbol names.
 For example,
-.Ql \[rs](_NARG)
+.Ql \[rs]<_NARG>
 will get the last argument.
 .Pp
-Other macro arguments and symbol interpolations will be expanded inside the parentheses.
+Other macro arguments and symbol interpolations will be expanded inside the angle brackets.
 For example, if
 .Ql \[rs]1
 is
 .Ql 13 ,
 then
-.Ql \[rs](\[rs]1)
+.Ql \[rs]<\[rs]1>
 will expand to
-.Ql \[rs](13) .
+.Ql \[rs]<13> .
 Or if
 .Ql v10 = 42
 and
 .Ql x = 10 ,
 then
-.Ql \[rs](v{d:x})
+.Ql \[rs]<v{d:x}>
 will expand to
-.Ql \[rs](42) .
+.Ql \[rs]<42> .
 .Pp
 Another way to access more than nine macro arguments is the
 .Ic SHIFT