workbench/c/Wait.c

   1 /*
   2     Copyright © 1995-2007, 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         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
  60 const TEXT version[] = "$VER: Wait 41.2 (30.4.2000)\n";
  61
  62 int __nocommandline;
  63
  64 int main (void)
  65 {
  66     IPTR                args[4] = { 0, 0, 0, 0 };
  67     struct RDArgs       *rda;
  68     LONG                error = RETURN_OK;
  69     ULONG               delay = 1;
  70
  71 #define ERROR(a) { error = a; goto end; }
  72
  73     rda = ReadArgs("TIME/N,SEC=SECS/S,MIN=MINS/S,UNTIL/K", args, NULL);
  74
  75     if (rda == NULL)
  76     {
  77         PrintFault(IoErr(),"Wait");
  78         ERROR(RETURN_FAIL);
  79     }
  80
  81     if (args[3])
  82     {
  83         /* UNTIL */
  84         struct DateTime         dt;
  85         struct DateStamp        ds;
  86         LONG                    now_secs, then_secs, diff_secs;
  87         UBYTE                   timestring[9];
  88
  89         DateStamp(&ds);
  90         now_secs = ds.ds_Minute * 60 + ds.ds_Tick / TICKS_PER_SECOND;
  91
  92         if (strlen((char *)args[3]) > 5)
  93         {
  94             PutStr("Time should be HH:MM");
  95             ERROR(RETURN_FAIL);
  96         }
  97
  98         strcpy(timestring, (UBYTE *)args[3]);
  99         strcat(timestring, ":00");
 100
 101         memset(&dt, 0, sizeof(dt));
 102         dt.dat_StrTime = timestring;
 103
 104         if (!StrToDate(&dt))
 105         {
 106             PutStr("Time should be HH:MM");
 107             ERROR(RETURN_FAIL);
 108         }
 109
 110         then_secs = dt.dat_Stamp.ds_Minute * 60 + dt.dat_Stamp.ds_Tick / TICKS_PER_SECOND;
 111         diff_secs = then_secs - now_secs;
 112
 113         if (diff_secs < 0)
 114         {
 115             diff_secs += 60L * 60L * 24L;
 116         }
 117
 118         delay = diff_secs * TICKS_PER_SECOND;
 119
 120     }
 121     else
 122     {
 123         if (args[0])
 124         {
 125             delay = *((ULONG *)args[0]);
 126         }
 127
 128         if (args[2])
 129         {
 130             delay *= 60L;
 131         }
 132
 133         delay *= TICKS_PER_SECOND;
 134     }
 135
 136     if (delay > 0)
 137     {
 138 // Commented out the following: Wait is often used in scripts to allow to break loops, so it must always care about breaking
 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                 PutStr("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 }