/* Handle #pragma, system V.4 style.  Supports #pragma weak and #pragma pack.
   Copyright (C) 1992 Free Software Foundation, Inc.

This file is part of GNU CC.

GNU CC 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.

GNU CC 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 GNU CC; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include <stdio.h>
#include "config.h"
#include "tree.h"
#include "function.h"

#ifdef HANDLE_SYSV_PRAGMA

/* Support #pragma weak by default if WEAK_ASM_OP is defined.  */
#if !defined (HANDLE_PRAGMA_WEAK) && defined (WEAK_ASM_OP) && defined (SET_ASM_OP)
#define HANDLE_PRAGMA_WEAK 1
#endif

/* See varasm.c for an identical definition.  */
enum pragma_state
{
  ps_start,
  ps_done,
  ps_bad,
  ps_weak,
  ps_name,
  ps_equals,
  ps_value,
  ps_pack,
  ps_left,
  ps_align,
  ps_right
};

/* When structure field packing is in effect, this variable is the
   number of bits to use as the maximum alignment.  When packing is not
   in effect, this is zero. */

extern int maximum_field_alignment;

/* File used for outputting assembler code.  */
extern FILE *asm_out_file;

/* Handle one token of a pragma directive.  TOKEN is the
   current token, and STRING is its printable form.  */

void
handle_pragma_token (string, token)
     char *string;
     tree token;
{
  static enum pragma_state state = ps_start, type;
  static char *name;
  static char *value;
  static int align;

  if (string == 0)
    {
      if (type == ps_pack)
	{
	  if (state == ps_right)
	    maximum_field_alignment = align * 8;
	  else
	    warning ("malformed `#pragma pack'");
	}
      else if (type == ps_weak)
	{
#ifdef HANDLE_PRAGMA_WEAK
	  if (HANDLE_PRAGMA_WEAK)
	    handle_pragma_weak (state, asm_out_file, name, value);

#endif /* HANDLE_PRAMA_WEAK */
	}

      type = state = ps_start;
      return;
    }

  switch (state)
    {
    case ps_start:
      if (token && TREE_CODE (token) == IDENTIFIER_NODE)
	{
	  if (strcmp (IDENTIFIER_POINTER (token), "pack") == 0)
	    type = state = ps_pack;
	  else if (strcmp (IDENTIFIER_POINTER (token), "weak") == 0)
	    type = state = ps_weak;
	  else
	    type = state = ps_done;
	}
      else
	type = state = ps_done;
      break;

    case ps_weak:
      if (token && TREE_CODE (token) == IDENTIFIER_NODE)
	{
	  name = IDENTIFIER_POINTER (token);
	  state = ps_name;
	}
      else
	state = ps_bad;
      break;

    case ps_name:
      state = (strcmp (string, "=") ? ps_bad : ps_equals);
      break;

    case ps_equals:
      if (token && TREE_CODE (token) == IDENTIFIER_NODE)
	{
	  value = IDENTIFIER_POINTER (token);
	  state = ps_value;
	}
      else
	state = ps_bad;
      break;

    case ps_value:
      state = ps_bad;
      break;

    case ps_pack:
      if (strcmp (string, "(") == 0)
	state = ps_left;
      else
	state = ps_bad;
      break;

    case ps_left:
      if (token && TREE_CODE (token) == INTEGER_CST
	  && TREE_INT_CST_HIGH (token) == 0)
	switch (TREE_INT_CST_LOW (token))
	  {
	  case 1:
	  case 2:
	  case 4:
	    align = TREE_INT_CST_LOW (token);
	    state = ps_align;
	    break;

	  default:
	    state = ps_bad;
	  }
      else if (! token && strcmp (string, ")") == 0)
	{
	  align = 0;
	  state = ps_right;
	}
      else
	state = ps_bad;
      break;

    case ps_align:
      if (strcmp (string, ")") == 0)
	state = ps_right;
      else
	state = ps_bad;
      break;

    case ps_right:
      state = ps_bad;
      break;

    case ps_bad:
    case ps_done:
      break;

    default:
      abort ();
    }
}
#endif /* HANDLE_SYSV_PRAGMA */
