Provided by: remind_03.01.04-1_i386 bug

NAME

       remind - a sophisticated reminder service

SYNOPSIS

       remind [options] filename [date] [*rep] [time]

DESCRIPTION

       Remind  reads  the supplied filename and executes the commands found in
       it.  The commands  are  used  to  issue  reminders  and  alarms.   Each
       reminder  or alarm can consist of a message sent to standard output, or
       a program to be executed.

       If filename is specified as a single dash ’-’, then  Remind  takes  its
       input from standard input.  This also implicitly enables the -o option,
       described below.

OPTIONS

       Remind has a slew of options.  If you’re new  to  the  program,  ignore
       them for now and skip to the section "Reminder Files".

       -n     The -n option causes Remind to print the next occurrence of each
              reminder in a simple calendar format.  You can sort this by date
              by piping the output through sort(1).

       -r     The  -r option disables RUN directives and the shell() function.
              As of Remind 3.00.17, using -u implies -r.

       -cn    The -c option causes Remind to produce a calendar that  is  sent
              to  standard  output.  If you supply a number n, then a calendar
              will be generated for n months, starting with the current month.
              By  default,  a calendar for only the current month is produced.
              If n starts with ’+’, then a calendar for n weeks is produced.

       -wcol[,pad[,spc]]]
              The -w option specifies the output width, padding and spacing of
              the  formatted  calendar  output.   Col  specifies the number of
              columns in the output device, and defaults to 80.  Pad specifies
              how  many  lines  to  use  to  "pad" empty calendar boxes.  This
              defaults to 5.  If you have many reminders on certain days  that
              make  your  calendar  too  large  to  fit on a page, you can try
              reducing pad to make the empty boxes smaller.  Spc specifies how
              many  blank  lines to leave between the day number and the first
              reminder entry.  It defaults to 1.

              Any of col, pad or spc can be omitted, providing you provide the
              correct number of commas.  Don’t use any spaces in the option.

       -s[a]n The  -s option is very similar to the -c option, except that the
              output calendar is not formatted.  It is  listed  in  a  "simple
              format"  that  can  be  used  as  input  for  more sophisticated
              calendar-drawing programs.  If n starts with  "+",  then  it  is
              interpreted as a number of weeks.

              If  you  immediately follow the s with the letter a, then Remind
              displays reminders on the calendar  on  the  day  they  actually
              occur  as  well  as  on  any  preceding  days  specified  by the
              reminder’s delta.

       -p[a]n The -p option is very similar to the -s option, except that  the
              output  contains  additional  information  for use by the Rem2PS
              program, which creates a PostScript calendar.  For this  option,
              n  cannot  start  with  "+"; it must specify a number of months.
              The format of the -p output is described in  the  rem2ps(1)  man
              page.   If  you immediately follow the p with the letter a, then
              Remind displays reminders  on  the  calendar  on  the  day  they
              actually occur as well as on any preceding days specified by the
              reminder’s delta.

       -l     If you use the -l option in conjunction with the -p option, then
              Remind outputs additional information for back-end programs such
              as  rem2ps.   This  additional  information  lets  the  back-end
              programs  correlate  a  reminder  with  the source file and line
              number that produced it.

       -m     The -m option causes the -c or -p options to produce a  calendar
              whose first column is Monday rather than Sunday.  (This conforms
              to the international standard.)

       -v     The -v option makes the output of Remind slightly more  verbose.
              Currently,  this  causes Remind to echo a bad line in case of an
              error, and to print a security message if  a  script  tests  the
              $RunOff system variable.

       -o     The -o option causes Remind to ignore all ONCE directives.

       -t     The   -t   option  causes  Remind  to  trigger  all  non-expired
              reminders, regardless of the delta supplied for each reminder.

       -h     The  -h  option  ("hush...")  suppresses  certain  warning   and
              information  messages.   In  particular,  if  no  reminders  are
              triggered, this mode produces no output.

       -a     The -a option causes Remind not  to  immediately  trigger  timed
              reminders  that would also be queued.  It also causes Remind not
              to place timed reminders in a calendar.

       -q     The -q option causes Remind not to  queue  timed  reminders  for
              later execution.

       -f     The  -f  option  causes  Remind to remain in the foreground when
              processing  queued  reminders,  rather  than   forking   off   a
              background process to handle them.

       -e     The  -e  option  diverts  error  messages  (normally sent to the
              standard error stream) to the standard output stream.

       -dchars
              The -d  option  enables  certain  debugging  modes.   The  chars
              specify which modes to enable:

         e      Echo all input lines

         x      Trace all expression evaluation

         t      Display all trigger date computation

         v      Dump the variable table after execution of the reminder script

         l      Echo lines when displaying error messages

       -g[a|d[a|d[a|d]]]
              Normally, reminders are issued in the order in  which  they  are
              encountered  in the reminder script.  The -g option cause Remind
              to sort reminders by date and time prior to issuing  them.   The
              optional a and d characters specify the sort order (ascending or
              descending) for the date, time and  priority  fields.   See  the
              section "Sorting Reminders" for more information.

       -b[n]  Set  the  time  format  for  the  calendar  and  simple-calendar
              outputs.  N can range from 0 to 2, with the default 0.  A  value
              of  0  causes times to be inserted in 12-hour (am/pm) format.  1
              causes times to be inserted in 24-hour format,  and  2  inhibits
              the automatic insertion of times in the calendar output.

       -x[n]  Sets  the  iteration  limit  for  the  SATISFY  clause  of a REM
              command.  Defaults to 150.

       -kcmd  Instead of simply printing MSG-type reminders, this causes  them
              to  be  passed to the specific cmd.  You must use ’%s’ where you
              want the body to appear, and may need to enclose this option  in
              quotes.   Note  that  all  shell  characters  in the body of the
              reminder are escaped with a backslash, and the  entire  body  of
              the  reminder  is  passed  as a single argument.  Note that this
              option overrides the -r option and the RUN OFF command.

              As an example, suppose you  have  an  X  Window  program  called
              xmessage  that  pops  up  a  window  and displays its invocation
              arguments.  You could use:

                        remind ’-kxmessage %s &’ ...

              to have all of your MSG-type reminders processed using xmessage.

              A  word of warning:  It is very easy to spawn dozens of xmessage
              processes with the above technique.  So be very careful.   Also,
              the  cmd  is  passed  as  an  argument to sprintf().  If you use
              formatting directives other than %s, or use  more  than  one  %s
              directive,  there’s  a  good  chance  that  you’ll crash Remind.
              Finally,  because  all  shell  and  whitespace  characters   are
              escaped,  the  program  you  execute  with the -k option must be
              prepared to handle the entire message as a single argument.

       -z[n]  Runs Remind in the daemon mode.  If n is supplied, it  specifies
              how  often  (in  minutes)  Remind should wake up to check if the
              reminder script has been changed.  N  defaults  to  5,  and  can
              range  from  5  to  60.  Note that the use of the -z option also
              enables the -f option.

              If you supply the option -z0, Remind  runs  in  a  special  mode
              called  server  mode.   This  is  documented in the tkremind man
              page; see tkremind(1).

       -uname Runs Remind with the uid and gid of the user specified by  name.
              The  option  changes  the uid and gid as described, and sets the
              environment  variables  HOME,  SHELL  and  USER  to   the   home
              directory,  shell, and user name, respectively, of the specified
              user.  LOGNAME is also set to the  specified  user  name.   This
              option  is meant for use in shell scripts that mail reminders to
              all users.  Note that as of Remind 3.00.17, using -u implies  -r
              -- the RUN directive and shell() functions are disabled.

              Non-root  users  can  also  use the -u option.  However, in this
              case, it only changes the  environment  variables  as  described
              above.  It does not change the effective uid or gid.

       -y     Causes  Remind to synthesize a tag for any reminder that lacks a
              TAG clause.

       -ivar=expr
              Sets the value of the specified var to expr, and preserves  var.
              Expr  can  be  any  valid  Remind  expression.   See the section
              "Initializing Variables on the Command Line" for more details.

       If you supply a date on the command line, it must consist of day  month
       year,  where  day  is the day of the month, month is at least the first
       three letters of the English name of the month, and year is a year (all
       4  digits)  from  1990 to about 2075.  You can leave out the day, which
       then defaults to 1.

       If you do supply a date on the  command  line,  then  Remind  uses  it,
       rather  than  the  actual  system date, as its notion of "today."  This
       lets you create calendars for future months, or test to  see  how  your
       reminders will be triggered in the future.  Similarly, you can supply a
       time (in 24-hour format -- for example, 17:15) to set  Remind’s  notion
       of  "now"  to  a particular time.  Supplying a time on the command line
       also implicitly enables the -q option and disables the -z option.

       In addition, you can supply a repeat  parameter,  which  has  the  form
       *num.   This  causes  Remind  to  be  run  num  times,  with  the  date
       incrementing on each iteration.  You may have to enclose the  parameter
       in  quotes  to  avoid  shell  expansion.   See the subsection "Repeated
       Execution" in the section "Calendar Mode" for more information.

REMINDER FILES

       Remind uses scripts to control its operation.  You  can  use  any  text
       editor capable of creating plain ASCII files to create a Remind script.
       The commands inside a script can range from the very simple and  almost
       immediately understandable:

            REM 6 Jan MSG David’s birthday

       to the baroque and obscure:

            REM [trigger(date(thisyear, 1, 1) + 180)] ++5 OMIT \
            sat sun BEFORE MSG [ord(thisyear-1980)] payment due %b!

       A  reminder  file  consists  of  commands,  with  one command per line.
       Several lines can be continued using the backslash character, as in the
       above example.  In this case, all of the concatenated lines are treated
       as a single line by Remind.  Note  that  if  an  error  occurs,  Remind
       reports the line number of the last line of a continued line.

       Remind  ignores  blank  lines,  and lines beginning with the ’#’ or ’;’
       characters.  You can use the semicolon as a comment  character  if  you
       wish  to  pass  a  Remind  script  through  the  C pre-processor, which
       interprets  the  ’#’  character  as  the  start  of  a   pre-processing
       directive.

       Remind  is  not  case  sensitive;  you can generally use any mixture of
       upper- or lower-case for commands, parameters, invocation options, etc.

