[deliverable/binutils-gdb.git] / gas / cond.c

/* cond.c - conditional assembly pseudo-ops, and .include
   Copyright (C) 1990, 91, 92, 93, 95, 96, 97, 98, 1999
   Free Software Foundation, Inc.

   This file is part of GAS, the GNU Assembler.

   GAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   GAS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GAS; see the file COPYING.  If not, write to the Free
   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.  */

#include "as.h"
#include "macro.h"

#include "obstack.h"

/* This is allocated to grow and shrink as .ifdef/.endif pairs are scanned. */
struct obstack cond_obstack;

struct file_line
{
  char *file;
  unsigned int line;
};

/* We push one of these structures for each .if, and pop it at the
   .endif.  */

struct conditional_frame
{
  /* The source file & line number of the "if".  */
  struct file_line if_file_line;
  /* The source file & line of the "else".  */
  struct file_line else_file_line;
  /* The previous conditional.  */
  struct conditional_frame *previous_cframe;
  /* Have we seen an else yet?  */
  int else_seen;
  /* Whether we are currently ignoring input.  */
  int ignoring;
  /* Whether a conditional at a higher level is ignoring input.  */
  int dead_tree;
  /* Macro nesting level at which this conditional was created.  */
  int macro_nest;
};

static void initialize_cframe PARAMS ((struct conditional_frame *cframe));
static char *get_mri_string PARAMS ((int, int *));

static struct conditional_frame *current_cframe = NULL;

void 
s_ifdef (arg)
     int arg;
{
  register char *name;		/* points to name of symbol */
  register symbolS *symbolP;	/* Points to symbol */
  struct conditional_frame cframe;

  SKIP_WHITESPACE ();		/* Leading whitespace is part of operand. */
  name = input_line_pointer;

  if (!is_name_beginner (*name))
    {
      as_bad (_("invalid identifier for \".ifdef\""));
      obstack_1grow (&cond_obstack, 0);
      ignore_rest_of_line ();
    }
  else
    {
      char c;

      c = get_symbol_end ();
      symbolP = symbol_find (name);
      *input_line_pointer = c;

      initialize_cframe (&cframe);
      cframe.ignoring = cframe.dead_tree || !((symbolP != 0) ^ arg);
      current_cframe = ((struct conditional_frame *)
			obstack_copy (&cond_obstack, &cframe,
				      sizeof (cframe)));

      if (LISTING_SKIP_COND ()
	  && cframe.ignoring
	  && (cframe.previous_cframe == NULL
	      || ! cframe.previous_cframe->ignoring))
	listing_list (2);

      demand_empty_rest_of_line ();
    }				/* if a valid identifyer name */
}				/* s_ifdef() */

void 
s_if (arg)
     int arg;
{
  expressionS operand;
  struct conditional_frame cframe;
  int t;
  char *stop = NULL;
  char stopc;

  if (flag_mri)
    stop = mri_comment_field (&stopc);

  SKIP_WHITESPACE ();		/* Leading whitespace is part of operand. */

  if (current_cframe != NULL && current_cframe->ignoring)
    {
      operand.X_add_number = 0;
      while (! is_end_of_line[(unsigned char) *input_line_pointer])
	++input_line_pointer;
    }
  else
    {
      expression (&operand);
      if (operand.X_op != O_constant)
	as_bad (_("non-constant expression in \".if\" statement"));
    }

  switch ((operatorT) arg)
    {
    case O_eq: t = operand.X_add_number == 0; break;
    case O_ne: t = operand.X_add_number != 0; break;
    case O_lt: t = operand.X_add_number < 0; break;
    case O_le: t = operand.X_add_number <= 0; break;
    case O_ge: t = operand.X_add_number >= 0; break;
    case O_gt: t = operand.X_add_number > 0; break;
    default:
      abort ();
      return;
    }

  /* If the above error is signaled, this will dispatch
     using an undefined result.  No big deal.  */
  initialize_cframe (&cframe);
  cframe.ignoring = cframe.dead_tree || ! t;
  current_cframe = ((struct conditional_frame *)
		    obstack_copy (&cond_obstack, &cframe, sizeof (cframe)));

  if (LISTING_SKIP_COND ()
      && cframe.ignoring
      && (cframe.previous_cframe == NULL
	  || ! cframe.previous_cframe->ignoring))
    listing_list (2);

  if (flag_mri)
    mri_comment_end (stop, stopc);

  demand_empty_rest_of_line ();
}				/* s_if() */

