workbench/c/Wait.c

   1 /*
   2     Copyright © 1995-2003, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Wait CLI Command.
   6 */
   7
   8 /******************************************************************************
   9
  10
  11     NAME
  12
  13         Wait [(n)] [SEC | SECS | MIN | MINS] [ UNTIL (time) ]
  14
  15     SYNOPSIS
  16
  17         TIME/N,SEC=SECS/S,MIN=MINS/S,UNTIL/K
  18
  19     LOCATION
  20
  21         Workbench:C
  22
  23     FUNCTION
  24
  25         Wait a certain amount of time or until a specified time. Using
  26         Wait without any arguments waits for one second.
  27
  28     INPUTS
  29
  30         TIME      --  the number of time units to wait (default is seconds)
  31         SEC=SECS  --  set the time unit to seconds
  32         MIN=MINS  --  set the time unit to minutes
  33         UNTIL     --  wait until the specified time is reached. The time
  34                       is given in the format HH:MM.
  35
  36     RESULT
  37
  38     NOTES
  39
  40     EXAMPLE
  41
  42     BUGS
  43
  44     SEE ALSO
  45
  46     INTERNALS
  47
  48 ******************************************************************************/
  49
  50 #include <exec/execbase.h>
  51 #include <exec/libraries.h>
  52 #include <devices/timer.h>
  53 #include <dos/dos.h>
  54
  55 #include <proto/dos.h>
  56 #include <proto/exec.h>
  57
  58 #include <string.h>
  59 #include <stdio.h>
  60
  61 static const char version[] = "$VER: Wait 41.2 (30.04.2000)\n";
  62
  63 int __nocommandline;
  64
  65 int main (void)
  66 {
  67     IPTR                args[4] = { 0, 0, 0, 0 };
  68     struct RDArgs       *rda;
  69     LONG                error = RETURN_OK;
  70     ULONG               delay = 1;
  71
  72 #define ERROR(a) { error = a; goto end; }
  73
  74     rda = ReadArgs("TIME/N,SEC=SECS/S,MIN=MINS/S,UNTIL/K", args, NULL);
  75
  76     if (rda == NULL)
  77     {
  78         PrintFault(IoErr(),"Wait");
  79         ERROR(RETURN_FAIL);
  80     }
  81
  82     if (args[3])
  83     {
  84         /* UNTIL */
  85         struct DateTime         dt;
  86         struct DateStamp        ds;
  87         LONG                    now_secs, then_secs, diff_secs;
  88         UBYTE                   timestring[9];
  89
  90         DateStamp(&ds);
  91         now_secs = ds.ds_Minute * 60 + ds.ds_Tick / TICKS_PER_SECOND;
  92
  93         if (strlen((char *)args[3]) > 5)
  94         {
  95             puts("Time should be HH:MM");
  96             ERROR(RETURN_FAIL);
  97         }
  98
  99         strcpy(timestring, (UBYTE *)args[3]);
 100         strcat(timestring, ":00");
 101
 102         memset(&dt, 0, sizeof(dt));
 103         dt.dat_StrTime = timestring;
 104
 105         if (!StrToDate(&dt))
 106         {
 107             puts("Time should be HH:MM");
 108             ERROR(RETURN_FAIL);
 109         }
 110
 111         then_secs = dt.dat_Stamp.ds_Minute * 60 + dt.dat_Stamp.ds_Tick / TICKS_PER_SECOND;
 112         diff_secs = then_secs - now_secs;
 113
 114         if (diff_secs < 0)
 115         {
 116             diff_secs += 60L * 60L * 24L;
 117         }
 118
 119         delay = diff_secs * TICKS_PER_SECOND;
 120
 121     }
 122     else
 123     {
 124         if (args[0])
 125         {
 126             delay = *((ULONG *)args[0]);
 127         }
 128
 129         if (args[2])
 130         {
 131             delay *= 60L;
 132         }
 133
 134         delay *= TICKS_PER_SECOND;
 135     }
 136
 137     if (delay > 0)
 138     {
 139         if (delay <= TICKS_PER_SECOND)
 140         {
 141             /* Don't care about breaking if delay is less than 1 second */
 142             Delay (delay);
 143         }
 144         else
 145         {
 146             struct MsgPort      *timermp;
 147             struct timerequest  *timerio;
 148             BOOL                memok = FALSE, devok = FALSE;
 149
 150             if ((timermp = CreateMsgPort()))
 151             {
 152                 if ((timerio = (struct timerequest *)CreateIORequest(timermp, sizeof(struct timerequest))))
 153                 {
 154                     memok = TRUE;
 155                     if (OpenDevice("timer.device", UNIT_VBLANK, &timerio->tr_node, 0) == 0)
 156                     {
 157                         ULONG timermask, sigs;
 158                         BOOL  done = FALSE;
 159
 160                         devok = TRUE;
 161
 162                         timerio->tr_node.io_Command = TR_ADDREQUEST;
 163                         timerio->tr_time.tv_secs    = delay / TICKS_PER_SECOND;
 164                         timerio->tr_time.tv_micro   = 1000000UL / TICKS_PER_SECOND * (delay % TICKS_PER_SECOND);
 165
 166                         timermask = 1L << timermp->mp_SigBit;
 167
 168                         SendIO(&timerio->tr_node);
 169
 170                         while(!done)
 171                         {
 172                             sigs = Wait(SIGBREAKF_CTRL_C | timermask);
 173
 174                             if (sigs & timermask)
 175                             {
 176                                 done = TRUE;
 177                             }
 178
 179                             if (sigs & SIGBREAKF_CTRL_C)
 180                             {
 181                                 if (!CheckIO(&timerio->tr_node)) AbortIO(&timerio->tr_node);
 182                                 WaitIO(&timerio->tr_node);
 183
 184                                 error = RETURN_WARN;
 185                                 done = TRUE;
 186                             }
 187
 188                         } /* while(!finished) */
 189                         CloseDevice(&timerio->tr_node);
 190
 191                     } /* if (OpenDevice("timer.device", UNIT_VBLANK, &timerio->tr_node, 0) == 0) */
 192                     DeleteIORequest(&timerio->tr_node);
 193
 194                 } /* if (timerio = (struct timerequest *)CreateIORequest(timermp, sizeof(struct timerequest))) */
 195                 DeleteMsgPort(timermp);
 196
 197             } /* if ((timermp = CreateMsgPort())) */
 198
 199             if (!memok)
 200             {
 201                 PrintFault(ERROR_NO_FREE_STORE,"Wait");
 202                 ERROR(RETURN_FAIL);
 203             }
 204             else if (!devok)
 205             {
 206                 puts("Wait: Could not open timer.device!");
 207                 ERROR(RETURN_FAIL);
 208             }
 209
 210         }
 211
 212     } /* if (delay > 0) */
 213
 214 end:
 215     if (rda)
 216     {
 217         FreeArgs(rda);
 218     }
 219
 220     return error;
 221 }