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

/* cond.c - conditional assembly pseudo-ops, and .include
   Copyright 1990, 1991, 1992, 1993, 1995, 1997, 1998, 2000, 2001
   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.
     Set also when a branch of an "if .. elseif .." tree has matched
     to prevent further matches.  */
  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;
{
  /* Points to name of symbol.  */
  register char *name;
  /* Points to symbol.  */
  register symbolS *symbolP;
  struct conditional_frame cframe;

  /* Leading whitespace is part of operand.  */
  SKIP_WHITESPACE ();
  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 */
}

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);

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

  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 ();
}

/* 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;
{
  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);

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

  if (current_cframe == NULL || current_cframe->ignoring)
    {
      while (! is_end_of_line[(unsigned char) *input_line_pointer])
	++input_line_pointer;

      if (current_cframe == NULL)
	return;
    }
  else
    {
      expressionS operand;
      int t;

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

      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->previous_cframe == NULL
	  || ! current_cframe->previous_cframe->ignoring))
    {
      if (! current_cframe->ignoring)
	listing_list (1);
      else
	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 ();
}

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);

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

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

      current_cframe->else_seen = 1;
    }

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

  demand_empty_rest_of_line ();
}

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 ();
}

int
ignore_input ()
{
  char *s;

  s = input_line_pointer;

  if (NO_PSEUDO_DOT || flag_m68k_mri)
    {
      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);
}

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