THE REM COMMAND

       The  most powerful command in a Remind script is the REM command.  This
       command is responsible for issuing reminders.  Its syntax is:

              REM [ONCE] [date_spec] [back] [delta] [repeat]  [PRIORITY  prio]
              [SKIP  |  BEFORE  |  AFTER]  [OMIT  omit_list] [AT time [tdelta]
              [trepeat]] [SCHED sched_function]  [WARN  warn_function]  [UNTIL
              expiry_date]  [SCANFROM  scan_date  | FROM start_date] [DURATION
              duration] [TAG tag] <MSG | MSF | RUN | CAL | SATISFY  |  SPECIAL
              special | PS | PSFILE> body

       The parts of the REM command can be specified in any order, except that
       the body must come immediately after the MSG, RUN, CAL, PS,  PSFILE  or
       SATISFY keyword.

       The  REM token is optional, providing that the remainder of the command
       cannot be mistaken for another Remind command such as OMIT or RUN.  The
       portion  of  the  REM  command  before the MSG, MSF RUN, CAL or SATISFY
       clause is called a trigger.

       MSG, MSF, RUN, CAL, SPECIAL, PS and PSFILE

       These keywords denote the type  of  the  reminder.   (SATISFY  is  more
       complicated and will be explained later.)  A MSG-type reminder normally
       prints a message to the standard output, after passing the body through
       a   special   substitution   filter,  described  in  the  section  "The
       Substitution Filter."  However, if you have used  the  -k  command-line
       option,  then MSG-type reminders are passed to the appropriate program.
       Note that the options -c, -s, -p and -n disable the -k option.

       Note that you can omit the reminder type, in which case it defaults  to
       MSG.  So you can write:

            6 January David’s Birthday

       although this is not recommended.

       The  MSF keyword is almost the same as the MSG keyword, except that the
       reminder is formatted to  fit  into  a  paragraph-like  format.   Three
       system  variables  control  the formatting of MSF-type reminders - they
       are $FirstIndent, $SubsIndent and $FormWidth.  They  are  discussed  in
       the  section "System Variables."  The MSF keyword causes the spacing of
       your reminder to be altered -  extra  spaces  are  discarded,  and  two
       spaces  are  placed after periods and other characters, as specified by
       the system variables $EndSent and $EndSentIg.  Note that if the body of
       the  reminder  includes  newline  characters  (placed there with the %_
       sequence), then the newlines are  treated  as  the  beginnings  of  new
       paragraphs, and the $FirstIndent indentation is used for the next line.
       You can use two consecutive newlines to have spaced paragraphs  emitted
       from a single reminder body.

       A  RUN-type  reminder  also  passes  the  body through the substitution
       filter, but then executes the result as a system command.   A  CAL-type
       reminder  is  used  only to place entries in the calendar produced when
       Remind is run with the -c, -s or -p options.

       A PS or PSFILE-type reminder is used to pass PostScript  code  directly
       to  the  printer when producing PostScript calendars.  This can be used
       to shade certain calendar entries (see the psshade() function), include
       graphics in the calendar, or almost any other purpose you can think of.
       You should not use these types of reminders unless you  are  an  expert
       PostScript  programmer.  The PS and PSFILE reminders are ignored unless
       Remind is run  with  the  -p  option.   See  the  section  "More  about
       PostScript" for more details.

       A  SPECIAL-type reminder is used to pass "out-of-band" information from
       Remind to a calendar-producing back-end.  It should be  followed  by  a
       word  indicating  the type of special data being passed.  The type of a
       special reminder depends on the back-end.   For  the  Rem2PS  back-end,
       SPECIAL  PostScript  is  equivalent  to a PS-type reminder, and SPECIAL
       PSFile is equivalent to a PSFILE-type reminder.  The body of a  SPECIAL
       reminder is obviously dependent upon the back-end.

       DATE SPECIFICATIONS

       A  date_spec  consists of zero to four parts.  These parts are day (day
       of month), month (month name), year and weekday.  Month and weekday are
       the  English  names  of  months and weekdays.  At least the first three
       characters must be used.  The following are  examples  of  the  various
       parts of a date_spec:

       day:   1, 22, 31, 14, 3

       month: JANUARY, feb, March, ApR, may, Aug

       year:  1990,  1993, 2030, 95 (interpreted as 1995).  The year can range
              from 1990 to 2075.

       weekday:
              Monday, tue, Wed, THU, Friday, saturday, sundAy

       Note that there can be several weekday components separated  by  spaces
       in a date_spec.

       INTERPRETATION OF DATE SPECIFICATIONS

       The following examples show how date specifications are interpreted.

       1.  Null date specification - the reminder is triggered every day.  The
       trigger date for a specific run is simply the current system date.

       2. Only day present.  The reminder is triggered on the specified day of
       each  month.  The trigger date for a particular run is the closest such
       day to the current system date.  For example:
            REM 1 MSG First of every month.
            REM 31 MSG 31st of every month that has 31 days.

       3. Only month present.  The reminder is  triggered  every  day  of  the
       specified month.  Example:
            REM Feb MSG Every day in February

       4.  day and month present.  Examples:
            REM 6 Jan MSG Every 6th of January
            REM Feb 29 MSG Every 29th of February

       5.  Only year present. Example:
            REM 1991 MSG Every day in 1991

       6.  year and day present.  Examples:
            REM 1 1990 MSG 1st of every month in 1990
            REM 1992 23 MSG 23rd of every month in 1992

       7.  year and month present.  Examples:
            REM Feb 1991 MSG Every day in Feb 1991
            REM 1992 September MSG Every day in Sept 1992

       8.  year, month and day present.  Examples:
            REM 8 Jan 1991 MSG 8th January 1991.
            REM 1992 March 9 MSG 9th March 1992.

       9.  weekday only.  Examples:
            REM Sat MSG Every Saturday
            REM Mon Tue Wed Thu Fri MSG Every working day
            REM Monday Wednesday MSG Every Monday and Wednesday

       10.  weekday and day present.  Examples:
            REM Sat 1 MSG First Saturday of every month
            REM Mon Tue Wed Thu Fri 15 \
                 MSG 1st working day after 15th of every month

       11.  weekday and month present.  Examples:
            REM Mon March MSG Every Monday in March
            REM Mon Tue Wed Thu Fri Feb MSG Every working day in February

       12.  weekday, month and day present.  Examples:
            REM Mon 1 March MSG First Monday in March
            REM Sat Sun 15 July MSG First Sat or Sun on or after 15 July

       13.  weekday and year present.  Example:
            REM Sat Sun 1991 MSG Every Saturday and Sunday in 1991

       14.  weekday, day and year present.  Examples:
            REM Mon 15 1990 MSG 1st Mon after 15th of every month in 1990
            REM Mon Tue Wed Thu Fri 1 1990 \
                 MSG 1st working day of every month in 1990

       15.  weekday, month and year present.  Example:
            REM Mon Wed 1991 Feb MSG Every Mon and Wed in Feb 1991.

       16.  weekday, day, month and year present.  Example:
            REM Mon Tue Wed Thu Fri 28 Oct 1990 \
                 MSG 1st working day on or after 28 October 1990.

       Note  that  when both weekday and day are specified, Remind chooses the
       first date on or after  the  specified  day  that  also  satisfies  the
       weekday constraint.  It does this by picking the first date on or after
       the specified day that is listed in the  list  of  weekdays.   Thus,  a
       reminder like:

            REM Mon Tue 28 Oct 1990 MSG Hi

       would  be  issued  only  on  Monday, 29 October, 1990.  It would not be
       issued on Tuesday, 30 October, 1990, since the 29th is the  first  date
       to satisfy the weekday constraints.

       BACKWARD SCANNING

       Sometimes,  it  is necessary to specify a date as being a set amount of
       time before another date.  For example, the  last  Monday  in  a  given
       month  is computed as the first Monday in the next month, minus 7 days.
       The back specification in the reminder is used in this case:

            REM Mon 1 -7 MSG Last Monday of every month.

       A back is specified with one or two  dashes  followed  by  an  integer.
       This  causes Remind to move "backwards" from what would normally be the
       trigger date.  The difference between --7 and -7 will be explained when
       the OMIT keyword is described.

       ADVANCE WARNING

       For some reminders, it is appropriate to receive advance warning of the
       event.  For example, you may wish to be reminded of someone’s  birthday
       several days in advance.  The delta portion of the REM command achieves
       this.  It is specified as one or two "+" signs followed by a number  n.
       Again,  the difference between the "+" and "++" forms will be explained
       under the OMIT keyword.  Remind will trigger the reminder  on  computed
       trigger  date, as well as on each of the n days before the event.  Here
       are some examples:

            REM 6 Jan +5 MSG Remind me of birthday 5 days in advance.

       The above example would be triggered every 6th of January, as  well  as
       the 1st through 5th of January.

       PERIODIC REMINDERS

       We  have  already  seen  some  built-in mechanisms for certain types of
       periodic reminders.  For example, an event  occurring  every  Wednesday
       could be specified as:

            REM Wed MSG Event!

       However,  events  that  do  not repeat daily, weekly, monthly or yearly
       require another approach.  The repeat  component  of  the  REM  command
       fills  this need.  To use it, you must completely specify a date (year,
       month and day, and optionally weekday.)  The  repeat  component  is  an
       asterisk followed by a number specifying the repetition period in days.

       For example, suppose you get paid every second Wednesday, and your last
       payday was Wednesday, 28 October, 1992.  You can use:

            REM 28 Oct 1992 *14 MSG Payday

       This  issues  the  reminder every 14 days, starting from the calculated
       trigger date.  You can use delta and back with repeat.  Note,  however,
       that  the  back  is  used  only  to  compute  the initial trigger date;
       thereafter, the reminder repeats with the specified period.  Similarly,
       if  you  specify  a  weekday,  it is used only to calculate the initial
       date, and does not affect the repetition period.

       SCANFROM and FROM

       The SCANFROM and FROM keywords  are  for  advanced  Remind  programmers
       only,  and  will  be  explained  in  the section "Details about Trigger
       Computation" near the end  of  this  manual.   Note  that  SCANFROM  is
       available  only  in  versions  of  Remind  from  03.00.04  up.  FROM is
       available only from 03.01.00 and later.

       PRIORITY

       The PRIORITY keyword must be followed by a number from 0 to  9999.   It
       is  used in calendar mode and when sorting reminders.  If two reminders
       have the same trigger date and time, then they are sorted by  priority.
       If  the PRIORITY keyword is not supplied, a default priority of 5000 is
       used.  (This default can be changed by adjusting  the  system  variable
       $DefaultPrio.    See   the   section   "System   Variables"   for  more
       information.)

       EXPIRY DATES

       Some reminders should be issued periodically for a  certain  time,  but
       then  expire.   For example, suppose you have a class every Friday, and
       that your last class is on 11 December 1992.  You can use:

            REM Fri UNTIL 11 Dec 1992 MSG Class today.

       Another example:  Suppose you have jury  duty  from  30  November  1992
       until  4  December 1992.  The following reminder will issue the message
       every day of your jury duty, as well as 2 days ahead of time:

            REM 30 Nov 1992 *1 +2 UNTIL 4 Dec 1992 MSG Jury duty

       Note that the repeat of *1 is necessary; without it, the reminder would
       be issued only on 30 November (and the two days preceding.)

       THE ONCE KEYWORD

       Sometimes,  it  is necessary to ensure that reminders are run only once
       on a given day.  For example, if you  have  a  reminder  that  makes  a
       backup of your files every Friday:

            REM Fri RUN do_backup

       (Here,  do_backup  is assumed to be a program or shell script that does
       the work.)  If you run Remind from your .login script, for example, and
       log  in  several  times per day, the do_backup program will be run each
       time you log in.   If,  however,  you  use  the  ONCE  keyword  in  the
       reminder,  the  Remind  checks  the  last  access  date of the reminder
       script.  If it is the same as the current date, Remind assumes that  it
       has  already been run, and will not issue reminders containing the ONCE
       keyword.

       Note that if you view or edit your reminder  script,  the  last  access
       date  will  be updated, and the ONCE keyword will not operate properly.
       If you start Remind with the -o option, then the ONCE keyword  will  be
       ignored.

       LOCALLY OMITTING WEEKDAYS

       The OMIT portion of the REM command is used to "omit" certain days when
       counting the delta or back.  It is specified  using  the  keyword  OMIT
       followed  by  a  list of weekdays.  Its action is best illustrated with
       examples:

            REM 1 +1 OMIT Sat Sun MSG Important Event

       This reminder is normally triggered on the first  of  every  month,  as
       well as the day preceding it.  However, if the first of the month falls
       on a Sunday or Monday, then the reminder is triggered starting from the
       previous  Friday.   This  is  because  the  delta  of +1 does not count
       Saturday or Sunday when it counts backwards from the  trigger  date  to
       determine how much advance warning to give.

       Contrast  this  with  the  use  of "++1" in the above command.  In this
       case, the reminder is triggered on the first of each month, as well  as
       the day preceding it.  The omitted days are counted.

            REM 1 -1 OMIT Sat Sun MSG Last working day of month

       Again, in the above example, the back of -1 normally causes the trigger
       date to be the last day of the month.  However,  because  of  the  OMIT
       clause,  if  the  first  of  the month falls on a Sunday or Monday, the
       trigger date is moved backwards past the weekend to  Friday.   (If  you
       have  globally  omitted  holidays, the reminder will be moved back past
       them, also.  See "The OMIT command" for more details.)

       By comparison, if we had used "--1", the reminder would be triggered on
       the last day of the month, regardless of the OMIT.

       TIMED REMINDERS

       Timed  reminders  are  those that have an AT keyword followed by a time
       and optional tdelta and trepeat.  The time must be specified in 24-hour
       format,  with  0:00 representing midnight, 12:00 representing noon, and
       23:59 representing one minute to midnight.  You can use either a  colon
       or a period to separate the hours from the minutes.  That is, 13:39 and
       13.39 are equivalent.

       Remind treats timed reminders specially.  If the  trigger  date  for  a
       timed  reminder is the same as the current system date, the reminder is
       queued for later activation.  When Remind has finished  processing  the
       reminder  file,  it  puts itself in the background, and activates timed
       reminders when the system time reached the specified time.

       If the trigger date is not the same as the system date, the reminder is
       not queued.

       For  example, the following reminder, triggered every working day, will
       emit a message telling you to leave at 5:00pm:

            REM Mon Tue Wed Thu Fri AT 17:00 MSG Time to leave!

       The following reminder will be triggered on Thursdays and Fridays,  but
       will only be queued on Fridays:

            REM Fri ++1 AT 13:00 MSG Lunch at 1pm Friday.

       The  tdelta  and  trepeat have the same form as a repeat and delta, but
       are specified in minutes.  For example, this reminder will be triggered
       at 12:00pm as well as 45 minutes before:

            REM AT 12:00 +45 MSG Example

       The  following  will be issued starting at 10:45, every half hour until
       11:45, and again at noon.

            REM AT 12:00 +75 *30 MSG Example2

       The "+75" means that the reminder is issued starting 75 minutes  before
       noon; in other words, at 10:45.  The *30 specifies that the reminder is
       subsequently to be issued every 30 minutes.  Note that the reminder  is
       always  issued  at  the  specified  time,  even  if the tdelta is not a
       multiple of the trepeat.  So the above example is  issued  at  10:45am,
       11:15am,  11:45am,  and  12:00pm.  Note that in the time specification,
       there is no distinction between the "+" and "++" forms of tdelta.

       Normally, Remind  will  issue  timed  reminders  as  it  processes  the
       reminder script, as well as queuing them for later.  If you do not want
       Remind to issue the reminders when processing the script, but  only  to
       queue  them  for  later, use the -a command-line option.  If you do not
       want reminders to be queued for later, use the -q command-line  option.

       Normally, Remind forks a background process to handle queued reminders.
       If you want Remind to remain in the foreground, use the -f command-line
       option.   This  is  useful, for example, in .xinitrc scripts, where you
       can use the command:

            remind -fa myreminders &

       This ensures that when  you  exit  X-Windows,  the  Remind  process  is
       killed.

       WARNING ABOUT TIMED REMINDERS

       Note:  If you use user-defined functions or variables (described later)
       in the bodies of timed reminders, then when  the  timed  reminders  are
       activated,  the  variables and functions have the definitions that were
       in effect at the end of the reminder script.  These definitions may not
       necessarily  be  those that were in effect at the time the reminder was
       queued.

       THE SCHED AND WARN KEYWORDS

       The SCHED keyword allows more precise control over  the  triggering  of
       timed  reminders,  and the WARN keyword allows precise control over the
       advance triggering of all types of reminders.  However, discussion must
       be  deferred  until  after  expressions  and user-defined functions are
       explained.  See the subsection "Precise Scheduling" further on.

       TAG AND DURATION

       The TAG keyword lets you "tag" certain  reminders.   This  facility  is
       used  by  certain  back-ends  or  systems  built around Remind, such as
       TkRemind.  These back-ends have specific rules about tags;  you  should
       not  use  the  TAG keyword yourself, or your script will interact badly
       with back-ends.

       The TAG keyword is followed by a tag consisting of up to 48 characters.

       If  you  supply the -y option to Remind, then any reminder that lacks a
       TAG will have one synthesized.  The synthesized  tag  consists  of  the
       characters  "__syn__" followed by the hexadecimal representation of the
       MD5 sum of the REM command line.  This lets  you  give  a  more-or-less
       unique identifier to each distinct REM command.

       The DURATION keyword makes sense only for timed reminders; it specifies
       the duration of an event.  Currently, this is not used, but it  may  be
       used  in future by back-ends or scheduling systems built around Remind.
       For example, if you have a 90-minute meeting starting  at  1:00pm,  you
       could use:

            REM 5 March 1999 AT 13:00 DURATION 1:30 MSG Meeting

       Note that duration is specified in hours and minutes.

THE SUBSTITUTION FILTER

       Before  being  processed, the body of a REM command is passed through a
       substitution filter.  The filter scans for sequences "%x" (where "x" is
       any  letter and certain other characters) and performs substitutions as
       shown below.  (All dates refer to the trigger date of the reminder.)

       %a     is replaced with "on weekday, day month, year"
              For example, consider the reminder:

              REM 18 Oct 1990 +4 MSG Meeting with Bob %a.

              On 16  October  1990,  it  would  print  "Meeting  with  Bob  on
              Thursday, 18 October, 1990."

              On  17 October 1990, it would print "Meeting with Bob tomorrow."

              On 18 October 1990, it would print "Meeting with Bob today."

       %b     is replaced with "in diff day’s time" where diff is  the  actual
              number  of  days  between the current date and the trigger date.
              (OMITs have no effect.)
              For example, consider:

              REM 18 Oct 1990 +4 MSG Meeting with Bob %b.

              On 16 October 1990, it would print "Meeting with Bob in 2  days’
              time."

              On  17 October 1990, it would print "Meeting with Bob tomorrow."

              On 18 October 1990, it would print "Meeting with Bob today."

       %c     is replaced with "on weekday"
              Example: REM 18 Oct 1990 +4 MSG Meeting with Bob %c.

              On 16  October  1990,  it  would  print  "Meeting  with  Bob  on
              Thursday."

              On  17 October 1990, it would print "Meeting with Bob tomorrow."

              On 18 October 1990, it would print "Meeting with Bob today."

       %d     is replaced with "day", the day of the month.

       %e     is replaced with "on dd-mm-yyyy"

       %f     is replaced with "on mm-dd-yyyy"

       %g     is replaced with "on weekday, day month"

       %h     is replaced with "on dd-mm"

       %i     is replaced with "on mm-dd"

       %j     is replaced with "on weekday, month  day-th,  year"   This  form
              appends  the  characters  "st", "nd", "rd" or "th" to the day of
              the month, as appropriate.

       %k     is replaced with "on weekday, month day-th"

       %l     is replaced with "on yyyy-mm-dd"

       %m     is replaced with "month", the name of the month.

       %n     is replaced with the number (1 to 12) of the month.

       %o     is replaced with " (today)" if and only if  the  current  system
              date is the same as the date being used by Remind as the current
              date.  Recall that you can specify a date for Remind to  use  on
              the  command line.  This substitution is not generally useful in
              a REM command, but is useful in a  BANNER  command.   (See  "The
              BANNER Command.")

       %p     is  replaced  with  "s" if the diff between the current date and
              the trigger date is not  1.   You  can  use  this  to  construct
              reminders like:
              REM 1 Jan +4 MSG %x day%p to go before New Year!

       %q     is  replaced  with "’s" if the diff between the trigger date and
              the current date is 1.  Otherwise,  it  is  replaced  with  "s’"
              This can be used as follows:
              REM 1 Jan +4 MSG New Year in %x day%q time!

       %r     is  replaced  with the day of the month (01 to 31) padded with a
              leading zero if needed to pad to two digits.

       %s     is replaced with "st", "nd", "rd" or "th" depending on  the  day
              of the month.

       %t     is  replaced  with  the number of the month (01 to 12) padded to
              two digits with a leading zero.

       %u     is replaced with "on  weekday,  day-th  month,  year"   This  is
              similar  to  %a except that "st", "nd", "rd" or "th" is added to
              the day as appropriate.

       %v     is replaced with "on weekday, day-th month"

       %w     is replaced with "weekday", the name of the day of the week.

       %x     is replaced with the diff  between  the  current  date  and  the
              trigger  date.  The diff is defined as the actual number of days
              between these two dates; OMITs are not  counted.   (Strict  date
              subtraction is performed.)

       %y     is replaced with "year", the year of the trigger date.

       %z     is replaced with "yy", the last two digits of the year.

       %_     (percent-underscore)  is  replaced  with a newline.  You can use
              this to achieve multi-line reminders.

       %1     is replaced with "now", "m minutes from now", "m  minutes  ago",
              "h  hours  from now", "h hours ago", "h hours and m minutes from
              now" or "h hours and m minutes ago", as appropriate for a  timed
              reminder.   Note  that  unless  you specify the -a option, timed
              reminders will be triggered like normal reminders,  and  thus  a
              timed   reminder  that  occurred  earlier  in  the  day  may  be
              triggered.  This causes the need for the "...ago" forms.

       %2     is replaced with "at hh:mmam" or "..pm" depending on the AT time
              of the reminder.

       %3     is replaced with "at hh:mm" in 24-hour format.

       %4     is  replaced with "mm" where mm is the number of minutes between
              "now" and the time specified by AT.  If the AT time  is  earlier
              than the current time, then the result is negative.

       %5     is  replaced  with  "ma"  where  ma is the absolute value of the
              number produced by %4.

       %6     is  replaced  with  "ago"  or  "from  now",  depending  on   the
              relationship between the AT time and the current time.

       %7     is replaced with the number of hours between the AT time and the
              current time.  It is always non-negative.

       %8     is replaced with the number of minutes between the AT  time  and
              the current time, after the hours (%7) have been subtracted out.
              This is a number ranging from 0 to 59.

       %9     is replaced with "s" if the value produced by %8 is not 1.

       %0     is replaced with "s" if the value produced by %7 is not 1.

       %!     is replaced with "is" if the current time is before the AT time,
              or "was" if it is after.

       %@     is similar to %2 but displays the current time.

       %#     is similar to %3 but displays the current time.

       %"     (percent-doublequote - ") is removed.  This sequence is not used
              by the substitution filter, but is used  to  tell  Remind  which
              text to include in a calendar entry when the -c, -s or -p option
              is chosen.  See "Calendar Mode"

       Notes:

       o      Remind normally prints a blank line after each reminder; if  the
              last  character  of  the body is "%", the blank line will not be
              printed.

       o      Substitutions a, b, c, e, f, g, h, i, j, k, l, u and v  all  are
              replaced  with  "today"  if  the current date equals the trigger
              date, or "tomorrow" if the trigger date is  one  day  after  the
              current  date.   Thus,  they  are  not the same as substitutions
              built up from the simpler %w, %y, etc.  sequences.

       o      Any of the substitutions dealing with time (0 through 9 and ’!’)
              produce  undefined  results  if used in a reminder that does not
              have an AT keyword.  Also, if a reminder has a delta and may  be
              triggered  on  several  days,  the time substitutions ignore the
              date.  Thus, the %1 substitution may report that a meeting is in
              15  minutes,  for  example, even though it may only be in 2 days
              time, because  a  delta  has  triggered  the  reminder.   It  is
              recommended  that  you  use the time substitutions only in timed
              reminders with no delta that are designed to be queued for timed
              activation.

       o      Capital  letters  can  be  used in the substitution sequence, in
              which case the first character  of  the  substituted  string  is
              capitalized (if it is normally a lower-case letter.)

       o      All other characters following a "%" sign are simply copied.  In
              particular, to get a "%" sign out, use "%%"  in  the  body.   To
              start  the  body  of  a  reminder  with a space, use "% ", since
              Remind normally scans for the first non-space character after  a
              MSG, CAL or RUN token.

