* Add support for RISC-V CORE-V extension (XCvBitmanip) with version 1.0.
+* The scrubber (pre-processor) now leaves in place more whitespace, to permit
+ various constructs not fitting the basic "insn opnd1,opnd2[,...]" scheme to
+ work. This, however, means that macro invocations like "m 1 + 2", i.e. not
+ using double quotes or parentheses around the (apparently) sole argument,
+ will now be treated as passing three arguments. Such lack of quotation /
+ parenthesization was never reliable to use.
+
Changes in 2.43:
* Add support for LoongArch .option for fine-grained control of assembly
/*State 0: beginning of normal line
1: After first whitespace on line (flush more white)
- 2: After first non-white (opcode) on line (keep 1white)
- 3: after second white on line (into operands) (flush white)
+ 2: After first non-white (opcode or maybe label when they're followed
+ by colons) on line (keep 1white)
+ 3: after subsequent white on line (typically into operands)
+ (flush more white)
4: after putting out a .linefile, put out digits
5: parsing a string, then go to old-state
6: putting out \ escape in a "d string.
7: no longer used
8: no longer used
- 9: After seeing symbol char in state 3 (keep 1white after symchar)
- 10: After seeing whitespace in state 9 (keep white before symchar)
- 11: After seeing a symbol character in state 0 (eg a label definition)
+ 9: After seeing non-white in state 3 (keep 1white)
+ 10: no longer used
+ 11: After seeing a non-white character in state 0 (eg a label definition)
-1: output string in out_string and go to the state in old_state
12: no longer used
#ifdef DOUBLEBAR_PARALLEL
&& (state < 1 || strchr (tc_comment_chars, ch)))
|| IS_NEWLINE (ch)
|| IS_LINE_SEPARATOR (ch)
- || IS_PARALLEL_SEPARATOR (ch))
+ || IS_PARALLEL_SEPARATOR (ch)
+ /* See comma related comment near the bottom of the function.
+ Reasoning equally applies to whitespace preceding a comma in
+ most cases. */
+ || (ch == ',' && state > 2 && state != 11))
{
if (scrub_m68k_mri)
{
character at the beginning of a line. */
goto recycle;
case 2:
+ case 9:
state = 3;
if (to + 1 < toend)
{
break;
}
goto recycle; /* Sp in operands */
- case 9:
- case 10:
-#ifndef TC_KEEP_OPERAND_SPACES
- if (scrub_m68k_mri)
-#endif
- {
- /* In MRI mode, we keep these spaces. */
- state = 3;
- UNGET (ch);
- PUT (' ');
- break;
- }
- state = 10; /* Sp after symbol char */
- goto recycle;
case 11:
if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
state = 1;
{
if (ch2 != EOF)
UNGET (ch2);
- if (state == 9 || state == 10)
- state = 3;
+ if (state == 1)
+ state = 2;
+ else if (state == 3)
+ state = 9;
PUT (ch);
}
break;
case LEX_IS_STRINGQUOTE:
quotechar = ch;
- if (state == 10)
- {
- /* Preserve the whitespace in foo "bar". */
- UNGET (ch);
- state = 3;
- PUT (' ');
-
- /* PUT didn't jump out. We could just break, but we
- know what will happen, so optimize a bit. */
- ch = GET ();
- old_state = 9;
- }
- else if (state == 3)
+ if (state == 3)
old_state = 9;
else if (state == 0)
old_state = 11; /* Now seeing label definition. */
UNGET (c);
}
#endif
- if (state == 10)
- {
- /* Preserve the whitespace in foo 'b'. */
- UNGET (ch);
- state = 3;
- PUT (' ');
- break;
- }
ch = GET ();
if (ch == EOF)
{
PUT (out_buf[0]);
break;
}
- if (state == 9)
- old_state = 3;
- else
- old_state = state;
+ old_state = state;
state = -1;
out_string = out_buf;
PUT (*out_string++);
#ifdef KEEP_WHITE_AROUND_COLON
state = 9;
#else
- if (state == 9 || state == 10)
- state = 3;
- else if (state != 3)
+ if (state == 2 || state == 11)
state = 1;
+ else
+ state = 9;
#endif
PUT (ch);
break;
break;
}
-#ifdef TC_D10V
- /* All insns end in a char for which LEX_IS_SYMBOL_COMPONENT is true.
- Trap is the only short insn that has a first operand that is
- neither register nor label.
- We must prevent exef0f ||trap #1 to degenerate to exef0f ||trap#1 .
- We can't make '#' LEX_IS_SYMBOL_COMPONENT because it is
- already LEX_IS_LINE_COMMENT_START. However, it is the
- only character in line_comment_chars for d10v, hence we
- can recognize it as such. */
- /* An alternative approach would be to reset the state to 1 when
- we see '||', '<'- or '->', but that seems to be overkill. */
- if (state == 10)
- PUT (' ');
-#endif
/* We have a line comment character which is not at the
start of a line. If this is also a normal comment
character, fall through. Otherwise treat it as a default
/* Fall through. */
case LEX_IS_SYMBOL_COMPONENT:
- if (state == 10)
- {
- /* This is a symbol character following another symbol
- character, with whitespace in between. We skipped
- the whitespace earlier, so output it now. */
- UNGET (ch);
- state = 3;
- PUT (' ');
- break;
- }
-
#ifdef TC_Z80
/* "af'" is a symbol containing '\''. */
if (state == 3 && (ch == 'a' || ch == 'A'))
}
}
#endif
- if (state == 3)
+
+ /* Fall through. */
+ default:
+ de_fault:
+ /* Some relatively `normal' character. */
+ if (state == 0)
+ state = 11; /* Now seeing label definition. */
+ else if (state == 1)
+ state = 2; /* Ditto. */
+ else if (state == 3)
state = 9;
/* This is a common case. Quickly copy CH and all the
&& mri_state == NULL
#if defined TC_ARM && defined OBJ_ELF
&& symver_state == NULL
+#endif
+#ifdef TC_Z80
+ /* See comma related comment below. */
+ && ch != ','
#endif
)
{
if (type != 0
&& type != LEX_IS_SYMBOL_COMPONENT)
break;
+#ifdef TC_Z80
+ /* Need to split at commas, to be able to enter state 16
+ when needed. */
+ if (ch2 == ',')
+ break;
+#endif
}
if (s > from)
}
}
- /* Fall through. */
- default:
- de_fault:
- /* Some relatively `normal' character. */
- if (state == 0)
- {
- state = 11; /* Now seeing label definition. */
- }
- else if (state == 1)
- {
- state = 2; /* Ditto. */
- }
- else if (state == 9)
- {
- if (!IS_SYMBOL_COMPONENT (ch))
- state = 3;
- }
- else if (state == 10)
- {
- if (ch == '\\')
- {
- /* Special handling for backslash: a backslash may
- be the beginning of a formal parameter (of a
- macro) following another symbol character, with
- whitespace in between. If that is the case, we
- output a space before the parameter. Strictly
- speaking, correct handling depends upon what the
- macro parameter expands into; if the parameter
- expands into something which does not start with
- an operand character, then we don't want to keep
- the space. We don't have enough information to
- make the right choice, so here we are making the
- choice which is more likely to be correct. */
- if (to + 1 >= toend)
- {
- /* If we're near the end of the buffer, save the
- character for the next time round. Otherwise
- we'll lose our state. */
- UNGET (ch);
- goto tofull;
- }
- *to++ = ' ';
- }
+ /* As a special case, to limit the delta to previous behavior, e.g.
+ also affecting listings, go straight to state 3 when seeing a
+ comma. Commas are special: While they can be used to separate
+ macro parameters or arguments, they cannot (on their own, i.e.
+ without quoting) be arguments (or parameter default values).
+ Hence successive whitespace is not meaningful there. */
+ if (ch == ',' && state == 9)
+ state = 3;
- state = 3;
- }
PUT (ch);
break;
}
static inline bool
skip_past_char (char **str, char c)
{
+ skip_whitespace (*str);
if (**str == c)
{
(*str)++;
start++;
#endif
+ skip_whitespace (start);
p = start;
if (!ISALPHA (*p) || !is_name_beginner (*p))
return NULL;
struct vector_type_el *typeinfo, unsigned int flags)
{
char *str = *ccp;
- bool is_alpha = ISALPHA (*str);
- const reg_entry *reg = parse_reg (&str);
+ bool is_alpha;
+ const reg_entry *reg;
struct vector_type_el atype;
struct vector_type_el parsetype;
bool is_typed_vecreg = false;
unsigned int err_flags = (flags & PTR_IN_REGLIST) ? SEF_IN_REGLIST : 0;
+ skip_whitespace (str);
+ is_alpha = ISALPHA (*str);
+ reg = parse_reg (&str);
+
atype.defined = 0;
atype.type = NT_invtype;
atype.width = -1;
do
{
if (in_range)
- {
- str++; /* skip over '-' */
- val_range = val;
- }
+ val_range = val;
const reg_entry *reg;
if (has_qualifier)
in_range = 0;
ptr_flags |= PTR_GOOD_MATCH;
}
- while (skip_past_comma (&str) || (in_range = 1, *str == '-'));
+ while (skip_past_comma (&str)
+ || (in_range = 1, skip_past_char (&str, '-')));
skip_whitespace (str);
if (*str != '}')
}
/* Check if we have parsed all the operands. */
+ skip_whitespace (str);
if (*str != '\0' && ! error_p ())
{
/* Set I to the index of the last present operand; this is
prefix_mode = (prefix_mode == GE_OPT_PREFIX_BIG) ? prefix_mode
: GE_OPT_PREFIX;
+ skip_whitespace (*str);
+
switch (prefix_mode)
{
case GE_NO_PREFIX: break;
while (*paramP != '}')
{
- regP = paramP;
memset (®_name, '\0', sizeof (reg_name));
+ while (ISSPACE (*paramP))
+ paramP++;
+
+ regP = paramP;
+
while (ISALNUM (*paramP))
paramP++;
/* Indicate nothing there. */
ep->X_op = O_absent;
+ /* Skip whitespace. */
+ while (ISSPACE (*s))
+ ++s;
+
if (*s == '[')
{
s = parse_exp (s + 1, &e);
+ /* Skip whitespace. */
+ while (ISSPACE (*s))
+ ++s;
+
if (*s == ']')
s++;
else
}
*oper += len;
+
+ /* Skip whitespace. */
+ while (ISSPACE (**oper))
+ ++*oper;
+
if ((*oper)[0] != '<' || (*oper)[1] != '<')
{
SET_ERROR_STRING (ERROR_UNDEFINE,
return false;
}
+ while (ISSPACE (**oper))
+ ++*oper;
+
if (!get_operand_value (op, oper, &soprnd->subs[0]))
{
*s = rc;
}
*s = rc;
- *oper += 1;
+ *oper = s + 1;
return true;
}
case OPRND_TYPE_VREG_WITH_INDEX:
if (parse_type_freg (oper, 0))
{
+ /* Skip whitespace. */
+ while (ISSPACE (**oper))
+ ++*oper;
if (**oper == '[')
{
(*oper)++;
if (is_imm_within_range (oper, 0, 0xf))
{
+ while (ISSPACE (**oper))
+ ++*oper;
if (**oper == ']')
{
unsigned int idx = --csky_insn.idx;
const char *parsestr, char **parsed_args)
{
char *p;
- char *end = NULL;
int i;
p = argstr;
i = 0;
else
{
/* Check that the argument string has no trailing arguments. */
- /* If we've got a %pmem relocation, we've zapped the parens with
- spaces. */
- if (strprefix (p, "%pmem") || strprefix (p, "%label"))
- end = strpbrk (p, ",");
- else
- end = strpbrk (p, " ,");
-
- if (end != NULL)
+ if (strpbrk (p, ",") != NULL)
as_bad (_("too many arguments"));
}
operands match. */
for (args = insn->args;; ++args)
{
+ if (*s == ' ' && *args != ' ')
+ ++s;
+
switch (*args)
{
case 'K':
'symbols' in the input string. Try not to create U
symbols for registers, etc. */
- /* This stuff checks to see if the expression ends in
- +%reg. If it does, it removes the register from
- the expression, and re-sets 's' to point to the
- right place. */
-
if (op_arg)
{
int npar = 0;
return special_case;
}
s = s1 + 1;
+ if (*s == ' ')
+ s++;
if (*s == ',' || *s == ']' || !*s)
continue;
if (*s != '+' && *s != '-')
memset (&the_insn.exp, 0, sizeof (the_insn.exp));
}
+ /* This stuff checks to see if the expression ends in
+ +%reg. If it does, it removes the register from
+ the expression, and re-sets 's' to point to the
+ right place. */
+
for (s1 = s; *s1 && *s1 != ',' && *s1 != ']'; s1++)
;
+ if (s1 != s && s1[-1] == ' ')
+ --s1;
if (s1 != s && ISDIGIT (s1[-1]))
{
if (s1[-2] == '%' && s1[-3] == '+')
- s1 -= 3;
- else if (strchr ("golir0123456789", s1[-2]) && s1[-3] == '%' && s1[-4] == '+')
- s1 -= 4;
- else if (s1[-3] == 'r' && s1[-4] == '%' && s1[-5] == '+')
- s1 -= 5;
+ {
+ if (s1[-3] == '+')
+ s1 -= 3;
+ else if (s1[-3] == ' ' && s1[-4] == '+')
+ s1 -= 4;
+ else
+ s1 = NULL;
+ }
+ else if (strchr ("golir0123456789", s1[-2]) && s1[-3] == '%')
+ {
+ if (s1[-4] == '+')
+ s1 -= 4;
+ else if (s1[-4] == ' ' && s1[-5] == '+')
+ s1 -= 5;
+ else
+ s1 = NULL;
+ }
+ else if (s1[-3] == 'r' && s1[-4] == '%')
+ {
+ if (s1[-5] == '+')
+ s1 -= 5;
+ else if (s1[-5] == ' ' && s1[-6] == '+')
+ s1 -= 6;
+ else
+ s1 = NULL;
+ }
else
s1 = NULL;
if (s1)
}
}
+ skip_white_space ();
+
if (*input_line_pointer == '}')
{
input_line_pointer++;
/* Skip the dash. */
++input_line_pointer;
+ skip_white_space ();
+
/* Get the second register in the range. */
if (! register_name (&exp2))
{
[ ]*[1-9][0-9]*[ ]+.... 0+70*[ ]+> .byte 7
[ ]*[1-9][0-9]*[ ]+.... 0+80*[ ]+> .byte 8
[ ]*[1-9][0-9]*[ ]+m[ ]+""[ ]+""[ ]+""
+[ ]*[1-9][0-9]*[ ]+
+[ ]*[1-9][0-9]*[ ]+m[ ]+1[ ]+\+2
+[ ]*[1-9][0-9]*[ ]+.... 0+10*[ ]+> .byte 1
+[ ]*[1-9][0-9]*[ ]+.... 0+20*[ ]+> .byte \+2
+[ ]*[1-9][0-9]*[ ]+m[ ]+\(3\)[ ]+\+4
+[ ]*[1-9][0-9]*[ ]+.... 0+30*[ ]+> .byte \(3\)
+[ ]*[1-9][0-9]*[ ]+.... 0+40*[ ]+> .byte \+4
+[ ]*[1-9][0-9]*[ ]+m[ ]+\(5\)[ ]+\(6\)
+[ ]*[1-9][0-9]*[ ]+.... 0+50*[ ]+> .byte \(5\)
+[ ]*[1-9][0-9]*[ ]+.... 0+60*[ ]+> .byte \(6\)
#pass
m "7" "8"
m "" "" ""
- .if 0
m 1 +2
m (3) +4
m (5) (6)
- .endif
+
+ .byte -1
{nf} \op $128, %ecx, %edx
{nf} \op $128, %r9
{nf} \op $128, %r9, %r31
- {nf} \op\()b $128, (%rax)
+ {nf} \op\(b) $128, (%rax)
{nf} \op $128, (%rax), %bl
- {nf} \op\()w $128, (%rax)
+ {nf} \op\(w) $128, (%rax)
{nf} \op $128, (%rax), %dx
- {nf} \op\()l $128, (%rax)
+ {nf} \op\(l) $128, (%rax)
{nf} \op $128, (%rax), %ecx
- {nf} \op\()q $128, (%rax)
+ {nf} \op\(q) $128, (%rax)
{nf} \op $128, (%rax), %r9
{nf} \op $1, %bl
{nf} \op $1, %ecx, %edx
{nf} \op $1, %r9
{nf} \op $1, %r9, %r31
- {nf} \op\()b $1, (%rax)
+ {nf} \op\(b) $1, (%rax)
{nf} \op $1, (%rax), %bl
- {nf} \op\()w $1, (%rax)
+ {nf} \op\(w) $1, (%rax)
{nf} \op $1, (%rax), %dx
- {nf} \op\()l $1, (%rax)
+ {nf} \op\(l) $1, (%rax)
{nf} \op $1, (%rax), %ecx
- {nf} \op\()q $1, (%rax)
+ {nf} \op\(q) $1, (%rax)
{nf} \op $1, (%rax), %r9
{nf} \op $0xff, %bl
{nf} \op $-1, %ecx, %edx
{nf} \op $-1, %r9
{nf} \op $-1, %r9, %r31
- {nf} \op\()b $0xff, (%rax)
+ {nf} \op\(b) $0xff, (%rax)
{nf} \op $-1, (%rax), %bl
- {nf} \op\()w $0xffff, (%rax)
+ {nf} \op\(w) $0xffff, (%rax)
{nf} \op $-1, (%rax), %dx
- {nf} \op\()l $0xffffffff, (%rax)
+ {nf} \op\(l) $0xffffffff, (%rax)
{nf} \op $-1, (%rax), %ecx
- {nf} \op\()q $-1, (%rax)
+ {nf} \op\(q) $-1, (%rax)
{nf} \op $-1, (%rax), %r9
.endr
{nf} ro\dir $63, %rdx
{nf} ro\dir $63, %rdx, %rax
- {nf} ro\dir\()b $7, (%rdx)
+ {nf} ro\dir\(b) $7, (%rdx)
{nf} ro\dir $7, (%rdx), %al
- {nf} ro\dir\()w $15, (%rdx)
+ {nf} ro\dir\(w) $15, (%rdx)
{nf} ro\dir $15, (%rdx), %ax
- {nf} ro\dir\()l $31, (%rdx)
+ {nf} ro\dir\(l) $31, (%rdx)
{nf} ro\dir $31, (%rdx), %eax
- {nf} ro\dir\()q $63, (%rdx)
+ {nf} ro\dir\(q) $63, (%rdx)
{nf} ro\dir $63, (%rdx), %rax
.endr
# Note: 2-6 want leaving alone with -Os.
.irp n, 1, 2, 6, 7
# Note: 16-bit 3-operand src!=dst non-ZU form needs leaving alone.
- {nf} imul $1<<\n, %\r\()dx, %\r\()cx
- {nf} imul $1<<\n, (%rdx), %\r\()cx
- {nf} imul $1<<\n, %\r\()cx, %\r\()cx
- {nf} imul $1<<\n, %\r\()cx
+ {nf} imul $1<<\n, %\r\(dx), %\r\(cx)
+ {nf} imul $1<<\n, (%rdx), %\r\(cx)
+ {nf} imul $1<<\n, %\r\(cx), %\r\(cx)
+ {nf} imul $1<<\n, %\r\(cx)
.ifeqs "\r",""
{nf} imulzu $1<<\n, %dx, %cx
char rxbuf[CGEN_MAX_RX_ELEMENTS];
char *rx = rxbuf;
const CGEN_SYNTAX_CHAR_TYPE *syn;
+ char prev_syntax_char = 0;
int reg_err;
syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
{
char c = CGEN_SYNTAX_CHAR (* syn);
+ /* See whitespace related comments in parse_insn_normal(). */
+ if (c != ' ' && prev_syntax_char != ' '
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ {
+ *rx++ = ' ';
+ *rx++ = '*';
+ }
+ prev_syntax_char = c;
+
switch (c)
{
/* Escape any regex metacharacters in the syntax. */
/* Replace non-syntax fields with globs. */
*rx++ = '.';
*rx++ = '*';
+ prev_syntax_char = 0;
}
}
const char *errmsg;
const char *p;
const CGEN_SYNTAX_CHAR_TYPE * syn;
-#ifdef CGEN_MNEMONIC_OPERANDS
- /* FIXME: wip */
- int past_opcode_p;
-#endif
+ char prev_syntax_char = 0;
+ bool past_opcode_p;
/* For now we assume the mnemonic is first (there are no leading operands).
We can parse it without needing to set up operand parsing.
#ifndef CGEN_MNEMONIC_OPERANDS
if (* str && ! ISSPACE (* str))
return _("unrecognized instruction");
+ past_opcode_p = true;
+#else
+ past_opcode_p = false;
#endif
CGEN_INIT_PARSE (cd);
cgen_init_parse_operand (cd);
-#ifdef CGEN_MNEMONIC_OPERANDS
- past_opcode_p = 0;
-#endif
/* We don't check for (*str != '\0') here because we want to parse
any trailing fake arguments in the syntax string. */
while (* syn != 0)
{
+ char c = CGEN_SYNTAX_CHAR_P (*syn) ? CGEN_SYNTAX_CHAR (*syn) : 0;
+
+ /* FIXME: Despite this check we may still take inappropriate advantage of
+ the fact that GAS's input scrubber will remove extraneous whitespace.
+ We may also be a little too lax with this now, yet being more strict
+ would require targets to indicate where whitespace is permissible. */
+ if (past_opcode_p && c != ' ' && ISSPACE (*str)
+ /* No whitespace between consecutive alphanumeric syntax elements. */
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ ++str;
+ prev_syntax_char = c;
+
/* Non operand chars must match exactly. */
- if (CGEN_SYNTAX_CHAR_P (* syn))
+ if (c != 0)
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- /* FIXME: We also take inappropriate advantage of the fact that
- GAS's input scrubber will remove extraneous blanks. */
- if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
+ if (TOLOWER (*str) == TOLOWER (c))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (CGEN_SYNTAX_CHAR(* syn) == ' ')
- past_opcode_p = 1;
+ if (c == ' ')
+ past_opcode_p = true;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- CGEN_SYNTAX_CHAR(*syn), *str);
+ c, *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- CGEN_SYNTAX_CHAR(*syn));
+ c);
return msg;
}
continue;
}
-#ifdef CGEN_MNEMONIC_OPERANDS
- (void) past_opcode_p;
-#endif
/* We have an operand of some sort. */
errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
if (errmsg)
char rxbuf[CGEN_MAX_RX_ELEMENTS];
char *rx = rxbuf;
const CGEN_SYNTAX_CHAR_TYPE *syn;
+ char prev_syntax_char = 0;
int reg_err;
syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
{
char c = CGEN_SYNTAX_CHAR (* syn);
+ /* See whitespace related comments in parse_insn_normal(). */
+ if (c != ' ' && prev_syntax_char != ' '
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ {
+ *rx++ = ' ';
+ *rx++ = '*';
+ }
+ prev_syntax_char = c;
+
switch (c)
{
/* Escape any regex metacharacters in the syntax. */
/* Replace non-syntax fields with globs. */
*rx++ = '.';
*rx++ = '*';
+ prev_syntax_char = 0;
}
}
const char *errmsg;
const char *p;
const CGEN_SYNTAX_CHAR_TYPE * syn;
-#ifdef CGEN_MNEMONIC_OPERANDS
- /* FIXME: wip */
- int past_opcode_p;
-#endif
+ char prev_syntax_char = 0;
+ bool past_opcode_p;
/* For now we assume the mnemonic is first (there are no leading operands).
We can parse it without needing to set up operand parsing.
#ifndef CGEN_MNEMONIC_OPERANDS
if (* str && ! ISSPACE (* str))
return _("unrecognized instruction");
+ past_opcode_p = true;
+#else
+ past_opcode_p = false;
#endif
CGEN_INIT_PARSE (cd);
cgen_init_parse_operand (cd);
-#ifdef CGEN_MNEMONIC_OPERANDS
- past_opcode_p = 0;
-#endif
/* We don't check for (*str != '\0') here because we want to parse
any trailing fake arguments in the syntax string. */
while (* syn != 0)
{
+ char c = CGEN_SYNTAX_CHAR_P (*syn) ? CGEN_SYNTAX_CHAR (*syn) : 0;
+
+ /* FIXME: Despite this check we may still take inappropriate advantage of
+ the fact that GAS's input scrubber will remove extraneous whitespace.
+ We may also be a little too lax with this now, yet being more strict
+ would require targets to indicate where whitespace is permissible. */
+ if (past_opcode_p && c != ' ' && ISSPACE (*str)
+ /* No whitespace between consecutive alphanumeric syntax elements. */
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ ++str;
+ prev_syntax_char = c;
+
/* Non operand chars must match exactly. */
- if (CGEN_SYNTAX_CHAR_P (* syn))
+ if (c != 0)
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- /* FIXME: We also take inappropriate advantage of the fact that
- GAS's input scrubber will remove extraneous blanks. */
- if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
+ if (TOLOWER (*str) == TOLOWER (c))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (CGEN_SYNTAX_CHAR(* syn) == ' ')
- past_opcode_p = 1;
+ if (c == ' ')
+ past_opcode_p = true;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- CGEN_SYNTAX_CHAR(*syn), *str);
+ c, *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- CGEN_SYNTAX_CHAR(*syn));
+ c);
return msg;
}
continue;
}
-#ifdef CGEN_MNEMONIC_OPERANDS
- (void) past_opcode_p;
-#endif
/* We have an operand of some sort. */
errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
if (errmsg)
char rxbuf[CGEN_MAX_RX_ELEMENTS];
char *rx = rxbuf;
const CGEN_SYNTAX_CHAR_TYPE *syn;
+ char prev_syntax_char = 0;
int reg_err;
syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
{
char c = CGEN_SYNTAX_CHAR (* syn);
+ /* See whitespace related comments in parse_insn_normal(). */
+ if (c != ' ' && prev_syntax_char != ' '
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ {
+ *rx++ = ' ';
+ *rx++ = '*';
+ }
+ prev_syntax_char = c;
+
switch (c)
{
/* Escape any regex metacharacters in the syntax. */
/* Replace non-syntax fields with globs. */
*rx++ = '.';
*rx++ = '*';
+ prev_syntax_char = 0;
}
}
const char *errmsg;
const char *p;
const CGEN_SYNTAX_CHAR_TYPE * syn;
-#ifdef CGEN_MNEMONIC_OPERANDS
- /* FIXME: wip */
- int past_opcode_p;
-#endif
+ char prev_syntax_char = 0;
+ bool past_opcode_p;
/* For now we assume the mnemonic is first (there are no leading operands).
We can parse it without needing to set up operand parsing.
#ifndef CGEN_MNEMONIC_OPERANDS
if (* str && ! ISSPACE (* str))
return _("unrecognized instruction");
+ past_opcode_p = true;
+#else
+ past_opcode_p = false;
#endif
CGEN_INIT_PARSE (cd);
cgen_init_parse_operand (cd);
-#ifdef CGEN_MNEMONIC_OPERANDS
- past_opcode_p = 0;
-#endif
/* We don't check for (*str != '\0') here because we want to parse
any trailing fake arguments in the syntax string. */
while (* syn != 0)
{
+ char c = CGEN_SYNTAX_CHAR_P (*syn) ? CGEN_SYNTAX_CHAR (*syn) : 0;
+
+ /* FIXME: Despite this check we may still take inappropriate advantage of
+ the fact that GAS's input scrubber will remove extraneous whitespace.
+ We may also be a little too lax with this now, yet being more strict
+ would require targets to indicate where whitespace is permissible. */
+ if (past_opcode_p && c != ' ' && ISSPACE (*str)
+ /* No whitespace between consecutive alphanumeric syntax elements. */
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ ++str;
+ prev_syntax_char = c;
+
/* Non operand chars must match exactly. */
- if (CGEN_SYNTAX_CHAR_P (* syn))
+ if (c != 0)
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- /* FIXME: We also take inappropriate advantage of the fact that
- GAS's input scrubber will remove extraneous blanks. */
- if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
+ if (TOLOWER (*str) == TOLOWER (c))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (CGEN_SYNTAX_CHAR(* syn) == ' ')
- past_opcode_p = 1;
+ if (c == ' ')
+ past_opcode_p = true;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- CGEN_SYNTAX_CHAR(*syn), *str);
+ c, *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- CGEN_SYNTAX_CHAR(*syn));
+ c);
return msg;
}
continue;
}
-#ifdef CGEN_MNEMONIC_OPERANDS
- (void) past_opcode_p;
-#endif
/* We have an operand of some sort. */
errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
if (errmsg)
char rxbuf[CGEN_MAX_RX_ELEMENTS];
char *rx = rxbuf;
const CGEN_SYNTAX_CHAR_TYPE *syn;
+ char prev_syntax_char = 0;
int reg_err;
syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
{
char c = CGEN_SYNTAX_CHAR (* syn);
+ /* See whitespace related comments in parse_insn_normal(). */
+ if (c != ' ' && prev_syntax_char != ' '
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ {
+ *rx++ = ' ';
+ *rx++ = '*';
+ }
+ prev_syntax_char = c;
+
switch (c)
{
/* Escape any regex metacharacters in the syntax. */
/* Replace non-syntax fields with globs. */
*rx++ = '.';
*rx++ = '*';
+ prev_syntax_char = 0;
}
}
const char *errmsg;
const char *p;
const CGEN_SYNTAX_CHAR_TYPE * syn;
-#ifdef CGEN_MNEMONIC_OPERANDS
- /* FIXME: wip */
- int past_opcode_p;
-#endif
+ char prev_syntax_char = 0;
+ bool past_opcode_p;
/* For now we assume the mnemonic is first (there are no leading operands).
We can parse it without needing to set up operand parsing.
#ifndef CGEN_MNEMONIC_OPERANDS
if (* str && ! ISSPACE (* str))
return _("unrecognized instruction");
+ past_opcode_p = true;
+#else
+ past_opcode_p = false;
#endif
CGEN_INIT_PARSE (cd);
cgen_init_parse_operand (cd);
-#ifdef CGEN_MNEMONIC_OPERANDS
- past_opcode_p = 0;
-#endif
/* We don't check for (*str != '\0') here because we want to parse
any trailing fake arguments in the syntax string. */
while (* syn != 0)
{
+ char c = CGEN_SYNTAX_CHAR_P (*syn) ? CGEN_SYNTAX_CHAR (*syn) : 0;
+
+ /* FIXME: Despite this check we may still take inappropriate advantage of
+ the fact that GAS's input scrubber will remove extraneous whitespace.
+ We may also be a little too lax with this now, yet being more strict
+ would require targets to indicate where whitespace is permissible. */
+ if (past_opcode_p && c != ' ' && ISSPACE (*str)
+ /* No whitespace between consecutive alphanumeric syntax elements. */
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ ++str;
+ prev_syntax_char = c;
+
/* Non operand chars must match exactly. */
- if (CGEN_SYNTAX_CHAR_P (* syn))
+ if (c != 0)
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- /* FIXME: We also take inappropriate advantage of the fact that
- GAS's input scrubber will remove extraneous blanks. */
- if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
+ if (TOLOWER (*str) == TOLOWER (c))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (CGEN_SYNTAX_CHAR(* syn) == ' ')
- past_opcode_p = 1;
+ if (c == ' ')
+ past_opcode_p = true;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- CGEN_SYNTAX_CHAR(*syn), *str);
+ c, *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- CGEN_SYNTAX_CHAR(*syn));
+ c);
return msg;
}
continue;
}
-#ifdef CGEN_MNEMONIC_OPERANDS
- (void) past_opcode_p;
-#endif
/* We have an operand of some sort. */
errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
if (errmsg)
char rxbuf[CGEN_MAX_RX_ELEMENTS];
char *rx = rxbuf;
const CGEN_SYNTAX_CHAR_TYPE *syn;
+ char prev_syntax_char = 0;
int reg_err;
syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
{
char c = CGEN_SYNTAX_CHAR (* syn);
+ /* See whitespace related comments in parse_insn_normal(). */
+ if (c != ' ' && prev_syntax_char != ' '
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ {
+ *rx++ = ' ';
+ *rx++ = '*';
+ }
+ prev_syntax_char = c;
+
switch (c)
{
/* Escape any regex metacharacters in the syntax. */
/* Replace non-syntax fields with globs. */
*rx++ = '.';
*rx++ = '*';
+ prev_syntax_char = 0;
}
}
const char *errmsg;
const char *p;
const CGEN_SYNTAX_CHAR_TYPE * syn;
-#ifdef CGEN_MNEMONIC_OPERANDS
- /* FIXME: wip */
- int past_opcode_p;
-#endif
+ char prev_syntax_char = 0;
+ bool past_opcode_p;
/* For now we assume the mnemonic is first (there are no leading operands).
We can parse it without needing to set up operand parsing.
#ifndef CGEN_MNEMONIC_OPERANDS
if (* str && ! ISSPACE (* str))
return _("unrecognized instruction");
+ past_opcode_p = true;
+#else
+ past_opcode_p = false;
#endif
CGEN_INIT_PARSE (cd);
cgen_init_parse_operand (cd);
-#ifdef CGEN_MNEMONIC_OPERANDS
- past_opcode_p = 0;
-#endif
/* We don't check for (*str != '\0') here because we want to parse
any trailing fake arguments in the syntax string. */
while (* syn != 0)
{
+ char c = CGEN_SYNTAX_CHAR_P (*syn) ? CGEN_SYNTAX_CHAR (*syn) : 0;
+
+ /* FIXME: Despite this check we may still take inappropriate advantage of
+ the fact that GAS's input scrubber will remove extraneous whitespace.
+ We may also be a little too lax with this now, yet being more strict
+ would require targets to indicate where whitespace is permissible. */
+ if (past_opcode_p && c != ' ' && ISSPACE (*str)
+ /* No whitespace between consecutive alphanumeric syntax elements. */
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ ++str;
+ prev_syntax_char = c;
+
/* Non operand chars must match exactly. */
- if (CGEN_SYNTAX_CHAR_P (* syn))
+ if (c != 0)
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- /* FIXME: We also take inappropriate advantage of the fact that
- GAS's input scrubber will remove extraneous blanks. */
- if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
+ if (TOLOWER (*str) == TOLOWER (c))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (CGEN_SYNTAX_CHAR(* syn) == ' ')
- past_opcode_p = 1;
+ if (c == ' ')
+ past_opcode_p = true;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- CGEN_SYNTAX_CHAR(*syn), *str);
+ c, *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- CGEN_SYNTAX_CHAR(*syn));
+ c);
return msg;
}
continue;
}
-#ifdef CGEN_MNEMONIC_OPERANDS
- (void) past_opcode_p;
-#endif
/* We have an operand of some sort. */
errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
if (errmsg)
char rxbuf[CGEN_MAX_RX_ELEMENTS];
char *rx = rxbuf;
const CGEN_SYNTAX_CHAR_TYPE *syn;
+ char prev_syntax_char = 0;
int reg_err;
syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
{
char c = CGEN_SYNTAX_CHAR (* syn);
+ /* See whitespace related comments in parse_insn_normal(). */
+ if (c != ' ' && prev_syntax_char != ' '
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ {
+ *rx++ = ' ';
+ *rx++ = '*';
+ }
+ prev_syntax_char = c;
+
switch (c)
{
/* Escape any regex metacharacters in the syntax. */
/* Replace non-syntax fields with globs. */
*rx++ = '.';
*rx++ = '*';
+ prev_syntax_char = 0;
}
}
const char *errmsg;
const char *p;
const CGEN_SYNTAX_CHAR_TYPE * syn;
-#ifdef CGEN_MNEMONIC_OPERANDS
- /* FIXME: wip */
- int past_opcode_p;
-#endif
+ char prev_syntax_char = 0;
+ bool past_opcode_p;
/* For now we assume the mnemonic is first (there are no leading operands).
We can parse it without needing to set up operand parsing.
#ifndef CGEN_MNEMONIC_OPERANDS
if (* str && ! ISSPACE (* str))
return _("unrecognized instruction");
+ past_opcode_p = true;
+#else
+ past_opcode_p = false;
#endif
CGEN_INIT_PARSE (cd);
cgen_init_parse_operand (cd);
-#ifdef CGEN_MNEMONIC_OPERANDS
- past_opcode_p = 0;
-#endif
/* We don't check for (*str != '\0') here because we want to parse
any trailing fake arguments in the syntax string. */
while (* syn != 0)
{
+ char c = CGEN_SYNTAX_CHAR_P (*syn) ? CGEN_SYNTAX_CHAR (*syn) : 0;
+
+ /* FIXME: Despite this check we may still take inappropriate advantage of
+ the fact that GAS's input scrubber will remove extraneous whitespace.
+ We may also be a little too lax with this now, yet being more strict
+ would require targets to indicate where whitespace is permissible. */
+ if (past_opcode_p && c != ' ' && ISSPACE (*str)
+ /* No whitespace between consecutive alphanumeric syntax elements. */
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ ++str;
+ prev_syntax_char = c;
+
/* Non operand chars must match exactly. */
- if (CGEN_SYNTAX_CHAR_P (* syn))
+ if (c != 0)
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- /* FIXME: We also take inappropriate advantage of the fact that
- GAS's input scrubber will remove extraneous blanks. */
- if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
+ if (TOLOWER (*str) == TOLOWER (c))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (CGEN_SYNTAX_CHAR(* syn) == ' ')
- past_opcode_p = 1;
+ if (c == ' ')
+ past_opcode_p = true;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- CGEN_SYNTAX_CHAR(*syn), *str);
+ c, *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- CGEN_SYNTAX_CHAR(*syn));
+ c);
return msg;
}
continue;
}
-#ifdef CGEN_MNEMONIC_OPERANDS
- (void) past_opcode_p;
-#endif
/* We have an operand of some sort. */
errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
if (errmsg)
char rxbuf[CGEN_MAX_RX_ELEMENTS];
char *rx = rxbuf;
const CGEN_SYNTAX_CHAR_TYPE *syn;
+ char prev_syntax_char = 0;
int reg_err;
syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
{
char c = CGEN_SYNTAX_CHAR (* syn);
+ /* See whitespace related comments in parse_insn_normal(). */
+ if (c != ' ' && prev_syntax_char != ' '
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ {
+ *rx++ = ' ';
+ *rx++ = '*';
+ }
+ prev_syntax_char = c;
+
switch (c)
{
/* Escape any regex metacharacters in the syntax. */
/* Replace non-syntax fields with globs. */
*rx++ = '.';
*rx++ = '*';
+ prev_syntax_char = 0;
}
}
const char *errmsg;
const char *p;
const CGEN_SYNTAX_CHAR_TYPE * syn;
-#ifdef CGEN_MNEMONIC_OPERANDS
- /* FIXME: wip */
- int past_opcode_p;
-#endif
+ char prev_syntax_char = 0;
+ bool past_opcode_p;
/* For now we assume the mnemonic is first (there are no leading operands).
We can parse it without needing to set up operand parsing.
#ifndef CGEN_MNEMONIC_OPERANDS
if (* str && ! ISSPACE (* str))
return _("unrecognized instruction");
+ past_opcode_p = true;
+#else
+ past_opcode_p = false;
#endif
CGEN_INIT_PARSE (cd);
cgen_init_parse_operand (cd);
-#ifdef CGEN_MNEMONIC_OPERANDS
- past_opcode_p = 0;
-#endif
/* We don't check for (*str != '\0') here because we want to parse
any trailing fake arguments in the syntax string. */
while (* syn != 0)
{
+ char c = CGEN_SYNTAX_CHAR_P (*syn) ? CGEN_SYNTAX_CHAR (*syn) : 0;
+
+ /* FIXME: Despite this check we may still take inappropriate advantage of
+ the fact that GAS's input scrubber will remove extraneous whitespace.
+ We may also be a little too lax with this now, yet being more strict
+ would require targets to indicate where whitespace is permissible. */
+ if (past_opcode_p && c != ' ' && ISSPACE (*str)
+ /* No whitespace between consecutive alphanumeric syntax elements. */
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ ++str;
+ prev_syntax_char = c;
+
/* Non operand chars must match exactly. */
- if (CGEN_SYNTAX_CHAR_P (* syn))
+ if (c != 0)
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- /* FIXME: We also take inappropriate advantage of the fact that
- GAS's input scrubber will remove extraneous blanks. */
- if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
+ if (TOLOWER (*str) == TOLOWER (c))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (CGEN_SYNTAX_CHAR(* syn) == ' ')
- past_opcode_p = 1;
+ if (c == ' ')
+ past_opcode_p = true;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- CGEN_SYNTAX_CHAR(*syn), *str);
+ c, *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- CGEN_SYNTAX_CHAR(*syn));
+ c);
return msg;
}
continue;
}
-#ifdef CGEN_MNEMONIC_OPERANDS
- (void) past_opcode_p;
-#endif
/* We have an operand of some sort. */
errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
if (errmsg)
char rxbuf[CGEN_MAX_RX_ELEMENTS];
char *rx = rxbuf;
const CGEN_SYNTAX_CHAR_TYPE *syn;
+ char prev_syntax_char = 0;
int reg_err;
syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
{
char c = CGEN_SYNTAX_CHAR (* syn);
+ /* See whitespace related comments in parse_insn_normal(). */
+ if (c != ' ' && prev_syntax_char != ' '
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ {
+ *rx++ = ' ';
+ *rx++ = '*';
+ }
+ prev_syntax_char = c;
+
switch (c)
{
/* Escape any regex metacharacters in the syntax. */
/* Replace non-syntax fields with globs. */
*rx++ = '.';
*rx++ = '*';
+ prev_syntax_char = 0;
}
}
const char *errmsg;
const char *p;
const CGEN_SYNTAX_CHAR_TYPE * syn;
-#ifdef CGEN_MNEMONIC_OPERANDS
- /* FIXME: wip */
- int past_opcode_p;
-#endif
+ char prev_syntax_char = 0;
+ bool past_opcode_p;
/* For now we assume the mnemonic is first (there are no leading operands).
We can parse it without needing to set up operand parsing.
#ifndef CGEN_MNEMONIC_OPERANDS
if (* str && ! ISSPACE (* str))
return _("unrecognized instruction");
+ past_opcode_p = true;
+#else
+ past_opcode_p = false;
#endif
CGEN_INIT_PARSE (cd);
cgen_init_parse_operand (cd);
-#ifdef CGEN_MNEMONIC_OPERANDS
- past_opcode_p = 0;
-#endif
/* We don't check for (*str != '\0') here because we want to parse
any trailing fake arguments in the syntax string. */
while (* syn != 0)
{
+ char c = CGEN_SYNTAX_CHAR_P (*syn) ? CGEN_SYNTAX_CHAR (*syn) : 0;
+
+ /* FIXME: Despite this check we may still take inappropriate advantage of
+ the fact that GAS's input scrubber will remove extraneous whitespace.
+ We may also be a little too lax with this now, yet being more strict
+ would require targets to indicate where whitespace is permissible. */
+ if (past_opcode_p && c != ' ' && ISSPACE (*str)
+ /* No whitespace between consecutive alphanumeric syntax elements. */
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ ++str;
+ prev_syntax_char = c;
+
/* Non operand chars must match exactly. */
- if (CGEN_SYNTAX_CHAR_P (* syn))
+ if (c != 0)
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- /* FIXME: We also take inappropriate advantage of the fact that
- GAS's input scrubber will remove extraneous blanks. */
- if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
+ if (TOLOWER (*str) == TOLOWER (c))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (CGEN_SYNTAX_CHAR(* syn) == ' ')
- past_opcode_p = 1;
+ if (c == ' ')
+ past_opcode_p = true;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- CGEN_SYNTAX_CHAR(*syn), *str);
+ c, *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- CGEN_SYNTAX_CHAR(*syn));
+ c);
return msg;
}
continue;
}
-#ifdef CGEN_MNEMONIC_OPERANDS
- (void) past_opcode_p;
-#endif
/* We have an operand of some sort. */
errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
if (errmsg)
char rxbuf[CGEN_MAX_RX_ELEMENTS];
char *rx = rxbuf;
const CGEN_SYNTAX_CHAR_TYPE *syn;
+ char prev_syntax_char = 0;
int reg_err;
syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
{
char c = CGEN_SYNTAX_CHAR (* syn);
+ /* See whitespace related comments in parse_insn_normal(). */
+ if (c != ' ' && prev_syntax_char != ' '
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ {
+ *rx++ = ' ';
+ *rx++ = '*';
+ }
+ prev_syntax_char = c;
+
switch (c)
{
/* Escape any regex metacharacters in the syntax. */
/* Replace non-syntax fields with globs. */
*rx++ = '.';
*rx++ = '*';
+ prev_syntax_char = 0;
}
}
const char *errmsg;
const char *p;
const CGEN_SYNTAX_CHAR_TYPE * syn;
-#ifdef CGEN_MNEMONIC_OPERANDS
- /* FIXME: wip */
- int past_opcode_p;
-#endif
+ char prev_syntax_char = 0;
+ bool past_opcode_p;
/* For now we assume the mnemonic is first (there are no leading operands).
We can parse it without needing to set up operand parsing.
#ifndef CGEN_MNEMONIC_OPERANDS
if (* str && ! ISSPACE (* str))
return _("unrecognized instruction");
+ past_opcode_p = true;
+#else
+ past_opcode_p = false;
#endif
CGEN_INIT_PARSE (cd);
cgen_init_parse_operand (cd);
-#ifdef CGEN_MNEMONIC_OPERANDS
- past_opcode_p = 0;
-#endif
/* We don't check for (*str != '\0') here because we want to parse
any trailing fake arguments in the syntax string. */
while (* syn != 0)
{
+ char c = CGEN_SYNTAX_CHAR_P (*syn) ? CGEN_SYNTAX_CHAR (*syn) : 0;
+
+ /* FIXME: Despite this check we may still take inappropriate advantage of
+ the fact that GAS's input scrubber will remove extraneous whitespace.
+ We may also be a little too lax with this now, yet being more strict
+ would require targets to indicate where whitespace is permissible. */
+ if (past_opcode_p && c != ' ' && ISSPACE (*str)
+ /* No whitespace between consecutive alphanumeric syntax elements. */
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ ++str;
+ prev_syntax_char = c;
+
/* Non operand chars must match exactly. */
- if (CGEN_SYNTAX_CHAR_P (* syn))
+ if (c != 0)
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- /* FIXME: We also take inappropriate advantage of the fact that
- GAS's input scrubber will remove extraneous blanks. */
- if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
+ if (TOLOWER (*str) == TOLOWER (c))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (CGEN_SYNTAX_CHAR(* syn) == ' ')
- past_opcode_p = 1;
+ if (c == ' ')
+ past_opcode_p = true;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- CGEN_SYNTAX_CHAR(*syn), *str);
+ c, *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- CGEN_SYNTAX_CHAR(*syn));
+ c);
return msg;
}
continue;
}
-#ifdef CGEN_MNEMONIC_OPERANDS
- (void) past_opcode_p;
-#endif
/* We have an operand of some sort. */
errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
if (errmsg)
char rxbuf[CGEN_MAX_RX_ELEMENTS];
char *rx = rxbuf;
const CGEN_SYNTAX_CHAR_TYPE *syn;
+ char prev_syntax_char = 0;
int reg_err;
syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
{
char c = CGEN_SYNTAX_CHAR (* syn);
+ /* See whitespace related comments in parse_insn_normal(). */
+ if (c != ' ' && prev_syntax_char != ' '
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ {
+ *rx++ = ' ';
+ *rx++ = '*';
+ }
+ prev_syntax_char = c;
+
switch (c)
{
/* Escape any regex metacharacters in the syntax. */
/* Replace non-syntax fields with globs. */
*rx++ = '.';
*rx++ = '*';
+ prev_syntax_char = 0;
}
}
const char *errmsg;
const char *p;
const CGEN_SYNTAX_CHAR_TYPE * syn;
-#ifdef CGEN_MNEMONIC_OPERANDS
- /* FIXME: wip */
- int past_opcode_p;
-#endif
+ char prev_syntax_char = 0;
+ bool past_opcode_p;
/* For now we assume the mnemonic is first (there are no leading operands).
We can parse it without needing to set up operand parsing.
#ifndef CGEN_MNEMONIC_OPERANDS
if (* str && ! ISSPACE (* str))
return _("unrecognized instruction");
+ past_opcode_p = true;
+#else
+ past_opcode_p = false;
#endif
CGEN_INIT_PARSE (cd);
cgen_init_parse_operand (cd);
-#ifdef CGEN_MNEMONIC_OPERANDS
- past_opcode_p = 0;
-#endif
/* We don't check for (*str != '\0') here because we want to parse
any trailing fake arguments in the syntax string. */
while (* syn != 0)
{
+ char c = CGEN_SYNTAX_CHAR_P (*syn) ? CGEN_SYNTAX_CHAR (*syn) : 0;
+
+ /* FIXME: Despite this check we may still take inappropriate advantage of
+ the fact that GAS's input scrubber will remove extraneous whitespace.
+ We may also be a little too lax with this now, yet being more strict
+ would require targets to indicate where whitespace is permissible. */
+ if (past_opcode_p && c != ' ' && ISSPACE (*str)
+ /* No whitespace between consecutive alphanumeric syntax elements. */
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ ++str;
+ prev_syntax_char = c;
+
/* Non operand chars must match exactly. */
- if (CGEN_SYNTAX_CHAR_P (* syn))
+ if (c != 0)
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- /* FIXME: We also take inappropriate advantage of the fact that
- GAS's input scrubber will remove extraneous blanks. */
- if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
+ if (TOLOWER (*str) == TOLOWER (c))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (CGEN_SYNTAX_CHAR(* syn) == ' ')
- past_opcode_p = 1;
+ if (c == ' ')
+ past_opcode_p = true;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- CGEN_SYNTAX_CHAR(*syn), *str);
+ c, *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- CGEN_SYNTAX_CHAR(*syn));
+ c);
return msg;
}
continue;
}
-#ifdef CGEN_MNEMONIC_OPERANDS
- (void) past_opcode_p;
-#endif
/* We have an operand of some sort. */
errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
if (errmsg)
char rxbuf[CGEN_MAX_RX_ELEMENTS];
char *rx = rxbuf;
const CGEN_SYNTAX_CHAR_TYPE *syn;
+ char prev_syntax_char = 0;
int reg_err;
syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
{
char c = CGEN_SYNTAX_CHAR (* syn);
+ /* See whitespace related comments in parse_insn_normal(). */
+ if (c != ' ' && prev_syntax_char != ' '
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ {
+ *rx++ = ' ';
+ *rx++ = '*';
+ }
+ prev_syntax_char = c;
+
switch (c)
{
/* Escape any regex metacharacters in the syntax. */
/* Replace non-syntax fields with globs. */
*rx++ = '.';
*rx++ = '*';
+ prev_syntax_char = 0;
}
}
const char *errmsg;
const char *p;
const CGEN_SYNTAX_CHAR_TYPE * syn;
-#ifdef CGEN_MNEMONIC_OPERANDS
- /* FIXME: wip */
- int past_opcode_p;
-#endif
+ char prev_syntax_char = 0;
+ bool past_opcode_p;
/* For now we assume the mnemonic is first (there are no leading operands).
We can parse it without needing to set up operand parsing.
#ifndef CGEN_MNEMONIC_OPERANDS
if (* str && ! ISSPACE (* str))
return _("unrecognized instruction");
+ past_opcode_p = true;
+#else
+ past_opcode_p = false;
#endif
CGEN_INIT_PARSE (cd);
cgen_init_parse_operand (cd);
-#ifdef CGEN_MNEMONIC_OPERANDS
- past_opcode_p = 0;
-#endif
/* We don't check for (*str != '\0') here because we want to parse
any trailing fake arguments in the syntax string. */
while (* syn != 0)
{
+ char c = CGEN_SYNTAX_CHAR_P (*syn) ? CGEN_SYNTAX_CHAR (*syn) : 0;
+
+ /* FIXME: Despite this check we may still take inappropriate advantage of
+ the fact that GAS's input scrubber will remove extraneous whitespace.
+ We may also be a little too lax with this now, yet being more strict
+ would require targets to indicate where whitespace is permissible. */
+ if (past_opcode_p && c != ' ' && ISSPACE (*str)
+ /* No whitespace between consecutive alphanumeric syntax elements. */
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ ++str;
+ prev_syntax_char = c;
+
/* Non operand chars must match exactly. */
- if (CGEN_SYNTAX_CHAR_P (* syn))
+ if (c != 0)
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- /* FIXME: We also take inappropriate advantage of the fact that
- GAS's input scrubber will remove extraneous blanks. */
- if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
+ if (TOLOWER (*str) == TOLOWER (c))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (CGEN_SYNTAX_CHAR(* syn) == ' ')
- past_opcode_p = 1;
+ if (c == ' ')
+ past_opcode_p = true;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- CGEN_SYNTAX_CHAR(*syn), *str);
+ c, *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- CGEN_SYNTAX_CHAR(*syn));
+ c);
return msg;
}
continue;
}
-#ifdef CGEN_MNEMONIC_OPERANDS
- (void) past_opcode_p;
-#endif
/* We have an operand of some sort. */
errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
if (errmsg)
while (*plex)
{
+ if (ISSPACE (*p))
+ ++p;
+
if (IS_LEX_CHAR (*plex))
{
/* If it's a plain char, just compare it. */
}
/* Check whether this syntax is accepted. */
+ if (ISSPACE (*p))
+ ++p;
if (*plex == 0 && (*p == '\0' || *p == '!' || *p == '#'))
return 1;
char rxbuf[CGEN_MAX_RX_ELEMENTS];
char *rx = rxbuf;
const CGEN_SYNTAX_CHAR_TYPE *syn;
+ char prev_syntax_char = 0;
int reg_err;
syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
{
char c = CGEN_SYNTAX_CHAR (* syn);
+ /* See whitespace related comments in parse_insn_normal(). */
+ if (c != ' ' && prev_syntax_char != ' '
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ {
+ *rx++ = ' ';
+ *rx++ = '*';
+ }
+ prev_syntax_char = c;
+
switch (c)
{
/* Escape any regex metacharacters in the syntax. */
/* Replace non-syntax fields with globs. */
*rx++ = '.';
*rx++ = '*';
+ prev_syntax_char = 0;
}
}
const char *errmsg;
const char *p;
const CGEN_SYNTAX_CHAR_TYPE * syn;
-#ifdef CGEN_MNEMONIC_OPERANDS
- /* FIXME: wip */
- int past_opcode_p;
-#endif
+ char prev_syntax_char = 0;
+ bool past_opcode_p;
/* For now we assume the mnemonic is first (there are no leading operands).
We can parse it without needing to set up operand parsing.
#ifndef CGEN_MNEMONIC_OPERANDS
if (* str && ! ISSPACE (* str))
return _("unrecognized instruction");
+ past_opcode_p = true;
+#else
+ past_opcode_p = false;
#endif
CGEN_INIT_PARSE (cd);
cgen_init_parse_operand (cd);
-#ifdef CGEN_MNEMONIC_OPERANDS
- past_opcode_p = 0;
-#endif
/* We don't check for (*str != '\0') here because we want to parse
any trailing fake arguments in the syntax string. */
while (* syn != 0)
{
+ char c = CGEN_SYNTAX_CHAR_P (*syn) ? CGEN_SYNTAX_CHAR (*syn) : 0;
+
+ /* FIXME: Despite this check we may still take inappropriate advantage of
+ the fact that GAS's input scrubber will remove extraneous whitespace.
+ We may also be a little too lax with this now, yet being more strict
+ would require targets to indicate where whitespace is permissible. */
+ if (past_opcode_p && c != ' ' && ISSPACE (*str)
+ /* No whitespace between consecutive alphanumeric syntax elements. */
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ ++str;
+ prev_syntax_char = c;
+
/* Non operand chars must match exactly. */
- if (CGEN_SYNTAX_CHAR_P (* syn))
+ if (c != 0)
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- /* FIXME: We also take inappropriate advantage of the fact that
- GAS's input scrubber will remove extraneous blanks. */
- if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
+ if (TOLOWER (*str) == TOLOWER (c))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (CGEN_SYNTAX_CHAR(* syn) == ' ')
- past_opcode_p = 1;
+ if (c == ' ')
+ past_opcode_p = true;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- CGEN_SYNTAX_CHAR(*syn), *str);
+ c, *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- CGEN_SYNTAX_CHAR(*syn));
+ c);
return msg;
}
continue;
}
-#ifdef CGEN_MNEMONIC_OPERANDS
- (void) past_opcode_p;
-#endif
/* We have an operand of some sort. */
errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
if (errmsg)
char rxbuf[CGEN_MAX_RX_ELEMENTS];
char *rx = rxbuf;
const CGEN_SYNTAX_CHAR_TYPE *syn;
+ char prev_syntax_char = 0;
int reg_err;
syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
{
char c = CGEN_SYNTAX_CHAR (* syn);
+ /* See whitespace related comments in parse_insn_normal(). */
+ if (c != ' ' && prev_syntax_char != ' '
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ {
+ *rx++ = ' ';
+ *rx++ = '*';
+ }
+ prev_syntax_char = c;
+
switch (c)
{
/* Escape any regex metacharacters in the syntax. */
/* Replace non-syntax fields with globs. */
*rx++ = '.';
*rx++ = '*';
+ prev_syntax_char = 0;
}
}
const char *errmsg;
const char *p;
const CGEN_SYNTAX_CHAR_TYPE * syn;
-#ifdef CGEN_MNEMONIC_OPERANDS
- /* FIXME: wip */
- int past_opcode_p;
-#endif
+ char prev_syntax_char = 0;
+ bool past_opcode_p;
/* For now we assume the mnemonic is first (there are no leading operands).
We can parse it without needing to set up operand parsing.
#ifndef CGEN_MNEMONIC_OPERANDS
if (* str && ! ISSPACE (* str))
return _("unrecognized instruction");
+ past_opcode_p = true;
+#else
+ past_opcode_p = false;
#endif
CGEN_INIT_PARSE (cd);
cgen_init_parse_operand (cd);
-#ifdef CGEN_MNEMONIC_OPERANDS
- past_opcode_p = 0;
-#endif
/* We don't check for (*str != '\0') here because we want to parse
any trailing fake arguments in the syntax string. */
while (* syn != 0)
{
+ char c = CGEN_SYNTAX_CHAR_P (*syn) ? CGEN_SYNTAX_CHAR (*syn) : 0;
+
+ /* FIXME: Despite this check we may still take inappropriate advantage of
+ the fact that GAS's input scrubber will remove extraneous whitespace.
+ We may also be a little too lax with this now, yet being more strict
+ would require targets to indicate where whitespace is permissible. */
+ if (past_opcode_p && c != ' ' && ISSPACE (*str)
+ /* No whitespace between consecutive alphanumeric syntax elements. */
+ && (!ISALNUM (c) || !ISALNUM (prev_syntax_char)))
+ ++str;
+ prev_syntax_char = c;
+
/* Non operand chars must match exactly. */
- if (CGEN_SYNTAX_CHAR_P (* syn))
+ if (c != 0)
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- /* FIXME: We also take inappropriate advantage of the fact that
- GAS's input scrubber will remove extraneous blanks. */
- if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
+ if (TOLOWER (*str) == TOLOWER (c))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (CGEN_SYNTAX_CHAR(* syn) == ' ')
- past_opcode_p = 1;
+ if (c == ' ')
+ past_opcode_p = true;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- CGEN_SYNTAX_CHAR(*syn), *str);
+ c, *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- CGEN_SYNTAX_CHAR(*syn));
+ c);
return msg;
}
continue;
}
-#ifdef CGEN_MNEMONIC_OPERANDS
- (void) past_opcode_p;
-#endif
/* We have an operand of some sort. */
errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
if (errmsg)
projects / thirdparty / binutils-gdb.git / commitdiff
