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