THE OMIT COMMAND

       In addition to being a keyword in the REM command, OMIT is a command in
       its own right.  Its syntax is:

              OMIT day month [year]

       The OMIT command is used  to  "globally"  omit  certain  days  (usually
       holidays).   These globally-omitted days are skipped by the "-" and "+"
       forms of back and delta.  Some examples:

            OMIT 1 Jan
            OMIT 7 Sep 1992

       The first example specifies a holiday that occurs on the same date each
       year  -  New  Year’s  Day.  The second example specifies a holiday that
       changes each year - Labour Day.  For these types of holidays, you  must
       create  an  OMIT  command for each year.  (Later, in the description of
       expressions and some of the more advanced features of Remind, you  will
       see how to automate this for some cases.)

       For convenience, you can use a delta and MSG or RUN keyword in the OMIT
       command.  The following sequences are exactly equivalent:

            OMIT 1 Jan
            REM 1 Jan +4 MSG New year’s day is %b!

            and

            OMIT 1 Jan +4 MSG New year’s day is %b!

       THE BEFORE, AFTER AND SKIP KEYWORDS

       Normally, days that are omitted, whether by a global  OMIT  command  or
       the  local OMIT keyword in a REM statement, only affect the counting of
       the -back or the +delta.  For example, suppose you have a meeting every
       Wednesday.  Suppose, too, that you have indicated 11 Nov as a holiday:

            OMIT 11 Nov +4 MSG Remembrance Day
            REM Wed +1 MSG Code meeting %b.

       The  above  sequence  will  issue  a  reminder  about  a meeting for 11
       November 1992, which is  a  Wednesday.   This  is  probably  incorrect.
       There are three options:

       BEFORE This  keyword  moves  the  reminder  to before any omitted days.
              Thus, in the above  example,  use  of  BEFORE  would  cause  the
              meeting reminder to be triggered on Tuesday, 10 November 1992.

       AFTER  This  keyword  moves the reminder to after any omitted days.  In
              the above example, the meeting reminder would  be  triggered  on
              Thursday, 12 November 1992.

       SKIP   This keyword causes the reminder to be skipped completely on any
              omitted days.  Thus, in the above example,  the  reminder  would
              not  be  triggered  on  11  November 1992.  However, it would be
              triggered as usual on the following Wednesday, 18 November 1992.

       The  BEFORE  and  AFTER keywords move the trigger date of a reminder to
       before or after a block of omitted  days,  respectively.   Suppose  you
       normally  run  a backup on the first day of the month.  However, if the
       first day of the month is a weekend or holiday, you run the  backup  on
       the first working day following the weekend or holiday.  You could use:

            REM 1 OMIT Sat Sun AFTER RUN do_backup

       Let’s examine how the trigger date is computed.  The  1  specifies  the
       first  day  of  the  month.   The  local  OMIT keyword causes the AFTER
       keyword to move the reminder forward past weekends.  Finally, the AFTER
       keyword  will  keep moving the reminder forward until it has passed any
       holidays specified with global OMIT commands.

THE INCLUDE COMMAND

       Remind allows you to include  other  files  in  your  reminder  script,
       similar  to  the  C preprocessor #include directive.  For example, your
       system administrator may maintain a file  of  holidays  or  system-wide
       reminders.  You can include these in your reminder script as follows:

            INCLUDE /usr/share/remind/holidays
            INCLUDE /usr/share/remind/reminders

       (The  actual  pathnames  vary  from  system to system - ask your system
       administrator.)

       INCLUDE files can be nested up to a depth of 8.

       If you specify a filename of "-" in the INCLUDE  command,  Remind  will
       begin reading from standard input.

THE RUN COMMAND

       If  you include other files in your reminder script, you may not always
       entirely trust the contents of the other files.  For example, they  may
       contain  RUN-type  reminders that could be used to access your files or
       perform undesired actions.  The RUN command can restrict this:  If  you
       include  the  command  RUN  OFF  in your top-level reminder script, any
       reminder or expression that would normally execute a system command  is
       disabled.   RUN  ON  will  re-enable  the execution of system commands.
       Note that the RUN ON  command  can  only  be  used  in  your  top-level
       reminder  script; it will not work in any files accessed by the INCLUDE
       command.  This is to protect you from someone placing a RUN ON  command
       in  an  included file.  However, the RUN OFF command can be used at top
       level or in an included file.

       If you run Remind with the -r command-line option,  RUN-type  reminders
       and  the  shell()  function  will  be  disabled,  regardless of any RUN
       commands in the reminder script.  However, any  command  supplied  with
       the -k option will still be executed.

       One  use  of  the  RUN command is to provide a secure interface between
       Remind and the Elm mail system.  The Elm system can automatically  scan
       incoming  mail for reminder or calendar entries, and place them in your
       calendar file.  To use  this  feature,  you  should  set  the  calendar
       filename  option  under Elm to be something like "~/.reminders.in", not
       your main reminder file!  This is so that any RUN ON commands mailed to
       you can never be activated.

       Then,  you can use the Elm scan message for calendar entries command to
       place reminders prefaced by "->"  into  .reminders.in.   In  your  main
       .reminders file, include the following lines:

            RUN OFF   # Disable RUN
            INCLUDE .reminders.in
            RUN ON    # Re-enable RUN

       In  addition,  Remind  contains a few other security features.  It will
       not read a file that is group- or world-writable.  It will not run set-
       uid.   If  it  reads  a file you don’t own, it will disable RUN and the
       shell() function.  And if it is run as root, it will  only  read  files
       owned by root.

THE BANNER COMMAND

       When Remind first issues a reminder, it prints a message like this:

            Reminders for Friday, 30th October, 1992 (today):

       (The  banner is not printed if any of the calendar-producing options is
       used, or if the -k option is used.)

       The BANNER command lets you change the format.  It should appear before
       any REM commands.  The format is:

              BANNER format

       The  format  is  similar  to  the  body of a REM command.  It is passed
       through the substitution  filter,  with  an  implicit  trigger  of  the
       current system date.  Thus, the default banner is equivalent to:

            BANNER Reminders for %w, %d%s %m, %y%o:

       You can disable the banner completely with BANNER %.  Or you can create
       a custom banner:

            BANNER Hi - here are your reminders for %y-%t-%r:

CONTROLLING THE OMIT CONTEXT

       Sometimes, it is necessary to temporarily change the global OMITs  that
       are in force for a few reminders.  Three commands allow you to do this:

       PUSH-OMIT-CONTEXT
              This command saves the  current  global  OMITs  on  an  internal
              stack.

       CLEAR-OMIT-CONTEXT
              This  command  clears  all of the global OMITs, starting you off
              with a "clean slate."

       POP-OMIT-CONTEXT
              This command restores the global OMITs that were  saved  by  the
              most recent PUSH-OMIT-CONTEXT.

       For example, suppose you have a block of reminders that require a clear
       OMIT context, and that they also introduce unwanted global  OMITs  that
       could  interfere  with  later  reminders.   You could use the following
       fragment:

            PUSH-OMIT-CONTEXT   # Save the current context
            CLEAR-OMIT-CONTEXT  # Clean the slate
            # Block of reminders goes here
            POP-OMIT-CONTEXT    # Restore the saved omit context