/* Get a string for the MRI IFC or IFNC pseudo-ops.  */

static char *
get_mri_string (terminator, len)
     int terminator;
     int *len;
{
  char *ret;
  char *s;

  SKIP_WHITESPACE ();
  s = ret = input_line_pointer;
  if (*input_line_pointer == '\'')
    {
      ++s;
      ++input_line_pointer;
      while (! is_end_of_line[(unsigned char) *input_line_pointer])
	{
	  *s++ = *input_line_pointer++;
	  if (s[-1] == '\'')
	    {
	      if (*input_line_pointer != '\'')
		break;
	      ++input_line_pointer;
	    }
	}
      SKIP_WHITESPACE ();
    }
  else
    {
      while (*input_line_pointer != terminator
	     && ! is_end_of_line[(unsigned char) *input_line_pointer])
	++input_line_pointer;
      s = input_line_pointer;
      while (s > ret && (s[-1] == ' ' || s[-1] == '\t'))
	--s;
    }

  *len = s - ret;
  return ret;
}

/* The MRI IFC and IFNC pseudo-ops.  */

void
s_ifc (arg)
     int arg;
{
  char *stop = NULL;
  char stopc;
  char *s1, *s2;
  int len1, len2;
  int res;
  struct conditional_frame cframe;

  if (flag_mri)
    stop = mri_comment_field (&stopc);

  s1 = get_mri_string (',', &len1);

  if (*input_line_pointer != ',')
    as_bad (_("bad format for ifc or ifnc"));
  else
    ++input_line_pointer;

  s2 = get_mri_string (';', &len2);

  res = len1 == len2 && strncmp (s1, s2, len1) == 0;

  initialize_cframe (&cframe);
  cframe.ignoring = cframe.dead_tree || ! (res ^ arg);
  current_cframe = ((struct conditional_frame *)
		    obstack_copy (&cond_obstack, &cframe, sizeof (cframe)));

  if (LISTING_SKIP_COND ()
      && cframe.ignoring
      && (cframe.previous_cframe == NULL
	  || ! cframe.previous_cframe->ignoring))
    listing_list (2);

  if (flag_mri)
    mri_comment_end (stop, stopc);

  demand_empty_rest_of_line ();
}

void 
s_elseif (arg)
     int arg;
{
  expressionS operand;
  int t;

  if (current_cframe == NULL)
    {
      as_bad (_("\".elseif\" without matching \".if\" - ignored"));

    }
  else if (current_cframe->else_seen)
    {
      as_bad (_("\".elseif\" after \".else\" - ignored"));
      as_bad_where (current_cframe->else_file_line.file,
		    current_cframe->else_file_line.line,
		    _("here is the previous \"else\""));
      as_bad_where (current_cframe->if_file_line.file,
		    current_cframe->if_file_line.line,
		    _("here is the previous \"if\""));
    }
  else
    {
      as_where (&current_cframe->else_file_line.file,
		&current_cframe->else_file_line.line);

      if (!current_cframe->dead_tree)
	{
	  current_cframe->ignoring = !current_cframe->ignoring;
	  if (LISTING_SKIP_COND ())
	    {
	      if (! current_cframe->ignoring)
		listing_list (1);
	      else
		listing_list (2);
	    }
	}			/* if not a dead tree */
    }				/* if error else do it */


  SKIP_WHITESPACE ();		/* Leading whitespace is part of operand. */

  if (current_cframe != NULL && current_cframe->ignoring)
    {
      operand.X_add_number = 0;
      while (! is_end_of_line[(unsigned char) *input_line_pointer])
	++input_line_pointer;
    }
  else
    {
      expression (&operand);
      if (operand.X_op != O_constant)
	as_bad (_("non-constant expression in \".elseif\" statement"));
    }
  
  switch ((operatorT) arg)
    {
    case O_eq: t = operand.X_add_number == 0; break;
    case O_ne: t = operand.X_add_number != 0; break;
    case O_lt: t = operand.X_add_number < 0; break;
    case O_le: t = operand.X_add_number <= 0; break;
    case O_ge: t = operand.X_add_number >= 0; break;
    case O_gt: t = operand.X_add_number > 0; break;
    default:
      abort ();
      return;
    }

  current_cframe->ignoring = current_cframe->dead_tree || ! t;

  if (LISTING_SKIP_COND ()
      && current_cframe->ignoring
      && (current_cframe->previous_cframe == NULL
	  || ! current_cframe->previous_cframe->ignoring))
    listing_list (2);

  demand_empty_rest_of_line ();
}

