Provided by: remind_04.02.05-1_amd64 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.

       If filename happens to be a directory rather than a plain file, then Remind reads  all  of
       the  files in that directory that match the pattern "*.rem".  The files are read in sorted
       order; the sort order may depend on your locale, but should match the sort order  used  by
       the shell to expand "*.rem".

       Remind  reads  its  files starting from the beginning to the end, or until it encounters a
       line whose sole content is "__EOF__" (without the quotes.)   Anything  after  the  __EOF__
       marker is completely ignored.

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).  Note that the -n option causes any -g option to be ignored.

       -j[n]  Runs Remind in "purge" mode to get rid of expired reminders.  See the section PURGE
              MODE for details.

       -r     The -r option disables RUN directives and the shell() function.

       -c[flags]n
              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.

              You can precede n (if any) with a set of flags.  The flags are as follows:

              '+'    causes a calendar for n weeks to be produced.

              'a'    causes Remind to display reminders on the calendar on the day they  actually
                     occur as well as on any preceding days specified by the reminder's delta.

              'l'    causes  Remind  to  use  VT100 line-drawing characters to draw the calendar.
                     The characters are hard-coded and will only work on terminals  that  emulate
                     the VT00 line-drawing character set.

              'u'    is  similar to 'l', but causes Remind to use UNICODE line-drawing characters
                     to draw the calendar.  The characters are hard-coded and will only  work  on
                     terminals  that are set to UTF-8 character encoding.  This flag also enables
                     the use of the UNICODE "left-to-right"  mark  that  can  fix  up  formatting
                     problems with right-to-left languages in the calendar display.

              'c'    causes  Remind  to  use  VT100 escape sequences to approximate SPECIAL COLOR
                     reminders.  Note that this flag is  kept  for  backwards-compatibility;  you
                     should use the -@[n][,m][,b] command-line option instead.

       -@[n][,m][,b]
              Tells  Remind  to  approximate SPECIAL COLOR and SHADE reminders using VT100 escape
              sequences.  The approximation is (of necessity) very coarse, because the VT100 only
              has  eight  different  color sequences, each with one of two brightnesses.  A color
              component greater than 64 is considered  "on",  and  if  any  of  the  three  color
              components is greater than 128, the color is considered "bright".

              If  you  supply  the  optional numeric parameters, the have the following meanings:
              n=0 tells Remind to use the standard 16 VT100 colors.   n=1  tells  it  to  use  an
              extended 256-color palette supported by many terminal emulators such as xterm.  And
              n=2 tells it to use  escape  sequences  that  support  true  24-bit  colors,  again
              supported by many terminal emulators such as xterm.

              If  the  optional  m parameter is supplied following a comma, then m=0 tells Remind
              that the terminal background is dark, and Remind will brighten up  dark  colors  to
              make  them  visible.   If m=1, then Remind assumes the terminal background is light
              and it will darken bright colors to make them visible.  If no m is supplied, or  it
              is  supplied  as  m=2,  then  Remind  does  not  perform  any adjustments, and some
              reminders may be hard or impossible to see  if  the  color  is  too  close  to  the
              terminal background color.

              If the optional b parameter is supplied following a comma, then b=0 tells Remind to
              ignore SPECIAL SHADE reminders (the  default)  and  b=1  tells  Remind  to  respect
              SPECIAL  SHADE  reminders by emitting VT100 escape codes to color the background of
              the calendar cell.  Note that SHADE does not work well unless  you  are  using  the
              extended  256-color  palette  (n=1) or the true 24-bit colors (n=2).  Note that for
              calendar cells that are shaded, the clamping mechanism described earlier for m=0 or
              m=1  is  skipped;  it  is  assumed  that  if you set both the foreground color of a
              reminder and the background color of a cell, then you know what you are doing.

       -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.  If col
              is not specified, or is specified as 0, it defaults to the  larger  of  71  or  the
              actual  width  of your terminal, or to 80 if standard output is not a terminal.  If
              col is specified as the letter t, then Remind attempts to  get  the  width  of  the
              /dev/tty terminal device.  This is useful, for example, if you pipe calendar output
              into less; even though standard output is a pipe, you want the calendar to be sized
              correctly for your terminal window:

                      remind -c -wt .reminders | less

              Note  that  the  value  of  col is also used to set the system variable $FormWidth,
              which is initialized to col - 8.  See "SYSTEM VARIABLES" for details.

              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][p][p][q]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, and various other back-end programs.  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.   If  you
              follow  the  p  with  another  p,  then Remind uses a more comprehensive JSON-based
              format rather than the "simple calendar" format.  This format is also documented in
              the  rem2ps(1)  man  page.   Finally, if you use three p's, as in -ppp, then Remind
              uses a pure JSON format, again documented in rem2ps(1).  If you include a q  letter
              with this option, then the normal calendar-mode substitution filter is disabled and
              the %"...%" sequences are preserved in the output.

              Note that the -pp or -ppp options also enable the -l option.

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

       -tn    If  you  supply a number n after the -t option, then Remind pretends that each non-
              expired reminder has a delta of n days and triggers reminders accordingly.

       -tt[n] The -tt option causes Remind to assume a default delta of n minutes for  all  timed
              reminders.  If -tt is given with no n, a default delta of 5 minutes is used.

       -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 trigger
              on  the  current  day.   It  also  causes  Remind not to place timed reminders in a
              calendar.  If you supply two or more -a options, then  Remind  will  trigger  timed
              reminders  that  are in the future, but will not trigger timed reminders whose time
              has passed.  (Regardless of how many -a options you supply, Remind will not include
              timed reminders in the calendar if at least one -a option is used.)

       -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

         f      Trace the reading of reminder files

       -g[a|d[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.

              Note that -g is ignored if you use the -n option.

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

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

              If  you  follow  the  -k  option  with a colon, then the command is applied only to
              queued timed reminders.  Normal reminders are  handled  as  usual.   In  the  above
              example,  if  you want normal reminders to simply be displayed as usual, but queued
              reminders to be sent to notify-send, you could use:

                        remind '-k:notify-send %s &' ...

              You use both -kcmd1 and -k:cmd2 to use different commands for  queued  versus  non-
              queued reminders.

       -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 1, and can range from 1 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.  However, if you prefix name with a +-sign, then RUN and shell() are  not
              disabled.   That  is,  -uwhatever  switches  the user to whatever and disables RUN,
              whereas -u+whatever switches the user to whatever but leaves RUN enabled.

              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.

       -+username
              Causes Remind to trust files owned by the user username.  Normally, if Remind reads
              a  file that you do not own, it disables RUN and the shell() function.  This option
              causes it to also trust files owned  by  username.   You  can  supply  multiple  -+
              options to trust multiple users, up to a limit of 20 trusted users.

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

       -ifunc(args)=definition
              Allows you to define a function on the command line.

       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 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.   The
       time may be specified in 24-hour format (eg, 13:20) or common "AM/PM" format (1:20pm).

       If  you  would rather specify the date more succinctly, you can supply it as YYYY-MM-DD or
       YYYY/MM/DD.  You can even supply a date and time on the  command  line  as  one  argument:
       YYYY-MM-DD@HH:MM.

       In  addition,  you  can  supply  a repeat parameter, which has the form *rep.  This causes
       Remind to be run rep 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-text  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 Dianne's birthday

       to the baroque and obscure:

            REM [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.

       Note that Remind processes line continuations before anything else.  For example:

            # This is a comment \
            This line is part of the comment because of line continuation \
            and so on.
            REM MSG This line is not ignored (no \ above)

       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]  [ADDOMIT]  [NOQUEUE]  [OMITFUNC  omit_function] [AT time
              [tdelta] [trepeat]] [SCHED sched_function] [WARN warn_function] [UNTIL  expiry_date
              |  THROUGH  last_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 Dianne'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.  A back-end must ignore a SPECIAL that it does  not
       recognize.

       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.  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 on or 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.

       SHORT-HAND DATE SPECIFICATIONS

       In addition to spelling out the day, month and year separately, you can specify YYYY-MM-DD
       or YYYY/MM/DD.  For example, the following statements are equivalent:

            REM 5 June 2010 MSG Cool!
            REM 2010-06-05  MSG Cool!

       You  can  also  specify  a  date  and  time  as  YYYY-MM-DD@HH:MM.   These  statements are
       equivalent:

            REM 19 Dec 2010 AT 16:45 MSG Hi
            REM 2010-12-19@16:45 MSG Hi

       There's one subtlety with short-hand date specifications:  The  following  statements  are
       not equivalent:

            REM 19 Dec 2010 AT 16:45 +60 MSG Hi
            REM 2010-12-19@16:45 +60 MSG Hi

       In  the  second  statement,  the  "+60"  is a delta that applies to the date rather than a
       tdelta that applies to the time.  We recommend explicitly using the AT keyword with  timed
       reminders.

       THE REMIND ALGORITHM

       Remind  uses  the following algorithm to compute a trigger date: Starting from the current
       date, it examines each day, one at a time, until it finds a date that satisfies  the  date
       specification,  or  proves  to  itself that no such date exists.  (Actually, Remind merely
       behaves as if it used this algorithm; it would be much too slow in practice.   Internally,
       Remind  uses  much  faster  techniques  to  calculate  a trigger date.)  See DETAILS ABOUT
       TRIGGER COMPUTATION for more information.

       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); this is the start
       date  of  the repetition period.  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 28 Oct 1992.  You can use delta and
       back with repeat.  Note, however, that the back is used only to compute the starting date;
       thereafter,  the  reminder repeats with the specified period.  Similarly, if you specify a
       weekday, it is used only  to  calculate  the  starting  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 1992-11-30 *1 +2 UNTIL 1992-12-04 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.)

       As a special case, you can use the THROUGH keyword instead of *1 and UNTIL.  The following
       two REM commands are equivalent:

            REM 1992-11-30 *1 +2 UNTIL 1992-12-04 MSG Jury duty

            REM 1992-11-30 +2 THROUGH 1992-12-04 MSG Jury duty

       If you have an expiry date via the use of THROUGH or UNTIL, then Remind will never trigger
       the reminder after the expiry date.  For example, if you have this:

               OMIT 2021-01-08
               REM 2021-01-01 THROUGH 2021-01-08 AFTER MSG Test

       the  reminder  will  not  be  triggered  on  2021-01-08,  and  nor will it be triggered on
       2021-01-09; even though the AFTER keyword would normally move the 8th's  reminder  to  the
       9th, the expiry date of 2021-01-08 overrides that.

       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.

       If you locally omit weekdays but also have globally-omitted weekdays,  then  the  list  of
       omitted weekdays is the union of the two.  Consider this example:

               OMIT Sat Sun
               REM 15 OMIT Fri Sat MSG Whatever

       In  the  REM  command, the effective list of omitted weekdays will be Friday, Saturday and
       Sunday.

       COMPUTED LOCAL OMITS

       The OMITFUNC phrase of the REM command allows you to supply  a  function  that  determines
       whether or not a date is omitted.  The function is passed a single parameter of type DATE,
       and must return a non-zero integer if the date is considered "omitted"  and  0  otherwise.
       Here's an example:

               FSET _third(x) (day(x) % 3) || \
                              (wkdaynum(x) == 0) || \
                              (wkdaynum(x) == 6)
               REM OMITFUNC _third AFTER MSG Working day divisible by 3

       In  the example above, the reminder is triggered every Monday to Friday whose day-of-month
       number is divisible by three.  Here's how it works:

       o      The OMITFUNC _third portion causes all days for which _third(x) returns non-zero to
              be  considered  "omitted".  This causes all days whose day-of-month number is not a
              multiple of three to be omitted.  Note that _third also  returns  non-zero  if  the
              weekday is Sunday or Saturday.

       o      The AFTER keyword causes the reminder to be moved after a block of omitted days.

       The combination of OMITFUNC and AFTER keyword causes the reminder to be issued on all days
       whose day-of-month number is divisible by three, but not on Saturday or Sunday.

       Note that if you use OMITFUNC, then a local OMIT is ignored as are all global  OMITs.   If
       you  want  to  omit  specific  weekdays,  your  omit  function  will need to test for them
       specifically.  If you want to take into account the global OMIT context,  then  your  omit
       function will need to test for that explicitly (using the isomitted() function.)

       Note  that  an incorrect OMITFUNC might cause all days to be considered omitted.  For that
       reason, when Remind searches through omitted days, it  terminates  the  search  after  the
       SATISFY iteration limit (command-line option -x.)

       ADDING TRIGGER DATES TO THE OMIT CONTEXT

       If  the  ADDOMIT  keyword appears in a REM command, then the trigger date (if one could be
       calculated) is automatically added to the list of global OMITs.

       The command:

               REM ... whatever ... ADDOMIT MSG Foo

       is identical in behaviour to the sequence:

               REM ... whatever ... SATISFY 1
               IF trigvalid()
                   OMIT [trigdate()] MSG Foo
               ENDIF

       TIMED REMINDERS

       Timed reminders are those that have an AT keyword followed by a time and  optional  tdelta
       and  trepeat.   The  time  may  be  specified  in  24-hour  format, with 0:00 representing
       midnight, 12:00  representing  noon,  and  23:59  representing  one  minute  to  midnight.
       Alternatively,  it  may be specified in common "AM/PM" format; in this case, the hour must
       range from 1 to 12.  12:00am represents midnight, 12:00pm  represents  noon,  and  11:59pm
       represents  one  minute  to midnight.  The "am" and "pm" portions are case-insensitive and
       the "m" is optional.

       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.  Note that if you use the
       NOQUEUE  modifier  in the REM command, then this queueing and background activation is not
       performed.  NOQUEUE is useful if you want a time to be associated with a reminder (eg,  in
       the calendar) but are not interested in a popup reminder happening at 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 1:00PM 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; see their documentation for details.

       The  TAG  keyword is followed by a tag consisting of up to 48 characters.  You can have as
       many TAG clauses as you like in a given REM statement.  A tag can  contain  any  character
       except for whitespace and a comma.

       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.  For example, if you have a 90-minute meeting starting at 1:00pm, you could use any
       of the following:

            REM 5 March 2021 AT 13:00 DURATION 1:30 MSG Meeting
            REM 5 March 2021 AT 13:00 DURATION 90 MSG Meeting
            REM 5 March 2021 AT 1:00pm DURATION 1:30 MSG Meeting
            REM 5 March 2021 AT 1:00pm DURATION 90 MSG Meeting

       For long-duration reminders, it is convenient to use expressions to simplify  writing  the
       DURATION.  For example, if you are away from 20 Feb 2023 through 23 Feb 2023 (a total of 4
       days) you could write:

               REM 20 Feb AT 00:00 DURATION [4*24]:00 MSG away
               REM 20 Feb AT 00:00 DURATION [4*24*60] MSG away

       Note that duration is specified either as hours:minutes or just as minutes specified as an
       integer.

       If  you specify a duration of 00:00 or 0, then Remind behaves exactly as if no DURATION at
       all had been present.  Although durations specified as  hours:minutes  look  superficially
       like a time-of-day, they are not; the hours component is not limited to the range 00-23.

SYNTACTIC SUGAR FOR REM

       The  REM  command  has syntactic sugar to let you express common reminders.  The following
       pairs of reminders are equivalent:

           REM First Monday April MSG Foo
           REM Mon 1 April        MSG Foo

           REM Second Monday May  MSG Bar
           REM Mon 8 May          MSG Bar

           REM Third Monday MSG Third Monday of every month
           REM Mon 15 MSG Third Monday of every month

           REM Fourth Sunday June 2025 MSG Fourth Sunday in June 2025
           REM Sun 22 June 2025 MSG Fourth Sunday in June 2025

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

           REM Last Monday April MSG Last Monday of every April
           REM Mon 1 May --7 MSG  Last Monday of every April

           REM Last Monday December 2025 MSG Last Monday of Dec 2025
           REM Monday 1 Jan 2026 --7 MSG Last Monday of Dec 2025

       Note that Last effectively adjusts the month and year, if necessary, to make the  reminder
       trigger on the correct date.

       The keyword IN is completely ignored, so you can write (for example):

           REM Second Monday in May MSG foo
           REM Last Monday in December 2025 MSG Bar

       An  alternate  form  of  back  makes  writing  reminders  easier.  The following groups of
       reminders are equivalent:

           REM ~~1 MSG Last day of every month
           REM Lastday MSG  Last day of every month
           REM 1 --1 MSG Last day of every month

           REM May ~~1 MSG Last day of May
           REM Lastday May MSG Last day of May
           REM 1 June --1 MSG Last day of May

           REM Dec 2025 ~~1 MSG Last day of December 2025
           REM Lastday Dec 2025 MSG Last day of December 2025
           REM 1 Jan 2026 --1 MSG Last day of December 2025

           REM Apr ~1 OMIT SAT SUN MSG Last workday of April
           REM Lastworkday April OMIT SAT SUN MSG Last workday of April
           REM 1 May -1 OMIT SAT SUN MSG Last workday of April

           REM Apr ~~7 MSG Seventh-last day of April
           REM 1 May --7 MSG Seventh-last day of April

           REM Apr ~2 OMIT SAT SUN MSG Second-last workday of April
           REM 1 May -2 OMIT SAT SUN MSG Second-last workday of April

       As we see, "Lastday" is equivalent to ~~1 and "Lastworkday" to ~1.

       Note that the First/Second/Third/Fourth/Last keywords and the ~ and ~~ form of back  imply
       a  value  for  the  day  of  the  month;  as  such,  they  cannot  be combined with a day.
       Additionally, First/Second/Third/Fourth/Last must have at least  one  weekday  name.   The
       following are illegal:

           REM First Monday 3 June MSG Huh?
           REM April 3 ~~1 MSG What?
           REM Second June MSG Where's the weekday???

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.  You can globally suppress the
              extra blank lines by setting $AddBlankLines to 0.

       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      The a, c, e, f, g, h, i, j, k, l, u, v, 2, and 3 substitutions may be  preceded  by
              an  asterisk  (for  example,  %*c)  which  causes  the word "at" or "on" that would
              normally be included in the output to be omitted.

       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 weekday [weekday...]

              or:

              OMIT [day] month [year]

              or:

              OMIT [day1] month1 [year1] THROUGH [day2] month2 [year2]

       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, but  not  by
       the "--" and "++" forms.  Some examples:

           OMIT Saturday Sunday
           OMIT 1 Jan
           OMIT 7 Sep 1992
           OMIT 15 Jan THROUGH 14 Feb
           OMIT May     # Equivalent to OMIT May 1 THROUGH May 31
           OMIT 25 Dec THROUGH 4 Jan
           OMIT 2023-05-03 THROUGH 2023-05-12
           OMIT Jun THROUGH July  # Equivalent to OMIT Jun 1 THROUGH July 31

       The  first  example  omits  every  Saturday and Sunday.  This is useful for reminders that
       shouldn't trigger on weekends.

       The second example specifies a holiday that occurs on the same date each year - New Year's
       Day.

       The  third  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.)

       As with the REM command, you can use shorthand specifiers for  dates;  the  following  are
       equivalent:

            OMIT 7 Sep 1992
            OMIT 1992-09-07

       For  convenience,  you  can  use  a delta and MSG or RUN keyword in the OMIT command.  The
       following sequences are 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 THROUGH keyword lets you  conveniently  OMIT  a  range  of  days.   For  example,  the
       following sequences are equivalent:

            OMIT 3 Jan 2011
            OMIT 4 Jan 2011
            OMIT 5 Jan 2011

            and

            OMIT 3 Jan 2011 THROUGH 5 Jan 2011

       You  can  make  a  THROUGH  OMIT do double-duty as a REM command as long as both dates are
       fully specified

            OMIT 6 Sep 2010 THROUGH 10 Sep 2010 MSG Vacation

       If you use a THROUGH clause, then either the year must be supplied before  and  after  the
       THROUGH, or it must be missing before and after the THROUGH.  The following are legal:

           OMIT 25 Dec THROUGH 6 Jan
           OMIT 25 Dec 2024 THROUGH 6 Jan 2025

       But the following are not:

           OMIT 25 Dec THROUGH 6 Jan 2025
           OMIT 25 Dec 2024 THROUGH 6 Jan

       You can debug your global OMITs with the following command:

            OMIT DUMP

       The OMIT DUMP command prints the current global omits to standard output.

       THE BEFORE, AFTER AND SKIP KEYWORDS

       Normally,  days  that  are  omitted, whether by a global OMIT command or the local OMIT or
       OMITFUNC keywords 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 DO AND INCLUDE COMMANDS

       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.

       If  you specify a directory as the argument to INCLUDE, then Remind will process all files
       in that directory that match the shell patterm "*.rem".  The files are processed in sorted
       order; the sort order matches that used by the shell when it expands "*.rem".

       Note  that the file specified by an INCLUDE command is interpreted relative to the current
       working directory of the Remind process.  If you want to include a file  relative  to  the
       directory  containing  the currently-processing file, use DO instead.  For example, if the
       current  file  is  /home/user/.reminders/foo.rem  and  Remind's   working   directory   is
       /home/user, then:

           # Read /home/user/.reminders/bar.rem
           DO bar.rem

           # Read /usr/share/bar.rem - absolute path
           DO /usr/share/bar.rem

           # Read /home/user/bar.rem
           INCLUDE bar.rem

           # Read /usr/share/bar.rem - absolute path
           INCLUDE /usr/share/bar.rem

       Arguably, the INCLUDE command should have worked the way DO does right from the start, but
       changing it would have broken backward-compatibility, hence the introduction of DO.

       Note that if the currently-processing reminders file was specified as a symbolic link to a
       file  that is not in the same directory as the symbolic link itself, DO will fail.  Remind
       does not resolve the real path of symbolic links, so you should avoid using symbolic links
       to files.

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.

       Note that if Remind reads standard input, it does not attempt to check  the  ownership  of
       standard  input,  even  if  it  is  coming from a file, and hence does not disable RUN and
       shell() in this situation.