EXPRESSIONS

       In  certain  contexts,  to  be  described  later,  Remind  will  accept
       expressions for evaluation.  Remind expressions resemble C expressions,
       but operate on different types of objects.

       DATA TYPES

       Remind expressions operate on five types of objects:

       INT    The INT data type consists of the integers representable in  one
              machine  word.   The  INT  data  type corresponds to the C "int"
              type.

       STRING The STRING data type consists of strings of characters.   It  is
              somewhat  comparable  to  a  C character array, but more closely
              resembles the string type in BASIC.

       TIME   The TIME data type consists of times of the day.  The TIME  data
              type  is internally stored as an integer representing the number
              of minutes since midnight.

       DATE   The DATE data type consists  of  dates  (later  than  1  January
              1990.)   Internally,  DATE  objects  are stored as the number of
              days since 1 January 1990.

       DATETIME
              The DATETIME data type consists of a  date  and  time  together.
              Internally, DATETIME objects are stored as the number of minutes
              since midnight, 1 January 1990.  You can  think  of  a  DATETIME
              object as being the combination of DATE and TIME parts.

       CONSTANTS

       The following examples illustrate constants in Remind expressions:

       INT constants
              12, 36, -10, 0, 1209

       STRING constants
              "Hello there", "This is a test", "\n\gosd\w", ""

              Note  that  the  empty  string  is  represented  by "", and that
              backslashes in a string are not  interpreted  specially,  as  in
              they are in C.

       TIME constants
              12:33, 0:01, 14:15, 16:42, 12.16, 13.00, 1.11

              Note  that TIME constants are written in 24-hour format.  Either
              the period or colon can be used to separate the minutes from the
              hours.   However,  Remind  will  consistently output times using
              only one separator character.  (The output  separator  character
              is chosen at compile-time.)

       DATE constants
              DATE  constants  are  expressed as ’yyyy/mm/dd’ or ’yyyy-mm-dd’,
              and the single quotes must be supplied.  This distinguishes date
              constants from division or subtraction of integers.  Examples:

              ´1993/02/22’, ’1992-12-25’, ’1999/01/01’

              Note  that DATE values are printed without the quotes.  Although
              either ’-’ or ’/’ is accepted as a date separator on input, when
              dates are printed, only one will be used.  The choice of whether
              to use ’-’ or ’/’ is  made  at  compile-time.   Note  also  that
              versions  of  Remind  prior  to  03.00.01  did  not support date
              constants.  In those versions, you must create dates  using  the
              date()  function.   Also,  versions  prior  to  03.00.02 did not
              support the ’-’ date separator.

       DATETIME constants
              DATETIME constants are expressed  similarly  to  DATE  constants
              with the addition of an "@HH:MM" part.  For example:

              ´2008-04-05@23:11’, ’1999/02/03@14:06’, ’2001-04-07@08:30’

              DATETIME  values  are  printed  without the quotes.  Notes about
              date and time separator characters for DATE and  TIME  constants
              apply also to DATETIME constants.

       OPERATORS

       Remind  has  the  following operators.  Operators on the same line have
       equal precedence, while operators on lower lines have lower  precedence
       than  those on higher lines.  The operators approximately correspond to
       C operators.

            !  -     (unary logical negation and arithmetic negation)
            *  /  %
            +  -
            <  <=  >  >=
            ==  !=
            &&
            ||

       DESCRIPTION OF OPERATORS

       !      Logical negation.  Can be  applied  to  an  INT  type.   If  the
              operand is non-zero, returns zero.  Otherwise, returns 1.

       -      Unary minus.  Can be applied to an INT.  Returns the negative of
              the operand.

       *      Multiplication.  Returns the product of two INTs.

       /      Integer division.  Returns the quotient of two INTs,  discarding
              the remainder.

       %      Modulus.   Returns  the  remainder  upon  dividing  one  INT  by
              another.

       +      Has several uses.  These are:

              INT + INT - returns the sum of two INTs.

              INT + TIME or TIME + INT - returns a TIME obtained by adding INT
              minutes to the original TIME.

              INT + DATE or DATE + INT - returns a DATE obtained by adding INT
              days to the original DATE.

              INT + DATETIME or DATETIME + INT - returns a  DATETIME  obtained
              by adding INT minutes to the original DATETIME.

              STRING  + STRING - returns a STRING that is the concatenation of
              the two original STRINGs.

              STRING + anything or anything + STRING - converts the non-STRING
              argument  to a STRING, and then performs concatenation.  See the
              coerce() function.

       -      Has several uses.  These are:

              INT - INT - returns the difference of two INTs.

              DATE - DATE - returns (as an INT) the difference in days between
              two DATEs.

              TIME  -  TIME  -  returns  (as an INT) the difference in minutes
              between two TIMEs.

              DATETIME - DATETIME - returns (as  an  INT)  the  difference  in
              minutes between two DATETIMEs.

              DATE  -  INT  - returns a DATE that is INT days earlier than the
              original DATE.

              TIME - INT - returns a TIME that is INT minutes earlier than the
              original TIME.

              DATETIME  - INT - returns a DATETIME that is INT minutes earlier
              than the original DATETIME.

       <, <=, >, and >=
              These are the comparison operators.  They can take  operands  of
              any  type,  but  both  operands  must  be of the same type.  The
              comparison operators return 1 if the comparison is true, or 0 if
              it  is false.  Note that string comparison is done following the
              lexical ordering of characters on your system,  and  that  upper
              and lower case are distinct for these operators.

       ==, != ==  tests  for  equality, returning 1 if its operands are equal,
              and 0 if they are not.  != tests for inequality.

              If the operands are not of the same type, == returns  0  and  !=
              returns 1.  Again, string comparisons are case-sensitive.

       &&     This  is the logical AND operator.  Both of its operands must be
              of type INT.  It returns 1 if both operands are non-zero, and  0
              otherwise.

       ||     This  is  the logical OR operator.  Both of its operands must be
              of type INT.  It returns 1 if either operand is non-zero, and  0
              otherwise.

       NOTES

       Operators  of equal precedence are always evaluated from left to right,
       except where parentheses dictate otherwise.  This is important, because
       the enhanced "+" operator is not necessarily associative.  For example:

            1 + 2 + "string" + 3 + 4  yields "3string34"
            1 + (2 + "string") + (3 + 4)  yields "12string7"
            12:59 + 1 + "test"  yields "13:00test"
            12:59 + (1 + "test")  yields "12:591test"

       The logical operators are not  so-called  short-circuit  operators,  as
       they  are  in  C.   Both  operands  are  always  evaluated.   Thus,  an
       expression such as:

            (f!=0) && (100/f <= 3)

       will cause an error if f is zero.

       VARIABLES

       Remind allows you to assign values to variables.  The  SET  command  is
       used as follows:

       SET var expr

       Var  is  the  name  of  a  variable.   It  must  start with a letter or
       underscore, and consist only of letters, digits and underscores.   Only
       the  first  12 characters of a variable name are significant.  Variable
       names are not case sensitive; thus, "Afoo"  and  "afOo"  are  the  same
       variable.  Examples:

            SET a 10 + (9*8)
            SET b "This is a test"
            SET mydir getenv("HOME")
            SET time 12:15
            SET date today()

       Note  that variables themselves have no type.  They take on the type of
       whatever you store in them.

       To delete a variable, use the UNSET command:

       UNSET var [var...]

       For example, to delete all the variables declared above, use:

            UNSET a b mydir time date

       SYSTEM VARIABLES

       In addition to the regular user variables, Remind has  several  "system
       variables"  that  are  used  to query or control the operating state of
       Remind.  System variables are available starting from version  03.00.07
       of Remind.

       All system variables begin with a dollar sign ’$’.  They can be used in
       SET commands and expressions just as regular variables can.  All system
       variables  always  hold  values of a specified type.  In addition, some
       system variables cannot be modified, and you cannot create  new  system
       variables.   System  variables  can  be initialized on the command line
       with the -i option, but you may need to quote them to avoid having  the
       shell  interpret  the dollar sign.  System variable names are not case-
       sensitive.

       The following system variables are defined.  Those  marked  "read-only"
       cannot  be  changed  with  the  SET command.  All system variables hold
       values of type INT, unless otherwise specified.

       $CalcUTC
              If 1 (the default), then Remind  uses  C  library  functions  to
              calculate the number of minutes between local and Universal Time
              Coordinated.  This affects astronomical calculations  (sunrise()
              for  example.)  If 0, then you must supply the number of minutes
              between local and Universal Time Coordinated in the $MinsFromUTC
              system variable.

       $CalMode (read-only)
              If  non-zero,  then  the  -c  option was supplied on the command
              line.

       $Daemon (read-only)
              If the daemon mode  -z  was  invoked,  contains  the  number  of
              minutes  between  wakeups.   If  not  running  in  daemon  mode,
              contains 0.  For the MS-DOS version, always contains 0.

       $DateSep
              This variable can be set only to  "/"  or  "-".   It  holds  the
              character used to separate portions of a date when Remind prints
              a DATE or DATETIME value.

       $DefaultPrio
              The default priority assigned to reminders  without  a  PRIORITY
              clause.   You  can set this as required to adjust the priorities
              of blocks of reminders without having  to  type  priorities  for
              individual  reminders.  At startup, $DefaultPrio is set to 5000;
              it can range from 0 to 9999.

       $DontFork (read-only)
              If non-zero, then the -c option  was  supplied  on  the  command
              line.  For the MS-DOS version, always contains 1.

       $DontTrigAts (read-only)
              If  non-zero,  then  the  -a  option was supplied on the command
              line.  For the MS-DOS version, always contains 0.

       $DontQueue (read-only)
              If non-zero, then the -q option  was  supplied  on  the  command
              line.  For the MS-DOS version, always contains 1.

       $EndSent (STRING type)
              Contains  a  list  of  characters  that end a sentence.  The MSF
              keyword inserts two spaces after these  characters.   Initially,
              $EndSent is set to ".!?" (period, exclamation mark, and question
              mark.)

       $EndSentIg (STRING type)
              Contains a list of characters that should be  ignored  when  MSF
              decides  whether  or  not  to place two spaces after a sentence.
              Initially, is set to  "’>)]}"+CHAR(34)  (single-quote,  greater-
              than, right parenthesis, right bracket, right brace, and double-
              quote.)

              For example, the default values work as follows:

                   MSF He said, "Huh! (Two spaces will follow this.)"  Yup.

              because the final parenthesis and quote  are  ignored  (for  the
              purposes of spacing) when they follow a period.

       $FirstIndent
              The number of spaces by which to indent the first line of a MSF-
              type reminder.  The default is 0.

       $FoldYear
              The standard Unix library functions may have difficulty  dealing
              with  dates later than 2037.  If this variable is set to 1, then
              the UTC calculations "fold back" years later  than  2037  before
              using  the  Unix  library  functions.   For example, to find out
              whether or not daylight savings time is in effect in June, 2077,
              the year is "folded back" to 2010, because both years begin on a
              Monday, and both are  non-leapyears.   The  rules  for  daylight
              savings  time  are thus presumed to be identical for both years,
              and the Unix library functions can  handle  2010.   By  default,
              this  variable  is  0.   Set it to 1 if the sun or UTC functions
              misbehave for years greater than 2037.

       $FormWidth
              The maximum width of each line of text for  formatting  MSF-type
              reminders.  The default is 72.  If an MSF-type reminder contains
              a word too long to fit in this width, it will not be truncated -
              the width limit will be ignored.

       $HushMode (read-only)
              If  non-zero,  then  the  -h  option was supplied on the command
              line.

       $IgnoreOnce (read-only)
              If non-zero, then the -o option  was  supplied  on  the  command
              line,  or  a date different from today’s true date was supplied.
              If non-zero, then ONCE directives will be ignored.

       $InfDelta (read-only)
              If non-zero, then the -t option  was  supplied  on  the  command
              line.

       $LatDeg, $LatMin, $LatSec
              These  specify the latitude of your location.  $LatDeg can range
              from -90 to 90,  and  the  others  from  -59  to  59.   Northern
              latitudes   are  positive;  southern  ones  are  negative.   For
              southern latitudes, all three components should be negative.

       $Location (STRING type)
              This is a string specifying the name of your  location.   It  is
              usually  the  name  of  your  town  or  city.   It can be set to
              whatever you like, but good style indicates that  it  should  be
              kept   consistent   with   the  latitude  and  longitude  system
              variables.

       $LongDeg, $LongMin, $LongSec
              These specify the longitude  of  your  location.   $LongDeg  can
              range  from  -180  to  180.   Western  longitudes  are positive;
              eastern ones are negative.

              The latitude and  longitude  information  is  required  for  the
              functions   sunrise()  and  sunset().   Default  values  can  be
              compiled into Remind, or you can SET the correct values  at  the
              start of your reminder scripts.

       $MaxSatIter
              The   maximum  number  of  iterations  for  the  SATISFY  clause
              (described later.)  Must be at least 10.

       $MinsFromUTC
              The number of minutes between  Universal  Time  Coordinated  and
              local  time.   If  $CalcUTC is non-zero, this is calculated upon
              startup of Remind.  Otherwise, you must set it  explicitly.   If
              $CalcUTC  is zero, then $MinsFromUTC is used in the astronomical
              calculations.  You must adjust  it  for  daylight  savings  time
              yourself.   Also,  if  you want to initialize $MinsFromUTC using
              the -i command-line option, you must also set $CalcUTC to 0 with
              the -i option.

       $NextMode (read-only)
              If  non-zero,  then  the  -n  option was supplied on the command
              line.

       $NumQueued (read-only)
              Contains the number of reminders queued so  far  for  background
              timed triggering.  For MS-DOS, always returns 0.

       $NumTrig (read-only)
              Contains the number of reminders triggered for the current date.
              One use for this variable is as follows:  Suppose  you  wish  to
              shade  in the box of a PostScript calendar whenever a holiday is
              triggered.  You could save the value of $NumTrig  in  a  regular
              variable  prior  to  executing a block of holiday reminders.  If
              the value of $NumTrig after the holiday block  is  greater  than
              the  saved  value,  then at least one holiday was triggered, and
              you can execute the command to shade in the calendar box.   (See
              the section "Calendar Mode".)

              Note that $NumTrig is affected only by REM commands; triggers in
              IFTRIG commands do not affect it.

       $PrefixLineNo (read-only)
              If non-zero, then the -l option  was  supplied  on  the  command
              line.

       $PSCal (read-only)
              If  non-zero,  then  the  -p  option was supplied on the command
              line.

       $RunOff (read-only)
              If non-zero, the RUN directives are disabled.

       $SimpleCal (read-only)
              Set to a non-zero value if either of the -p or  -s  command-line
              options was supplied.

       $SortByDate (read-only)
              Set  to  0  if  no  -g  option  is used, 1 if sorting by date in
              ascending order, or 2 if sorting by date in descending order.

       $SortByPrio (read-only)
              Set to 0 if no -g option is used, 1 if sorting  by  priority  in
              ascending  order,  or  2  if  sorting  by priority in descending
              order.

       $SortByTime (read-only)
              Set to 0 if no -g option is  used,  1  if  sorting  by  time  in
              ascending order, or 2 if sorting by time in descending order.

       $SubsIndent
              The number of spaces by which all lines (except the first) of an
              MSF-type reminder should be indented.  The default is 0.

       Note:  If any of the calendar modes are in effect, then the  values  of
       $Daemon,  $DontFork,  $DontTrigAts, $DontQueue, $HushMode, $IgnoreOnce,
       $InfDelta, and $NextMode are not meaningful.

       $TimeSep
              This variable can be set only to  ":"  or  ".".   It  holds  the
              character used to separate portions of a time when Remind prints
              a TIME or DATETIME value.

       BUILT-IN FUNCTIONS

       Remind has a plethora of built-in functions.  The syntax for a function
       call  is  the  same  as  in  C  -  the function name, followed a comma-
       separated list of arguments in parentheses.   Function  names  are  not
       case-sensitive.   If a function takes no arguments, it must be followed
       by "()" in the function call.  Otherwise, Remind will interpret it as a
       variable name, and probably not work correctly.

       In  the  descriptions  below, short forms are used to denote acceptable
       types for the arguments.  The characters "i", "s",  "d",  "t"  and  "q"
       denote  INT,  STRING,  DATE, TIME and DATETIME arguments, respectively.
       If an argument  can  be  one  of  several  types,  the  characters  are
       concatenated.   For example, "di_arg" denotes an argument that can be a
       DATE or an INT.  "x_arg" denotes an argument that can be of  any  type.
       The type of the argument is followed by an underscore and an identifier
       naming the argument.

       The built-in functions are:

       abs(i_num)
              Returns the absolute value of num.

       access(s_file, si_mode)
              Tests the access permissions for the file file.  Mode can  be  a
              string, containing a mix of the characters "rwx" for read, write
              and execute permission testing.  Alternatively, mode  can  be  a
              number  as  described  in  the  UNIX access(2) system call.  The
              function returns  0  if  the  file  can  be  accessed  with  the
              specified mode, and -1 otherwise.

       args(s_fname)
              Returns  the  number  of  arguments expected by the user-defined
              function fname, or -1 if no such user-defined  function  exists.
              Note  that  this  function examines only user-defined functions,
              not built-in functions.  Its main use is to determine whether or
              not   a   particular  user-defined  function  has  been  defined
              previously.  The args() function is available only  in  versions
              of Remind from 03.00.04 and up.

       asc(s_string)
              Returns  an INT that is the ASCII code of the first character in
              string.  As a special case, asc("") returns 0.

       baseyr()
              Returns the "base year" that was compiled into Remind  (normally
              1990.)   All  dates  are stored internally as the number of days
              since 1 January of baseyr().

       char(i_i1 [,i_i2...])
              This function can take any number of INT arguments.  It  returns
              a   STRING   consisting  of  the  characters  specified  by  the
              arguments.  Note that none of the arguments  can  be  0,  unless
              there  is only one argument.  As a special case, char(0) returns
              "".

              Note that because Remind does not support escaping of characters
              in strings, the only way to get a double-quote in a string is to
              use char(34).

       choose(i_index, x_arg1 [,x_arg2...])
              Choose must take at least two arguments, the first of  which  is
              an  INT.   If  index  is  n, then the nth subsequent argument is
              returned.  If index is less than 1, then arg1 is  returned.   If
              index  is  greater than the number of subsequent arguments, then
              the last argument is returned.  Examples:

                 choose(0, "foo", 1:13, 1000) returns "foo"
                 choose(1, "foo", 1:13, 1000) returns "foo"
                 choose(2, "foo", 1:13, 1000) returns 1:13
                 choose(3, "foo", 1:13, 1000) returns 1000
                 choose(4, "foo", 1:13, 1000) returns 1000
              Note that all arguments to choose() are always evaluated.

       coerce(s_type, x_arg)
              This function converts  arg  to  the  specified  type,  if  such
              conversion  is  possible.   Type must be one of "INT", "STRING",
              "DATE", "TIME" or "DATETIME" (case-insensitive).  The conversion
              rules are as follows:

              If  arg  is  already  of  the  type  specified,  it  is returned
              unchanged.

              If  type  is  "STRING",  then  arg  is  converted  to  a  string
              consisting of its printed representation.

              If  type is "DATE", then an INT arg is converted by interpreting
              it as the number of days since 1 January baseyr().  A STRING arg
              is  converted  by  attempting to read it as if it were a printed
              date.  A DATETIME is converted to a date by  dropping  the  time
              component.  A TIME arg cannot be converted to a date.

              If  type is "TIME", then an INT arg is converted by interpreting
              it as the number of minutes since midnight.   A  STRING  arg  is
              converted by attempting to read it as if it were a printed time.
              A  DATETIME  is  converted  to  a  time  by  dropping  the  date
              component.  A DATE arg cannot be converted to a time.

              If  type  is  "DATETIME",  then  an  INT  arg  is  converted  by
              interpreting it as the  number  of  minutes  since  midnight,  1
              January  baseyr().   A STRING is converted by attempting to read
              it as if it were a printed  datetime.   Other  types  cannot  be
              converted to a datetime.

              If  type  is  "INT",  then DATE, TIME and DATETIME arguments are
              converted using the reverse of procedures  described  above.   A
              STRING arg is converted by parsing it as an integer.

       current()
              Returns  the  current  date and time as a DATETIME object.  This
              may be the actual date and time, or may be  the  date  and  time
              supplied on the command line.

       date(i_y, i_m, i_d)
              The  date()  function returns a DATE object with the year, month
              and day components specified by y, m and d.

       datetime(args)
              The datetime() function can  take  anywhere  from  two  to  five
              arguments.   It  always  returns  a  DATETIME generated from its
              arguments.

              If you supply two arguments, the first must be a  DATE  and  the
              second a TIME.

              If  you supply three arguments, the first must be a DATE and the
              second and third must be INTs.  The second and  third  arguments
              are interpreted as hours and minutes and converted to a TIME.

              If  you  supply  four  arguments,  the first three must be INTs,
              interpreted as the year, month and  day.   The  fourth  argument
              must be a TIME.

              Finally, if you supply five arguments, they must all be INTs and
              are interpreted as year, month, day, hour and minute.

       dawn([dq_date])
              Returns the time of "civil dawn" on the specified date.  If date
              is  omitted,  defaults  to  today().   If  a  datetime object is
              supplied, only the date component is used.

       day(dq_date)
              This function takes a DATE  or  DATETIME  as  an  argument,  and
              returns an INT that is the day-of-month component of date.

       daysinmon(i_m, i_y)
              Returns the number of days in month m (1-12) of the year y.

       defined(s_var)
              Returns 1 if the variable named by var is defined, or 0 if it is
              not.
              Note that defined() takes a STRING argument; thus, to  check  if
              variable X is defined, use:

                        defined("X")

              and not:

                        defined(X)

              The  second  example will attempt to evaluate X, and will return
              an error if it is undefined or not of type STRING.

       dosubst(s_str [,d_date [,t_time]]) or dosubst(s_str [,q_datetime])
              Returns a STRING that is the result of passing str  through  the
              substitution  filter described earlier.  The parameters date and
              time (or datetime) establish the effective trigger date and time
              used  by the substitution filter.  If date and time are omitted,
              they default to today() and now().

              Note that if str does not end with "%", a newline character will
              be added to the end of the result.  Also, calling dosubst() with
              a date that is in the  past  (i.e.,  if  date  <  today())  will
              produce undefined results.

              Dosubst()  is  only  available starting from version 03.00.04 of
              Remind.

       dusk([dq_date])
              Returns the time of "civil twilight" on the specified date.   If
              date is omitted, defaults to today().

       easterdate(dqi_arg)
              If arg is an INT, then returns the date of Easter Sunday for the
              specified year.  If arg is a DATE or DATETIME, then returns  the
              date  of  the  next  Easter  Sunday  on or after arg.  (The time
              component of a datetime is ignored.)

       filedate(s_filename)
              Returns the modification date of filename.  If filename does not
              exist,  or  its  modification  date is before the year baseyr(),
              then 1 January of baseyr() is returned.

       filedatetime(s_filename)
              Returns the modification date and time of filename.  If filename
              does  not  exist,  or  its  modification date is before the year
              baseyr(), then midnight, 1 January of baseyr() is returned.

       filedir()
              Returns the directory  that  contains  the  current  file  being
              processed.   It  may  be a relative or absolute pathname, but is
              guaranteed to be correct  for  use  in  an  INCLUDE  command  as
              follows:

                 INCLUDE [filedir()]/stuff

              This  includes  the  file  "stuff"  in the same directory as the
              current file being processed.

       filename()
              Returns (as a  STRING)  the  name  of  the  current  file  being
              processed by Remind.  Inside included files, returns the name of
              the included file.

       getenv(s_envvar)
              Similar  to  the  getenv(2)  system  call.   Returns  a   string
              representing  the  value  of the specified environment variable.
              Returns "" if the environment variable  is  not  defined.   Note
              that  the  names  of  environment  variables are generally case-
              sensitive;   thus,   getenv("HOME")   is   not   the   same   as
              getenv("home").

       hour(tq_time)
              Returns the hour component of time.

       iif(si_test1, x_arg1, [si_test2, x_arg2,...], x_default)
              If  test1  is  not  zero  or  the  null  string,  returns  arg1.
              Otherwise, if test2 is not zero  or  the  null  string,  returns
              arg2,  and  so  on.   If  all  of  the test arguments are false,
              returns default.  Note that all arguments are always  evaluated.
              This  function  accepts  an  odd number of arguments - note that
              prior to version 03.00.05 of Remind,  it  accepted  3  arguments
              only.   The  3-argument  version  of  iif()  is  compatible with
              previous versions of Remind.

       index(s_search, s_target [,i_start)
              Returns an INT that is the location  of  target  in  the  string
              search.   The  first  character  of  a string is numbered 1.  If
              target does not exist in search, then 0 is returned.

              The optional parameter start specifies the position in search at
              which to start looking for target.

       isdst([d_date [,t_time]]) or isdst(q_datetime)
              Returns  a positive number if daylight savings time is in effect
              on the specified date and time.  Date defaults  to  today()  and
              time defaults to midnight.

              Note  that  this  function is only as reliable as the C run-time
              library  functions.   It  is  available  starting  with  version
              03.00.07 of Remind.

       isleap(idq_arg)
              Returns 1 if arg is a leap year, and 0 otherwise.  Arg can be an
              INT, DATE  or  DATETIME  object.   If  a  DATE  or  DATETIME  is
              supplied, then the year component is used in the test.

       isomitted(dq_date)
              Returns  1  if  date  is  omitted, given the current global OMIT
              context.  Returns 0 otherwise.  (If a datetime is supplied, only
              the date part is used.)

       hebdate(i_day, s_hebmon [,idq_yrstart [,i_jahr [,i_aflag]]])
              Support for Hebrew dates - see the section "The Hebrew Calendar"

       hebday(dq_date)
              Support for Hebrew dates - see the section "The Hebrew Calendar"

       hebmon(dq_date)
              Support for Hebrew dates - see the section "The Hebrew Calendar"

       hebyear(dq_date)
              Support for Hebrew dates - see the section "The Hebrew Calendar"

       language()
              Returns  a STRING naming the language supported by Remind.  (See
              "Foreign Language Support.") By default, Remind is  compiled  to
              support  English  messages,  so this function returns "English".
              For other languages, this function will return the English  name
              of  the  language  (e.g.  "German")  Note that language() is not
              available in versions of Remind prior to 03.00.02.

       lower(s_string)
              Returns a  STRING  with  all  upper-case  characters  in  string
              converted to lower-case.

       max(x_arg1 [,x_arg2...)
              Can  take any number of arguments, and returns the maximum.  The
              arguments can be of any type, but must all be of the same  type.
              They are compared as with the > operator.

       min(x_arg1 [,x_arg2...)
              Can  take any number of arguments, and returns the minimum.  The
              arguments can be of any type, but must all be of the same  type.
              They are compared as with the < operator.

       minsfromutc([d_date [,t_time]]) or minsfromutc(q_datetime)
              Returns  the  number  of minutes from Universal Time Coordinated
              (formerly GMT) to local time on the  specified  date  and  time.
              Date  defaults  to  today()  and  time defaults to midnight.  If
              local time is before UTC, the result  is  negative.   Otherwise,
              the result is positive.

              Note  that  this  function is only as reliable as the C run-time
              library  functions.   It  is  available  starting  with  version
              03.00.07 of Remind.

       minute(tq_time)
              Returns the minute component of time.

       mon(dqi_arg)
              If  arg is of DATE or DATETIME type, returns a string that names
              the month component of the date.  If arg is an INT from 1 to 12,
              returns a string that names the month.

       monnum(dq_date)
              Returns an INT from 1 to 12, representing the month component of
              date.

       moondate(i_phase [,d_date [,t_time]]) or moondate(i_phase, q_datetime)
              This function returns the date of the first  occurrence  of  the
              phase  phase  of  the moon on or after date and time.  Phase can
              range from 0 to 3, with 0 signifying new moon, 1 first  quarter,
              2  full  moon,  and  3  third  quarter.   If date is omitted, it
              defaults to  today().   If  time  is  omitted,  it  defaults  to
              midnight.

              For  example,  the  following  returns the date of the next full
              moon:

                        SET fullmoon moondate(2)

       moontime(i_phase [,d_date [,t_time]]) or moontime(i_phase, q_datetime)
              This function returns the time of the first  occurrence  of  the
              phase  phase  of  the moon on or after date and time.  Phase can
              range from 0 to 3, with 0 signifying new moon, 1 first  quarter,
              2  full  moon,  and  3  third  quarter.   If date is omitted, it
              defaults to  today().   If  time  is  omitted,  it  defaults  to
              midnight.  Moontime() is intended to be used in conjunction with
              moondate().   The  moondate()  and  moontime()   functions   are
              accurate  to  within  a  couple  of minutes of the times in "Old
              Farmer’s Almanac" for Ottawa, Ontario.

              For example, the following returns the date and time of the next
              full moon:

                        MSG Next full moon at [moontime(2)] on [moondate(2)]

       moondatetime(i_phase   [,d_date  [,t_time]])  or  moondatetime(i_phase,
       q_datetime)
              This function is similar to moondate and moontime, but returns a
              DATETIME result.

       moonphase([d_date [,t_time]]) or moonphase(q_datetime)
              This function returns the phase of the moon on  date  and  time,
              which  default  to  today()  and  midnight,  respectively.   The
              returned value is an integer from 0  to  359,  representing  the
              phase  of  the  moon in degrees.  0 is a new moon, 180 is a full
              moon, 90 is first-quarter, etc.

       nonomitted(dq_start, dq_end [,s_wkday...])
              This function returns the number  of  non-omitted  days  between
              start  and  end.   If  start is non-omitted, then it is counted.
              end is never counted.

              Note that end must be greater than or equal to start or an error
              is  reported.  In addition to using the global OMIT context, you
              can supply additional arguments that are names of weekdays to be
              omitted.

              For example, the following line sets a to 11 (assuming no global
              OMITs):

                   set a nonomitted(’2007-08-01’, ’2007-08-16’, "Sat", "Sun")

              because Thursday, 16 August 2007 is the 11th  working  day  (not
              counting Saturday and Sunday) after Wednesday, 1 August 2007.

              nonomitted has various uses.  For example, many schools run on a
              six-day cycle and the day number is not incremented on holidays.
              Suppose  the  school year starts with Day 1 on 4 September 2007.
              The following reminder will label day numbers in a calendar:

                 IF today() >= ’2007-09-04’
                     set daynum nonomitted(’2007-09-04’, today(), "Sat", "Sun")
                     REM OMIT SAT SUN SKIP CAL Day [(daynum % 6) + 1]
                 ENDIF

              Here’s a more complex example:   Suppose  your  normal  garbage-
              collection  day  is  Thursday,  but  if  any  of  Monday through
              Thursday of a week is a holiday, the  collection  day  moves  to
              Friday.  Here’s one way to solve it:

                 FSET prev_monday(x) x - wkdaynum(x-1)

                 REM Thu Fri SATISFY [wkdaynum(trigdate()) == 4 && \
                          nonomitted(prev_monday(today()), today()+1) == 4 || \
                          wkdaynum(trigdate()) == 5 && \
                          nonomitted(prev_monday(today()), today()+1) <= 4] \
                          MSG Garbage Day

              Whew!  (You’ll need to see "THE SATISFY CLAUSE" later on.)  We’d
              better explain that one: The prev_monday helper function takes a
              date  and  returns  the  date  of  the previous Monday.  The REM
              command will trigger  on  the  first  Thursday  or  Friday  that
              satisfies one of the following conditions:

              1) Either it’s a Thursday and there are exactly four non-omitted
              days between the previous Monday and tomorrow, or

              2) It’s a Friday and there are four or  fewer  non-omitted  days
              between  the  previous  Monday  and  tomorrow.   We need the "or
              fewer" condition to handle the case of more than one holiday  in
              a  given week.  If that happens, garbage day still only moves by
              one day.

              Obviously, the answer you get from  nonomitted  depends  on  the
              global  OMIT  context.   If  you use moveable OMITs, you may get
              inconsistent results.

       now()  Returns the current system time, as a TIME type.   This  may  be
              the actual time, or a time supplied on the command line.

       ord(i_num)
              Returns  a  string that is the ordinal number num.  For example,
              ord(2) returns "2nd", and ord(213) returns "213th".

       ostype()
              Returns "UNIX".  Remind used to run on OS/2 and MS-DOS, but does
              not any longer.

       plural(i_num [,s_str1 [,s_str2]])
              Can  take  from  one  to  three  arguments.   If one argument is
              supplied, returns "s" if num is not 1, and "" if num is 1.

              If two arguments are supplied, returns str1 + "s" if num is  not
              1.  Otherwise, returns str1.

              If  three  arguments are supplied, returns str1 if num is 1, and
              str2 otherwise.

       psmoon(i_phase [,i_size [,s_note [,i_notesize]]])
              [DEPRECATED] Returns a STRING consisting of PostScript  code  to
              draw  a  moon in the upper-left hand corner of the calendar box.
              Phase specifies the phase of the moon, and is 0  (new  moon),  1
              (first quarter), 2 (full moon) or 3 (third quarter).  If size is
              specified, it controls the radius  of  the  moon  in  PostScript
              units  (1/72  inch.)  If it is not specified or is negative, the
              size of the day-number font is used.

              For example, the following four lines place moon symbols on  the
              PostScript calendar:

                        REM [trigger(moondate(0))] PS [psmoon(0)]
                        REM [trigger(moondate(1))] PS [psmoon(1)]
                        REM [trigger(moondate(2))] PS [psmoon(2)]
                        REM [trigger(moondate(3))] PS [psmoon(3)]

              If  note  is  specified,  the  text is used to annotate the moon
              display.  The font is the same font used for  calendar  entries.
              If  notesize is given, it specifies the font size to use for the
              annotation, in PostScript units (1/72 inch.)  If notesize is not
              given,  it  defaults to the size used for calendar entries.  (If
              you annotate the display, be careful not to  overwrite  the  day
              number  -- Remind does not check for this.)  For example, if you
              want the time of each new moon displayed, you could use this  in
              your reminder script:

                   REM [trigger(moondate(0))] PS [psmoon(0, -1, moontime(0)+"")]

              Note  how  the  time is coerced to a string by concatenating the
              null string.

       psshade(i_gray) or psshade(i_red, i_green, i_blue)
              [DEPRECATED]  Returns  a  STRING  that  consists  of  PostScript
              commands  to  shade  a  calendar  box.   Num  can  range  from 0
              (completely  black)  to  100  (completely  white.)    If   three
              arguments  are given, they specify red, green and blue intensity
              from 0 to 100.  Here’s an example of how to use this:

                        REM Sat Sun PS [psshade(95)]

              The above command emits PostScript code  to  lightly  shade  the
              boxes for Saturday and Sunday in a PostScript calendar.

              Note  that psmoon and psshade are deprecated; instead you should
              use the SPECIAL SHADE and SPECIAL MOON reminders as described in
              "Out-of-Band Reminders."

       realcurrent()
              Returns  (as  a  DATETIME)  the  true  date  and  time of day as
              provided by the  operating  system.   This  is  in  contrast  to
              current(), which may return a time supplied on the command line.

       realnow()
              Returns the true time  of  day  as  provided  by  the  operating
              system.   This  is in contrast to now(), which may return a time
              supplied on the command line.

       realtoday()
              Returns the date as provided by the operating system.   This  is
              in contrast to Remind’s concept of "today", which may be changed
              if it is running in  calendar  mode,  or  if  a  date  has  been
              supplied on the command line.

       sgn(i_num)
              Returns  -1  if  num is negative, 1 if num is positive, and 0 if
              num is zero.

       shell(s_cmd [,i_maxlen])
              Executes cmd as a system command,  and  returns  the  first  511
              characters   of  output  resulting  from  cmd.   Any  whitespace
              character in the output is converted to a space.  Note  that  if
              RUN  OFF  has  been  executed, or the -r command-line option has
              been used, shell() will result in an error, and cmd will not  be
              executed.

       If   maxlen  is  specified,  then  shell()  returns  the  first  maxlen
       characters of output  (rather  than  the  first  511).   If  maxlen  is
       specified  as  a  negative  number,  then  all  the  output from cmd is
       returned.

       strlen(s_str)
              Returns the length of str.

       substr(s_str, i_start [,i_end])
              Returns a STRING consisting of all characters in str from  start
              up  to  and  including end.  Characters are numbered from 1.  If
              end is not supplied, then it defaults to the length of str.

       sunrise([dq_date])
              Returns a TIME indicating the time of sunrise on  the  specified
              date  (default  today().)   In  high  latitudes, there may be no
              sunrise on a particular day, in which case sunrise() returns the
              INT 0 if the sun never sets, or 1440 if it never rises.

       sunset([dq_date])
              Returns  a  TIME  indicating the time of sunset on the specified
              date (default today().)  In high  latitudes,  there  may  be  no
              sunset  on  a particular day, in which case sunset() returns the
              INT 0 if the sun never rises, or 1440 if it never sets.

              The functions sunrise() and sunset() are based on  an  algorithm
              in  "Almanac  for Computers for the year 1978" by L. E. Doggett,
              Nautical Almanac Office, USNO.  They require  the  latitude  and
              longitude  to  be  specified  by  setting the appropriate system
              variables.  (See "System Variables".)  The sun functions  should
              be  accurate  to within about 2 minutes for latitudes lower than
              60 degrees.  The functions are available starting  from  version
              03.00.07 of Remind.

       time(i_hr, i_min)
              Creates  a TIME with the hour and minute components specified by
              hr and min.

       today()
              Returns Remind’s notion of "today."   This  may  be  the  actual
              system date, or a date supplied on the command line, or the date
              of the calendar entry currently being computed.

       trigdate()
              Returns the calculated trigger date of the last  REM  or  IFTRIG
              command.   If  used  in  the body of a REM command, returns that
              command’s trigger date.  If the most recent REM command did  not
              yield a computable trigger date, returns the integer 0.

       trigdatetime()
              Similar to trigdate(), but returns a DATETIME if the most recent
              triggerable REM command had an AT clause.  If there  was  no  AT
              clause,  returns  a  DATE.   If  no  trigger  could be computed,
              returns the integer 0.

       trigger(d_date   [,t_time    [,i_utcflag]])    or    trigger(q_datetime
       [,i_utcflag])
              Returns a string suitable for use in a REM command, allowing you
              to  calculate  trigger  dates  in  advance.   (See  the  section
              "Expression pasting" for more information.)  Note that trigger()
              always  returns its result in English, even for foreign-language
              versions of Remind.  This is to avoid problems  with  certain  C
              libraries  that  do  not  handle  accented  characters properly.
              Normally, the date  and  time  are  the  local  date  and  time;
              however,   if  utcflag  is  non-zero,  the  date  and  time  are
              interpreted as UTC times,  and  are  converted  to  local  time.
              Examples:

                   trigger(’1993/04/01’)

              returns "1 April 1993",

                   trigger(’1994/08/09’, 12:33)

              returns "9 August 1994 AT 12:33", as does:

                   trigger(’1994/08/09@12:33’).

              Finally:

                   trigger(’1994/12/01’, 03:00, 1)

              returns  "30  November  1994 AT 22:00" for EST, which is 5 hours
              behind UTC.  The value for your time zone may differ.

       trigtime()
              Returns the time of the last REM command with an AT clause.   If
              the last REM did not have an AT clause, returns the integer 0.

       trigvalid()
              Returns  1  if the value returned by trigdate() is valid for the
              most recent REM command, or 0 otherwise.  Sometimes REM commands
              cannot calculate a trigger date.  For example, the following REM
              command can never be triggered:

                 REM Mon OMIT Mon SKIP MSG Impossible!

       typeof(x_arg)
              Returns "STRING", "INT", "DATE", "TIME" or "DATETIME", depending
              on the type of arg.

       tzconvert(q_datetime, s_srczone [,s_dstzone])
              Converts  datetime  from  the  time zone named by srczone to the
              time zone named by dstzone.  If dstzone is omitted, the  default
              system time zone is used.  The return value is a DATETIME.  Time
              zone names are system-dependent; consult your  operating  system
              for legal values.  Here is an example:

           tzconvert(’2007-07-08@01:14’, "Canada/Eastern", "Canada/Pacific")

                 returns

           2007-07-07@22:14

       upper(s_string)
              Returns  a  STRING  with  all  lower-case  characters  in string
              converted to upper-case.

       value(s_varname [,x_default])
              Returns the value  of  the  specified  variable.   For  example,
              value("X"+"Y")  returns  the  value  of  variable  XY,  if it is
              defined.  If XY is not defined, an error results.

              However, if you supply a second argument, it is returned if  the
              varname  is  not  defined.   The  expression value("XY", 0) will
              return 0 if XY is not defined, and the value  of  XY  if  it  is
              defined.

       version()
              Returns  a string specifying the version of Remind.  For version
              03.00.04, returns "03.00.04".  It  is  guaranteed  that  as  new
              versions of Remind are released, the value returned by version()
              will strictly  increase,  according  to  the  rules  for  string
              ordering.

       wkday(dqi_arg)
              If  arg is a DATE or DATETIME, returns a string representing the
              day of the week of the date.  If arg is an  INT  from  0  to  6,
              returns the corresponding weekday ("Sunday" to "Saturday").

       wkdaynum(dq_date)
              Returns a number from 0 to 6 representing the day-of-week of the
              specified  date.   (0  represents  Sunday,  and   6   represents
              Saturday.)

       year(dq_date)
              Returns a INT that is the year component of date.

EXPRESSION PASTING

       An  extremely  powerful  feature  of Remind is its macro capability, or
       "expression pasting."

       In almost any situation where Remind is not  expecting  an  expression,
       you  can "paste" an expression in.  To do this, surround the expression
       with square brackets.  For example:

            REM [trigger(mydate)] MSG foo

       This evaluates the  expression  "trigger(mydate)",  where  "mydate"  is
       presumably  some  pre-computed  variable,  and then "pastes" the result
       into the command-line for the parser to process.

       A formal description of this is:  When Remind encounters a  "pasted-in"
       expression,  it  evaluates  the expression, and coerces the result to a
       STRING.  It then substitutes the string for the  pasted-in  expression,
       and  continues  parsing.  Note, however, that expressions are evaluated
       only once, not recursively.  Thus, writing:

            ["[a+b]"]

       causes Remind to read the token "[a+b]".  It does not interpret this as
       a  pasted-in  expression.  In fact, the only way to get a literal left-
       bracket into a reminder is to use ["["].

       You can use expression pasting almost anywhere.  However, there  are  a
       few exceptions:

       o      If  Remind is expecting an expression, as in the SET command, or
              the IF command, then no expression  pasting  takes  place.   The
              expression  is  simply  evaluated as if the square brackets were
              not there.

       o      You cannot use expression pasting for the first token on a line.
              For example, the following will not work:

                 ["SET"] a 1

              This restriction is because Remind must be able to unambiguously
              determine the  first  token  of  a  line  for  the  flow-control
              commands (to be discussed later.)

              In  fact,  if Remind cannot determine the first token on a line,
              it assumes that it is a REM command.  If  expression-pasting  is
              used,  Remind  assumes it is a REM command.  Thus, the following
              three commands are equivalent:

                        REM 12 Nov 1993 AT 13:05 MSG BOO!
                        12 Nov 1993 AT 13:05 MSG BOO!
                        [12] ["Nov " + 1993] AT [12:05+60] MSG BOO!

       o      You cannot use expression-pasting to determine  the  type  (MSG,
              CAL,  etc.)  of a REM command.  You can paste expressions before
              and after the MSG, etc keywords, but cannot  do  something  like
              this:

                 REM ["12 Nov 1993 AT 13:05 " + "MSG" + " BOO!"]

       COMMON PITFALLS IN EXPRESSION PASTING

       Remember,  when  pasting  in  expressions,  that  extra  spaces are not
       inserted.  Thus, something like:

            REM[expr]MSG[expr]

       will probably fail.

       If you use an expression to calculate a delta or back, ensure that  the
       result is a positive number.  Something like:

            REM +[mydelta] Nov 12 1993 MSG foo

       will fail if mydelta happens to be negative.

FLOW CONTROL COMMANDS

       Remind  has  commands  that  control  the  flow  of  a reminder script.
       Normally, reminder scripts are processed sequentially.  However, IF and
       related  commands  allow  you  to process files conditionally, and skip
       sections that you don’t want interpreted.

       THE IF COMMAND

       The IF command has the following form:

            IF expr
                 t-command
                 t-command...
            ELSE
                 f-command
                 f-command...
            ENDIF

       Note that the commands are shown indented for clarity.  Also, the  ELSE
       portion can be omitted.  IF commands can be nested up to a small limit,
       probably around 8 or 16 levels of nesting, depending on your system.

       If the expr evaluates to a non-zero INT, or a non-null STRING, then the
       IF  portion  is  considered  true, and the t-commands are executed.  If
       expr evaluates to zero or  null,  then  the  f-commands  (if  the  ELSE
       portion  is  present)  are  executed.   If  expr  is not of type INT or
       STRING, then it is an error.

       Examples:

            IF defined("want_hols")
                 INCLUDE /usr/share/remind/holidays
            ENDIF

            IF today() > ’1992/2/10’
                 set missed_ap "You missed it!"
            ELSE
                 set missed_ap "Still have time..."
            ENDIF

       THE IFTRIG COMMAND

       The IFTRIG command is similar to an IF command, except that it computes
       a  trigger  (as  in  the  REM  command),  and  evaluates  to  true if a
       corresponding REM command would trigger.  Examples:

            IFTRIG 1 Nov
                 ; Executed on 1 Nov
            ELSE
                 ; Executed except on 1 Nov
            ENDIF

            IFTRIG 1 -1 OMIT Sat Sun +4
                 ; Executed on last working day of month,
                 ; and the 4 working days preceding it
            ELSE
                 ; Executed except on above days
            ENDIF

       Note that the IFTRIG command computes a  trigger  date,  which  can  be
       retrieved  with the trigdate() function.  You can use all of the normal
       trigger components, such as UNTIL, delta, etc in the IFTRIG command.

USER-DEFINED FUNCTIONS

       In addition to the built-in functions, Remind allows you to define your
       own functions.  The FSET command does this for you:

       FSET fname(args) expr

       Fname  is  the  name  of  the  function, and follows the convention for
       naming variables.  Args is a comma-separated  list  of  arguments,  and
       expr  is  an expression.  Args can be empty, in which case you define a
       function taking no parameters.  Here are some examples:

            FSET double(x) 2*x
            FSET yeardiff(date1, date2) year(date1) - year(date2)
            FSET since(x) ord(year(trigdate())-x)

       The last function is useful in birthday reminders.  For example:

            REM 1 Nov +12 MSG Dean’s [since(1984)] birthday is %b.

       Dean was born in 1984.  The above example, on 1  November  1992,  would
       print:

            Dean’s 8th birthday is today.

       Notes:

       o      If  you  access  a  variable  in expr that is not in the list of
              arguments, the "global" value (if any) is used.

       o      Function  and  parameter  names  are  significant  only  to   12
              characters.

       o      The  value()  function  always  accesses the "global" value of a
              variable, even if it has the same  name  as  an  argument.   For
              example:

                        fset func(x) value("x")
                        set x 1
                        set y func(5)

              The  above sequence sets y to 1, which is the global value of x.

       o      User-defined functions may call other functions, including other
              user-defined   functions.   However,  recursive  calls  are  not
              allowed.

       o      User-defined functions are  not  syntax-checked  when  they  are
              defined; parsing occurs only when they are called.

       o      If  a  user-defined  function  has  the  same name as a built-in
              function, it is ignored and the built-in function is  used.   To
              prevent  conflicts  with  future  versions  of Remind (which may
              define more built-in functions), you may wish to name all  user-
              defined functions beginning with an underscore.

PRECISE SCHEDULING

       The  WARN keyword allows precise control over advance warning in a more
       flexible manner than the delta mechanism.  It should be followed by the
       name of a user-defined function, warn_function.

       If  a warn_function is supplied, then it must take one argument of type
       INT.   Remind  ignores  any  delta,  and  instead  calls  warn_function
       successively with the arguments 1, 2, 3, ...

       Warn_function’s return value n is interpreted as follows:

       o      If  n is positive, then the reminder is triggered exactly n days
              before its trigger date.

       o      If n is negative, then it is triggered n days before its trigger
              date, not counting OMITted days.

       As  an  example, suppose you wish to be warned of American Independence
       Day 5, 3, and 1 days in advance.  You could use this:

            FSET _wfun(x) choose(x, 5, 3, 1, 0)
            REM 4 July WARN _wfun MSG American Independence Day is %b.

       NOTES

       1      If an error occurs during the evaluation of warn_function,  then
              Remind  stops  calling  it and simply issues the reminder on its
              trigger date.

       2      If the absolute-values of the return values of warn_function are
              not monotonically decreasing, Remind stops calling it and issues
              the reminder on its trigger date.

       3      Warn_function should (as a matter of good style) return 0 as the
              final  value  in  its  sequence  of  return  values.  However, a
              reminder  will  always  be  triggered  on  its   trigger   date,
              regardless of what warn_function does.

       Similarly  to  WARN,  the SCHED keyword allows precise control over the
       scheduling of timed reminders.  It should be followed by the name of  a
       user-defined function, sched_function.

       If a scheduling function is supplied, then it must take one argument of
       type INT.  Rather than using the AT time, time delta, and time  repeat,
       Remind  calls  the scheduling function to determine when to trigger the
       reminder.  The first  time  the  reminder  is  queued,  the  scheduling
       function  is  called  with an argument of 1.  Each time the reminder is
       triggered, it is re-scheduled by calling the scheduling function again.
       On each call, the argument is incremented by one.

       The  return  value of the scheduling function must be an INT or a TIME.
       If the return value is a  TIME,  then  the  reminder  is  re-queued  to
       trigger at that time.  If it is a positive integer n, then the reminder
       is re-queued to trigger at the previous trigger time  plus  n  minutes.
       Finally,  if it is a negative integer or zero, then the reminder is re-
       queued to trigger n minutes before the AT time.  Note that  there  must
       be an AT clause for the SCHED clause to do anything.

       Here’s an example:

            FSET _sfun(x) choose(x, -60, 30, 15, 10, 3, 1, 1, 1, 1, 0)
            REM AT 13:00 SCHED _sfun MSG foo

       The reminder would first be triggered at 13:00-60 minutes, or at 12:00.
       It would next be triggered 30 minutes later, at 12:30.  Then, it  would
       be triggered at 12:45, 12:55, 12:58, 12:59, 13:00, 13:01 and 13:02.

       NOTES

       1      If  an  error  occurs  during the evaluation of sched_func, then
              Remind reverts to using the AT time and  the  delta  and  repeat
              values, and never calls sched_func again.

       2      If  processing sched_func yields a time earlier than the current
              system time, it is repeatedly called  with  increasing  argument
              until  it  yields  a  value greater than or equal to the current
              time.  However, if the sequence of values calculated during  the
              repetition  is  not  strictly increasing, then Remind reverts to
              the default behaviour and never calls sched_func again.

       3      It is quite possible  using  sched_func  to  keep  triggering  a
              reminder even after the AT-time.  However, it is not possible to
              reschedule a reminder  past  midnight  -  no  crossing  of  date
              boundaries  is  allowed.   Also,  it  is  quite  possible to not
              trigger a reminder on the AT time  when  you  use  a  scheduling
              function.   However,  if  your scheduling function is terminated
              (for reasons 1 and 2) before the AT time  of  the  reminder,  it
              will  be  triggered  at  the  AT time, because normal processing
              takes over.

       4      Your scheduling functions should (as a  matter  of  good  style)
              return  0 when no more scheduling is required.  See the example.

       5      All scheduling functions are evaluated after the  entire  Remind
              script  has  been read in.  So whatever function definitions are
              in effect at the end of the script are used.

THE SATISFY CLAUSE

       The form of REM that uses SATISFY is as follows:

       REM trigger SATISFY expr

       The way this works is as follows:  Remind first  calculates  a  trigger
       date,  in  the  normal  fashion.   Next,  it  sets  trigdate()  to  the
       calculated trigger date.  It then evaluates expr.  If the result is not
       the  null  string or zero, processing ends.  Otherwise, Remind computes
       the next trigger date, and re-tests  expr.   This  iteration  continues
       until  expr  evaluates  to non-zero or non-null, or until the iteration
       limit specified with the -x command-line option is reached.

       If expr is not satisfied, then trigvalid() is  set  to  0.   Otherwise,
       trigvalid() is set to 1.  In any event, no error message is issued.

       This  is  really  useful only if expr involves a call to the trigdate()
       function; otherwise, expr will not change as Remind iterates.

       An example of the usefulness of SATISFY:  Suppose you wish to be warned
       of every Friday the 13th.  Your first attempt may be:

            # WRONG!
            REM Fri 13 +2 MSG Friday the 13th is %b.

       But  this won’t work.  This reminder triggers on the first Friday on or
       after the 13th of each month.   The  way  to  do  it  is  with  a  more
       complicated sequence:

            REM 13 SATISFY wkdaynum(trigdate()) == 5
            IF trigvalid()
                 REM [trigger(trigdate())] +2 MSG \
                 Friday the 13th is %b.
            ENDIF

       Let’s  see how this works.  The SATISFY clause iterates through all the
       13ths of successive months, until a trigger date is found whose day-of-
       week  is  Friday  (==  5).   If  a  valid  date  was  found, we use the
       calculated trigger date (converted  into  a  trigger  format  with  the
       trigger() function) to set up the next reminder.

       We could also have written:

            REM Fri SATISFY day(trigdate()) == 13

       but  this  would  result in more iterations, since "Fridays" occur more
       often than "13ths of the month."

       This technique of using one REM command to calculate a trigger date  to
       be used by another command is quite powerful.  For example, suppose you
       wanted to OMIT Labour day, which is the first Monday in September.  You
       could use:

            # Note: SATISFY 1 is an idiom for "do nothing"
            REM Mon 1 Sept SATISFY 1
            OMIT [trigger(trigdate())]

       CAVEAT: This only omits the next Labour Day, not all Labour Days in the
       future.  This could cause strange results,  as  the  OMIT  context  can
       change  depending  on  the  current  date.  For example, if you use the
       following command after the above commands:

            REM Mon AFTER msg hello

       the result will not be as you expect.  Consider  producing  a  calendar
       for  September,  1992.   Labour  Day  was on Monday, 7 September, 1992.
       However, when  Remind  gets  around  to  calculating  the  trigger  for
       Tuesday,  8  September,  1992,  the  OMIT  command will now be omitting
       Labour Day for 1993, and the "Mon AFTER" command will not be triggered.
       (But  see  the  description  of  SCANFROM in the section "Details about
       Trigger Computation.")

       It is probably best to stay away  from  computing  OMIT  trigger  dates
       unless you keep these pitfalls in mind.

       For  versions  of Remind starting from 03.00.07, you can include a MSG,
       RUN, etc. clause in a SATISFY clause as follows:

            REM trigger_stuff SATISFY [expr] MSG body

       Note that for this case only, the expr after SATISFY must  be  enclosed
       in braces.  It must come after all the other components of the trigger,
       and immediately before the MSG, RUN, etc. keyword.  If expr  cannot  be
       satisfied, then the reminder is not triggered.

       Thus, the "Friday the 13th" example can be expressed more compactly as:

            REM 13 +2 SATISFY [wkdaynum(trigdate()) == 5] \
                 MSG Friday the 13th is %b.

       And you can trigger a reminder on  Mondays,  Wednesdays  and  Thursdays
       occurring on odd-numbered days of the month with the following:

            REM Mon Wed Thu SATISFY [day(trigdate())%2] \
                 MSG Here it is!!!

DEBUGGING REMINDER SCRIPTS

       Although  the  command-line  -d  option  is useful for debugging, it is
       often overkill.  For example, if you turn  on  the  -dx  option  for  a
       reminder  file  with many complex expressions, you’ll get a huge amount
       of output.  The DEBUG command allows you to control the debugging flags
       under program control.  The format is:

       DEBUG [+flagson] [-flagsoff]

       Flagson  and flagsoff consist of strings of the characters "extvl" that
       correspond to the  debugging  options  discussed  in  the  command-line
       options  section.   If  preceded with a "+", the corresponding group of
       debugging options is switched on.  Otherwise, they  are  switched  off.
       For  example,  you  could  use  this  sequence  to  debug a complicated
       expression:

            DEBUG +x
            set a very_complex_expression(many_args)
            DEBUG -x

       THE DUMPVARS COMMAND

       The command DUMPVARS displays the values of variables in  memory.   Its
       format is:

       DUMPVARS [var...]

       If   you   supply   a  space-separated  list  of  variable  names,  the
       corresponding variables are displayed.  If you do not supply a list  of
       variables,  then  all  variables  in  memory  are displayed.  To dump a
       system variable, put its name in the list of variables to dump.  If you
       put  a  lone  dollar  sign  in  the list of variables to dump, then all
       system variables will be dumped.

       THE ERRMSG COMMAND

       The ERRMSG command has the following format:

       ERRMSG body

       The body is passed through the substitution filter  (with  an  implicit
       trigger  date  of  today())  and  printed  to  the error output stream.
       Example:

            IF !defined("critical_var")
                 ERRMSG You must supply a value for "critical_var"
                 EXIT
            ENDIF

       THE EXIT COMMAND

       The above example also shows the use of the EXIT command.  This  causes
       an  unconditional  exit  from  script  processing.   Any  queued  timed
       reminders are discarded.  If you are in calendar mode (described next),
       then the calendar processing is aborted.

       If  you  supply  an  INT-type  expression after the EXIT command, it is
       returned to the calling program as the exit status.  Otherwise, an exit
       status of 99 is returned.

       THE FLUSH COMMAND

       This  command  simply  consists  of the word FLUSH on a line by itself.
       The command flushes the standard output and standard error streams used
       by  Remind.   This  is  not  terribly useful to most people, but may be
       useful if you run Remind as a subprocess of another program,  and  want
       to use pipes for communication.

CALENDAR MODE

       If you supply the -c, -s or -p command-line option, then Remind runs in
       "calendar  mode."   In  this  mode,  Remind   interprets   the   script
       repeatedly,  performing  one  iteration through the whole file for each
       day in the calendar.  Reminders that  trigger  are  saved  in  internal
       buffers, and then inserted into the calendar in the appropriate places.

       If you also supply the -a option, then Remind will  not  include  timed
       reminders in the calendar.

       The -p option is used in conjunction with the Rem2PS program to produce
       a calendar in PostScript format.  For example,  the  following  command
       will send PostScript code to standard output:

            remind -p .reminders | rem2ps

       You  can print a PostScript calendar by piping this to the lpr command.

       If you have a reminder script called ".reminders", and you execute this
       command:

            remind -c .reminders jan 1993

       then Remind executes the script 31 times, once for each day in January.
       Each time it executes the script, it increments the value  of  today().
       Any  reminders  whose trigger date matches today() are entered into the
       calendar.

       MSG and CAL-type reminders, by default, have their entire body inserted
       into  the  calendar.  RUN-type reminders are not normally inserted into
       the calendar.  However, if you enclose a portion of  the  body  in  the
       %"...%" sequence, only that portion is inserted.  For example, consider
       the following:

            REM 6 Jan MSG %"David’s birthday%" is %b

       In the normal mode, Remind would print "David’s birthday is today" on 6
       January.   However,  in  the  calendar  mode,  only  the  text "David’s
       birthday" is inserted into the box for 6 January.

       If you explicitly use the %"...%" sequence in a RUN-type reminder, then
       the  text between the delimiters is inserted into the calendar.  If you
       use the sequence %"%" in a MSG or CAL-type reminder, then  no  calendar
       entry is produced for that reminder.

       PRESERVING VARIABLES

       Because  Remind  iterates  through  the  script  for  each  day  in the
       calendar, slow operations may severely reduce the speed of producing  a
       calendar.

       For  example,  suppose  you  set  the  variables "me" and "hostname" as
       follows:

            SET me shell("whoami")
            SET hostname shell("hostname")

       Normally, Remind clears all variables between  iterations  in  calendar
       mode.   However, if certain variables are slow to compute, and will not
       change between iterations, you can "preserve"  their  values  with  the
       PRESERVE  command.   Also,  since  function  definitions  are preserved
       between calendar iterations, there is no need to redefine them on  each
       iteration.  Thus, you could use the following sequence:

            IF ! defined("initialized")
                 set initialized 1
                 set me shell("whoami")
                 set hostname shell("hostname")
                 fset func(x) complex_expr
                 preserve initialized me hostname
            ENDIF

       The  operation  is  as  follows:   On  the  first iteration through the
       script, "initialized" is not defined.  Thus, the  commands  between  IF
       and  ENDIF  are executed.  The PRESERVE command ensures that the values
       of  initialized,  me  and  hostname  are   preserved   for   subsequent
       iterations.   On  the  next  iteration, the commands are skipped, since
       initialized has remained defined.  Thus, time-consuming operations that
       do not depend on the value of today() are done only once.

       System  variables  (those whose names start with ’$’) are automatically
       preserved between calendar iterations.

       Note that for efficiency, Remind caches the reminder  script  (and  any
       INCLUDEd files) in memory when producing a calendar.

       Timed  reminders are sorted and placed into the calendar in time order.
       These are followed by non-timed reminders.  Remind automatically places
       the  time  of  timed  reminders  in  the  calendar  according to the -b
       command-line option.  Reminders in calendar mode are sorted as  if  the
       -g option had been used; you can change the sort order in calendar mode
       by explicitly using the -g option to specify a different order from the
       default.

       REPEATED EXECUTION

       If  you  supply  a repeat parameter on the command line, and do not use
       the -c, -p, or -s options, Remind  operates  in  a  similar  manner  to
       calendar   mode.    It   repeatedly   executes   the  reminder  script,
       incrementing  today()  with  each  iteration.   The  same  rules  about
       preserving  variables  and function definitions apply.  Note that using
       repeat on the command line also enables the -q option and disables  any
       -z  option.   As  an example, if you want to see how Remind will behave
       for the next week, you can type:

            remind .reminders ’*7’

       If you want to print the dates of the next 1000 days, use:

            (echo ’banner %’; echo ’msg [today()]%’) | remind - ’*1000’

INITIALIZING VARIABLES ON THE COMMAND LINE

       The -i option is used to initialize variables  on  the  Remind  command
       line.   The  format  is -ivar=expr, where expr is any valid expression.
       Note that you may have to use quotes or escapes to  prevent  the  shell
       from  interpreting special characters in expr.  You can have as many -i
       options as you want on the command line,  and  they  are  processed  in
       order.   Thus,  if  a  variable  is defined in one -i option, it can be
       referred to by subsequent -i options.

       Note that if you supply a date on the command line, it  is  not  parsed
       until all options have been processed.  Thus, if you use today() in any
       of the -i expressions, it will return the same value as realtoday() and
       not the date supplied on the command line.

       Any  variables  defined  on  the command line are preserved as with the
       PRESERVE command.

       You should not have any spaces between the  -i  option  and  the  equal
       sign;  otherwise,  strange  variable names are created that can only be
       accessed with the value() or defined() functions.

MORE ABOUT POSTSCRIPT

       The PS and PSFILE  reminders  pass  PostScript  code  directly  to  the
       printer.   They  differ  in  that  the PS-type reminder passes its body
       directly to the PostScript output (after processing by the substitution
       filter)  while  the  PSFILE-type’s  body  should  simply  consist  of a
       filename.  The Rem2PS program will open the file named in  the  PSFILE-
       type reminder, and include its contents in the PostScript output.

       The  PostScript-type reminders for a particular day are included in the
       PostScript output in sorted order of priority.  Note that the order  of
       PostScript  commands  has  a  major  impact  on  the  appearance of the
       calendars.  For example, PostScript code to shade a calendar  box  will
       obliterate code to draw a moon symbol if the moon symbol code is placed
       in the calendar first.  For this reason, you should not provide  PS  or
       PSFILE-type  reminders with priorities; instead, you should ensure that
       they appear in the reminder script in the  correct  order.   PostScript
       code should draw objects working from the background to the foreground,
       so that foreground objects properly overlay background  ones.   If  you
       prioritize  these  reminders  and  run the script using descending sort
       order for priorities, the PostScript output will not work.

       All of the PostScript code for a particular date is enclosed in a save-
       restore  pair.   However,  if  several  PostScript-type  reminders  are
       triggered for a single day, each section of PostScript is not  enclosed
       in  a  save-restore  pair  -  instead,  the  entire  body  of  included
       PostScript is enclosed.

       PostScript-type reminders are executed by the PostScript printer before
       any  regular  calendar  entries.   Thus,  regular calendar entries will
       overlay the PostScript-type reminders, allowing you to create shaded or
       graphical backgrounds for particular days.

       Before  executing  your  PostScript  code, the origin of the PostScript
       coordinate system is positioned to the bottom left-hand corner  of  the
       "box"  in  the calendar representing today().  This location is exactly
       in the middle of the intersection of the bottom and  left  black  lines
       delineating  the  box  -  you  may have to account for the thickness of
       these lines when calculating positions.

       Several PostScript variables are available to the PostScript  code  you
       supply.   All distance and size variables are in PostScript units (1/72
       inch.)  The variables are:

       LineWidth
              The width of the black grid lines making up the calendar.

       Border The border between the center of the grid lines  and  the  space
              used  to  print calendar entries.  This border is normally blank
              space.

       BoxWidth and BoxHeight
              The width and height of the calendar box, from  center-to-center
              of the black gridlines.

       InBoxHeight
              The  height  from the center of the bottom black gridline to the
              top of the regular calendar entry area.  The space from here  to
              the top of the box is used only to draw the day number.

       /DayFont, /EntryFont, /SmallFont, /TitleFont and /HeadFont
              The  fonts  used  to draw the day numbers, the calendar entries,
              the small calendars, the calendar title (month,  year)  and  the
              day-of-the-week headings, respectively.

       DaySize, EntrySize, TitleSize and HeadSize
              The  sizes  of the above fonts.  (The size of the small calendar
              font is not defined here.)  For example, if you wanted to  print
              the  Hebrew date next to the regular day number in the calendar,
              use:

            REM PS Border BoxHeight Border sub DaySize sub moveto \
               /DayFont findfont DaySize scalefont setfont \
               ([hebday(today())] [hebmon(today())]) show

              Note how /DayFont and DaySize are used.

       Note that if you supply PostScript code,  it  is  possible  to  produce
       invalid  PostScript files.  Always test your PostScript thoroughly with
       a PostScript viewer before sending it to the printer.  You  should  not
       use any document structuring comments in your PostScript code.

DAEMON MODE

       If  you  use  the  -z  command-line option, Remind runs in the "daemon"
       mode.  In this mode, no "normal" reminders are issued.   Instead,  only
       timed  reminders are collected and queued, and are then issued whenever
       they reach their trigger time.

       In  addition,  Remind  wakes  up  every  few  minutes  to   check   the
       modification  date on the reminder script (the filename supplied on the
       command line.)  If Remind detects that the script has changed,  it  re-
       executes itself in daemon mode, and interprets the changed script.

       In  daemon mode, Remind also re-reads the remind script when it detects
       that the system date has changed.

       In daemon mode, Remind acts as if the -f option had been  used,  so  to
       run in the daemon mode in the background, use:

            remind -z .reminders &

       If  you  use  sh  or  bash,  you may have to use the "nohup" command to
       ensure that the daemon is not killed when you log out.

SORTING REMINDERS

       The -g option causes Remind to sort reminders by trigger date, time and
       priority before issuing them.  Note that reminders are still calculated
       in the order encountered in the script.   However,  rather  than  being
       issued  immediately, they are saved in an internal buffer.  When Remind
       has finished processing the script, it issues the  saved  reminders  in
       sorted  order.  The -g option can be followed by up to three characters
       that must all be "a" or "d".  The first character  specifies  the  sort
       order  by  trigger date (ascending or descending), the second specifies
       the sort order by trigger time and the third specifies the  sort  order
       by priority.  The default is to sort all fields in ascending order.

       In  ascending order, reminders are issued with the most imminent first.
       Descending order is  the  reverse.   Reminders  are  always  sorted  by
       trigger  date, and reminders with the same trigger date are then sorted
       by trigger time.  Non-timed reminders are  always  issued  after  timed
       reminders  in this mode.  If two reminders have the same date and time,
       then the priority is used to break ties.  Reminders with the same date,
       time and priority are issued in the order they were encountered.

       You can define a user-defined function called SORTBANNER that takes one
       DATE-type argument.  In sort mode, the following sequence happens:

       If Remind notices that the next  reminder  to  issue  has  a  different
       trigger  date  from  the  previous one (or if it is the first one to be
       issued), then SORTBANNER  is  called  with  the  trigger  date  as  its
       argument.   The  result  is coerced to a string, and passed through the
       substitution filter with the appropriate trigger date.  The  result  is
       then displayed.

       Here’s an example - consider the following fragment:

            # Switch off the normal banner
            BANNER %
            REM 11 March 1993 ++1 MSG Not so important
            REM 17 March 1993 ++7 MSG Way in the future
            REM 10 March 1993 MSG Important Reminder
            REM 11 March 1993 ++1 MSG Not so important - B
            FSET sortbanner(x) iif(x == today(), \
                 "***** THINGS TO DO TODAY *****", \
                 "----- Things to do %b -----")

       Running  this  with  the  -gaa  option  on  10  March 1993 produces the
       following output:

            ***** THINGS TO DO TODAY *****

            Important Reminder

            ----- Things to do tomorrow -----

            Not so important

            Not so important - B

            ----- Things to do in 7 days’ time -----

            Way in the future

       You can use the args() built-in function to determine  whether  or  not
       SORTBANNER  has  been  defined.   (This  could be used, for example, to
       provide a default definition  for  SORTBANNER  in  a  system-wide  file
       included at the end of the user’s file.)  Here’s an example:

            # Create a default sortbanner function if it hasn’t already
            # been defined
            if args("sortbanner") != 1
                 fset sortbanner(x) "--- Things to do %b ---"
            endif

MSGPREFIX() AND MSGSUFFIX()

       You  can  define  two  functions  in your script called msgprefix() and
       msgsuffix().  They should each accept one argument, a number from 0  to
       9999.

       In normal mode, for MSG- and MSF-type reminders, the following sequence
       occurs when Remind triggers a reminder:

       o      If msgprefix() is defined, it is evaluated with the priority  of
              the reminder as its argument.  The result is printed.  It is not
              passed through the substitution filter.

       o      The body of the reminder is printed.

       o      If msgsuffix() is defined, it is evaluated with the priority  of
              the reminder as its argument.  The result is printed.  It is not
              passed through the substitution filter.

       Here’s  an  example:   The  following  definition   causes   priority-0
       reminders to be preceded by "URGENT", and priority-6000 reminders to be
       preceded by "(not important)".

            fset msgprefix(x) iif(x==0, "URGENT: ", \
                 x==6000, "(not important) ", "")

       In Calendar Mode (with the -c, -s or -p options), an analogous pair  of
       functions  named calprefix() and calsuffix() can be defined.  They work
       with all reminders that produce an entry in the  calendar  (i.e.,  CAL-
       and possibly RUN-type reminders as well as MSG-type reminders.)

       NOTES

       Normally,  the  body  of  a  reminder is followed by a carriage return.
       Thus, the results of msgsuffix() will appear on the next line.  If  you
       don’t  want  this, end the body of the reminder with a percentage sign,
       "%".  If you want a space between  your  reminders,  simply  include  a
       carriage return (char(13)) as part of the msgsuffix() return value.

       If   Remind   has   problems  evaluating  msgprefix(),  msgsuffix()  or
       sortbanner(), you will see a lot of error messages.  For an example  of
       this, define the following:

            fset msgprefix(x) x/0

FOREIGN LANGUAGE SUPPORT

       Your  version  of  Remind  may have been compiled to support a language
       other than English.  This support may or may  not  be  complete  -  for
       example,  all  error  and  usage  messages  may  still  be  in English.
       However, at a minimum, foreign-language versions of Remind will  output
       names  of  months  and  weekdays  in  the  foreign language.  Also, the
       substitution mechanism will  substitute  constructs  suitable  for  the
       foreign language rather than for English.

       A  foreign-language version of Remind will accept either the English or
       foreign-language names of weekdays and months  in  a  reminder  script.
       However,  for  compatibility between versions of Remind, you should use
       only the English names in your scripts.  Also, if your  C  compiler  or
       run-time  libraries  are not "8-bit clean" or don’t understand the ISO-
       Latin character set, month or day names with accented letters  may  not
       be recognized.

THE HEBREW CALENDAR

       Remind  has  support  for  the  Hebrew  calendar, which is a luni-solar
       calendar.  This allows you to create  reminders  for  Jewish  holidays,
       jahrzeits (anniversaries of deaths) and smachot (joyous occasions.)

       THE HEBREW YEAR

       The  Hebrew  year  has 12 months, alternately 30 and 29 days long.  The
       months are: Tishrey, Heshvan, Kislev, Tevet, Shvat, Adar, Nisan,  Iyar,
       Sivan,  Tamuz,  Av  and  Elul.   In Biblical times, the year started in
       Nisan, but Rosh Hashana (Jewish New Year) is now celebrated on the  1st
       and 2nd of Tishrey.

       In  a  cycle  of 19 years, there are 7 leap years, being years 3, 6, 8,
       11, 14, 17 and 19 of the cycle.  In a leap year, an extra month  of  30
       days is added before Adar.  The two Adars are called Adar A and Adar B.

       For certain religious reasons, the  year  cannot  start  on  a  Sunday,
       Wednesday  or Friday.  To adjust for this, a day is taken off Kislev or
       added to Heshvan.  Thus, a regular year can have from 353 to 355  days,
       and a leap year from 383 to 385.

       When Kislev or Heshvan is short, it is called chaser, or lacking.  When
       it is long, it is called shalem, or full.

       The Jewish date changes at sunset.  However,  Remind  will  change  the
       date  at  midnight,  not  sunset.   So in the period between sunset and
       midnight, Remind will be a day earlier than the true Jewish date.  This
       should not be much of a problem in practice.

       The  computations  for  the  Jewish  calendar were based on the program
       "hdate" written by Amos Shapir of the Hebrew University  of  Jerusalem,
       Israel.  He also supplied the preceding explanation of the calendar.

       HEBREW DATE FUNCTIONS

       hebday(d_date)
              Returns  the  day  of the Hebrew month corresponding to the date
              parameter.  For example, 12 April 1993 corresponds to  21  Nisan
              5753.  Thus, hebday(’1993/04/12’) returns 21.

       hebmon(d_date)
              Returns the name of the Hebrew month corresponding to date.  For
              example, hebmon(’1993/04/12’) returns "Nisan".

       hebyear(d_date)
              Returns the Hebrew year corresponding  to  date.   For  example,
              hebyear(’1993/04/12’) returns 5753.

       hebdate(i_day, s_hebmon [,id_yrstart [,i_jahr [,i_aflag]]])
              The hebdate() function is the most complex of the Hebrew support
              functions.  It can take from 2 to 5  arguments.   It  returns  a
              DATE corresponding to the Hebrew date.

              The  day parameter can range from 1 to 30, and specifies the day
              of the Hebrew month.  The hebmon parameter is a string that must
              name  one  of  the Hebrew months specified above.  Note that the
              month  must  be  spelled  out  in  full,  and  use  the  English
              transliteration shown previously.  You can also specify "Adar A"
              and "Adar B."  Month names are not case-sensitive.

              The yrstart parameter can either be a DATE or an INT.  If it  is
              a DATE, then the hebdate() scans for the first Hebrew date on or
              after that date.  For example:

                        hebdate(15, "Nisan", ’1990/01/01’)

              returns 1990/03/30, because that is the first occurrence  of  15
              Nisan on or after 1 January 1990.

              If yrstart is an INT, it is interpreted as a Hebrew year.  Thus:

                        hebdate(22, "Kislev", 5756)

              returns 1995/12/15, because that date corresponds to 22  Kislev,
              5756.   Note  that  none  of the Hebrew date functions will work
              with dates outside Reminds normal range for dates.

              If yrstart is not supplied, it defaults to today().

              The jahr modifies the behaviour of hebdate() as follows:

              If jahr is 0 (the default), then hebdate() keeps scanning  until
              it  finds  a  date  that exactly satisfies the other parameters.
              For example:

                        hebdate(30, "Adar A", 1993/01/01)

              returns 1995/03/02, corresponding to 30 Adar  A,  5755,  because
              that  is the next occurrence of 30 Adar A after 1 January, 1993.
              This behaviour  is  appropriate  for  Purim  Katan,  which  only
              appears in leap years.

              If jahr is 1, then the date is modified as follows:

              o      30 Heshvan is converted to 1 Kislev in years when Heshvan
                     is chaser

              o      30 Kislev is converted to 1 Tevet in years when Kislev is
                     chaser

              o      30 Adar A is converted to 1 Nisan in non-leapyears

              o      Other  dates in Adar A are moved to the corresponding day
                     in Adar in non-leapyears

              This behaviour is appropriate for smachot (joyous occasions) and
              for some jahrzeits - see "JAHRZEITS."

              if jahr is 2, then the date is modified as follows:

              o      30  Kislev  and 30 Heshvan are converted to 29 Kislev and
                     29 Heshvan, respectively, if the month is chaser

              o      30 Adar A is converted to 30 Shvat in non-leapyears

              o      Other dates in Adar A are moved to the corresponding  day
                     in Adar in non-leapyears

              if  jahr  is not 0, 1, or 2, it is interpreted as a Hebrew year,
              and the  behaviour  is  calculated  as  described  in  the  next
              section, "JAHRZEITS."

              The  aflag  parameter modifies the behaviour of the function for
              dates in Adar during leap years.  The  aflag  is  only  used  if
              yrstart is a DATE type.

              The  aflag only affects date calculations if hebmon is specified
              as "Adar".  In leap years, the following algorithm is followed:

              o      If aflag is 0, then the date  is  triggered  in  Adar  B.
                     This is the default.

              o      If  aflag  is  1,  then  the date is triggered in Adar A.
                     This may be appropriate for jahrzeits  in  the  Ashkenazi
                     tradition; consult a rabbi.

              o      If  aflag is 2, then the date is triggered in both Adar A
                     and Adar B of  a  leap  year.   Some  Ashkenazim  perform
                     jahrzeit in both Adar A and Adar B.

       JAHRZEITS

       A  jahrzeit  is a yearly commemoration of someone’s death.  It normally
       takes place on the anniversary of the death,  but  may  be  delayed  if
       burial is delayed - consult a rabbi for more information.

       In addition, because some months change length, it is not obvious which
       day the anniversary of a death is.  The following rules are used:

       o      If the death occurred on 30 Heshvan, and  Heshvan  in  the  year
              after  the  death is chaser, then the jahrzeit is observed on 29
              Heshvan  in  years  when  Heshvan  is  chaser.   Otherwise,  the
              yahrzeit is observed on 1 Kislev when Heshvan is chaser.

       o      If the death occurred on 30 Kislev, and Kislev in the year after
              the death is chaser, then the jahrzeit is observed on 29  Kislev
              in  years  when  Kislev  is  chaser.  Otherwise, the yahrzeit is
              observed on 1 Tevet when Kislev is chaser.

       o      If the death occurred on 1-29 Adar A, it  is  observed  on  1-29
              Adar in non-leapyears.

       o      If  the  death occurred on 30 Adar A, it is observed on 30 Shvat
              in a non-leapyear.

       Specifying a Hebrew year for the  jahr  parameter  causes  the  correct
       behaviour  to  be selected for a death in that year.  You may also have
       to specify aflag, depending on your tradition.

       The jahrzeit information was supplied by Frank Yellin, who quoted  "The
       Comprehensive  Hebrew  Calendar"  by  Arthur  Spier,  and  "Calendrical
       Calculations" by E. M. Reingold and Nachum Dershowitz.

OUT-OF-BAND REMINDERS

       The SPECIAL keyword is used to transmit  "out-of-band"  information  to
       Remind  backends,  such as tkremind or Rem2PS.  They are used only when
       piping data from a remind -p line.  (Note that the COLOR special is  an
       exception;  it  downgrades  to the equivalent of MSG in reminds normal
       mode of operation.)

       The various  SPECIALs  recognized  are  particular  for  each  backend;
       however,  there  are three SPECIALs that all backends should attempt to
       support.   They  are  currently  supported  by  Rem2PS,  tkremind   and
       rem2html.

       The SHADE special replaces the psshade() function.  Use it like this:
            REM Sat Sun SPECIAL SHADE 128
            REM Mon SPECIAL SHADE 255 0 0
       The SHADE keyword is followed by either one or three numbers, from 0 to
       255.  If one number is supplied, it  is  interpreted  as  a  grey-scale
       value  from  black  (0) to white (255).  If three numbers are supplied,
       they are interpreted as RGB components  from  minimum  (0)  to  maximum
       (255).   The example above shades weekends a fairly dark grey and makes
       Mondays a fully-saturated red.  (These  shadings  appear  in  calendars
       produced by Rem2PS, tkremind and rem2html.)

       The MOON special replaces the psmoon() function.  Use it like this:
            REM [trigger(moondate(0))] SPECIAL MOON 0
            REM [trigger(moondate(1))] SPECIAL MOON 1
            REM [trigger(moondate(2))] SPECIAL MOON 2
            REM [trigger(moondate(3))] SPECIAL MOON 3
       These  draw little moons on the various calendars.  The complete syntax
       of the MOON special is as follows:
            ... SPECIAL MOON phase moonsize fontsize msg

       Phase is a number from 0 to 3, with 0 representing a new  moon,  1  the
       first quarter, 2 a full moon and 3 the last quarter.

       moonsize  is  the diameter in PostScript units of the moon to draw.  If
       omitted or supplied as -1, the backend chooses an appropriate size.

       fontsize is the font size in PostScript units of the msg

       Msg is additional text that is placed near the moon glyph.

       Note that only the Rem2PS backend supports moonsize and  fontsize;  the
       other backends use fixed sizes.

       The  COLOR  special  lets  you place colored reminders in the calendar.
       Use it like this:

            REM ... SPECIAL COLOR 255 0 0 This is a bright red reminder
            REM ... SPECIAL COLOR 0 128 0 This is a dark green reminder

       Immediately following COLOR should be  three  decimal  numbers  ranging
       from 0 to 255 specifying red, green and blue intensities, respectively.
       The rest of the line is the text to put in the calendar.

       The COLOR special is "doubly special", because in its normal  operating
       mode, remind treats a COLOR special just like a MSG-type reminder.

MISCELLANEOUS

       COMMAND ABBREVIATIONS

       The following tokens can be abbreviated:

       o      REM  can be omitted - it is implied if no other valid command is
              present.

       o      CLEAR-OMIT-CONTEXT --> CLEAR

       o      PUSH-OMIT-CONTEXT --> PUSH

       o      POP-OMIT-CONTEXT --> POP

       o      DUMPVARS --> DUMP

       o      BANNER --> BAN

       o      INCLUDE --> INC

       o      SCANFROM --> SCAN

       NIFTY EXAMPLES

       This section is a sampling of what you can do with Remind.

            REM 5 Feb 1991 AT 14:00 +45 *30 \
            RUN mail -s "Meeting at %2" $LOGNAME </dev/null &

       On 5 February, 1991, this reminder will mail you reminders of a  2:00pm
       meeting  at  1:15, 1:45 and 2:00.  The subject of the mail message will
       be "Meeting at 2:00pm" and the body of the message will be blank.

            REM AT 17:00 RUN echo "5:00pm - GO HOME!" | xless -g +0+0 &

       This reminder will pop up an xless window at  5:00pm  every  day.   The
       xless window will contain the line "5:00pm - GO HOME!"

            REM AT 23:59 RUN (sleep 120; remind -a [filename()]) &

       This  reminder will run at one minute to midnight.  It will cause a new
       Remind process to start at one minute past midnight.  This  allows  you
       to have a continuous reminder service so you can work through the night
       and still get timed reminders for early in the morning.  Note that this
       trick  is no longer necessary, providing you run Remind in daemon mode.

            remind -c12 /dev/null Jan 1993

       This invocation of Remind will cause it to print a calendar  for  1993,
       with all entries left blank.

            REM CAL [trigdate()-date(year(trigdate()), 1, 1)+1]

       This example puts an entry in each box of a calendar showing the number
       (1-365 or 366) of the day of the year.

            REM Tue 2 Nov SATISFY (year(trigdate())%4) == 0
            IF trigvalid()
                 REM [trigger(trigdate())] ++5 MSG \
                 U.S. Presidential Election!!
            ENDIF

       This example warns you 5  days  ahead  of  each  American  presidential
       election.  The first REM command calculates the first Tuesday after the
       first Monday in November.  (This is equivalent to the first Tuesday  on
       or after 2 November.)  The SATISFY clause ensures that the trigger date
       is issued only in election years, which are multiples of 4.  The second
       REM command actually issues the reminder.

       DETAILS ABOUT TRIGGER COMPUTATION

       Here  is a conceptual description of how triggers are calculated.  Note
       that Remind actually uses a much  more  efficient  procedure,  but  the
       results  are the same as if the conceptual procedure had been followed.

       Remind starts from the current date (that is, the value of today()) and
       scans  forward,  examining each day one at a time until it finds a date
       that satisfies the trigger, or can prove that  no  such  dates  (on  or
       later than today()) exist.

       If  Remind  is  executing  a  SATISFY-type  reminder,  it evaluates the
       expression with trigdate()  set  to  the  date  found  above.   If  the
       expression  evaluates  to zero or the null string, Remind continues the
       scanning procedure described above, starting with  the  day  after  the
       trigger found above.

       The  SCANFROM  clause (having a syntax similar to UNTIL) can modify the
       search strategy  used.   In  this  case,  Remind  begins  the  scanning
       procedure  at  scan_date,  which  is the date specified in the SCANFROM
       clause.  For example:

            REM Mon 1 SCANFROM 17 Jan 1992 MSG Foo

       The example above will always have a trigger date of Monday, 3 February
       1992.  That is because Remind starts scanning from 17 January 1992, and
       stops scanning as soon as it hits a date that satisfies "Mon 1."

       The main use of SCANFROM is in situations where you want  to  calculate
       the  positions  of  floating holidays.  Consider the Labour Day example
       shown much earlier.  Labour Day is the first Monday in  September.   It
       can move over a range of 7 days.  Consider the following sequence:

            REM Mon 1 Sept SCANFROM [trigger(today()-7)] SATISFY 1
            OMIT [trigger(trigdate())]

            REM Mon AFTER MSG Hello

       The  SCANFROM clause makes sure that Remind begins scanning from 7 days
       before the current date.  This ensures that Labour Day for the  current
       year  will continue to be triggered until 7 days after it has occurred.
       This allows you to safely use the AFTER keyword as shown.

       In general, use SCANFROM as shown for safe movable OMITs.   The  amount
       you  should  scan  back by (7 days in the example above) depends on the
       number of possible consecutive OMITted days that may occur, and on  the
       range of the movable holiday.  Generally, a value of 7 is safe.

       The  FROM  clause  operates  almost like the counterpoint to UNTIL.  It
       prevents the reminder  from  triggering  before  the  FROM  date.   For
       example, the following reminder:

            REM Mon Thu FROM 23 Jul 2007 UNTIL 2 Aug 2007 MSG Test

       will trigger on Mondays and Thursdays between 23 July 2007 and 2 August
       2007 inclusive.

       FROM is really just syntactic sugar; you could implement  the  reminder
       above as follows:

            REM Mon Thu SCANFROM [trigger(max(today(), ’2007-07-23’))] \
                   UNTIL 2 Aug 2007 MSG Test

       but  that’s  a  lot  harder  to  read.   Internally, Remind treats FROM
       exactly as illustrated using SCANFROM.  For that reason, you cannot use
       both FROM and SCANFROM.

       Note  that  if  you  use  one  REM command to calculate a trigger date,
       perform date calculations (addition or subtraction,  for  example)  and
       then use the modified date in a subsequent REM command, the results may
       not be what you intended.  This is because you  have  circumvented  the
       normal  scanning  mechanism.  You should try to write REM commands that
       compute trigger dates that can be used  unmodified  in  subsequent  REM
       commands.   The file "defs.rem" that comes with the Remind distribution
       contains examples.

       DETAILS ABOUT TRIGVALID()

       The trigvalid() function returns 1 if Remind could find a trigger  date
       for  the previous REM or IFTRIG command.  More specifically, it returns
       1 if Remind finds a date not before the starting date of  the  scanning
       that  satisfies the trigger.  In addition, there is one special case in
       which trigvalid() returns 1 and trigdate() returns a meaningful result:

       If  the  REM  or  IFTRIG  command  did not contain an UNTIL clause, and
       contained all of the day, month and year components, then  Remind  will
       correctly  compute  a trigger date, even if it happens to be before the
       start of scanning.  Note that this behaviour is not true  for  versions
       of Remind prior to 03.00.01.

AUTHOR

       Remind   is   now   supported   by   Roaring   Penguin   Software  Inc.
       (http://www.roaringpenguin.com)

       David F. Skoll <dfs@roaringpenguin.com> wrote Remind.   The  moon  code
       was  copied  largely  unmodified  from  "moontool" by John Walker.  The
       sunrise and  sunset  functions  use  ideas  from  programs  by  Michael
       Schwartz  and  Marc  T. Kaufman.  The Hebrew calendar support was taken
       from  "hdate"  by  Amos  Shapir.   OS/2  support  was  done  by  Darrel
       Hankerson,  Russ  Herman,  and  Norman  Walsh.   The  supported foreign
       languages and their translators are  listed  below.   Languages  marked
       "complete"  support  error  messages  and  usage  instructions  in that
       language; all others only support the substitution filter mechanism and
       month/day names.

       German -- Wolfgang Thronicke

       Dutch -- Willem Kasdorp and Erik-Jan Vens

       Finnish -- Mikko Silvonen (complete)

       French -- Laurent Duperval (complete)

       Norwegian -- Trygve Randen

       Danish -- Mogens Lynnerup

       Polish -- Jerzy Sobczyk (complete)

       Brazilian Portuguese -- Marco Paganini (complete)

       Italian -- Valerio Aimale

       Romanian -- Liviu Daia

       Spanish -- Rafa Couto

       Icelandic -- Björn Davíðsson

BUGS

       There’s   no  good  reason  why  read-only  system  variables  are  not
       implemented as functions, or why functions like  version(),  etc.   are
       not implemented as read-only system variables.

       Hebrew dates in Remind change at midnight instead of sunset.

       Language  should  be  selectable  at run-time, not compile-time.  Don’t
       expect this to happen soon!   Remind  has  some  built-in  limits  (for
       example, number of global OMITs.)

BIBLIOGRAPHY

       Nachum  Dershowitz  and Edward M. Reingold, "Calendrical Calculations",
       Software-Practice and Experience, Vol. 20(9), Sept. 1990, pp 899-928.

       L. E. Doggett, Almanac  for  computers  for  the  year  1978,  Nautical
       Almanac Office, USNO.

       Richard  Siegel  and  Michael  and  Sharon Strassfeld, The First Jewish
       Catalog, Jewish Publication Society of America.

SEE ALSO

       rem, rem2ps, tkremind