void 
s_endif (arg)
     int arg ATTRIBUTE_UNUSED;
{
  struct conditional_frame *hold;

  if (current_cframe == NULL)
    {
      as_bad (_("\".endif\" without \".if\""));
    }
  else
    {
      if (LISTING_SKIP_COND ()
	  && current_cframe->ignoring
	  && (current_cframe->previous_cframe == NULL
	      || ! current_cframe->previous_cframe->ignoring))
	listing_list (1);

      hold = current_cframe;
      current_cframe = current_cframe->previous_cframe;
      obstack_free (&cond_obstack, hold);
    }				/* if one pop too many */

  if (flag_mri)
    {
      while (! is_end_of_line[(unsigned char) *input_line_pointer])
	++input_line_pointer;
    }

  demand_empty_rest_of_line ();
}				/* s_endif() */

void 
s_else (arg)
     int arg ATTRIBUTE_UNUSED;
{
  if (current_cframe == NULL)
    {
      as_bad (_(".else without matching .if - ignored"));

    }
  else if (current_cframe->else_seen)
    {
      as_bad (_("duplicate \"else\" - ignored"));
      as_bad_where (current_cframe->else_file_line.file,
		    current_cframe->else_file_line.line,
		    _("here is the previous \"else\""));
      as_bad_where (current_cframe->if_file_line.file,
		    current_cframe->if_file_line.line,
		    _("here is the previous \"if\""));
    }
  else
    {
      as_where (&current_cframe->else_file_line.file,
		&current_cframe->else_file_line.line);

      if (!current_cframe->dead_tree)
	{
	  current_cframe->ignoring = !current_cframe->ignoring;
	  if (LISTING_SKIP_COND ())
	    {
	      if (! current_cframe->ignoring)
		listing_list (1);
	      else
		listing_list (2);
	    }
	}			/* if not a dead tree */

      current_cframe->else_seen = 1;
    }				/* if error else do it */

  if (flag_mri)
    {
      while (! is_end_of_line[(unsigned char) *input_line_pointer])
	++input_line_pointer;
    }

  demand_empty_rest_of_line ();
}				/* s_else() */

void 
s_ifeqs (arg)
     int arg;
{
  char *s1, *s2;
  int len1, len2;
  int res;
  struct conditional_frame cframe;

  s1 = demand_copy_C_string (&len1);

  SKIP_WHITESPACE ();
  if (*input_line_pointer != ',')
    {
      as_bad (_(".ifeqs syntax error"));
      ignore_rest_of_line ();
      return;
    }

  ++input_line_pointer;

  s2 = demand_copy_C_string (&len2);

  res = len1 == len2 && strncmp (s1, s2, len1) == 0;

  initialize_cframe (&cframe);
  cframe.ignoring = cframe.dead_tree || ! (res ^ arg);
  current_cframe = ((struct conditional_frame *)
		    obstack_copy (&cond_obstack, &cframe, sizeof (cframe)));

  if (LISTING_SKIP_COND ()
      && cframe.ignoring
      && (cframe.previous_cframe == NULL
	  || ! cframe.previous_cframe->ignoring))
    listing_list (2);

  demand_empty_rest_of_line ();
}				/* s_ifeqs() */

