* 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 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)
+ 2: After first non-white (opcode) on line (keep 1white)
+ 3: after second white on line (into operands) (flush 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 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)
+ 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)
-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)
- /* 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))
+ || IS_PARALLEL_SEPARATOR (ch))
{
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 == 1)
- state = 2;
- else if (state == 3)
- state = 9;
+ if (state == 9 || state == 10)
+ state = 3;
PUT (ch);
}
break;
case LEX_IS_STRINGQUOTE:
quotechar = ch;
- if (state == 3)
+ 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)
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;
}
- old_state = state;
+ if (state == 9)
+ old_state = 3;
+ else
+ old_state = state;
state = -1;
out_string = out_buf;
PUT (*out_string++);
#ifdef KEEP_WHITE_AROUND_COLON
state = 9;
#else
- if (state == 2 || state == 11)
+ if (state == 9 || state == 10)
+ state = 3;
+ else if (state != 3)
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
-
- /* 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)
+ 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)
}
}
- /* 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;
+ /* 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++ = ' ';
+ }
+ 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;
- const reg_entry *reg;
+ bool is_alpha = ISALPHA (*str);
+ const reg_entry *reg = parse_reg (&str);
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)
- val_range = val;
+ {
+ str++; /* skip over '-' */
+ 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, skip_past_char (&str, '-')));
+ while (skip_past_comma (&str) || (in_range = 1, *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 != '}')
{
- memset (®_name, '\0', sizeof (reg_name));
-
- while (ISSPACE (*paramP))
- paramP++;
-
regP = paramP;
+ memset (®_name, '\0', sizeof (reg_name));
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 = s + 1;
+ *oper += 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 (strpbrk (p, ",") != NULL)
+ /* 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)
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] == '+')
- {
- 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;
- }
+ 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;
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)
-
- .byte -1
+ .endif
{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;
- char prev_syntax_char = 0;
- bool past_opcode_p;
+#ifdef CGEN_MNEMONIC_OPERANDS
+ /* FIXME: wip */
+ int past_opcode_p;
+#endif
/* 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 (c != 0)
+ if (CGEN_SYNTAX_CHAR_P (* syn))
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- if (TOLOWER (*str) == TOLOWER (c))
+ /* 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)))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (c == ' ')
- past_opcode_p = true;
+ if (CGEN_SYNTAX_CHAR(* syn) == ' ')
+ past_opcode_p = 1;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- c, *str);
+ CGEN_SYNTAX_CHAR(*syn), *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- c);
+ CGEN_SYNTAX_CHAR(*syn));
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;
- char prev_syntax_char = 0;
- bool past_opcode_p;
+#ifdef CGEN_MNEMONIC_OPERANDS
+ /* FIXME: wip */
+ int past_opcode_p;
+#endif
/* 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 (c != 0)
+ if (CGEN_SYNTAX_CHAR_P (* syn))
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- if (TOLOWER (*str) == TOLOWER (c))
+ /* 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)))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (c == ' ')
- past_opcode_p = true;
+ if (CGEN_SYNTAX_CHAR(* syn) == ' ')
+ past_opcode_p = 1;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- c, *str);
+ CGEN_SYNTAX_CHAR(*syn), *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- c);
+ CGEN_SYNTAX_CHAR(*syn));
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;
- char prev_syntax_char = 0;
- bool past_opcode_p;
+#ifdef CGEN_MNEMONIC_OPERANDS
+ /* FIXME: wip */
+ int past_opcode_p;
+#endif
/* 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 (c != 0)
+ if (CGEN_SYNTAX_CHAR_P (* syn))
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- if (TOLOWER (*str) == TOLOWER (c))
+ /* 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)))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (c == ' ')
- past_opcode_p = true;
+ if (CGEN_SYNTAX_CHAR(* syn) == ' ')
+ past_opcode_p = 1;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- c, *str);
+ CGEN_SYNTAX_CHAR(*syn), *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- c);
+ CGEN_SYNTAX_CHAR(*syn));
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;
- char prev_syntax_char = 0;
- bool past_opcode_p;
+#ifdef CGEN_MNEMONIC_OPERANDS
+ /* FIXME: wip */
+ int past_opcode_p;
+#endif
/* 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 (c != 0)
+ if (CGEN_SYNTAX_CHAR_P (* syn))
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- if (TOLOWER (*str) == TOLOWER (c))
+ /* 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)))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (c == ' ')
- past_opcode_p = true;
+ if (CGEN_SYNTAX_CHAR(* syn) == ' ')
+ past_opcode_p = 1;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- c, *str);
+ CGEN_SYNTAX_CHAR(*syn), *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- c);
+ CGEN_SYNTAX_CHAR(*syn));
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;
- char prev_syntax_char = 0;
- bool past_opcode_p;
+#ifdef CGEN_MNEMONIC_OPERANDS
+ /* FIXME: wip */
+ int past_opcode_p;
+#endif
/* 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 (c != 0)
+ if (CGEN_SYNTAX_CHAR_P (* syn))
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- if (TOLOWER (*str) == TOLOWER (c))
+ /* 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)))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (c == ' ')
- past_opcode_p = true;
+ if (CGEN_SYNTAX_CHAR(* syn) == ' ')
+ past_opcode_p = 1;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- c, *str);
+ CGEN_SYNTAX_CHAR(*syn), *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- c);
+ CGEN_SYNTAX_CHAR(*syn));
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;
- char prev_syntax_char = 0;
- bool past_opcode_p;
+#ifdef CGEN_MNEMONIC_OPERANDS
+ /* FIXME: wip */
+ int past_opcode_p;
+#endif
/* 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 (c != 0)
+ if (CGEN_SYNTAX_CHAR_P (* syn))
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- if (TOLOWER (*str) == TOLOWER (c))
+ /* 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)))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (c == ' ')
- past_opcode_p = true;
+ if (CGEN_SYNTAX_CHAR(* syn) == ' ')
+ past_opcode_p = 1;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- c, *str);
+ CGEN_SYNTAX_CHAR(*syn), *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- c);
+ CGEN_SYNTAX_CHAR(*syn));
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;
- char prev_syntax_char = 0;
- bool past_opcode_p;
+#ifdef CGEN_MNEMONIC_OPERANDS
+ /* FIXME: wip */
+ int past_opcode_p;
+#endif
/* 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 (c != 0)
+ if (CGEN_SYNTAX_CHAR_P (* syn))
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- if (TOLOWER (*str) == TOLOWER (c))
+ /* 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)))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (c == ' ')
- past_opcode_p = true;
+ if (CGEN_SYNTAX_CHAR(* syn) == ' ')
+ past_opcode_p = 1;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- c, *str);
+ CGEN_SYNTAX_CHAR(*syn), *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- c);
+ CGEN_SYNTAX_CHAR(*syn));
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;
- char prev_syntax_char = 0;
- bool past_opcode_p;
+#ifdef CGEN_MNEMONIC_OPERANDS
+ /* FIXME: wip */
+ int past_opcode_p;
+#endif
/* 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 (c != 0)
+ if (CGEN_SYNTAX_CHAR_P (* syn))
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- if (TOLOWER (*str) == TOLOWER (c))
+ /* 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)))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (c == ' ')
- past_opcode_p = true;
+ if (CGEN_SYNTAX_CHAR(* syn) == ' ')
+ past_opcode_p = 1;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- c, *str);
+ CGEN_SYNTAX_CHAR(*syn), *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- c);
+ CGEN_SYNTAX_CHAR(*syn));
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;
- char prev_syntax_char = 0;
- bool past_opcode_p;
+#ifdef CGEN_MNEMONIC_OPERANDS
+ /* FIXME: wip */
+ int past_opcode_p;
+#endif
/* 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 (c != 0)
+ if (CGEN_SYNTAX_CHAR_P (* syn))
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- if (TOLOWER (*str) == TOLOWER (c))
+ /* 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)))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (c == ' ')
- past_opcode_p = true;
+ if (CGEN_SYNTAX_CHAR(* syn) == ' ')
+ past_opcode_p = 1;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- c, *str);
+ CGEN_SYNTAX_CHAR(*syn), *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- c);
+ CGEN_SYNTAX_CHAR(*syn));
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;
- char prev_syntax_char = 0;
- bool past_opcode_p;
+#ifdef CGEN_MNEMONIC_OPERANDS
+ /* FIXME: wip */
+ int past_opcode_p;
+#endif
/* 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 (c != 0)
+ if (CGEN_SYNTAX_CHAR_P (* syn))
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- if (TOLOWER (*str) == TOLOWER (c))
+ /* 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)))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (c == ' ')
- past_opcode_p = true;
+ if (CGEN_SYNTAX_CHAR(* syn) == ' ')
+ past_opcode_p = 1;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- c, *str);
+ CGEN_SYNTAX_CHAR(*syn), *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- c);
+ CGEN_SYNTAX_CHAR(*syn));
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;
- char prev_syntax_char = 0;
- bool past_opcode_p;
+#ifdef CGEN_MNEMONIC_OPERANDS
+ /* FIXME: wip */
+ int past_opcode_p;
+#endif
/* 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 (c != 0)
+ if (CGEN_SYNTAX_CHAR_P (* syn))
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- if (TOLOWER (*str) == TOLOWER (c))
+ /* 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)))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (c == ' ')
- past_opcode_p = true;
+ if (CGEN_SYNTAX_CHAR(* syn) == ' ')
+ past_opcode_p = 1;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- c, *str);
+ CGEN_SYNTAX_CHAR(*syn), *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- c);
+ CGEN_SYNTAX_CHAR(*syn));
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;
- char prev_syntax_char = 0;
- bool past_opcode_p;
+#ifdef CGEN_MNEMONIC_OPERANDS
+ /* FIXME: wip */
+ int past_opcode_p;
+#endif
/* 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 (c != 0)
+ if (CGEN_SYNTAX_CHAR_P (* syn))
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- if (TOLOWER (*str) == TOLOWER (c))
+ /* 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)))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (c == ' ')
- past_opcode_p = true;
+ if (CGEN_SYNTAX_CHAR(* syn) == ' ')
+ past_opcode_p = 1;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- c, *str);
+ CGEN_SYNTAX_CHAR(*syn), *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- c);
+ CGEN_SYNTAX_CHAR(*syn));
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;
- char prev_syntax_char = 0;
- bool past_opcode_p;
+#ifdef CGEN_MNEMONIC_OPERANDS
+ /* FIXME: wip */
+ int past_opcode_p;
+#endif
/* 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 (c != 0)
+ if (CGEN_SYNTAX_CHAR_P (* syn))
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
- if (TOLOWER (*str) == TOLOWER (c))
+ /* 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)))
{
#ifdef CGEN_MNEMONIC_OPERANDS
- if (c == ' ')
- past_opcode_p = true;
+ if (CGEN_SYNTAX_CHAR(* syn) == ' ')
+ past_opcode_p = 1;
#endif
++ syn;
++ str;
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
- c, *str);
+ CGEN_SYNTAX_CHAR(*syn), *str);
return msg;
}
else
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
- c);
+ CGEN_SYNTAX_CHAR(*syn));
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
