/* This file is part of the origami distrubution. (Amiga Port)
 *
 * Source code written by Thomas Hadig in September 1991
 * Version : 1.6.42 alpha, June 1992
 * (C) 1992 by Thomas Hadig
 * may be distributed unchanged ! (see copyright notes)
 */

/* !!! AREXX port is highly experimental !!! (arexx alpha) */
/*{{{  #includes*/
#include <sys/types.h>
#include <limits.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#ifdef LATTICE
#include <dos.h>
#include <error.h>
#endif
#include <intuition/intuition.h>

#ifdef LATTICE
#include <proto/exec.h>
#else
#include <clib/exec_protos.h>
#endif
#include <devices/timer.h>
#undef TRUE
#undef FALSE

#include <local/bool.h>

#define SIGNALS_C
#define I_FOLDFILING_C
#define I_MAIN_C
#define I_KEYBOARD_C
#define I_SCREEN_C
#define I_PROMPT_C
#define I_VIRTUAL_C
#define I_GETMSG_C
#ifdef AREXX
#  define I_GETTK_C
#endif

#include "origami.h"
#include "exit.h"
#include "origami:amiga/h/arexx.h"
extern bool push_macro (TOKEN *);
/*}}}  */
/*{{{  variables*/
char general_abort_key = -1;
private bool alarm_running=FALSE;
int alarm_time = -1;
extern int executing_macro;
#ifdef AREXX
extern struct MsgPort *arexxtaskport,*arexxport;
extern struct ProcID arexx_pid;
int arexx_var;
#endif
/*}}}  */

/*{{{  alarm handling*/
/*{{{  set_alarm*/
void set_alarm(int delay)
{
 if (timer)
  {
   alarm_running = TRUE;
   if (delay!=0) alarm_time=delay;
   if (alarm_time<MIN_ALARMTIME || alarm_time>MAX_ALARMTIME)
     alarm_time=NORM_ALARMTIME;
   if (tr.tr_time.tv_secs==0)
    {
     tr.tr_node.io_Command = TR_ADDREQUEST;
     tr.tr_node.io_Message.mn_ReplyPort = mpp;
     tr.tr_time.tv_secs = alarm_time*60;
     tr.tr_time.tv_micro = 0;
     SendIO ((struct IORequest *)&tr);
    }
  }
}
/*}}}  */
/*{{{  got_alarm*/
void got_alarm(void)
{
 if (alarm_running&&auto_save) auto_write();
 interrupt_restore=TRUE;
}
/*}}}  */
/*{{{  reset_alarm*/
void reset_alarm(void)
{
 alarm_running=FALSE;
}
/*}}}  */
/*}}}  */
/*{{{  abort handling*/
/*{{{  enable_sig_abort*/
void enable_sig_abort(void)
{
}
/*}}}  */
/*{{{  disable_sig_abort*/
void disable_sig_abort(void)
{
  signal(SIGINT, SIG_IGN);
}
/*}}}  */
/*}}}  */
/*{{{  unused definitions*/
/*{{{  bktoshell           suspend Origami and wait to wake up*/
void bktoshell(void)
{
    message("no job control",TRUE);
}
/*}}}  */
/*{{{  send me a mail concerning dumped file*/
private void mail_me(char *name)
{
}
/*}}}  */
/*}}}  */
/*{{{  exiting origami*/
/*{{{  exit_origami*/
public void exit_origami(RETURNS c, unsigned char *string)
{
  /*{{{  end_data_handle*/
  if (end_data_handle())
   {
     Print("\n");
     Print(get_msg(F_VM_FAIL,"access",strerror(errno)));
     c=r_vir_err;
   }
  /*}}}  */
  if (string)
  {
    Print ("\n");
    Print(string);
  }
  Print ("\n");
  close(msg_file);
  exit (c);
}
/*}}}  */
/*{{{  die_a_slow_death*/
private int die_a_slow_death(int sig,int code)
 {
  exit_origami(r_sig,NULL);
 }
/*}}}  */
/*}}}  */
/*{{{  init_signals*/
void init_signals(void)
{
  disable_abort();
}
/*}}}  */
#ifdef AREXX
/*{{{  handle_arexx_start*/
void handle_arexx_start (void)

 {
  arexx_tag = FALSE;
  /*fprintf (stderr,"start\n");*/
  macro_int[arexx_var]=-1;
  switch (arexx_tag_msg->class)
   {
    /*{{{  AREXX_REQUEST*/
    case AREXX_REQUEST:
      push_macro (arexx_fix_macro_req);
      push_macro ((TOKEN *)arexx_tag_msg->my_message);
      break;
    /*}}}  */
    /*{{{  AREXX_OCL*/
    case AREXX_OCL:
      push_macro (arexx_fix_macro_ocl);
      push_macro ((TOKEN *)arexx_tag_msg->my_message);
      break;
    /*}}}  */
    /*{{{  AREXX_CAME_DOWN*/
    case AREXX_CAME_DOWN:  /* why? maybe killed or so */
      PutMsg (arexxport,(struct Message *)arexx_tag_msg);
      message ("Arexx got killed ! Closing port !",TRUE);
      wait (&arexx_pid);
      arexx_tag_msg = NULL;
      arexxtaskport = NULL;
    /*}}}  */
    /*{{{  default*/
    default:
      macro_int[arexx_var]=-1;
    /*}}}  */
   }
 }
/*}}}  */
/*{{{  handle_arexx_stop*/
void handle_arexx_stop(void)

 {
  /*fprintf (stderr,"stop : arexx_var %d\n",arexx_var);*/
  switch (arexx_tag_msg->class)
   {
    /*{{{  AREXX_REQUEST*/
    case AREXX_REQUEST:
      arexx_tag_msg->my_message[0]=macro_int[arexx_var];
      break;
    /*}}}  */
   }
  if (arexxtaskport) ReplyMsg ((struct Message *)arexx_tag_msg);
  arexx_tag_msg=NULL;
  macro_int[arexx_var]=-1;
 }
/*}}}  */
/*{{{  my_calloc_*/
/* This function is used to allocate memory for the macro-variables, so I
 * added one variable for arexx ! */

void *my_calloc_ (unsigned i,unsigned j)

 {
  int *ptr;

  arexx_var = (int)i;
  if (ptr=calloc (i+1,j))
   {
    ptr[arexx_var]=-1;
    arexx_fix_macro_req[set_both] = arexx_var;
    arexx_fix_macro_ocl[set_both] = arexx_var;
    arexx_fix_macro_req[set_only_req] = arexx_var;
   }
  return ptr;
 }
/*}}}  */
#endif
/*{{{  my_strstr*/
char *my_strstr (char *text, char *search)

 {
  if (!strlen(text)) return NULL;
  return strstr(text,search);
 }
/*}}}  */