Subversion Repositories openrisc

/* Implementation of the SIGNAL and ALARM g77 intrinsics

   Copyright (C) 2005, 2007, 2009, 2011 Free Software Foundation, Inc.

   Contributed by François-Xavier Coudert <coudert@clipper.ens.fr>

This file is part of the GNU Fortran runtime library (libgfortran).

Libgfortran 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 3 of the License, or (at your option) any later version.

Libgfortran 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.

Under Section 7 of GPL version 3, you are granted additional

permissions described in the GCC Runtime Library Exception, version

3.1, as published by the Free Software Foundation.

You should have received a copy of the GNU General Public License and

a copy of the GCC Runtime Library Exception along with this program;

see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

<http://www.gnu.org/licenses/>.  */

#include "libgfortran.h"

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <signal.h>

#ifdef HAVE_INTTYPES_H

#include <inttypes.h>

#endif

#include <errno.h>

/* SIGNAL subroutine with PROCEDURE as handler  */

extern void signal_sub (int *, void (*)(int), int *);

iexport_proto(signal_sub);

void

signal_sub (int *number, void (*handler)(int), int *status)

{

  intptr_t ret;

  if (status != NULL)

    {

      ret = (intptr_t) signal (*number, handler);

      *status = (int) ret;

    }

  else

    signal (*number, handler);

}

iexport(signal_sub);

/* SIGNAL subroutine with INTEGER as handler  */

extern void signal_sub_int (int *, int *, int *);

iexport_proto(signal_sub_int);

void

signal_sub_int (int *number, int *handler, int *status)

{

  intptr_t ptr = *handler, ret;

  if (status != NULL)

    {

      ret = (intptr_t) signal (*number, (void (*)(int)) ptr);

      *status = (int) ret;

    }

  else

    signal (*number, (void (*)(int)) ptr);

}

iexport(signal_sub_int);

/* SIGNAL function with PROCEDURE as handler  */

extern int signal_func (int *, void (*)(int));

iexport_proto(signal_func);

int

signal_func (int *number, void (*handler)(int))

{

  int status;

  signal_sub (number, handler, &status);

  return status;

}

iexport(signal_func);

/* SIGNAL function with INTEGER as handler  */

extern int signal_func_int (int *, int *);

iexport_proto(signal_func_int);

int

signal_func_int (int *number, int *handler)

{

  int status;

  signal_sub_int (number, handler, &status);

  return status;

}

iexport(signal_func_int);

/* ALARM intrinsic with PROCEDURE as handler  */

extern void alarm_sub_i4 (int *, void (*)(int), GFC_INTEGER_4 *);

iexport_proto(alarm_sub_i4);

void

alarm_sub_i4 (int * seconds __attribute__ ((unused)),

              void (*handler)(int) __attribute__ ((unused)),

              GFC_INTEGER_4 *status)

{

#if defined (SIGALRM) && defined (HAVE_ALARM) 

  if (status != NULL)

    {

      if (signal (SIGALRM, handler) == SIG_ERR)

        *status = -1;

      else

        *status = alarm (*seconds);

    }

  else

    {

      signal (SIGALRM, handler);

      alarm (*seconds);

    }

#else

  errno = ENOSYS;

  if (status != NULL)

    *status = -1;

#endif

}

iexport(alarm_sub_i4);

extern void alarm_sub_i8 (int *, void (*)(int), GFC_INTEGER_8 *);

iexport_proto(alarm_sub_i8);

void

alarm_sub_i8 (int *seconds __attribute__ ((unused)),

              void (*handler)(int) __attribute__ ((unused)),

              GFC_INTEGER_8 *status)

{

#if defined (SIGALRM) && defined (HAVE_ALARM)

  if (status != NULL)

    {

      if (signal (SIGALRM, handler) == SIG_ERR)

        *status = -1;

      else

        *status = alarm (*seconds);

    }

  else

    {

      signal (SIGALRM, handler);

      alarm (*seconds);

    }

#else

  errno = ENOSYS;

  if (status != NULL)

    *status = -1;

#endif

}

iexport(alarm_sub_i8);

/* ALARM intrinsic with INTEGER as handler  */

extern void alarm_sub_int_i4 (int *, int *, GFC_INTEGER_4 *);

iexport_proto(alarm_sub_int_i4);

void

alarm_sub_int_i4 (int *seconds __attribute__ ((unused)),

                  int *handler __attribute__ ((unused)),

                  GFC_INTEGER_4 *status)

{

#if defined (SIGALRM) && defined (HAVE_ALARM)

  if (status != NULL)

    {

      if (signal (SIGALRM, (void (*)(int)) (intptr_t) *handler) == SIG_ERR)

        *status = -1;

      else

        *status = alarm (*seconds);

    }

  else

    {

      signal (SIGALRM, (void (*)(int)) (intptr_t) *handler);

      alarm (*seconds);

    }

#else

  errno = ENOSYS;

  if (status != NULL)

    *status = -1;

#endif

}

iexport(alarm_sub_int_i4);

extern void alarm_sub_int_i8 (int *, int *, GFC_INTEGER_8 *);

iexport_proto(alarm_sub_int_i8);

void

alarm_sub_int_i8 (int *seconds __attribute__ ((unused)),

                  int *handler __attribute__ ((unused)),

                  GFC_INTEGER_8 *status)

{

#if defined (SIGALRM) && defined (HAVE_ALARM)

  if (status != NULL)

    {

      if (signal (SIGALRM, (void (*)(int)) (intptr_t) *handler) == SIG_ERR)

        *status = -1;

      else

        *status = alarm (*seconds);

    }

  else

    {

      signal (SIGALRM, (void (*)(int)) (intptr_t) *handler);

      alarm (*seconds);

    }

#else

  errno = ENOSYS;

  if (status != NULL)

    *status = -1;

#endif

}

iexport(alarm_sub_int_i8);