Return to c-pragma.c CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/c-pragma.c, revision 1.1

1.1     ! root        1: /* Handle #pragma, system V.4 style.  Supports #pragma weak and #pragma pack.
        !             2:    Copyright (C) 1992 Free Software Foundation, Inc.
        !             3: 
        !             4: This file is part of GNU CC.
        !             5: 
        !             6: GNU CC is free software; you can redistribute it and/or modify
        !             7: it under the terms of the GNU General Public License as published by
        !             8: the Free Software Foundation; either version 2, or (at your option)
        !             9: any later version.
        !            10: 
        !            11: GNU CC is distributed in the hope that it will be useful,
        !            12: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            14: GNU General Public License for more details.
        !            15: 
        !            16: You should have received a copy of the GNU General Public License
        !            17: along with GNU CC; see the file COPYING.  If not, write to
        !            18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
        !            19: 
        !            20: #include <stdio.h>
        !            21: #include "config.h"
        !            22: #include "tree.h"
        !            23: 
        !            24: #ifdef HANDLE_SYSV_PRAGMA
        !            25: 
        !            26: /* Support #pragma weak by default if WEAK_ASM_OP is defined.  */
        !            27: #if !defined (HANDLE_PRAGMA_WEAK) && defined (WEAK_ASM_OP) && defined (SET_ASM_OP)
        !            28: #define HANDLE_PRAGMA_WEAK 1
        !            29: #endif
        !            30: 
        !            31: /* When structure field packing is in effect, this variable is the
        !            32:    number of bits to use as the maximum alignment.  When packing is not
        !            33:    in effect, this is zero. */
        !            34: 
        !            35: extern int maximum_field_alignment;
        !            36: 
        !            37: /* File used for outputting assembler code.  */
        !            38: extern FILE *asm_out_file;
        !            39: 
        !            40: /* Handle one token of a pragma directive.  TOKEN is the
        !            41:    current token, and STRING is its printable form.  */
        !            42: 
        !            43: void
        !            44: handle_pragma_token (string, token)
        !            45:      char *string;
        !            46:      tree token;
        !            47: {
        !            48:   static enum pragma_state
        !            49:     {
        !            50:       ps_start,
        !            51:       ps_done,
        !            52:       ps_bad,
        !            53:       ps_weak,
        !            54:       ps_name,
        !            55:       ps_equals,
        !            56:       ps_value,
        !            57:       ps_pack,
        !            58:       ps_left,
        !            59:       ps_align,
        !            60:       ps_right
        !            61:       } state = ps_start, type;
        !            62:   static char *name;
        !            63:   static char *value;
        !            64:   static int align;
        !            65: 
        !            66:   if (string == 0)
        !            67:     {
        !            68:       if (type == ps_pack)
        !            69:        {
        !            70:          if (state == ps_right)
        !            71:            maximum_field_alignment = align * 8;
        !            72:          else
        !            73:            warning ("malformed `#pragma pack'");
        !            74:        }
        !            75:       else if (type == ps_weak)
        !            76:        {
        !            77: #ifdef HANDLE_PRAGMA_WEAK
        !            78:          if (HANDLE_PRAGMA_WEAK)
        !            79:            {
        !            80:              if (state == ps_name || state == ps_value)
        !            81:                {
        !            82:                  fprintf (asm_out_file, "\t%s\t", WEAK_ASM_OP);
        !            83:                  ASM_OUTPUT_LABELREF (asm_out_file, name);
        !            84:                  fputc ('\n', asm_out_file);
        !            85:                  if (state == ps_value)
        !            86:                    {
        !            87:                      fprintf (asm_out_file, "\t%s\t", SET_ASM_OP);
        !            88:                      ASM_OUTPUT_LABELREF (asm_out_file, name);
        !            89:                      fputc (',', asm_out_file);
        !            90:                      ASM_OUTPUT_LABELREF (asm_out_file, value);
        !            91:                      fputc ('\n', asm_out_file);
        !            92:                    }
        !            93:                }
        !            94:              else if (! (state == ps_done || state == ps_start))
        !            95:                warning ("malformed `#pragma weak'");
        !            96:            }
        !            97: #endif /* HANDLE_PRAMA_WEAK */
        !            98:        }
        !            99: 
        !           100:       type = state = ps_start;
        !           101:       return;
        !           102:     }
        !           103: 
        !           104:   switch (state)
        !           105:     {
        !           106:     case ps_start:
        !           107:       if (token && TREE_CODE (token) == IDENTIFIER_NODE)
        !           108:        {
        !           109:          if (strcmp (IDENTIFIER_POINTER (token), "pack") == 0)
        !           110:            type = state = ps_pack;
        !           111:          else if (strcmp (IDENTIFIER_POINTER (token), "weak") == 0)
        !           112:            type = state = ps_weak;
        !           113:          else
        !           114:            type = state = ps_done;
        !           115:        }
        !           116:       else
        !           117:        type = state = ps_done;
        !           118:       break;
        !           119: 
        !           120:     case ps_weak:
        !           121:       if (token && TREE_CODE (token) == IDENTIFIER_NODE)
        !           122:        {
        !           123:          name = IDENTIFIER_POINTER (token);
        !           124:          state = ps_name;
        !           125:        }
        !           126:       else
        !           127:        state = ps_bad;
        !           128:       break;
        !           129: 
        !           130:     case ps_name:
        !           131:       state = (strcmp (string, "=") ? ps_bad : ps_equals);
        !           132:       break;
        !           133: 
        !           134:     case ps_equals:
        !           135:       if (token && TREE_CODE (token) == IDENTIFIER_NODE)
        !           136:        {
        !           137:          value = IDENTIFIER_POINTER (token);
        !           138:          state = ps_value;
        !           139:        }
        !           140:       else
        !           141:        state = ps_bad;
        !           142:       break;
        !           143: 
        !           144:     case ps_value:
        !           145:       state = ps_bad;
        !           146:       break;
        !           147: 
        !           148:     case ps_pack:
        !           149:       if (strcmp (string, "(") == 0)
        !           150:        state = ps_left;
        !           151:       else
        !           152:        state = ps_bad;
        !           153:       break;
        !           154: 
        !           155:     case ps_left:
        !           156:       if (token && TREE_CODE (token) == INTEGER_CST
        !           157:          && TREE_INT_CST_HIGH (token) == 0)
        !           158:        switch (TREE_INT_CST_LOW (token))
        !           159:          {
        !           160:          case 1:
        !           161:          case 2:
        !           162:          case 4:
        !           163:            align = TREE_INT_CST_LOW (token);
        !           164:            state = ps_align;
        !           165:            break;
        !           166: 
        !           167:          default:
        !           168:            state = ps_bad;
        !           169:          }
        !           170:       else if (! token && strcmp (string, ")") == 0)
        !           171:        {
        !           172:          align = 0;
        !           173:          state = ps_right;
        !           174:        }
        !           175:       else
        !           176:        state = ps_bad;
        !           177:       break;
        !           178: 
        !           179:     case ps_align:
        !           180:       if (strcmp (string, ")") == 0)
        !           181:        state = ps_right;
        !           182:       else
        !           183:        state = ps_bad;
        !           184:       break;
        !           185: 
        !           186:     case ps_right:
        !           187:       state = ps_bad;
        !           188:       break;
        !           189: 
        !           190:     case ps_bad:
        !           191:     case ps_done:
        !           192:       break;
        !           193: 
        !           194:     default:
        !           195:       abort ();
        !           196:     }
        !           197: }
        !           198: #endif /* HANDLE_SYSV_PRAGMA */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.