THE INCLUDECMD COMMAND

       Remind allows you to execute a shell command and evaluate the output of that command as if
       it  were an included file.  For example, you could have scripts that extract reminders out
       of a database and print them on stdout as REM commands.  Here is an example:

            INCLUDECMD extract_reminders_for dfs

       We assume that the command "extract_reminders_for" extracts reminders  out  of  a  central
       database for the named user.  Another use-case of INCLUDECMD is if you have your reminders
       stored in a file in some non-Remind format; you can write a command that  transforms  them
       to  Remind  format  and  then Remind can "include" the file with an appropriate INCLUDECMD
       command.

       Note that if RUN is disabled, then INCLUDECMD  will  fail  with  the  error  message  "RUN
       disabled"

       INCLUDECMD  passes  the rest of the line to popen(3), meaning that the command is executed
       by the shell.  As such, shell metacharacters  may  need  escaping  or  arguments  quoting,
       depending on what you're trying to do.  Remind itself does not perform any modification of
       the command line (apart from the normal [expr] expression-pasting mechanism).

       If the command passed to INCLUDECMD begins with  an  exclamation  mark  "!",  then  Remind
       disables RUN for the output of the command.  If you are running a command whose output you
       don't quite trust, you should prefix it with "!" so that any RUN commands it emits fail.

       An INCLUDECMD command counts towards the INCLUDE nesting depth.  For any given Remind run,
       a given INCLUDECMD command is only executed once and the results are cached.  For example,
       if you generate a calendar, each unique INCLUDECMD command is run just once, not once  for
       each  day  of the produced calendar.  "Uniqueness" is determined by looking at the command
       that will be passed to the shell, so if (for example)  your  INCLUDECMD  uses  expression-
       pasting  that  results  in differences depending on the value of today(), then each unique
       version of the command will be executed once.

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 is used for two different purposes:  To represent a time of day
              with one-minute precision or to represent a  duration  with  one-minute  precision.
              The  context of where a TIME is used determines whether it is interpreted as a time
              of day or a duration.

              In contexts where a TIME represents a time of day, it may range from 00:00 to 23:59
              and  is  stored  internally as an integer from 0 to 1439 representing the number of
              minutes since midnight.

              In contexts where a TIME represents a duration, there is no upper limit on the hour
              component  (beyond  that  imposed  by  the restriction that a duration expressed in
              minutes  must  fit  into  the  signed  integer  type  of  your  CPU  architecture.)
              Internally, a duration is stored as an integer number of minutes.

       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", "\nHello\tThere", ""

              Note that the empty string is  represented  by  "".   Remind  supports  the  escape
              sequences  "\a", "\b", "\f", "\n", "\r", "\t" and "\v" which have the same meanings
              as their counterparts in C.  To include a quote in a string, use "\"".   Any  other
              character  preceded  by  a  backslash  is  inserted  into the string as-is, but the
              backslash itself is removed.  To include a backslash in a string, use "\\".

       TIME constants
              12:33, 0:01, 14:15, 16:42, 12.16, 13.00, 1.11, 4:30PM, 12:20am

              Note that TIME constants may be written in 24-hour  format  or  in  common  "AM/PM"
              format.  If you use "AM/PM" format, then the hour can range from 1 to 12.  Either a
              period or colon can be used to separate  the  minutes  from  the  hours.   However,
              Remind  will  consistently  output times in 24-hour format using only one separator
              character.  (The output separator character is chosen at compile-time.)

              If the TIME is used where Remind expects a  time-of-day  (for  example,  in  an  AT
              clause),  then it can be written in 24-hour format (ranging from 00:00 to 23:59) or
              12-hour format (ranging from 12:00am to 11:59pm).  If the TIME is used where Remind
              expects  a  duration,  it  must  not have an am or pm suffix and the hour can be as
              large as you want, so long as the total number of minutes in the duration fits in a
              signed integer variable.

       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, optionally followed by "am" or "pm".  For example:

              '2008-04-05@23:11', '1999/02/03@14:06', '2001-04-07@08:30', '2020-01-01@3:20pm'

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

       ZERO VALUES

       The non-string types all have an associated zero value, which is treated as "false" by the
       IF command and the logical operators.  The zero values are:

              INT - 0

              DATE - '1990-01-01'

              TIME - 00:00

              DATETIME - '1990-01-01@00:00'

       Additionally,  for the purpose of the IF command (but not the logical operators) the empty
       string "" is considered a false value.

       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.  The result will always range from 00:00 through 23:59.

              TIME + TIME treats the second TIME parameter as a duration,  converting  it  to  an
              integer  number of minutes past midnight, and then performs addition as with TIME +
              INT.

              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.

              DATETIME + TIME or TIME +  DATETIME  treats  the  TIME  parameter  as  a  duration,
              converting  it  to  an  integer  number of minutes past midnight, and then performs
              addition as with DATETIME + INT.

              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.

              DATETIME - TIME - coerces the TIME to an  INT  and  then  performs  subtraction  as
              above.

       <, <=, >, 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 the same type
              and must not be STRING type.  Returns the second operand if both operands are  non-
              zero.  Otherwise, returns a zero of the same type as the operands.

       ||     This is the logical OR operator.  Both of its operands must be of the same type and
              must not be of STRING type.  It returns the first operand that is non-zero; if both
              operands are zero, then returns a zero of the same type as the operands.

       NOTES

       If the result of an addition, subtraction or multiplication operation would not fit in a C
       "int" type, Remind issues a "Number too high" error.  Unlike C,  integer  operations  will
       not simply give the wrong answer in case of overflow.

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

       Variables set with SET or on the command-line with -ivar=expr have global scope.

       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.

       $AddBlankLines
              If  set  to  1  (the  default),  then Remind normally prints a blank line after the
              banner and each reminder.  (This can be suppressed by ending the reminder or banner
              with  a  single percent sign.)  If $AddBlankLines is set to 0, then Remind does not
              print the blank line.  In this case, ending a reminder with % has  no  effect.   If
              you do want a blank line after a reminder, end it with %_ to insert a newline.

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

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

       $DefaultColor
              This  variable  can  be  set to a string that has the form of three space-separated
              numbers.  Each number must be an integer from 0 to 255, or all three  numbers  must
              be  -1.  The default value of $DefaultColor is "-1 -1 -1", which suppresses default
              coloring of MSG-type reminders.  If you set $DefaultColor to any other value,  then
              all  MSG-, MSF- and CAL-type reminders are effectively converted into SPECIAL COLOR
              reminders whose color value is specified by $DefaultColor.

              Unlike other system variables, the value of $DefaultColor is not preserved  between
              calendar  iterations;  rather,  it  is  reset  to  "-1  -1 -1" at the start of each
              iteration.

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

       $DefaultTDelta
              The default time delta used if no +N is given in an AT clause.  This is normally 0,
              but can be set  with  the  -tt  option  or  explicitly  set  in  your  script.   If
              $DefaultDelta  is  non-zero, you can use an explicit delta of +0 in an AT clause to
              countermand the default delta.

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

       $DontTrigAts (read-only)
              The number of times that the -a option was supplied on the command line.

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

       $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 saving 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 saving 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 the width of the terminal in columns, minus 8, but clamped at a  minimum
              of 20 and a maximum of 500.  If standard output is not a terminal, then 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.

       $IntMax (read-only)
              The  largest  representable  INT.   On  a machine with 32-bit signed integers using
              twos-complement representation, this will be 2147483647.

       $IntMin (read-only)
              The smallest representable INT.  On a machine with  32-bit  signed  integers  using
              twos-complement representation, this will be -2147483648.

       $Latitude (STRING type)
              The  latitude  of  your  location,  expressed  as a string that is a floating-point
              number.  Because Remind does not have a native  floating-point  type,  we  need  to
              express  it as a string.  $Latitude can range from "-90.0" to "90.0", with positive
              numbers representing points north of the equator and negative numbers  representing
              south.  Note that regardless of your locale, $Latitude is always interpreted in the
              "C" locale and as such, the decimal point must be a period (".").

       $Longitude (STRING type)
              The longitude of your location, expressed as a  string  that  is  a  floating-point
              number.   Because  Remind  does  not  have a native floating-point type, we need to
              express it as a string.  $Longitude  can  range  from  "-180.0"  to  "180.0",  with
              positive  numbers  representing  points east of the Greenwich Meridian and negative
              numbers representing west.  Note that regardless  of  your  locale,  $Longitude  is
              always  interpreted  in  the  "C"  locale  and as such, the decimal point must be a
              period (".").

              For example, the coordinates of  the  Statue  of  Liberty  in  New  York  City  are
              approximately set by:

                  SET $Latitude   "40.68933"
                  SET $Longitude "-74.04454"

       $LatDeg, $LatMin, $LatSec (DEPRECATED)
              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.  These
              three variables are deprecated; you should use $Latitude instead.

       $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 (DEPRECATED)
              These specify the longitude of your location.  $LongDeg can range from -180 to 180.
              Western  longitudes  are  positive; eastern ones are negative.  Note that all three
              components should have the same sign: All positive for western longitudes  and  all
              negative  for  eastern  longitudes.  Note that for historical reasons, the sign for
              longitude is different from the usual convention!  If you  find  the  longitude  of
              your location from a search engine, you will most likely need to invert the sign to
              have it work correctly with Remind.  These  three  variables  are  deprecated;  you
              should  use  $Longitude  instead.   Note  also  that  $Longitude  uses the standard
              convention of negative for western longitudes and positive for eastern ones.

              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.

              Note that setting  any  of  $LongDec,  $LongMin  and  $LongSec  updates  $Longitude
              correspondingly,  and  setting  $Longitude updates $LongDeg, $LongMin and $LongSec.
              Similar rules apply to $Latitude, $LatDeg, $LatMin and $LatSec.

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

       $MaxStringLen
              A limit on the longest string that Remind will allow you to create.  The default is
              65535.  If you set $MaxStringLen to 0 or to -1,  then  remind  will  allow  you  to
              create arbitrarily-long strings, at least until it runs out of memory.

       $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 saving  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.

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

       $SuppressLRM
              Normally, when Remind is run with the -c option in a UTF-8 locale, it emits a left-
              to-right  mark  sequence  after  printing  day  names or reminders.  Some terminals
              render this incorrectly, so you can use:

                  SET $SuppressLRM 1

              at the top of your reminder file to suppress the LRM sequences, or you  can  invoke
              Remind with the option '-i$SuppressLRM=1'.

       $SysInclude (read-only, STRING type)
              A  directory  path  containing  standard reminder scripts.  Currently, Remind ships
              with some standard holiday files and language packs.  The value of  $SysInclude  is
              "/usr/share/remind" on this installation.

       $T (read-only, DATE type)
              Exactly equivalent to trigdate().  (See BUILT-IN FUNCTIONS.)

       $Td (read-only)
              Equivalent to day(trigdate()).

       $Tm (read-only)
              Equivalent to monnum(trigdate()).

       $Tw (read-only)
              Equivalent to wkdaynum(trigdate()).

       $Ty (read-only)
              Equivalent to year(trigdate()).

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

       $UntimedFirst (read-only)
              Set to 1 if the -g option is used with a fourth sort character of  "d";  set  to  0
              otherwise.

       $U (read-only, DATE type)
              Exactly equivalent to today().  (See BUILT-IN FUNCTIONS.)

       $Ud (read-only)
              Equivalent to day(today()).

       $Um (read-only)
              Equivalent to monnum(today()).

       $Uw (read-only)
              Equivalent to wkdaynum(today()).

       $Uy (read-only)
              Equivalent to year(today()).

       $UseVTColors (read-only)
              Set to 1 if the -@ or -cc options were used; 0 otherwise.

       $UseBGVTColors (read-only)
              Set to 1 if the -@,,1 option was used; 0 otherwise.

       $Use256Colors (read-only)
              Set to 1 if the -@1 option was used; 0 otherwise.

       $UseTrueColors (read-only)
              Set to 1 if the -@2 option was used; 0 otherwise.

       $TerminalBackground (read-only)
              Returns  -1  if  the  terminal  background  color  was  not  specified, 0 if it was
              specified as dark with the -@,0 option or 1 if it was specified as light  with  the
              -@,1 option.

       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.

       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.

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

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

       ampm(tq_time [,s_am [,s_pm]])
              Returns a STRING that is the result of converting time (which is either a TIME or a
              DATETIME object) to "AM/PM" format.  The optional  arguments  am  and  pm  are  the
              strings  to  append  in  the AM and PM case, respectively; they default to "AM" and
              "PM".  The function obeys the system variables $DateSep, $TimeSep and  $DateTimeSep
              when formatting its output.  For example:

                      ampm(0:22)                 returns "12:22AM"
                      ampm(17:45, "am", "pm")    returns "5:45pm"
                      ampm('2020-03-14@21:34')   returns "2020-03-14@9:34PM"

       ansicolor(i_red, i_green, i_blue [,i_bg [,i_clamp]])
              Returns  a  STRING  that contains an ANSI escape sequence for changing the terminal
              text color.  The parameters red,  green  and  blue  are  integers  from  0  to  255
              specifying  the  value  of  the respective color component.  As a special case, all
              three values can be -1, in which case the ANSI sequence "ESC[0m" is returned, which
              resets all text attributes to normal.

              The  string  returned by ansicolor depends on the color mode that Remind is running
              in, as specified by the -@ option.  If color mode is not  enabled,  then  ansicolor
              always  returns  the  empty string.  Otherwise, it returns the escape sequence that
              best approximates the color according to the -@ color mode.

              The optional bg argument is either 0 or 1.  If 0 (the default), then the foreground
              color  is  set.   If  1,  then  the background color is set.  Note that setting the
              background color only works in 256-color or true-color mode.

              The optional clamp argument is either 0 or 1.  If 0 (the default), then colors  are
              not adjusted based on the terminal background color.  If 1, then Remind attempts to
              adjust dark or bright colors so they have enough contrast  to  be  visible  in  the
              terminal.

              The  first three arguments may alternatively be specified as a string consisting of
              three space-separated numbers, as in this example: "128 128 0"

              As a special case, ansicolor("") is equivalent to ansicolor(-1,-1,-1)  and  returns
              the ANSI sequence to reset all text attributes to normal.

              Note  that  inserting  ANSI  color  sequences in calendar mode will produce garbled
              results.  Therefore, we recommend defining functions such as the  ones  below  that
              return the empty string in calendar mode:

                      IF $CalMode
                          FSET fg(r,g,b) ""
                          FSET bg(r,g,b) ""
                      ELSE
                          FSET fg(r,g,b) ansicolor(r,g,b)
                          FSET bg(r,g,b) ansicolor(r,g,b,1)
                      ENDIF
                      REM [fg(255,0,0)][bg(64,64,64)]Red on Gray[fg(-1,-1,-1)] in normal mode
                      REM SPECIAL COLOR 0 255 0 Green in normal and calendar mode

              If  you  use the ansicolor function, don't forget to reset the color back to normal
              with ansicolor(-1,-1,-1) or subsequent reminders will continue to be colored.

       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.  For UTF-8 strings, this will return the UTF-8
              byte with which the string begins, which is not likely to be very useful  (and  may
              indeed be negative on machines where char is a signed type.)

       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  bytes  specified  by  the  arguments.   It is easy to create invalid UTF-8
              sequences; char does not check for this.  Note that none of the arguments can be 0,
              unless there is only one argument.  As a special case, char(0) returns "".

       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.

       columns([s_arg])
              If called with no arguments, columns() behaves as follows: If standard output is  a
              TTY,  returns  the  width  of the terminal in columns.  If standard output is not a
              TTY, attempts to open "/dev/tty" to obtain  the  terminal  size.   If  this  fails,
              returns -1.

              If called with a single string argument, columns(str) returns the number of columns
              str will occupy if printed to a terminal.   ANSI  color-changing  sequences  occupy
              zero  columns  whereas  some  Unicode  characters occupy two columns.  columns(str)
              takes all of that into account.  Note that if Remind was compiled  without  Unicode
              support, columns(str) returns a type mismatch error.

       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.

       datepart(dq_datetime)
              Returns a DATE object representing the date portion of datetime.

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

              Note  that  easterdate  computes the Western Easter.  For the Orthodox Easter date,
              see orthodoxeaster.

       evaltrig(s_trigger [,dq_start])
              Evaluates trigger as if it were a REM or IFTRIG trigger specification  and  returns
              the  trigger date as a DATE (or as a DATETIME if there is an AT clause.)  Returns a
              negative INT if no trigger could be computed.

              Normally, evaltrig finds a trigger date on or after today.  If you supply the start
              argument, then it scans starting from there.

              For example, the expression:

                evaltrig("Mon 1", '2008-10-07')

              returns  '2008-11-03', since that is the first date on or after 7 October 2008 that
              satisfies "Mon 1".

              If you want to see how many days it is from the first Monday in  October,  2008  to
              the first Monday in November, 2008, use:

                evaltrig("Mon 1", '2008-11-01') - evaltrig("Mon 1", '2008-10-01')

              and  the  answer  is  28.   The trigger argument to evaltrig can have all the usual
              trigger clauses (OMIT, AT, SKIP,  etc.)  but  cannot  have  a  SATISFY,  MSG,  etc.
              reminder-type clause.

       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.  Note that this workaround is no longer necessary because DO stuff  will
              achieve the same goal.

              Note  that  if  the currently-processing reminders file was specified as a symbolic
              link, then filedir() returns the directory containing the symbolic link and not the
              directory  containing  the  target  of  the  symbolic link.  You should avoid using
              symbolic links to files unless both the symbolic link and its target happen  to  be
              in the same directory.

       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").

       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"

       hour(tq_time)
              Returns the hour component of time.

       htmlescape(s_str)
              Returns  a  modified copy of str where "<" is replaced with "&lt;"; ">" is replaced
              with "&gt;" and "&" is replaced with "&amp;"

       htmlstriptags(s_str)
              Returns a modified copy of str where HTML tags are  stripped  out.   The  stripping
              algorithm  is  fairly  naive;  the  function  starts  stripping  characters when it
              encounters a "<" and it stops stripping when it encounters a ">".

       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.

       isany(arg1 [,arg2, ..., argN]);
              Returns 1 if the first argument arg1 is equal to any of  the  subsequent  arguments
              arg2  through  argN;  returns  0 otherwise.  Also returns 0 if called with only one
              argument.

              As an example, the following two expressions are equivalent:

                      (a == b) || (a == c) || (a == d) || (a == e)

                      isany(a, b, c, d, e)

       isdst([d_date [,t_time]]) or isdst(q_datetime)
              Returns a positive number if daylight saving 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.)  Note that any
              local OMIT or OMITFUNC clauses are not taken into account by this function.

       language()
              Returns a STRING naming the language supported by Remind.  (See "SUPPORT FOR  OTHER
              LANGUAGES")  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.

       localtoutc(q_datetime)
              Given a DATETIME object interpreted in the  local  time  zone,  return  a  DATETIME
              object that expresses the same time in UTC.

       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.

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

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

       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.  However, in a REM command, any local OMITFUNC
              clause is not taken into account by this function.

              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

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

              Here is a more complex use for  nonomitted.   My  garbage  collection  follows  two
              interleaved  14-day  cycles:  One Friday, garbage and paper recycling ("Black Box")
              are collected.  The next Friday, garbage and plastic  recycling  ("Blue  Box")  are
              collected.   If  any of Monday-Friday is a holiday, collection is delayed until the
              Saturday.  Here's a way to encode these rules:

                 fset _garbhol(x) wkdaynum(x) == 5 && nonomitted(x-4, x+1) < 5
                 REM 12 November 1999 *14 AFTER OMITFUNC _garbhol MSG Black Box
                 REM 19 November 1999 *14 AFTER OMITFUNC _garbhol MSG Blue Box

              Here's how it works:  The _garbhol(x) user-defined function returns 1 if  and  only
              if  (1)  x  is a Friday and (2) there is at least one OMITted day from the previous
              Monday up to and including the Friday.

              The first REM statement sets up the 14-day  black-box  cycle.   The  AFTER  keyword
              makes  it  move  collection  to the Saturday if _garbhol returns 1.  The second REM
              statement sets up the 14-day blue-box cycle with a similar adjustment made by AFTER
              in conjunction with _garbhol.

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

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

              Note  that  orthodoxeaster  computes  the  Orthodox Easter.  For the Western Easter
              date, see easterdate.

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

       pad(x_arg, s_padstr, i_len [, i_right])
              Converts the first argument arg to a string if necessary, and then if it is shorter
              than  len  characters,  pads  to  to len characters using as many copies (including
              partial copies) of padstr as necessary.  By default, the string is left-padded, but
              if right is supplied and non-zero, the string will be right-padded.

              Here are some examples:

                  pad(3, "0", 2)        -->  "03"
                  pad(465, "0", 2)      -->  "465"
                  pad("foo", " ", 5)    -->  "  foo"
                  pad("foo", " ", 5, 1) -->  "foo  "
                  pad("foo", "bar", 11) -->  "barbarbafoo"

       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 [moondate(0)] PS [psmoon(0)]
                        REM [moondate(1)] PS [psmoon(1)]
                        REM [moondate(2)] PS [psmoon(2)]
                        REM [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 [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.

       rows() If  standard  output  is  a  TTY,  returns  the height of the terminal in rows.  If
              standard output is not a TTY, attempts to open "/dev/tty" to  obtain  the  terminal
              size.  If this fails, returns -1.

       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 it
              defaults to the value of the system variable $MaxStringLen.

       shellescape(s_str)
              Returns str with all shell metacharacters such as " ",  "*",  etc  escaped  with  a
              backslash.  For example:

               SET a shellescape("a b*? c&d$e")

              will set a to:

               "a\ b\*\?\ c\&d\$e"

       slide(d_start, i_amt [,s_wkday...])
              This  function  is  the  inverse  of  nonomitted.   It  adds amt days (which can be
              negative) to start, not counting omitted days.  The optional  wkday  arguments  are
              additional weekday names to omit.

              Consider this example:

                   OMIT 14 May 2009
                   SET a slide('2009-05-13', 5, "Sat", "Sun")

              In  this  case, a is set to 2009-05-21.  That's because we slide forward by 5 days,
              not including Thursday, May 14 or Saturday and Sunday, May 16 and 17.  You  can  go
              backwards, too, so:

                   OMIT 14 May 2009
                   SET a slide('2009-05-21', -5, "Sat", "Sun")

              takes a back to 2009-05-13.

       soleq(i_which [, dqi_start])
              The  soleq  function  computes solstices and equinoxes.  The which parameter ranges
              from 0 to 3, and specifies which event  we  are  interested  in:  0  is  the  March
              equinox;  1  is the June solstice; 2 is the September equinox and 3 is the December
              solstice.

              The optional start parameter can either be an integer specifying the  year  of  the
              event we are interested in, or a DATE or DATETIME object; if the latter, then soleq
              returns the first event on or after the  date  part  of  the  start  parameter  (it
              ignores the time component if start is a DATETIME.)  If start is not supplied, then
              it defaults to today().

              The return value of soleq() is a DATETIME object specifying the date  and  time  of
              the  solstice or equinox in the local time zone.  It should be accurate to within 3
              minues or so in the worst case.

              See the included file $SysInclude/seasons.rem for examples of how to use soleq().

       stdout()
              Returns a string representing where Remind's standard output is going.  The  return
              values are one of the following: "TTY" if standard-output is a terminal, "BLOCKDEV"
              if it is a block device (very unlikely), "CHARDEV" if it is a character device (eg,
              /dev/null),  "DIR"  if it is a directory (very unlikely), "PIPE" if it is a pipe or
              FIFO, "SYMLINK" if it is a symlink (very unlikely), "SOCKET" if it is a socket,  or
              "UNKNOWN" if it could not be determined.

              The  purpose  of  stdout() is mostly to distinguish between TTY and non-TTY output;
              you may wish to change or disable colors if the output is not going to a TTY.

       strlen(s_str)
              Returns the length of str.  If the length of str is too large to  represent  as  an
              integer, emits a "Number too high" error.

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

       timepart(tq_datetime)
              Returns a TIME object representing the time portion of datetime.

       timezone([dq_datetime])
              Returns a string representing the local time zone name of the given  DATETIME.   If
              no argument is supplied, Remind uses the value of current().  If a DATE rather than
              DATETIME is supplied, Remind uses a time part of 00:00.

       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.

       trig(s_1 [,s_2, ...])
              For each string argument s_n, trig evaluates s_n as if it  were  a  REM  or  IFTRIG
              trigger  specification.   If the trigger would trigger today, then the trigger date
              is returned and no further triggers are evaluated.  If none of the  triggers  would
              trigger today, then the zero date 1990-01-01 is returned.
              trig  also  has  a  zero-argument  form;  this returns the trigger date of the most
              recent trig function that returned a non-zero trigger date.

              trig can be used to make more sophisticated versions of IFTRIG.   For  example,  if
              you  have  meetings  every Monday in June and July, and you want warnings 3 days in
              advance, you could use:

                  REM [trig("Mon Jun +3", "Mon July +3")] +3 MSG Meeting %b

              NOTE: We need to repeat the +3 delta outside  of  the  trig  function  for  advance
              warning  to  work  properly.   This  is  because  trig returns a date constant (the
              trigger date) and the REM command does not know the details of trig's arguments.

              Note that because Remind does not have short-circuit logical  operators,  something
              like:

                  SET a trig("Mon +7") || trig("Fri +7")

              would  set  the value of trig() to the date of the following Thursday.  Even though
              trig("Mon +7")  always  returns  true,  the  logical-OR  operator  still  evaluates
              trig("Fri +7") which also returns true and sets trig().

              You  can  work  around  the  lack of a short-circuit logical-OR as follows: If trig
              returns a true value, the specific value it returns can be coerced to a DATE  which
              is the trigger date.  So the following code:

                  SET a trig("Mon +4") || trig("Fri +4")
                  IF a
                      REM [a] +4 MSG [wkday($T)] %b.
                  ENDIF

              would operate as follows:

                  On Monday:    Monday today.
                  On Tuesday:   Friday in 3 days' time.
                  On Wednesday: Friday in 2 days' time.
                  On Thursday:  Monday in 4 days' time.
                  On Friday:    Monday in 3 days' time.
                  On Saturday:  Monday in 2 days' time.
                  On Sunday:    Monday tomorrow.

              Compare with the following:

                  SET a trig("Mon +4") || trig("Fri +4")
                  IF a
                      REM [trig()] +4 MSG [wkday($T)] %b.
                  ENDIF

              which yields:

                  On Monday:    Friday in 4 days' time.
                  On Tuesday:   Friday in 3 days' time.
                  On Wednesday: Friday in 2 days' time.
                  On Thursday:  Friday tomorrow.
                  On Friday:    Friday today.
                  On Saturday:  Monday in 2 days' time.
                  On Sunday:    Monday tomorrow.

              That  is  because  trig()  returns  the trigger date of the last trig function that
              returns true, whereas the value of a is the trigger date of the first trig function
              that returns true.

              Important  Note:   Because trig() always returns an absolute date, it will not work
              properly with a SATISFY clause.  Consider this reminder:

                  REM [trig("Mar", "Apr")] SATISFY [$Td == 15] MSG 15 Mar or April

              If we run Remind on 5 March 2022, we might expect the trigger date to be calculated
              as  15  March  2022...  but that's not what happens.  Instead, the trig function is
              evaluated first, and it returns 2022-03-05.  So as far as Remind is concerned,  the
              REM statement becomes:

                  REM 2022-03-05 SATISFY [$Td == 15] MSG 15 Mar or April

              and the SATISFY expression is never true.  So: Do not mix trig() and SATISFY.

       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.  See "MULTI-DAY EVENTS" for more
              information.

       trigeventstart()
              Returns a DATETIME representing the  start  of  the  most  recent  triggerable  REM
              command  that  had an AT clause.  For events without a DURATION or that do not span
              multiple days, returns the same as trigdatetime().  If the REM command did not have
              an  AT  clause,  returns  the  integer  -1 (and differs from trigdatetime() in this
              respect.)  See "MULTI-DAY EVENTS" for more information.

       trigeventduration()
              Returns a TIME representing the duration of the most recent triggerable REM command
              that  had  an  AT and a DURATION clause.  If the event does not span multiple days,
              returns the same thing as trigduration().  If the  REM  command  lacked  an  AT  or
              DURATION clause, returns -1.  See "MULTI-DAY EVENTS" for more information.

       trigback()
              Returns  the  "back"  amount of the last REM or IFTRIG command.  Returns a positive
              integer N if the "back" is of the form -N, or a negative integer if it  is  of  the
              form --N.  If there is no "back", then returns 0.

       trigdelta()
              Returns  the  "delta" amount of the last REM or IFTRIG command.  Returns a positive
              integer N if the "delta" is of the form +N, or a negative integer if it is  of  the
              form ++N.  If there is no "delta", then returns 0.

       trigtimedelta()
              Similar  to  trigdelta(),  but  returns  the delta used in the AT clause of a timed
              reminder.

       trigrep()
              Returns the "repeat" amount of the last REM or IFTRIG command.  Returns a  positive
              integer N if the "repeat" is of the form *N.  If there is no "repeat", then returns
              0.

       trigtimerep()
              Similar to trigrep(), but returns the repeat used in  the  AT  clause  of  a  timed
              reminder.

       trigduration()
              Returns  (as  a TIME type) the DURATION parameter of a timed reminder.  If there is
              no DURATION parameter, returns the integer -1.  See  "MULTI-DAY  EVENTS"  for  more
              information.

       trigpriority()
              Returns the PRIORITY of the last REM or IFTRIG command.

       triguntil()
              Returns (as a DATE type) the UNTIL parameter of the last REM or IFTRIG command.  If
              there was no UNTIL parameter, returns the  integer  -1.   If  there  is  a  THROUGH
              parameter,  that  will  be  returned  by  triguntil() since "THROUGH yyyy-mm-dd" is
              simply syntactic sugar for "*1 UNTIL yyyy-mm-dd".

       trigscanfrom()
              Returns (as a DATE type) the SCANFROM parameter of the last REM or IFTRIG  command.
              If  there  was  no  SCANFROM parameter, returns the integer -1.  Note that FROM and
              SCANFROM interact; a reminder that has a "FROM yyyy-mm-dd" parameter will act as if
              it has a SCANFROM parameter whose value is the maximum of "yyyy-mm-dd" and today.

       trigfrom()
              Returns  (as a DATE type) the FROM parameter of the last REM or IFTRIG command.  If
              there was no FROM parameter, returns the integer -1.

       trigger(d_date [,t_time [,i_utcflag]]) or trigger(q_datetime [,i_utcflag])
              Returns a string suitable for use in a REM command or a SCANFROM or  UNTIL  clause,
              allowing  you to calculate trigger dates in advance.  Note that in earlier versions
              of Remind, trigger was required to convert a date into something  the  REM  command
              could  consume.   However,  in  this version of Remind, you can omit it.  Note that
              trigger() always returns its result in English, even for  non-English  versions  of
              Remind.   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.

       trigtags()
              Returns a comma-separated list of the TAGs associated  with  the  most  recent  REM
              command  that  was  triggered.  Returns the empty string if there were no TAGs.  If
              there are multiple tags, they are each separated by a single comma, not a comma and
              a space.

       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.  If a REM command has  an  AT  clause
              with a DURATION, then you can compute the end time as trigtime() + trigduration().

       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.

       utctolocal(q_datetime)
              Given a DATETIME object interpreted in UTC, return a DATETIME object that expresses
              the same time in the local time zone.

       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  04.02.05,  returns
              "04.02.05".   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.

       weekno([dq_date, [i_wkstart, [i_daystart]]])
              Returns the week number of the year.  If no arguments are supplied, returns the ISO
              8601 week number for today().  If one argument date is supplied, then  returns  the
              ISO  8601  week  number for that date.  If two arguments are supplied, then wkstart
              must range from 0 to 6, and represents the first day of  the  week  (with  0  being
              Sunday  and 6 being Saturday.).  If wkstart is not supplied, then it defaults to 1.
              If the third argument daystart is supplied, then it specifies when Week  1  starts.
              If  daystart is less than or equal to 7, then Week 1 starts on the first wkstart on
              or after January daystart.  Otherwise, Week 1 starts on the  first  wkstart  on  or
              after  December  daystart.   If omitted, daystart defaults to 29 (following the ISO
              8601 definition.)

       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.

MULTI-DAY EVENTS

       If  you  specify  a start time with AT and a duration with DURATION, you can create events
       that span multiple days.  Consider these two REM statements:

           REM 1991-02-13 AT 16:00 DURATION 72:00 MSG 72-hour event
           REM 1991-02-13 THROUGH 1991-02-16 AT 16:00 MSG Four events

       The first statement creates a single event that starts on 13 February 1991  at  16:00  and
       runs through 16 February 1991 at 16:00

       The  second  statements creates four separate events that start at 16:00 on 13, 14, 15 and
       16 February 1991 and have indefinite duration.

       Remind handles multi-day events specially.  These are the rules:

       On the first day of a multi-day event, trigdatetime() will return the  starting  date  and
       time of the event, and trigduration() will return the original DURATION.

       On  each  subsequent  day of a multi-day event, trigdatetime() will return midnight on the
       day in question, and trigduration() will return the  remaining  duration.   Consider  this
       example:

           #!/bin/sh
           remind - 12 feb 1991 '*6' <<'EOF'
           BANNER %
           REM 1991-02-13 AT 16:00 DURATION 72:00 SATISFY 1
           set a trigdatetime()
           set b trigduration()
           set c trigeventstart()
           set d trigeventduration()
           MSG now=[today()] dt=[a] dur=[b] estart=[c] edur=[d]%
           EOF

       The output is:

       now=1991-02-12 dt=1991-02-13@16:00 dur=72:00 estart=1991-02-13@16:00 edur=72:00
       now=1991-02-13 dt=1991-02-13@16:00 dur=72:00 estart=1991-02-13@16:00 edur=72:00
       now=1991-02-14 dt=1991-02-14@00:00 dur=64:00 estart=1991-02-13@16:00 edur=72:00
       now=1991-02-15 dt=1991-02-15@00:00 dur=40:00 estart=1991-02-13@16:00 edur=72:00
       now=1991-02-16 dt=1991-02-16@00:00 dur=16:00 estart=1991-02-13@16:00 edur=72:00
       now=1991-02-17 dt=1991-02-13@16:00 dur=72:00 estart=-1 edur=-1

       As  you  see,  the  trigdatetime()  and trigduration() functions return the start time and
       duration of the remaining  portion  of  a  multi-day  event,  whereas  trigeventstart  and
       trigeventduration  always  return  the original start and duration of the multi-day event.
       Note also that the return value for expired reminders  is  not  reliable;  the  fact  that
       trigeventstart and trigeventduration return -1 in that case is an implementation artifact.

       SELF-OVERLAPPING EVENTS

       A  multi-day event has the possibility of "overlapping itself".  When this happens, Remind
       prefers the later event (only one copy of an event is ever triggered for  a  given  date.)
       Consider this example:

          #!/bin/sh
          remind - '*5' 10 Feb 1991 <<'EOF'

          BANNER %
          REM MON at 0:00 DURATION 192:0 MSG [today()] [trigeventstart()] [trigduration()]%

          EOF

       The output is:

          1991-02-10 1991-02-04@00:00 48:00
          1991-02-11 1991-02-11@00:00 192:00
          1991-02-12 1991-02-11@00:00 168:00
          1991-02-13 1991-02-11@00:00 144:00
          1991-02-14 1991-02-11@00:00 120:00

       Although  the  event  from  1991-02-04  still  has  24 hours left on 1991-02-11, the fresh
       occurrence on 1991-02-11 takes precedences and is the one that is triggered.

       I do not recommend constructing self-overlapping multi-day events.

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 [mydate] MSG foo

       This  evaluates  the  expression  "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, you
              should not include square brackets.  For example, use:

                 SET a 4+5
       and not:
                 SET a [4+5]

       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!"]

              However, as an escape hatch, the sequence SPECIAL type means the same thing as just
              type  where  type  is  one  of MSG, MSF, RUN, CAL, PS and PSFILE.  This lets you do
              something like this:

                      SET type "MSG"
                      REM 12 Nov 2024 SPECIAL [type] Hello

              You can use this to control the types of your reminders based on variables you set,
              how Remind is invoked, etc.

       COMMON PITFALLS WITH EXPRESSION PASTING

       Remember that extra spaces are not inserted when an expression is pasted.  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, a DATE that is not 1990-01-01, a TIME that is not
       00:00, a DATETIME that is not 1990-01-01@00:00, 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.

       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.  However, you cannot use a type specifier such as  CAL,
       MSG or SATISFY; attempting to do so yields a parse error.

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 to 64 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.

       To delete a user-defined function, use FUNSET.  This takes a space-separated list of user-
       defined functions to delete.  For example, after the command:

               FUNSET myfunc1 otherfunc thirdfunc

       it is guaranteed that no user-defined functions named myfunc1, otherfunc or thirdfunc will
       exist.   Remind  does  not  issue an error if you try to FUNSET a nonexistent user-defined
       function; it simply does nothing in that case.

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  and  the  error  message  "Can't
       compute trigger" is issued.  Otherwise, trigvalid() is set to 1.

       This is really useful only if expr involves a call to the trigdate() or related functions;
       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 [trigdate()] +2 MSG \
                 Friday the 13th is %b.
            ENDIF

       You can write the REM statement a little more concisely:

            REM 13 SATISFY $Tw == 5

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

       Here  is  another  example:  Suppose  you  want to be reminded of something on the 15th of
       January, April, July, and October.  You could make four separate reminders, or  you  could
       use:

               REM 15 SATISFY [isany($Tm, 1, 4, 7, 10)] MSG 15th Reminder!

       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 [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 square brackets.
       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 [$Tw == 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 [$Td %2 ] MSG Here it is!!!

       Note that SATISFY and OMITFUNC can often be used to solve  the  same  problem,  though  in
       different  ways.  Sometimes a SATISFY is cleaner and sometimes an OMITFUNC; experiment and
       use whichever seems clearer.

POSSIBLY-UNCOMPUTABLE TRIGGERS

       Occasionally, you may wish to suppress the "Can't compute trigger" warnings for  reminders
       for  which  a  trigger  date  cannot  be computed.  For example, the following reminder is
       triggered on a Monday that is not a holiday if the following Tuesday is a holiday:

               REM Mon SKIP SATISFY [isomitted($T+1)] MSG Work between holidays

       However, if there are no Mondays after today's date that  satisfy  the  condition,  Remind
       will  print  the  "Can't  compute  trigger"  error.   To  suppress  this,  use  the MAYBE-
       UNCOMPUTABLE keyword:

               REM MAYBE-UNCOMPUTABLE Mon SKIP SATISFY [isomitted($T+1)] MSG Work between holidays

       It's almost never appropriate to use MAYBE-UNCOMPUTABLE, but it is provided for those rare
       occasions  when  it  makes  sense.   If  you  use MAYBE-UNCOMPUTABLE inside the evaltrig()
       function, then untriggerable triggers return -1.  For example:

               SET a evaltrig("MAYBE-UNCOMPUTABLE Mon SKIP OMIT Mon")

       will set a to -1.

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 "extvlf" 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 %"Dianne's birthday%" is %b

       In the normal mode, Remind  would  print  "Dianne's  birthday  is  today"  on  6  January.
       However,  in the calendar mode, only the text "Dianne'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.

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

       You can also define a function on the command line by using:

       -ifunc(args)=definition

       Be sure to protect special characters from shell interpretation.

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.

PURGE MODE

       If  you  supply  the  -j command-line option, Remind runs in purge mode.  In this mode, it
       tries to purge expired reminders from your reminder files.

       In purge mode, Remind reads your reminder  file  and  creates  a  new  file  by  appending
       ".purged"  to the original file name.  Note that Remind never edits your original file; it
       always creates a new .purged file.

       If you invoke Remind against a directory instead of a file, then a .purged file is created
       for each *.rem file in the directory.

       Normally, Remind does not create .purged files for INCLUDed files.  However, if you supply
       a numeric argument after -j, then Remind will create .purged files for the specified level
       of  INCLUDE.   For example, if you invoke Remind with the argument -j2, then .purged files
       will be created for the file (or directory) specified  on  the  command  line,  any  files
       included  by them, and any files included by those files.  However, .purged files will not
       be created for third-or-higher level INCLUDE files.

       Determining which reminders have expired is extremely tricky.  Remind does its  best,  but
       you should always compare the .purged file to the original file and hand-merge the changes
       back in.

       Remind annotates the .purged file as follows:

       An expired reminder is prefixed with:  #!P: Expired:

       In situations where Remind cannot reliably determine that something was expired,  you  may
       see the following comments inserted before the problematic line:

          #!P: Cannot purge SATISFY-type reminders

          #!P: The next IF evaluated false...
          #!P: REM statements in IF block not checked for purging.

          #!P: The previous IF evaluated true.
          #!P: REM statements in ELSE block not checked for purging

          #!P: The next IFTRIG did not trigger.
          #!P: REM statements in IFTRIG block not checked for purging.

          #!P: Next line has expired, but contains expression...  please verify

          #!P: Next line may have expired, but contains non-constant expression

          #!P! Could not parse next line: Some-Error-Message-Here

       Remind  always annotates .purged files with lines beginning with "#!P".  If such lines are
       encountered in the original file, they are not copied to the .purged file.

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 four 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.  If the fourth character is "d", the untimed reminders are
       sorted before timed reminders.  The default is to sort all fields in ascending  order  and
       to sort untimed reminders after timed reminders.

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

COMPILE-TIME SUPPORT FOR OTHER LANGUAGES

       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, non-English versions of Remind will output
       names of months and weekdays in the selected language.  Also, the  substitution  mechanism
       will substitute constructs suitable for the selected language rather than for English.

       Note  that  a non-English version of Remind will accept only English names of weekdays and
       months in a reminder script.

RUN-TIME SUPPORT FOR OTHER LANGUAGES

       Remind has run-time support for other languages, and  it  is  expected  that  compile-time
       support will be deprecated in favour of run-time support.

       A  number of system variables let you translate various phrases to other languages.  These
       system variables are:

       $Monday, $Tuesday, $Wednesday, $Thursday, $Friday, $Saturday
              Set each of these system variables to a string representing the corresponding day's
              name in your language.  Strings must be valid UTF-8 strings.

       $January,  $February,  $March,  $April, $May, $June, $July, $August, $September, $October,
       $November, $December
              Set each of these system variables  to  a  string  representing  the  corresponding
              month's name in your language.  Strings must be valid UTF-8 strings.

       $Ago, $Am, $And, $At, $Hour, $Is, $Minute, $Now, $On, $Pm, $Was
              Set  each of these system variables to the translation of the corresponding English
              word into your language.  Note that $Am and $Pm should be the translations of  "AM"
              and "PM" (morning and afternoon time indicators) respectively.

       $Hplu, $Mplu
              Set  these  to  the  suffix to add to the word for "hour" and "minute" to make them
              plural.  In English, both would be set to "s".

       $Fromnow
              Set this to the translation of the English phrase "from now"

       Note that if you set any of the language-related system variables, they should be set in a
       section  of your script that always is evaluated.  If you set them inside an IF statement,
       for example, results are unpredictable.

       Note also that the Rem2PS back-end does not support the full range  of  UTF-8  characters.
       The TkRemind, rem2html and rem2pdf back-ends all do support the full UTF-8 range.

RUN-TIME MODIFICATION OF THE SUBSTITUTION FILTER

       The  system  variables  mentioned  in the previous section are not typically sufficient to
       properly translate Remind's output to another language.  Some languages  have  complicated
       rules  for  AM  vs PM times and others have complex rules for making words plural.  Remind
       therefore allows you to define a number of functions  that  modify  the  behavior  of  the
       substitution filter at run-time.  The functions are:

       subst_ampm(h)
              This  function  is passed a single integer, namely an hour from 0 to 23.  It should
              return a string that indicates "AM" or  "PM"  or  even  finer  gradations  in  some
              languages.

       subst_ordinal(d)
              This  function  is passed a single integer, namely a day of the month from 1 to 31.
              It should return a string that is suffixed to the day number to  turn  it  into  an
              ordinal  number.   In  English,  for example, the function might return "st", "nd",
              "rd" or "th", depending on d.

       subst_N(alt, date, time)
              This is actually a family of functions, where  N  is  a  letter  or  number.   This
              function  completely overrides the substitution sequence "%N".  The three arguments
              are  an  integer  alt  which,  if  non-zero,  indicates  that  the   alternate-mode
              substitution  sequence "%*N" was encountered; date which is the trigger date of the
              reminder and time which is the trigger time.

       subst_Nx(alt, date, time)
              Again, this is a family of functions.  It is similar to the subst_N  family  except
              it is only called if date is two or more days away from today().  This is useful if
              you don't want to override the "today" or "tomorrow" output for  most  substitution
              sequences.

       Here's  an  example of how you might customize your substitution filter.  Suppose you want
       to change the "%b" sequence to substitute "the day after tomorrow" for an event  two  days
       from now.  You could do this:

           FSET subst_bx(a,d,t) iif(d==today()+2, "the day after tomorrow", \
                                    "in " + (d-today()) + " days' time")
           REM [today()+3] ++3 MSG Event 1 is %b%
           REM [today()+2] ++3 MSG Event 2 is %b%
           REM [today()+1] ++3 MSG Event 3 is %b%
           REM [today()]   ++3 MSG Event 4 is %b%

       The output of this script is:

           Event 1 is in 3 days' time
           Event 2 is the day after tomorrow
           Event 3 is tomorrow
           Event 4 is today

       Note  how  Event  2's wording was changed from the normal "in 2 days' time", and note also
       that the "tomorrow" and "today" events used  the  normal  substitution---subst_bx  is  not
       called for trigger days of today or tomorrow.

       As  a  special  case, if a subst_Nx or subst_N function returns the integer zero, then the
       normal substitution mechanism is used.  Therefore, the previous example  could  have  been
       written more simply as:

           FSET subst_bx(a,d,t) iif(d==today()+2, "the day after tomorrow", 0)

       You  can  define  your  own  substitution  sequences  in  addition to the built-in ones as
       follows:  If you define a function named subst_name(alt, date, time),  then  the  sequence
       %{name}  calls  the  function  with alt set to 0 and date and time to the trigger date and
       time, respectively.  The %{name} sequence is replaced with whatever the function  returns.
       The sequence %*{name} is similar, but calls the function with alt set to 1.

       If  you  use  a  %{name} sequence and the function subst_name is not defined or returns an
       error, then %{name} is replaced with the empty string.

LANGUAGE PACKS

       Remind ships with a number of language packs, which are simply reminder scripts located in
       [$SysInclude]/lang.  The currently-shipping language packs are:

       da.rem  (Danish),  de.rem (German), es.rem (Spanish), fr.rem (French), is.rem (Icelandic),
       it.rem (Italian), nl.rem (Dutch), no.rem (Norwegian), pl.rem (Polish), pt.rem (Portuguese)
       and ro.rem (Romanian).

       To  use  a  language  pack (in this example, de.rem), simply place this at the top of your
       reminders file:

           INCLUDE [$SysInclude]/lang/de.rem

       If you want Remind to try to find the language pack appropriate for your locale  settings,
       use:

           INCLUDE [$SysInclude]/lang/auto.rem

       You  are  encouraged  to  study  the  language  packs  to see how to translate Remind into
       additional languages.

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  Remind's  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 remind's
       normal mode of operation.)

       The  various  SPECIALs recognized are particular for each backend; however, there are four
       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 [moondate(0)] SPECIAL MOON 0
            REM [moondate(1)] SPECIAL MOON 1
            REM [moondate(2)] SPECIAL MOON 2
            REM [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

       You can spell COLOR either the American way ("COLOR") or the British way ("COLOUR").  This
       manual will use the American way.

       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.  Also, if you  invoke  Remind  with  -@[n],
       then it approximates SPECIAL COLOR reminders on your terminal.

       See  also  the  documentation  of the $DefaultColor system variable in the section "SYSTEM
       VARIABLES".

       The WEEK special lets you place annotations such as the week number in the calendar.   For
       example,  this would number each Monday with the ISO 8601 week number.  The week number is
       shown like this: "(Wn)" in this example, but you can put whatever text you like after  the
       WEEK keyword.

            REM Monday SPECIAL WEEK (W[weekno()])

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 [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 [today()-7] ADDOMIT MSG Labour Day
            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.

       As a special case, you can simply use a negative number after SCANFROM; a negative  number
       -N  is  interpreted  as  N  days  before  today.  Thus, the previous example could also be
       written like this:

            REM Mon 1 Sept SCANFROM -7 ADDOMIT MSG Labour Day
            REM Mon AFTER MSG Hello

       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 [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

       Dianne Skoll <dianne@skoll.ca> 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 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.

       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.

HOME PAGE

       https://dianne.skoll.ca/projects/remind/

SEE ALSO

       rem(1), rem2ps(1), rem2pdf(1), tkremind(1), rem2html(1)