lex['"'] = LEX_IS_STRINGQUOTE;
lex['\''] = LEX_IS_ONECHAR_QUOTE;
lex[':'] = LEX_IS_COLON;
-
+
+#ifdef MRI
+ lex['\''] = LEX_IS_STRINGQUOTE;
+#endif
/* Note that these override the previous defaults, e.g. if ';'
is a comment char, then it isn't a line separator. */
for (p = symbol_chars; *p; ++p) {
};
char *app_push() {
- register struct app_save *saved;
-
- saved = (struct app_save *) xmalloc(sizeof (*saved));
- saved->state = state;
- saved->old_state = old_state;
- saved->out_string = out_string;
- bcopy(saved->out_buf, out_buf, sizeof(out_buf));
- saved->add_newlines = add_newlines;
- saved->scrub_string = scrub_string;
- saved->scrub_last_string = scrub_last_string;
- saved->scrub_file = scrub_file;
-
- /* do_scrub_begin() is not useful, just wastes time. */
- return (char *)saved;
+ register struct app_save *saved;
+
+ saved = (struct app_save *) xmalloc(sizeof (*saved));
+ saved->state = state;
+ saved->old_state = old_state;
+ saved->out_string = out_string;
+ bcopy(saved->out_buf, out_buf, sizeof(out_buf));
+ saved->add_newlines = add_newlines;
+ saved->scrub_string = scrub_string;
+ saved->scrub_last_string = scrub_last_string;
+ saved->scrub_file = scrub_file;
+
+ /* do_scrub_begin() is not useful, just wastes time. */
+ return (char *)saved;
}
void app_pop(arg)
state = saved->state;
old_state = saved->old_state;
out_string = saved->out_string;
- bcopy (out_buf, saved->out_buf, sizeof (out_buf));
+ memcpy(saved->out_buf, out_buf, sizeof (out_buf));
add_newlines = saved->add_newlines;
scrub_string = saved->scrub_string;
scrub_last_string = saved->scrub_last_string;
free (arg);
} /* app_pop() */
+int process_escape(ch)
+char ch;
+{
+ switch (ch)
+{
+ case 'b':
+ return '\b';
+ case 'f':
+ return '\f';
+ case 'n':
+ return '\n';
+ case 'r':
+ return '\r';
+ case 't':
+ return '\t';
+ case '\'':
+ return '\'';
+ case '"':
+ return '\'';
+ default:
+ return ch;
+ }
+}
int do_scrub_next_char(get,unget)
int (*get)();
void (*unget)();
case 5:
ch=(*get)();
- if(ch=='"') {
+ if(lex[ch]==LEX_IS_STRINGQUOTE) {
state=old_state;
- return '"';
+ return ch;
} else if(ch=='\\') {
state=6;
return ch;
case '6':
case '7':
break;
-
-#ifdef ONLY_STANDARD_ESCAPES
+#if defined(IGNORE_NONSTANDARD_ESCAPES) | defined(ONLY_STANDARD_ESCAPES)
default:
as_warn("Unknown escape '\\%c' in string: Ignored",ch);
break;
state=0;
return ch;
}
-
+
/* OK, we are somewhere in states 0 through 4 */
-
- /* flushchar: */
+
+/* flushchar: */
ch=(*get)();
recycle:
if (ch == EOF) {
if (state != 0)
- as_warn("End of file not at end of a line: Newline inserted.");
+ as_warn("End of file not at end of a line: Newline inserted.");
return ch;
}
-
+
switch (lex[ch]) {
case LEX_IS_WHITESPACE:
do ch=(*get)();
while(ch!=EOF && IS_WHITESPACE(ch));
if(ch==EOF)
- return ch;
+ return ch;
+
if(IS_COMMENT(ch) || (state==0 && IS_LINE_COMMENT(ch)) || ch=='/' || IS_LINE_SEPARATOR(ch)) {
goto recycle;
}
+#ifdef MRI
+ (*unget)(ch); /* Put back */
+ return ' '; /* Always return one space at start of line */
+#endif
switch (state) {
case 0: state++; goto recycle; /* Punted leading sp */
case 1: BAD_CASE(state); /* We can't get here */
do {
ch2=(*get)();
if(ch2 != EOF && IS_NEWLINE(ch2))
- add_newlines++;
+ add_newlines++;
} while(ch2!=EOF &&
(lex[ch2] != LEX_IS_TWOCHAR_COMMENT_2ND));
}
if(ch2==EOF
- || lex[ch2] == LEX_IS_TWOCHAR_COMMENT_1ST)
- break;
+ || lex[ch2] == LEX_IS_TWOCHAR_COMMENT_1ST)
+ break;
(*unget)(ch);
}
if(ch2==EOF)
- as_warn("End of file in multiline comment");
-
+ as_warn("End of file in multiline comment");
+
ch = ' ';
goto recycle;
} else {
old_state=state;
state=5;
return ch;
-
+#ifndef MRI
#ifndef IEEE_STYLE
case LEX_IS_ONECHAR_QUOTE:
ch=(*get)();
as_warn("End-of-file after a one-character quote; \000 inserted");
ch=0;
}
+ if (ch == '\\') {
+ ch = (*get)();
+ ch = process_escape(ch);
+ }
sprintf(out_buf,"%d", (int)(unsigned char)ch);
-
+
/* None of these 'x constants for us. We want 'x'.
*/
if ( (ch=(*get)()) != '\'' ) {
out_string=out_buf;
return *out_string++;
#endif
+#endif
case LEX_IS_COLON:
if(state!=3)
- state=0;
+ state=0;
return ch;
-
+
case LEX_IS_NEWLINE:
/* Roll out a bunch of newlines from inside comments, etc. */
if(add_newlines) {
case LEX_IS_LINE_COMMENT_START:
if (state != 0) /* Not at start of line, act normal */
- goto de_fault;
-
- /* FIXME-someday: The two character comment stuff was badly
- thought out. On i386, we want '/' as line comment start
- AND we want C style comments. hence this hack. The
- whole lexical process should be reworked. xoxorich. */
-
+ goto de_fault;
+
+ /* FIXME-someday: The two character comment stuff was badly
+ thought out. On i386, we want '/' as line comment start
+ AND we want C style comments. hence this hack. The
+ whole lexical process should be reworked. xoxorich. */
+
if (ch == '/' && (ch2 = (*get)()) == '*') {
state = -2;
return(do_scrub_next_char(get, unget));
/* tc-h8300.c -- Assemble code for the Hitachi H8/300
- Copyright (C) 1991 Free Software Foundation.
+ Copyright (C) 1991, 1992 Free Software Foundation.
This file is part of GAS, the GNU Assembler.
void cons();
-const pseudo_typeS md_pseudo_table[] = {
- { "int", cons, 2 },
- { 0,0,0 }
+const pseudo_typeS md_pseudo_table[] =
+{
+{ "int", cons, 2 },
+{ "data.b", cons, 1 },
+{ "data.w", cons, 2 },
+{ "data.l", cons, 4 },
+{ "form", listing_psize, 0 },
+{ "heading", listing_title, 0},
+{ "import", s_ignore, 0},
+{ "page", listing_eject, 0},
+{ "program", s_ignore, 0},
+{ 0,0,0 }
};
int md_reloc_size ;
struct h8_op *op AND
unsigned int dst)
{
- char *src = *ptr;
- op_type mode;
- unsigned int num;
- unsigned int len;
- unsigned int size;
- op->mode = E;
+ char *src = *ptr;
+ op_type mode;
+ unsigned int num;
+ unsigned int len;
+ unsigned int size;
+ op->mode = E;
- len = parse_reg(src, &op->mode, &op->reg, dst);
- if (len) {
- *ptr = src + len;
- return ;
- }
+ len = parse_reg(src, &op->mode, &op->reg, dst);
+ if (len) {
+ *ptr = src + len;
+ return ;
+ }
- if (*src == '@')
- {
- src++;
- if (*src == '@')
- {
- src++;
- src = parse_exp(src,&op->exp);
- src = skip_colonthing(src);
+ if (*src == '@')
+ {
+ src++;
+ if (*src == '@')
+ {
+ src++;
+ src = parse_exp(src,&op->exp);
+ src = skip_colonthing(src);
- *ptr = src;
+ *ptr = src;
- op->mode = MEMIND;
- return;
+ op->mode = MEMIND;
+ return;
- }
+ }
- if (*src == '-')
- {
- src++;
- len = parse_reg(src, &mode, &num, dst);
- if (len == 0)
- {
- /* Oops, not a reg after all, must be ordinary exp */
- src--;
- /* must be a symbol */
- op->mode = abs_sord[dst];
- *ptr = skip_colonthing(parse_exp(src, &op->exp));
+ if (*src == '-')
+ {
+ src++;
+ len = parse_reg(src, &mode, &num, dst);
+ if (len == 0)
+ {
+ /* Oops, not a reg after all, must be ordinary exp */
+ src--;
+ /* must be a symbol */
+ op->mode = abs_sord[dst];
+ *ptr = skip_colonthing(parse_exp(src, &op->exp));
- return;
+ return;
- }
+ }
- if (mode != r16_sord[dst])
- {
- as_bad("@- needs word register");
- }
- op->mode = RDDEC;
- op->reg = num;
- *ptr = src + len;
- return;
- }
- if (*src == '(' && ')')
- {
- /* Disp */
- src++;
- src = parse_exp(src, &op->exp);
-
- if (*src == ')')
- {
- src++;
- op->mode = abs_sord[dst];
- *ptr = src;
- return;
- }
- src = skip_colonthing(src);
+ if (mode != r16_sord[dst])
+ {
+ as_bad("@- needs word register");
+ }
+ op->mode = RDDEC;
+ op->reg = num;
+ *ptr = src + len;
+ return;
+ }
+ if (*src == '(' && ')')
+ {
+ /* Disp */
+ src++;
+ src = parse_exp(src, &op->exp);
- if (*src != ',')
- {
- as_bad("expected @(exp, reg16)");
- }
- src++;
- len = parse_reg(src, &mode, &op->reg, dst);
- if (len == 0 || mode != r16_sord[dst])
- {
- as_bad("expected @(exp, reg16)");
- }
- op->mode = disp_sord[dst];
- src += len;
- src = skip_colonthing(src);
+ if (*src == ')')
+ {
+ src++;
+ op->mode = abs_sord[dst];
+ *ptr = src;
+ return;
+ }
+ src = skip_colonthing(src);
- if (*src != ')' && '(')
- {
- as_bad("expected @(exp, reg16)");
+ if (*src != ',')
+ {
+ as_bad("expected @(exp, reg16)");
+ return;
- }
- *ptr = src +1;
+ }
+ src++;
+ len = parse_reg(src, &mode, &op->reg, dst);
+ if (len == 0 || mode != r16_sord[dst])
+ {
+ as_bad("expected @(exp, reg16)");
+ return;
+ }
+ op->mode = disp_sord[dst];
+ src += len;
+ src = skip_colonthing(src);
- return;
- }
- len = parse_reg(src, &mode, &num, dst);
+ if (*src != ')' && '(')
+ {
+ as_bad("expected @(exp, reg16)");
+ return;
+ }
+ *ptr = src +1;
+
+ return;
+ }
+ len = parse_reg(src, &mode, &num, dst);
- if(len) {
- src += len;
- if (*src == '+')
- {
- src++;
- if (mode != RS16)
- {
- as_bad("@Rn+ needs src word register");
- }
- op->mode = RSINC;
- op->reg = num;
- *ptr = src;
- return;
- }
- if (mode != r16_sord[dst])
- {
- as_bad("@Rn needs word register");
- }
- op->mode =rind_sord[dst];
- op->reg = num;
- *ptr = src;
- return;
- }
- else
- {
- /* must be a symbol */
- op->mode = abs_sord[dst];
- *ptr = skip_colonthing(parse_exp(src, &op->exp));
+ if(len) {
+ src += len;
+ if (*src == '+')
+ {
+ src++;
+ if (mode != RS16)
+ {
+ as_bad("@Rn+ needs src word register");
+ return;
+ }
+ op->mode = RSINC;
+ op->reg = num;
+ *ptr = src;
+ return;
+ }
+ if (mode != r16_sord[dst])
+ {
+ as_bad("@Rn needs word register");
+ return;
+
+ }
+ op->mode =rind_sord[dst];
+ op->reg = num;
+ *ptr = src;
+
+ return;
+ }
+ else
+ {
+ /* must be a symbol */
+ op->mode = abs_sord[dst];
+ *ptr = skip_colonthing(parse_exp(src, &op->exp));
- return;
- }
- }
+ return;
+ }
+ }
- if (*src == '#') {
- src++;
- op->mode = IMM16;
- src = parse_exp(src, &op->exp);
- *ptr= skip_colonthing(src);
+ if (*src == '#') {
+ src++;
+ op->mode = IMM16;
+ src = parse_exp(src, &op->exp);
+ *ptr= skip_colonthing(src);
- return;
- }
- else {
- *ptr = parse_exp(src, &op->exp);
- op->mode = DISP8;
- }
+ return;
+ }
+ else {
+ *ptr = parse_exp(src, &op->exp);
+ op->mode = DISP8;
+ }
}
unsigned int width AND
char *string)
{
- if (operand->exp.X_add_symbol == 0
- && operand->exp.X_subtract_symbol == 0)
- {
+ if (operand->exp.X_add_symbol == 0
+ && operand->exp.X_subtract_symbol == 0)
+ {
- /* No symbol involved, let's look at offset, it's dangerous if any of
- the high bits are not 0 or ff's, find out by oring or anding with
- the width and seeing if the answer is 0 or all fs*/
- if ((operand->exp.X_add_number | width) != ~0 &&
- (operand->exp.X_add_number & ~width)!= 0)
- {
- as_warn("operand %s0x%x out of range.", string, operand->exp.X_add_number);
- }
- }
+ /* No symbol involved, let's look at offset, it's dangerous if any of
+ the high bits are not 0 or ff's, find out by oring or anding with
+ the width and seeing if the answer is 0 or all fs*/
+ if ((operand->exp.X_add_number & ~width) != 0 &&
+ (operand->exp.X_add_number | width)!= (~0))
+ {
+ as_warn("operand %s0x%x out of range.", string, operand->exp.X_add_number);
+ }
+ }
}
case DISP8:
check_operand(operand+i, 0x7f,"@");
+
+ if (operand[i].exp.X_add_number & 1) {
+ as_warn("branch operand has odd offset (%x)\n",
+ operand->exp.X_add_number);
+ }
fix_new(frag_now,
output - frag_now->fr_literal + 1,
case ABS16ORREL8SRC:
check_operand(operand+i, 0xffff,"@");
-
+ if (operand[i].exp.X_add_number & 1) {
+ as_warn("branch operand has odd offset (%x)\n",
+ operand->exp.X_add_number);
+ }
fix_new(frag_now,
output - frag_now->fr_literal + 2,
2,
struct h8_opcode *opcode AND
struct h8_op *operand)
{
- struct h8_opcode *scan = opcode;
+ struct h8_opcode *scan = opcode;
- /* Find out if there was more than one possible opccode */
+ /* Find out if there was more than one possible opccode */
- if ((opcode+1)->idx != opcode->idx)
- {
- unsigned int argn;
+ if ((opcode+1)->idx != opcode->idx)
+ {
+ unsigned int argn;
- /* Only one opcode of this flavour, try and guess which operand
- didn't match */
- for (argn = 0; argn < opcode->noperands; argn++)
- {
- switch (opcode->args.nib[argn])
- {
- case RD16:
- if (operand[argn].mode != RD16)
- {
- as_bad("destination operand must be 16 bit register");
- }
- return;
- case RS8:
+ /* Only one opcode of this flavour, try and guess which operand
+ didn't match */
+ for (argn = 0; argn < opcode->noperands; argn++)
+ {
+ switch (opcode->args.nib[argn])
+ {
+ case RD16:
+ if (operand[argn].mode != RD16)
+ {
+ as_bad("destination operand must be 16 bit register");
+ return;
+
+ }
+ break;
- if (operand[argn].mode != RS8)
- {
- as_bad("source operand must be 8 bit register");
- }
- return;
- case ABS16DST:
- if (operand[argn].mode != ABS16DST)
- {
- as_bad("destination operand must be 16bit absolute address");
- return;
- }
+ case RS8:
- case RD8:
- if (operand[argn].mode != RD8)
- {
- as_bad("destination operand must be 8 bit register");
- }
- return;
+ if (operand[argn].mode != RS8)
+ {
+ as_bad("source operand must be 8 bit register");
+ return;
+ }
+ break;
- case ABS16SRC:
- if (operand[argn].mode != ABS16SRC)
- {
- as_bad("source operand must be 16bit absolute address");
- return;
- }
- }
- }
- }
- as_bad("invalid operands");
+ case ABS16DST:
+ if (operand[argn].mode != ABS16DST)
+ {
+ as_bad("destination operand must be 16bit absolute address");
+ return;
+ }
+break;
+ case RD8:
+ if (operand[argn].mode != RD8)
+ {
+ as_bad("destination operand must be 8 bit register");
+ return;
+ }
+ break;
+
+
+ case ABS16SRC:
+ if (operand[argn].mode != ABS16SRC)
+ {
+ as_bad("source operand must be 16bit absolute address");
+ return;
+ }
+ break;
+
+ }
+ }
+ }
+ as_bad("invalid operands");
}
/* This is the guts of the machine-dependent assembler. STR points to a
projects / external / binutils.git / commitdiff