int 
ignore_input ()
{
  char *s;

  s = input_line_pointer;

  if (flag_m68k_mri
#ifdef NO_PSEUDO_DOT
      || 1
#endif
      )
    {
      if (s[-1] != '.')
	--s;
    }
  else
    {
      if (s[-1] != '.')
	return (current_cframe != NULL) && (current_cframe->ignoring);
    }

  /* We cannot ignore certain pseudo ops.  */
  if (((s[0] == 'i'
	|| s[0] == 'I')
       && (!strncasecmp (s, "if", 2)
	   || !strncasecmp (s, "ifdef", 5)
	   || !strncasecmp (s, "ifndef", 6)))
      || ((s[0] == 'e'
	   || s[0] == 'E')
	  && (!strncasecmp (s, "else", 4)
	      || !strncasecmp (s, "endif", 5)
	      || !strncasecmp (s, "endc", 4))))
    return 0;

  return (current_cframe != NULL) && (current_cframe->ignoring);
}				/* ignore_input() */

static void 
initialize_cframe (cframe)
     struct conditional_frame *cframe;
{
  memset (cframe, 0, sizeof (*cframe));
  as_where (&cframe->if_file_line.file,
	    &cframe->if_file_line.line);
  cframe->previous_cframe = current_cframe;
  cframe->dead_tree = current_cframe != NULL && current_cframe->ignoring;
  cframe->macro_nest = macro_nest;
}

/* Give an error if a conditional is unterminated inside a macro or
   the assembly as a whole.  If NEST is non negative, we are being
   called because of the end of a macro expansion.  If NEST is
   negative, we are being called at the of the input files.  */

void
cond_finish_check (nest)
     int nest;
{
  if (current_cframe != NULL && current_cframe->macro_nest >= nest)
    {
      if (nest >= 0)
	as_bad (_("end of macro inside conditional"));
      else
	as_bad (_("end of file inside conditional"));
      as_bad_where (current_cframe->if_file_line.file,
		    current_cframe->if_file_line.line,
		    _("here is the start of the unterminated conditional"));
      if (current_cframe->else_seen)
	as_bad_where (current_cframe->else_file_line.file,
		      current_cframe->else_file_line.line,
		      _("here is the \"else\" of the unterminated conditional"));
    }
}

/* This function is called when we exit out of a macro.  We assume
   that any conditionals which began within the macro are correctly
   nested, and just pop them off the stack.  */

void
cond_exit_macro (nest)
     int nest;
{
  while (current_cframe != NULL && current_cframe->macro_nest >= nest)
    {
      struct conditional_frame *hold;

      hold = current_cframe;
      current_cframe = current_cframe->previous_cframe;
      obstack_free (&cond_obstack, hold);
    }
}

/* end of cond.c */
Commit	Line	Data
252b5132	1	/* cond.c - conditional assembly pseudo-ops, and .include
49309057	2	Copyright (C) 1990, 91, 92, 93, 95, 96, 97, 98, 1999
252b5132 RH	3	Free Software Foundation, Inc.
	4
	5	This file is part of GAS, the GNU Assembler.
	6
	7	GAS is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2, or (at your option)
	10	any later version.
	11
	12	GAS is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with GAS; see the file COPYING. If not, write to the Free
	19	Software Foundation, 59 Temple Place - Suite 330, Boston, MA
	20	02111-1307, USA. */
	21
	22	#include "as.h"
	23	#include "macro.h"
	24
	25	#include "obstack.h"
	26
	27	/* This is allocated to grow and shrink as .ifdef/.endif pairs are scanned. */
	28	struct obstack cond_obstack;
	29
	30	struct file_line
	31	{
	32	char *file;
	33	unsigned int line;
	34	};
	35
	36	/* We push one of these structures for each .if, and pop it at the
	37	.endif. */
	38
	39	struct conditional_frame
	40	{
	41	/* The source file & line number of the "if". */
	42	struct file_line if_file_line;
	43	/* The source file & line of the "else". */
	44	struct file_line else_file_line;
	45	/* The previous conditional. */
	46	struct conditional_frame *previous_cframe;
	47	/* Have we seen an else yet? */
	48	int else_seen;
	49	/* Whether we are currently ignoring input. */
	50	int ignoring;
	51	/* Whether a conditional at a higher level is ignoring input. */
	52	int dead_tree;
	53	/* Macro nesting level at which this conditional was created. */
	54	int macro_nest;
	55	};
	56
	57	static void initialize_cframe PARAMS ((struct conditional_frame *cframe));
	58	static char get_mri_string PARAMS ((int, int ));
	59
	60	static struct conditional_frame *current_cframe = NULL;
	61
	62	void
	63	s_ifdef (arg)
	64	int arg;
	65	{
	66	register char name; / points to name of symbol */
49309057	67	register symbolS symbolP; / Points to symbol */
252b5132 RH	68	struct conditional_frame cframe;
	69
	70	SKIP_WHITESPACE (); /* Leading whitespace is part of operand. */
	71	name = input_line_pointer;
	72
	73	if (!is_name_beginner (*name))
	74	{
	75	as_bad (_("invalid identifier for \".ifdef\""));
	76	obstack_1grow (&cond_obstack, 0);
	77	ignore_rest_of_line ();
	78	}
	79	else
	80	{
	81	char c;
	82
	83	c = get_symbol_end ();
	84	symbolP = symbol_find (name);
	85	*input_line_pointer = c;
	86
	87	initialize_cframe (&cframe);
	88	cframe.ignoring = cframe.dead_tree \|\| !((symbolP != 0) ^ arg);
	89	current_cframe = ((struct conditional_frame *)
	90	obstack_copy (&cond_obstack, &cframe,
	91	sizeof (cframe)));
	92
	93	if (LISTING_SKIP_COND ()
	94	&& cframe.ignoring
	95	&& (cframe.previous_cframe == NULL
	96	\|\| ! cframe.previous_cframe->ignoring))
	97	listing_list (2);
	98
	99	demand_empty_rest_of_line ();
	100	} /* if a valid identifyer name */
	101	} /* s_ifdef() */
	102
	103	void
	104	s_if (arg)
	105	int arg;
	106	{
	107	expressionS operand;
	108	struct conditional_frame cframe;
	109	int t;
	110	char *stop = NULL;
	111	char stopc;
	112
	113	if (flag_mri)
	114	stop = mri_comment_field (&stopc);
	115
	116	SKIP_WHITESPACE (); /* Leading whitespace is part of operand. */
	117
	118	if (current_cframe != NULL && current_cframe->ignoring)
	119	{
	120	operand.X_add_number = 0;
	121	while (! is_end_of_line[(unsigned char) *input_line_pointer])
	122	++input_line_pointer;
	123	}
	124	else
	125	{
	126	expression (&operand);
	127	if (operand.X_op != O_constant)
	128	as_bad (_("non-constant expression in \".if\" statement"));
	129	}
	130
	131	switch ((operatorT) arg)
132	{
133	case O_eq: t = operand.X_add_number == 0; break;
134	case O_ne: t = operand.X_add_number != 0; break;
135	case O_lt: t = operand.X_add_number < 0; break;
136	case O_le: t = operand.X_add_number <= 0; break;
137	case O_ge: t = operand.X_add_number >= 0; break;
138	case O_gt: t = operand.X_add_number > 0; break;
139	default:
140	abort ();
141	return;
142	}
143
144	/* If the above error is signaled, this will dispatch
145	using an undefined result. No big deal. */
146	initialize_cframe (&cframe);
147	cframe.ignoring = cframe.dead_tree \|\| ! t;
148	current_cframe = ((struct conditional_frame *)
149	obstack_copy (&cond_obstack, &cframe, sizeof (cframe)));
150
151	if (LISTING_SKIP_COND ()
152	&& cframe.ignoring
153	&& (cframe.previous_cframe == NULL
154	\|\| ! cframe.previous_cframe->ignoring))
155	listing_list (2);
156
157	if (flag_mri)
158	mri_comment_end (stop, stopc);
159
160	demand_empty_rest_of_line ();
161	} /* s_if() */
162
163	/* Get a string for the MRI IFC or IFNC pseudo-ops. */
164
165	static char *
166	get_mri_string (terminator, len)
167	int terminator;
168	int *len;
169	{
170	char *ret;
171	char *s;
172
173	SKIP_WHITESPACE ();
174	s = ret = input_line_pointer;
175	if (*input_line_pointer == '\'')
176	{
177	++s;
178	++input_line_pointer;
179	while (! is_end_of_line[(unsigned char) *input_line_pointer])
180	{
181	s++ = input_line_pointer++;
182	if (s[-1] == '\'')
183	{
184	if (*input_line_pointer != '\'')
185	break;
186	++input_line_pointer;
187	}
188	}
189	SKIP_WHITESPACE ();
190	}
191	else
192	{
193	while (*input_line_pointer != terminator
194	&& ! is_end_of_line[(unsigned char) *input_line_pointer])
195	++input_line_pointer;
196	s = input_line_pointer;
197	while (s > ret && (s[-1] == ' ' \|\| s[-1] == '\t'))
198	--s;
199	}
200
201	*len = s - ret;
202	return ret;
203	}
204
205	/* The MRI IFC and IFNC pseudo-ops. */
206
207	void
208	s_ifc (arg)
209	int arg;
210	{
211	char *stop = NULL;
212	char stopc;
213	char s1, s2;
214	int len1, len2;
215	int res;
216	struct conditional_frame cframe;
217
218	if (flag_mri)
219	stop = mri_comment_field (&stopc);
220
221	s1 = get_mri_string (',', &len1);
222
223	if (*input_line_pointer != ',')
224	as_bad (_("bad format for ifc or ifnc"));
225	else
226	++input_line_pointer;
227
228	s2 = get_mri_string (';', &len2);
229
230	res = len1 == len2 && strncmp (s1, s2, len1) == 0;
231
232	initialize_cframe (&cframe);
233	cframe.ignoring = cframe.dead_tree \|\| ! (res ^ arg);
234	current_cframe = ((struct conditional_frame *)
235	obstack_copy (&cond_obstack, &cframe, sizeof (cframe)));
236
237	if (LISTING_SKIP_COND ()
238	&& cframe.ignoring
239	&& (cframe.previous_cframe == NULL
240	\|\| ! cframe.previous_cframe->ignoring))
241	listing_list (2);
242
243	if (flag_mri)
244	mri_comment_end (stop, stopc);
245
246	demand_empty_rest_of_line ();
247	}
248
3fd9f047 TW	249	void
	250	s_elseif (arg)
	251	int arg;
	252	{
	253	expressionS operand;
	254	int t;
	255
	256	if (current_cframe == NULL)
	257	{
	258	as_bad (_("\".elseif\" without matching \".if\" - ignored"));
	259
	260	}
	261	else if (current_cframe->else_seen)
	262	{
	263	as_bad (_("\".elseif\" after \".else\" - ignored"));
	264	as_bad_where (current_cframe->else_file_line.file,
	265	current_cframe->else_file_line.line,
	266	_("here is the previous \"else\""));
	267	as_bad_where (current_cframe->if_file_line.file,
	268	current_cframe->if_file_line.line,
	269	_("here is the previous \"if\""));
	270	}
	271	else
	272	{
	273	as_where (&current_cframe->else_file_line.file,
	274	&current_cframe->else_file_line.line);
	275
	276	if (!current_cframe->dead_tree)
	277	{
	278	current_cframe->ignoring = !current_cframe->ignoring;
	279	if (LISTING_SKIP_COND ())
	280	{
	281	if (! current_cframe->ignoring)
	282	listing_list (1);
	283	else
	284	listing_list (2);
	285	}
	286	} /* if not a dead tree */
	287	} /* if error else do it */
	288
	289
	290	SKIP_WHITESPACE (); /* Leading whitespace is part of operand. */
	291
	292	if (current_cframe != NULL && current_cframe->ignoring)
	293	{
	294	operand.X_add_number = 0;
	295	while (! is_end_of_line[(unsigned char) *input_line_pointer])
	296	++input_line_pointer;
	297	}
	298	else
	299	{
	300	expression (&operand);
	301	if (operand.X_op != O_constant)
	302	as_bad (_("non-constant expression in \".elseif\" statement"));
	303	}
	304
	305	switch ((operatorT) arg)
	306	{
	307	case O_eq: t = operand.X_add_number == 0; break;
	308	case O_ne: t = operand.X_add_number != 0; break;
	309	case O_lt: t = operand.X_add_number < 0; break;
	310	case O_le: t = operand.X_add_number <= 0; break;
	311	case O_ge: t = operand.X_add_number >= 0; break;
	312	case O_gt: t = operand.X_add_number > 0; break;
313	default:
314	abort ();
315	return;
316	}
317
318	current_cframe->ignoring = current_cframe->dead_tree \|\| ! t;
319
320	if (LISTING_SKIP_COND ()
321	&& current_cframe->ignoring
322	&& (current_cframe->previous_cframe == NULL
323	\|\| ! current_cframe->previous_cframe->ignoring))
324	listing_list (2);
325
326	demand_empty_rest_of_line ();
327	}
328
252b5132 RH	329	void
252b5132 RH	330	s_endif (arg)
ab9da554	331	int arg ATTRIBUTE_UNUSED;
252b5132 RH	332	{
	333	struct conditional_frame *hold;
	334
	335	if (current_cframe == NULL)
	336	{
	337	as_bad (_("\".endif\" without \".if\""));
	338	}
	339	else
	340	{
	341	if (LISTING_SKIP_COND ()
	342	&& current_cframe->ignoring
	343	&& (current_cframe->previous_cframe == NULL
	344	\|\| ! current_cframe->previous_cframe->ignoring))
	345	listing_list (1);
	346
	347	hold = current_cframe;
	348	current_cframe = current_cframe->previous_cframe;
	349	obstack_free (&cond_obstack, hold);
	350	} /* if one pop too many */
	351
	352	if (flag_mri)
	353	{
	354	while (! is_end_of_line[(unsigned char) *input_line_pointer])
	355	++input_line_pointer;
	356	}
	357
	358	demand_empty_rest_of_line ();
	359	} /* s_endif() */
	360
	361	void
	362	s_else (arg)
ab9da554	363	int arg ATTRIBUTE_UNUSED;
252b5132 RH	364	{
	365	if (current_cframe == NULL)
	366	{
	367	as_bad (_(".else without matching .if - ignored"));
	368
	369	}
	370	else if (current_cframe->else_seen)
	371	{
	372	as_bad (_("duplicate \"else\" - ignored"));
	373	as_bad_where (current_cframe->else_file_line.file,
	374	current_cframe->else_file_line.line,
	375	_("here is the previous \"else\""));
	376	as_bad_where (current_cframe->if_file_line.file,
	377	current_cframe->if_file_line.line,
	378	_("here is the previous \"if\""));
	379	}
	380	else
	381	{
	382	as_where (&current_cframe->else_file_line.file,
	383	&current_cframe->else_file_line.line);
	384
	385	if (!current_cframe->dead_tree)
	386	{
	387	current_cframe->ignoring = !current_cframe->ignoring;
	388	if (LISTING_SKIP_COND ())
	389	{
	390	if (! current_cframe->ignoring)
	391	listing_list (1);
	392	else
	393	listing_list (2);
	394	}
	395	} /* if not a dead tree */
	396
	397	current_cframe->else_seen = 1;
	398	} /* if error else do it */
	399
	400	if (flag_mri)
	401	{
	402	while (! is_end_of_line[(unsigned char) *input_line_pointer])
	403	++input_line_pointer;
	404	}
	405
	406	demand_empty_rest_of_line ();
	407	} /* s_else() */
	408
	409	void
	410	s_ifeqs (arg)
	411	int arg;
	412	{
	413	char s1, s2;
	414	int len1, len2;
	415	int res;
	416	struct conditional_frame cframe;
	417
	418	s1 = demand_copy_C_string (&len1);
	419
	420	SKIP_WHITESPACE ();
	421	if (*input_line_pointer != ',')
	422	{
	423	as_bad (_(".ifeqs syntax error"));
	424	ignore_rest_of_line ();
	425	return;
	426	}
	427
428	++input_line_pointer;
429
430	s2 = demand_copy_C_string (&len2);
431
432	res = len1 == len2 && strncmp (s1, s2, len1) == 0;
433
434	initialize_cframe (&cframe);
435	cframe.ignoring = cframe.dead_tree \|\| ! (res ^ arg);
436	current_cframe = ((struct conditional_frame *)
437	obstack_copy (&cond_obstack, &cframe, sizeof (cframe)));
438
439	if (LISTING_SKIP_COND ()
440	&& cframe.ignoring
441	&& (cframe.previous_cframe == NULL
442	\|\| ! cframe.previous_cframe->ignoring))
443	listing_list (2);
444
445	demand_empty_rest_of_line ();
446	} /* s_ifeqs() */
447
448	int
449	ignore_input ()
450	{
451	char *s;
452
453	s = input_line_pointer;
454
455	if (flag_m68k_mri
456	#ifdef NO_PSEUDO_DOT
457	\|\| 1
458	#endif
459	)
460	{
461	if (s[-1] != '.')
462	--s;
463	}
464	else
465	{
466	if (s[-1] != '.')
467	return (current_cframe != NULL) && (current_cframe->ignoring);
468	}
469
470	/* We cannot ignore certain pseudo ops. */
471	if (((s[0] == 'i'
472	\|\| s[0] == 'I')
473	&& (!strncasecmp (s, "if", 2)
474	\|\| !strncasecmp (s, "ifdef", 5)
475	\|\| !strncasecmp (s, "ifndef", 6)))
476	\|\| ((s[0] == 'e'
477	\|\| s[0] == 'E')
478	&& (!strncasecmp (s, "else", 4)
479	\|\| !strncasecmp (s, "endif", 5)
480	\|\| !strncasecmp (s, "endc", 4))))
481	return 0;
482
483	return (current_cframe != NULL) && (current_cframe->ignoring);
484	} /* ignore_input() */
485
486	static void
487	initialize_cframe (cframe)
488	struct conditional_frame *cframe;
489	{
490	memset (cframe, 0, sizeof (*cframe));
491	as_where (&cframe->if_file_line.file,
492	&cframe->if_file_line.line);
493	cframe->previous_cframe = current_cframe;
494	cframe->dead_tree = current_cframe != NULL && current_cframe->ignoring;
495	cframe->macro_nest = macro_nest;
496	}
497
498	/* Give an error if a conditional is unterminated inside a macro or
499	the assembly as a whole. If NEST is non negative, we are being
500	called because of the end of a macro expansion. If NEST is
501	negative, we are being called at the of the input files. */
502
503	void
504	cond_finish_check (nest)
505	int nest;
506	{
507	if (current_cframe != NULL && current_cframe->macro_nest >= nest)
508	{
509	if (nest >= 0)
510	as_bad (_("end of macro inside conditional"));
511	else
512	as_bad (_("end of file inside conditional"));
513	as_bad_where (current_cframe->if_file_line.file,
514	current_cframe->if_file_line.line,
515	_("here is the start of the unterminated conditional"));
516	if (current_cframe->else_seen)
517	as_bad_where (current_cframe->else_file_line.file,
518	current_cframe->else_file_line.line,
519	_("here is the \"else\" of the unterminated conditional"));
520	}
521	}
522
523	/* This function is called when we exit out of a macro. We assume
524	that any conditionals which began within the macro are correctly
525	nested, and just pop them off the stack. */
526
527	void
528	cond_exit_macro (nest)
529	int nest;
530	{
531	while (current_cframe != NULL && current_cframe->macro_nest >= nest)
532	{
533	struct conditional_frame *hold;
534
535	hold = current_cframe;
536	current_cframe = current_cframe->previous_cframe;
537	obstack_free (&cond_obstack, hold);
538	}
539	}
540
541	/* end of cond.c */