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".
OPTIONS
Remind has a slew of options. If you’re new to the program, ignore
them for now and skip to the section "Reminder Files".
-n The -n option causes Remind to print the next occurrence of each
reminder in a simple calendar format. You can sort this by date
by piping the output through sort(1).
-r The -r option disables RUN directives and the shell() function.
As of Remind 3.00.17, using -u implies -r.
-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.
’c’ causes Remind to use VT100 escape sequences to approximate
SPECIAL COLOR reminders. 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".
-wcol[,pad[,spc]]]
The -w option specifies the output width, padding and spacing of
the formatted calendar output. Col specifies the number of
columns in the output device, and defaults to 80. Pad specifies
how many lines to use to "pad" empty calendar boxes. This
defaults to 5. If you have many reminders on certain days that
make your calendar too large to fit on a page, you can try
reducing pad to make the empty boxes smaller. Spc specifies how
many blank lines to leave between the day number and the first
reminder entry. It defaults to 1.
Any of col, pad or spc can be omitted, providing you provide the
correct number of commas. Don’t use any spaces in the option.
-s[a]n The -s option is very similar to the -c option, except that the
output calendar is not formatted. It is listed in a "simple
format" that can be used as input for more sophisticated
calendar-drawing programs. If n starts with "+", then it is
interpreted as a number of weeks.
If you immediately follow the s with the letter a, then Remind
displays reminders on the calendar on the day they actually
occur as well as on any preceding days specified by the
reminder’s delta.
-p[a]n The -p option is very similar to the -s option, except that the
output contains additional information for use by the Rem2PS
program, which creates a PostScript calendar. For this option,
n cannot start with "+"; it must specify a number of months.
The format of the -p output is described in the rem2ps(1) man
page. If you immediately follow the p with the letter a, then
Remind displays reminders on the calendar on the day they
actually occur as well as on any preceding days specified by the
reminder’s delta.
-l If you use the -l option in conjunction with the -p option, then
Remind outputs additional information for back-end programs such
as rem2ps. This additional information lets the back-end
programs correlate a reminder with the source file and line
number that produced it.
-m The -m option causes the -c or -p options to produce a calendar
whose first column is Monday rather than Sunday. (This conforms
to the international standard.)
-v The -v option makes the output of Remind slightly more verbose.
Currently, this causes Remind to echo a bad line in case of an
error, and to print a security message if a script tests the
$RunOff system variable.
-o The -o option causes Remind to ignore all ONCE directives.
-t The -t option causes Remind to trigger all non-expired
reminders, regardless of the delta supplied for each reminder.
-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.
-h The -h option ("hush...") suppresses certain warning and
information messages. In particular, if no reminders are
triggered, this mode produces no output.
-a The -a option causes Remind not to immediately trigger timed
reminders that would also be queued. It also causes Remind not
to place timed reminders in a calendar.
-q The -q option causes Remind not to queue timed reminders for
later execution.
-f The -f option causes Remind to remain in the foreground when
processing queued reminders, rather than forking off a
background process to handle them.
-e The -e option diverts error messages (normally sent to the
standard error stream) to the standard output stream.
-dchars
The -d option enables certain debugging modes. The chars
specify which modes to enable:
e Echo all input lines
x Trace all expression evaluation
t Display all trigger date computation
v Dump the variable table after execution of the reminder script
l Echo lines when displaying error messages
f Trace the reading of reminder files
-g[a|d[a|d[a|d]]]
Normally, reminders are issued in the order in which they are
encountered in the reminder script. The -g option cause Remind
to sort reminders by date and time prior to issuing them. The
optional a and d characters specify the sort order (ascending or
descending) for the date, time and priority fields. See the
section "Sorting Reminders" for more information.
-b[n] Set the time format for the calendar and simple-calendar
outputs. N can range from 0 to 2, with the default 0. A value
of 0 causes times to be inserted in 12-hour (am/pm) format. 1
causes times to be inserted in 24-hour format, and 2 inhibits
the automatic insertion of times in the calendar output.
-x[n] Sets the iteration limit for the SATISFY clause of a REM
command. Defaults to 150.
-kcmd Instead of simply printing MSG-type reminders, this causes them
to be passed to the specific cmd. You must use ’%s’ where you
want the body to appear, and may need to enclose this option in
quotes. Note that all shell characters in the body of the
reminder are escaped with a backslash, and the entire body of
the reminder is passed as a single argument. Note that this
option overrides the -r option and the RUN OFF command.
As an example, suppose you have an X Window program called
xmessage that pops up a window and displays its invocation
arguments. You could use:
remind ’-kxmessage %s &’ ...
to have all of your MSG-type reminders processed using xmessage.
A word of warning: It is very easy to spawn dozens of xmessage
processes with the above technique. So be very careful. Also,
the cmd is passed as an argument to sprintf(). If you use
formatting directives other than %s, or use more than one %s
directive, there’s a good chance that you’ll crash Remind.
Finally, because all shell and whitespace characters are
escaped, the program you execute with the -k option must be
prepared to handle the entire message as a single argument.
-z[n] Runs Remind in the daemon mode. If n is supplied, it specifies
how often (in minutes) Remind should wake up to check if the
reminder script has been changed. N defaults to 5, and can
range from 5 to 60. Note that the use of the -z option also
enables the -f option.
If you supply the option -z0, Remind runs in a special mode
called server mode. This is documented in the tkremind man
page; see tkremind(1).
-uname Runs Remind with the uid and gid of the user specified by name.
The option changes the uid and gid as described, and sets the
environment variables HOME, SHELL and USER to the home
directory, shell, and user name, respectively, of the specified
user. LOGNAME is also set to the specified user name. This
option is meant for use in shell scripts that mail reminders to
all users. Note that as of Remind 3.00.17, using -u implies -r
-- the RUN directive and shell() functions are disabled.
Non-root users can also use the -u option. However, in this
case, it only changes the environment variables as described
above. It does not change the effective uid or gid.
-y Causes Remind to synthesize a tag for any reminder that lacks a
TAG clause.
-ivar=expr
Sets the value of the specified var to expr, and preserves var.
Expr can be any valid Remind expression. See the section
"Initializing Variables on the Command Line" for more details.
-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 (in 24-hour format -- for example, 17:15) to set Remind’s notion
of "now" to a particular time. Supplying a time on the command line
also implicitly enables the -q option and disables the -z option.
In addition, you can supply a repeat parameter, which has the form
*num. This causes Remind to be run num times, with the date
incrementing on each iteration. You may have to enclose the parameter
in quotes to avoid shell expansion. See the subsection "Repeated
Execution" in the section "Calendar Mode" for more information.
REMINDER FILES
Remind uses scripts to control its operation. You can use any text
editor capable of creating plain ASCII files to create a Remind script.
The commands inside a script can range from the very simple and almost
immediately understandable:
REM 6 Jan MSG David’s birthday
to the baroque and obscure:
REM [trigger(date(thisyear, 1, 1) + 180)] ++5 OMIT \
sat sun BEFORE MSG [ord(thisyear-1980)] payment due %b!
A reminder file consists of commands, with one command per line.
Several lines can be continued using the backslash character, as in the
above example. In this case, all of the concatenated lines are treated
as a single line by Remind. Note that if an error occurs, Remind
reports the line number of the last line of a continued line.
Remind ignores blank lines, and lines beginning with the ’#’ or ’;’
characters. You can use the semicolon as a comment character if you
wish to pass a Remind script through the C pre-processor, which
interprets the ’#’ character as the start of a pre-processing
directive.
Remind is not case sensitive; you can generally use any mixture of
upper- or lower-case for commands, parameters, invocation options, etc.
THE REM COMMAND
The most powerful command in a Remind script is the REM command. This
command is responsible for issuing reminders. Its syntax is:
REM [ONCE] [date_spec] [back] [delta] [repeat] [PRIORITY prio]
[SKIP | BEFORE | AFTER] [OMIT omit_list] [AT time [tdelta]
[trepeat]] [SCHED sched_function] [WARN warn_function] [UNTIL
expiry_date] [SCANFROM scan_date | FROM start_date] [DURATION
duration] [TAG tag] <MSG | MSF | RUN | CAL | SATISFY | SPECIAL
special | PS | PSFILE> body
The parts of the REM command can be specified in any order, except that
the body must come immediately after the MSG, RUN, CAL, PS, PSFILE or
SATISFY keyword.
The REM token is optional, providing that the remainder of the command
cannot be mistaken for another Remind command such as OMIT or RUN. The
portion of the REM command before the MSG, MSF RUN, CAL or SATISFY
clause is called a trigger.
MSG, MSF, RUN, CAL, SPECIAL, PS and PSFILE
These keywords denote the type of the reminder. (SATISFY is more
complicated and will be explained later.) A MSG-type reminder normally
prints a message to the standard output, after passing the body through
a special substitution filter, described in the section "The
Substitution Filter." However, if you have used the -k command-line
option, then MSG-type reminders are passed to the appropriate program.
Note that the options -c, -s, -p and -n disable the -k option.
Note that you can omit the reminder type, in which case it defaults to
MSG. So you can write:
6 January David’s Birthday
although this is not recommended.
The MSF keyword is almost the same as the MSG keyword, except that the
reminder is formatted to fit into a paragraph-like format. Three
system variables control the formatting of MSF-type reminders - they
are $FirstIndent, $SubsIndent and $FormWidth. They are discussed in
the section "System Variables." The MSF keyword causes the spacing of
your reminder to be altered - extra spaces are discarded, and two
spaces are placed after periods and other characters, as specified by
the system variables $EndSent and $EndSentIg. Note that if the body of
the reminder includes newline characters (placed there with the %_
sequence), then the newlines are treated as the beginnings of new
paragraphs, and the $FirstIndent indentation is used for the next line.
You can use two consecutive newlines to have spaced paragraphs emitted
from a single reminder body.
A RUN-type reminder also passes the body through the substitution
filter, but then executes the result as a system command. A CAL-type
reminder is used only to place entries in the calendar produced when
Remind is run with the -c, -s or -p options.
A PS or PSFILE-type reminder is used to pass PostScript code directly
to the printer when producing PostScript calendars. This can be used
to shade certain calendar entries (see the psshade() function), include
graphics in the calendar, or almost any other purpose you can think of.
You should not use these types of reminders unless you are an expert
PostScript programmer. The PS and PSFILE reminders are ignored unless
Remind is run with the -p option. See the section "More about
PostScript" for more details.
A SPECIAL-type reminder is used to pass "out-of-band" information from
Remind to a calendar-producing back-end. It should be followed by a
word indicating the type of special data being passed. The type of a
special reminder depends on the back-end. For the Rem2PS back-end,
SPECIAL PostScript is equivalent to a PS-type reminder, and SPECIAL
PSFile is equivalent to a PSFILE-type reminder. The body of a SPECIAL
reminder is obviously dependent upon the back-end.
DATE SPECIFICATIONS
A date_spec consists of zero to four parts. These parts are day (day
of month), month (month name), year and weekday. Month and weekday are
the English names of months and weekdays. At least the first three
characters must be used. The following are examples of the various
parts of a date_spec:
day: 1, 22, 31, 14, 3
month: JANUARY, feb, March, ApR, may, Aug
year: 1990, 1993, 2030, 95 (interpreted as 1995). The year can range
from 1990 to 2075.
weekday:
Monday, tue, Wed, THU, Friday, saturday, sundAy
Note that there can be several weekday components separated by spaces
in a date_spec.
INTERPRETATION OF DATE SPECIFICATIONS
The following examples show how date specifications are interpreted.
1. Null date specification - the reminder is triggered every day. The
trigger date for a specific run is simply the current system date.
2. Only day present. The reminder is triggered on the specified day of
each month. The trigger date for a particular run is the closest such
day to the current system date. For example:
REM 1 MSG First of every month.
REM 31 MSG 31st of every month that has 31 days.
3. Only month present. The reminder is triggered every day of the
specified month. Example:
REM Feb MSG Every day in February
4. day and month present. Examples:
REM 6 Jan MSG Every 6th of January
REM Feb 29 MSG Every 29th of February
5. Only year present. Example:
REM 1991 MSG Every day in 1991
6. year and day present. Examples:
REM 1 1990 MSG 1st of every month in 1990
REM 1992 23 MSG 23rd of every month in 1992
7. year and month present. Examples:
REM Feb 1991 MSG Every day in Feb 1991
REM 1992 September MSG Every day in Sept 1992
8. year, month and day present. Examples:
REM 8 Jan 1991 MSG 8th January 1991.
REM 1992 March 9 MSG 9th March 1992.
9. weekday only. Examples:
REM Sat MSG Every Saturday
REM Mon Tue Wed Thu Fri MSG Every working day
REM Monday Wednesday MSG Every Monday and Wednesday
10. weekday and day present. Examples:
REM Sat 1 MSG First Saturday of every month
REM Mon Tue Wed Thu Fri 15 \
MSG 1st working day after 15th of every month
11. weekday and month present. Examples:
REM Mon March MSG Every Monday in March
REM Mon Tue Wed Thu Fri Feb MSG Every working day in February
12. weekday, month and day present. Examples:
REM Mon 1 March MSG First Monday in March
REM Sat Sun 15 July MSG First Sat or Sun on or after 15 July
13. weekday and year present. Example:
REM Sat Sun 1991 MSG Every Saturday and Sunday in 1991
14. weekday, day and year present. Examples:
REM Mon 15 1990 MSG 1st Mon after 15th of every month in 1990
REM Mon Tue Wed Thu Fri 1 1990 \
MSG 1st working day of every month in 1990
15. weekday, month and year present. Example:
REM Mon Wed 1991 Feb MSG Every Mon and Wed in Feb 1991.
16. weekday, day, month and year present. Example:
REM Mon Tue Wed Thu Fri 28 Oct 1990 \
MSG 1st working day on or after 28 October 1990.
Note that when both weekday and day are specified, Remind chooses the
first date on or after the specified day that also satisfies the
weekday constraint. It does this by picking the first date on or after
the specified day that is listed in the list of weekdays. Thus, a
reminder like:
REM Mon Tue 28 Oct 1990 MSG Hi
would be issued only on Monday, 29 October, 1990. It would not be
issued on Tuesday, 30 October, 1990, since the 29th is the first date
to satisfy the weekday constraints.
BACKWARD SCANNING
Sometimes, it is necessary to specify a date as being a set amount of
time before another date. For example, the last Monday in a given
month is computed as the first Monday in the next month, minus 7 days.
The back specification in the reminder is used in this case:
REM Mon 1 -7 MSG Last Monday of every month.
A back is specified with one or two dashes followed by an integer.
This causes Remind to move "backwards" from what would normally be the
trigger date. The difference between --7 and -7 will be explained when
the OMIT keyword is described.
ADVANCE WARNING
For some reminders, it is appropriate to receive advance warning of the
event. For example, you may wish to be reminded of someone’s birthday
several days in advance. The delta portion of the REM command achieves
this. It is specified as one or two "+" signs followed by a number n.
Again, the difference between the "+" and "++" forms will be explained
under the OMIT keyword. Remind will trigger the reminder on computed
trigger date, as well as on each of the n days before the event. Here
are some examples:
REM 6 Jan +5 MSG Remind me of birthday 5 days in advance.
The above example would be triggered every 6th of January, as well as
the 1st through 5th of January.
PERIODIC REMINDERS
We have already seen some built-in mechanisms for certain types of
periodic reminders. For example, an event occurring every Wednesday
could be specified as:
REM Wed MSG Event!
However, events that do not repeat daily, weekly, monthly or yearly
require another approach. The repeat component of the REM command
fills this need. To use it, you must completely specify a date (year,
month and day, and optionally weekday.) The repeat component is an
asterisk followed by a number specifying the repetition period in days.
For example, suppose you get paid every second Wednesday, and your last
payday was Wednesday, 28 October, 1992. You can use:
REM 28 Oct 1992 *14 MSG Payday
This issues the reminder every 14 days, starting from the calculated
trigger date. You can use delta and back with repeat. Note, however,
that the back is used only to compute the initial trigger date;
thereafter, the reminder repeats with the specified period. Similarly,
if you specify a weekday, it is used only to calculate the initial
date, and does not affect the repetition period.
SCANFROM and FROM
The SCANFROM and FROM keywords are for advanced Remind programmers
only, and will be explained in the section "Details about Trigger
Computation" near the end of this manual. Note that SCANFROM is
available only in versions of Remind from 03.00.04 up. FROM is
available only from 03.01.00 and later.
PRIORITY
The PRIORITY keyword must be followed by a number from 0 to 9999. It
is used in calendar mode and when sorting reminders. If two reminders
have the same trigger date and time, then they are sorted by priority.
If the PRIORITY keyword is not supplied, a default priority of 5000 is
used. (This default can be changed by adjusting the system variable
$DefaultPrio. See the section "System Variables" for more
information.)
EXPIRY DATES
Some reminders should be issued periodically for a certain time, but
then expire. For example, suppose you have a class every Friday, and
that your last class is on 11 December 1992. You can use:
REM Fri UNTIL 11 Dec 1992 MSG Class today.
Another example: Suppose you have jury duty from 30 November 1992
until 4 December 1992. The following reminder will issue the message
every day of your jury duty, as well as 2 days ahead of time:
REM 30 Nov 1992 *1 +2 UNTIL 4 Dec 1992 MSG Jury duty
Note that the repeat of *1 is necessary; without it, the reminder would
be issued only on 30 November (and the two days preceding.)
THE ONCE KEYWORD
Sometimes, it is necessary to ensure that reminders are run only once
on a given day. For example, if you have a reminder that makes a
backup of your files every Friday:
REM Fri RUN do_backup
(Here, do_backup is assumed to be a program or shell script that does
the work.) If you run Remind from your .login script, for example, and
log in several times per day, the do_backup program will be run each
time you log in. If, however, you use the ONCE keyword in the
reminder, the Remind checks the last access date of the reminder
script. If it is the same as the current date, Remind assumes that it
has already been run, and will not issue reminders containing the ONCE
keyword.
Note that if you view or edit your reminder script, the last access
date will be updated, and the ONCE keyword will not operate properly.
If you start Remind with the -o option, then the ONCE keyword will be
ignored.
LOCALLY OMITTING WEEKDAYS
The OMIT portion of the REM command is used to "omit" certain days when
counting the delta or back. It is specified using the keyword OMIT
followed by a list of weekdays. Its action is best illustrated with
examples:
REM 1 +1 OMIT Sat Sun MSG Important Event
This reminder is normally triggered on the first of every month, as
well as the day preceding it. However, if the first of the month falls
on a Sunday or Monday, then the reminder is triggered starting from the
previous Friday. This is because the delta of +1 does not count
Saturday or Sunday when it counts backwards from the trigger date to
determine how much advance warning to give.
Contrast this with the use of "++1" in the above command. In this
case, the reminder is triggered on the first of each month, as well as
the day preceding it. The omitted days are counted.
REM 1 -1 OMIT Sat Sun MSG Last working day of month
Again, in the above example, the back of -1 normally causes the trigger
date to be the last day of the month. However, because of the OMIT
clause, if the first of the month falls on a Sunday or Monday, the
trigger date is moved backwards past the weekend to Friday. (If you
have globally omitted holidays, the reminder will be moved back past
them, also. See "The OMIT command" for more details.)
By comparison, if we had used "--1", the reminder would be triggered on
the last day of the month, regardless of the OMIT.
TIMED REMINDERS
Timed reminders are those that have an AT keyword followed by a time
and optional tdelta and trepeat. The time must be specified in 24-hour
format, with 0:00 representing midnight, 12:00 representing noon, and
23:59 representing one minute to midnight. You can use either a colon
or a period to separate the hours from the minutes. That is, 13:39 and
13.39 are equivalent.
Remind treats timed reminders specially. If the trigger date for a
timed reminder is the same as the current system date, the reminder is
queued for later activation. When Remind has finished processing the
reminder file, it puts itself in the background, and activates timed
reminders when the system time reached the specified time.
If the trigger date is not the same as the system date, the reminder is
not queued.
For example, the following reminder, triggered every working day, will
emit a message telling you to leave at 5:00pm:
REM Mon Tue Wed Thu Fri AT 17:00 MSG Time to leave!
The following reminder will be triggered on Thursdays and Fridays, but
will only be queued on Fridays:
REM Fri ++1 AT 13:00 MSG Lunch at 1pm Friday.
The tdelta and trepeat have the same form as a repeat and delta, but
are specified in minutes. For example, this reminder will be triggered
at 12:00pm as well as 45 minutes before:
REM AT 12:00 +45 MSG Example
The following will be issued starting at 10:45, every half hour until
11:45, and again at noon.
REM AT 12:00 +75 *30 MSG Example2
The "+75" means that the reminder is issued starting 75 minutes before
noon; in other words, at 10:45. The *30 specifies that the reminder is
subsequently to be issued every 30 minutes. Note that the reminder is
always issued at the specified time, even if the tdelta is not a
multiple of the trepeat. So the above example is issued at 10:45am,
11:15am, 11:45am, and 12:00pm. Note that in the time specification,
there is no distinction between the "+" and "++" forms of tdelta.
Normally, Remind will issue timed reminders as it processes the
reminder script, as well as queuing them for later. If you do not want
Remind to issue the reminders when processing the script, but only to
queue them for later, use the -a command-line option. If you do not
want reminders to be queued for later, use the -q command-line option.
Normally, Remind forks a background process to handle queued reminders.
If you want Remind to remain in the foreground, use the -f command-line
option. This is useful, for example, in .xinitrc scripts, where you
can use the command:
remind -fa myreminders &
This ensures that when you exit X-Windows, the Remind process is
killed.
WARNING ABOUT TIMED REMINDERS
Note: If you use user-defined functions or variables (described later)
in the bodies of timed reminders, then when the timed reminders are
activated, the variables and functions have the definitions that were
in effect at the end of the reminder script. These definitions may not
necessarily be those that were in effect at the time the reminder was
queued.
THE SCHED AND WARN KEYWORDS
The SCHED keyword allows more precise control over the triggering of
timed reminders, and the WARN keyword allows precise control over the
advance triggering of all types of reminders. However, discussion must
be deferred until after expressions and user-defined functions are
explained. See the subsection "Precise Scheduling" further on.
TAG AND DURATION
The TAG keyword lets you "tag" certain reminders. This facility is
used by certain back-ends or systems built around Remind, such as
TkRemind. These back-ends have specific rules about tags; you should
not use the TAG keyword yourself, or your script will interact badly
with back-ends.
The TAG keyword is followed by a tag consisting of up to 48 characters.
If you supply the -y option to Remind, then any reminder that lacks a
TAG will have one synthesized. The synthesized tag consists of the
characters "__syn__" followed by the hexadecimal representation of the
MD5 sum of the REM command line. This lets you give a more-or-less
unique identifier to each distinct REM command.
The DURATION keyword makes sense only for timed reminders; it specifies
the duration of an event. Currently, this is not used, but it may be
used in future by back-ends or scheduling systems built around Remind.
For example, if you have a 90-minute meeting starting at 1:00pm, you
could use:
REM 5 March 1999 AT 13:00 DURATION 1:30 MSG Meeting
Note that duration is specified in hours and minutes.
THE SUBSTITUTION FILTER
Before being processed, the body of a REM command is passed through a
substitution filter. The filter scans for sequences "%x" (where "x" is
any letter and certain other characters) and performs substitutions as
shown below. (All dates refer to the trigger date of the reminder.)
%a is replaced with "on weekday, day month, year"
For example, consider the reminder:
REM 18 Oct 1990 +4 MSG Meeting with Bob %a.
On 16 October 1990, it would print "Meeting with Bob on
Thursday, 18 October, 1990."
On 17 October 1990, it would print "Meeting with Bob tomorrow."
On 18 October 1990, it would print "Meeting with Bob today."
%b is replaced with "in diff day’s time" where diff is the actual
number of days between the current date and the trigger date.
(OMITs have no effect.)
For example, consider:
REM 18 Oct 1990 +4 MSG Meeting with Bob %b.
On 16 October 1990, it would print "Meeting with Bob in 2 days’
time."
On 17 October 1990, it would print "Meeting with Bob tomorrow."
On 18 October 1990, it would print "Meeting with Bob today."
%c is replaced with "on weekday"
Example: REM 18 Oct 1990 +4 MSG Meeting with Bob %c.
On 16 October 1990, it would print "Meeting with Bob on
Thursday."
On 17 October 1990, it would print "Meeting with Bob tomorrow."
On 18 October 1990, it would print "Meeting with Bob today."
%d is replaced with "day", the day of the month.
%e is replaced with "on dd-mm-yyyy"
%f is replaced with "on mm-dd-yyyy"
%g is replaced with "on weekday, day month"
%h is replaced with "on dd-mm"
%i is replaced with "on mm-dd"
%j is replaced with "on weekday, month day-th, year" This form
appends the characters "st", "nd", "rd" or "th" to the day of
the month, as appropriate.
%k is replaced with "on weekday, month day-th"
%l is replaced with "on yyyy-mm-dd"
%m is replaced with "month", the name of the month.
%n is replaced with the number (1 to 12) of the month.
%o is replaced with " (today)" if and only if the current system
date is the same as the date being used by Remind as the current
date. Recall that you can specify a date for Remind to use on
the command line. This substitution is not generally useful in
a REM command, but is useful in a BANNER command. (See "The
BANNER Command.")
%p is replaced with "s" if the diff between the current date and
the trigger date is not 1. You can use this to construct
reminders like:
REM 1 Jan +4 MSG %x day%p to go before New Year!
%q is replaced with "’s" if the diff between the trigger date and
the current date is 1. Otherwise, it is replaced with "s’"
This can be used as follows:
REM 1 Jan +4 MSG New Year in %x day%q time!
%r is replaced with the day of the month (01 to 31) padded with a
leading zero if needed to pad to two digits.
%s is replaced with "st", "nd", "rd" or "th" depending on the day
of the month.
%t is replaced with the number of the month (01 to 12) padded to
two digits with a leading zero.
%u is replaced with "on weekday, day-th month, year" This is
similar to %a except that "st", "nd", "rd" or "th" is added to
the day as appropriate.
%v is replaced with "on weekday, day-th month"
%w is replaced with "weekday", the name of the day of the week.
%x is replaced with the diff between the current date and the
trigger date. The diff is defined as the actual number of days
between these two dates; OMITs are not counted. (Strict date
subtraction is performed.)
%y is replaced with "year", the year of the trigger date.
%z is replaced with "yy", the last two digits of the year.
%_ (percent-underscore) is replaced with a newline. You can use
this to achieve multi-line reminders.
%1 is replaced with "now", "m minutes from now", "m minutes ago",
"h hours from now", "h hours ago", "h hours and m minutes from
now" or "h hours and m minutes ago", as appropriate for a timed
reminder. Note that unless you specify the -a option, timed
reminders will be triggered like normal reminders, and thus a
timed reminder that occurred earlier in the day may be
triggered. This causes the need for the "...ago" forms.
%2 is replaced with "at hh:mmam" or "..pm" depending on the AT time
of the reminder.
%3 is replaced with "at hh:mm" in 24-hour format.
%4 is replaced with "mm" where mm is the number of minutes between
"now" and the time specified by AT. If the AT time is earlier
than the current time, then the result is negative.
%5 is replaced with "ma" where ma is the absolute value of the
number produced by %4.
%6 is replaced with "ago" or "from now", depending on the
relationship between the AT time and the current time.
%7 is replaced with the number of hours between the AT time and the
current time. It is always non-negative.
%8 is replaced with the number of minutes between the AT time and
the current time, after the hours (%7) have been subtracted out.
This is a number ranging from 0 to 59.
%9 is replaced with "s" if the value produced by %8 is not 1.
%0 is replaced with "s" if the value produced by %7 is not 1.
%! is replaced with "is" if the current time is before the AT time,
or "was" if it is after.
%@ is similar to %2 but displays the current time.
%# is similar to %3 but displays the current time.
%" (percent-doublequote - ") is removed. This sequence is not used
by the substitution filter, but is used to tell Remind which
text to include in a calendar entry when the -c, -s or -p option
is chosen. See "Calendar Mode"
Notes:
o Remind normally prints a blank line after each reminder; if the
last character of the body is "%", the blank line will not be
printed.
o Substitutions a, b, c, e, f, g, h, i, j, k, l, u and v all are
replaced with "today" if the current date equals the trigger
date, or "tomorrow" if the trigger date is one day after the
current date. Thus, they are not the same as substitutions
built up from the simpler %w, %y, etc. sequences.
o Any of the substitutions dealing with time (0 through 9 and ’!’)
produce undefined results if used in a reminder that does not
have an AT keyword. Also, if a reminder has a delta and may be
triggered on several days, the time substitutions ignore the
date. Thus, the %1 substitution may report that a meeting is in
15 minutes, for example, even though it may only be in 2 days
time, because a delta has triggered the reminder. It is
recommended that you use the time substitutions only in timed
reminders with no delta that are designed to be queued for timed
activation.
o Capital letters can be used in the substitution sequence, in
which case the first character of the substituted string is
capitalized (if it is normally a lower-case letter.)
o All other characters following a "%" sign are simply copied. In
particular, to get a "%" sign out, use "%%" in the body. To
start the body of a reminder with a space, use "% ", since
Remind normally scans for the first non-space character after a
MSG, CAL or RUN token.
THE OMIT COMMAND
In addition to being a keyword in the REM command, OMIT is a command in
its own right. Its syntax is:
OMIT day month [year]
The OMIT command is used to "globally" omit certain days (usually
holidays). These globally-omitted days are skipped by the "-" and "+"
forms of back and delta. Some examples:
OMIT 1 Jan
OMIT 7 Sep 1992
The first example specifies a holiday that occurs on the same date each
year - New Year’s Day. The second example specifies a holiday that
changes each year - Labour Day. For these types of holidays, you must
create an OMIT command for each year. (Later, in the description of
expressions and some of the more advanced features of Remind, you will
see how to automate this for some cases.)
For convenience, you can use a delta and MSG or RUN keyword in the OMIT
command. The following sequences are exactly equivalent:
OMIT 1 Jan
REM 1 Jan +4 MSG New year’s day is %b!
and
OMIT 1 Jan +4 MSG New year’s day is %b!
THE BEFORE, AFTER AND SKIP KEYWORDS
Normally, days that are omitted, whether by a global OMIT command or
the local OMIT keyword in a REM statement, only affect the counting of
the -back or the +delta. For example, suppose you have a meeting every
Wednesday. Suppose, too, that you have indicated 11 Nov as a holiday:
OMIT 11 Nov +4 MSG Remembrance Day
REM Wed +1 MSG Code meeting %b.
The above sequence will issue a reminder about a meeting for 11
November 1992, which is a Wednesday. This is probably incorrect.
There are three options:
BEFORE This keyword moves the reminder to before any omitted days.
Thus, in the above example, use of BEFORE would cause the
meeting reminder to be triggered on Tuesday, 10 November 1992.
AFTER This keyword moves the reminder to after any omitted days. In
the above example, the meeting reminder would be triggered on
Thursday, 12 November 1992.
SKIP This keyword causes the reminder to be skipped completely on any
omitted days. Thus, in the above example, the reminder would
not be triggered on 11 November 1992. However, it would be
triggered as usual on the following Wednesday, 18 November 1992.
The BEFORE and AFTER keywords move the trigger date of a reminder to
before or after a block of omitted days, respectively. Suppose you
normally run a backup on the first day of the month. However, if the
first day of the month is a weekend or holiday, you run the backup on
the first working day following the weekend or holiday. You could use:
REM 1 OMIT Sat Sun AFTER RUN do_backup
Let’s examine how the trigger date is computed. The 1 specifies the
first day of the month. The local OMIT keyword causes the AFTER
keyword to move the reminder forward past weekends. Finally, the AFTER
keyword will keep moving the reminder forward until it has passed any
holidays specified with global OMIT commands.
THE INCLUDE COMMAND
Remind allows you to include other files in your reminder script,
similar to the C preprocessor #include directive. For example, your
system administrator may maintain a file of holidays or system-wide
reminders. You can include these in your reminder script as follows:
INCLUDE /usr/share/remind/holidays
INCLUDE /usr/share/remind/reminders
(The actual pathnames vary from system to system - ask your system
administrator.)
INCLUDE files can be nested up to a depth of 8.
If you specify a filename of "-" in the INCLUDE command, Remind will
begin reading from standard input.
If you specify a directory as the argument to INCLDUE, 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".
THE RUN COMMAND
If you include other files in your reminder script, you may not always
entirely trust the contents of the other files. For example, they may
contain RUN-type reminders that could be used to access your files or
perform undesired actions. The RUN command can restrict this: If you
include the command RUN OFF in your top-level reminder script, any
reminder or expression that would normally execute a system command is
disabled. RUN ON will re-enable the execution of system commands.
Note that the RUN ON command can only be used in your top-level
reminder script; it will not work in any files accessed by the INCLUDE
command. This is to protect you from someone placing a RUN ON command
in an included file. However, the RUN OFF command can be used at top
level or in an included file.
If you run Remind with the -r command-line option, RUN-type reminders
and the shell() function will be disabled, regardless of any RUN
commands in the reminder script. However, any command supplied with
the -k option will still be executed.
One use of the RUN command is to provide a secure interface between
Remind and the Elm mail system. The Elm system can automatically scan
incoming mail for reminder or calendar entries, and place them in your
calendar file. To use this feature, you should set the calendar
filename option under Elm to be something like "~/.reminders.in", not
your main reminder file! This is so that any RUN ON commands mailed to
you can never be activated.
Then, you can use the Elm scan message for calendar entries command to
place reminders prefaced by "->" into .reminders.in. In your main
.reminders file, include the following lines:
RUN OFF # Disable RUN
INCLUDE .reminders.in
RUN ON # Re-enable RUN
In addition, Remind contains a few other security features. It will
not read a file that is group- or world-writable. It will not run set-
uid. If it reads a file you don’t own, it will disable RUN and the
shell() function. And if it is run as root, it will only read files
owned by root.
THE BANNER COMMAND
When Remind first issues a reminder, it prints a message like this:
Reminders for Friday, 30th October, 1992 (today):
(The banner is not printed if any of the calendar-producing options is
used, or if the -k option is used.)
The BANNER command lets you change the format. It should appear before
any REM commands. The format is:
BANNER format
The format is similar to the body of a REM command. It is passed
through the substitution filter, with an implicit trigger of the
current system date. Thus, the default banner is equivalent to:
BANNER Reminders for %w, %d%s %m, %y%o:
You can disable the banner completely with BANNER %. Or you can create
a custom banner:
BANNER Hi - here are your reminders for %y-%t-%r:
CONTROLLING THE OMIT CONTEXT
Sometimes, it is necessary to temporarily change the global OMITs that
are in force for a few reminders. Three commands allow you to do this:
PUSH-OMIT-CONTEXT
This command saves the current global OMITs on an internal
stack.
CLEAR-OMIT-CONTEXT
This command clears all of the global OMITs, starting you off
with a "clean slate."
POP-OMIT-CONTEXT
This command restores the global OMITs that were saved by the
most recent PUSH-OMIT-CONTEXT.
For example, suppose you have a block of reminders that require a clear
OMIT context, and that they also introduce unwanted global OMITs that
could interfere with later reminders. You could use the following
fragment:
PUSH-OMIT-CONTEXT # Save the current context
CLEAR-OMIT-CONTEXT # Clean the slate
# Block of reminders goes here
POP-OMIT-CONTEXT # Restore the saved omit context
EXPRESSIONS
In certain contexts, to be described later, Remind will accept
expressions for evaluation. Remind expressions resemble C expressions,
but operate on different types of objects.
DATA TYPES
Remind expressions operate on five types of objects:
INT The INT data type consists of the integers representable in one
machine word. The INT data type corresponds to the C "int"
type.
STRING The STRING data type consists of strings of characters. It is
somewhat comparable to a C character array, but more closely
resembles the string type in BASIC.
TIME The TIME data type consists of times of the day. The TIME data
type is internally stored as an integer representing the number
of minutes since midnight.
DATE The DATE data type consists of dates (later than 1 January
1990.) Internally, DATE objects are stored as the number of
days since 1 January 1990.
DATETIME
The DATETIME data type consists of a date and time together.
Internally, DATETIME objects are stored as the number of minutes
since midnight, 1 January 1990. You can think of a DATETIME
object as being the combination of DATE and TIME parts.
CONSTANTS
The following examples illustrate constants in Remind expressions:
INT constants
12, 36, -10, 0, 1209
STRING constants
"Hello there", "This is a test", "\n\gosd\w", ""
Note that the empty string is represented by "", and that
backslashes in a string are not interpreted specially, as in
they are in C.
TIME constants
12:33, 0:01, 14:15, 16:42, 12.16, 13.00, 1.11
Note that TIME constants are written in 24-hour format. Either
the period or colon can be used to separate the minutes from the
hours. However, Remind will consistently output times using
only one separator character. (The output separator character
is chosen at compile-time.)
DATE constants
DATE constants are expressed as ’yyyy/mm/dd’ or ’yyyy-mm-dd’,
and the single quotes must be supplied. This distinguishes date
constants from division or subtraction of integers. Examples:
´1993/02/22’, ’1992-12-25’, ’1999/01/01’
Note that DATE values are printed without the quotes. Although
either ’-’ or ’/’ is accepted as a date separator on input, when
dates are printed, only one will be used. The choice of whether
to use ’-’ or ’/’ is made at compile-time. Note also that
versions of Remind prior to 03.00.01 did not support date
constants. In those versions, you must create dates using the
date() function. Also, versions prior to 03.00.02 did not
support the ’-’ date separator.
DATETIME constants
DATETIME constants are expressed similarly to DATE constants
with the addition of an "@HH:MM" part. For example:
´2008-04-05@23:11’, ’1999/02/03@14:06’, ’2001-04-07@08:30’
DATETIME values are printed without the quotes. Notes about
date and time separator characters for DATE and TIME constants
apply also to DATETIME constants.
OPERATORS
Remind has the following operators. Operators on the same line have
equal precedence, while operators on lower lines have lower precedence
than those on higher lines. The operators approximately correspond to
C operators.
! - (unary logical negation and arithmetic negation)
* / %
+ -
< <= > >=
== !=
&&
||
DESCRIPTION OF OPERATORS
! Logical negation. Can be applied to an INT type. If the
operand is non-zero, returns zero. Otherwise, returns 1.
- Unary minus. Can be applied to an INT. Returns the negative of
the operand.
* Multiplication. Returns the product of two INTs.
/ Integer division. Returns the quotient of two INTs, discarding
the remainder.
% Modulus. Returns the remainder upon dividing one INT by
another.
+ Has several uses. These are:
INT + INT - returns the sum of two INTs.
INT + TIME or TIME + INT - returns a TIME obtained by adding INT
minutes to the original TIME.
INT + DATE or DATE + INT - returns a DATE obtained by adding INT
days to the original DATE.
INT + DATETIME or DATETIME + INT - returns a DATETIME obtained
by adding INT minutes to the original DATETIME.
STRING + STRING - returns a STRING that is the concatenation of
the two original STRINGs.
STRING + anything or anything + STRING - converts the non-STRING
argument to a STRING, and then performs concatenation. See the
coerce() function.
- Has several uses. These are:
INT - INT - returns the difference of two INTs.
DATE - DATE - returns (as an INT) the difference in days between
two DATEs.
TIME - TIME - returns (as an INT) the difference in minutes
between two TIMEs.
DATETIME - DATETIME - returns (as an INT) the difference in
minutes between two DATETIMEs.
DATE - INT - returns a DATE that is INT days earlier than the
original DATE.
TIME - INT - returns a TIME that is INT minutes earlier than the
original TIME.
DATETIME - INT - returns a DATETIME that is INT minutes earlier
than the original DATETIME.
<, <=, >, and >=
These are the comparison operators. They can take operands of
any type, but both operands must be of the same type. The
comparison operators return 1 if the comparison is true, or 0 if
it is false. Note that string comparison is done following the
lexical ordering of characters on your system, and that upper
and lower case are distinct for these operators.
==, != == tests for equality, returning 1 if its operands are equal,
and 0 if they are not. != tests for inequality.
If the operands are not of the same type, == returns 0 and !=
returns 1. Again, string comparisons are case-sensitive.
&& This is the logical AND operator. Both of its operands must be
of type INT. It returns 1 if both operands are non-zero, and 0
otherwise.
|| This is the logical OR operator. Both of its operands must be
of type INT. It returns 1 if either operand is non-zero, and 0
otherwise.
NOTES
Operators of equal precedence are always evaluated from left to right,
except where parentheses dictate otherwise. This is important, because
the enhanced "+" operator is not necessarily associative. For example:
1 + 2 + "string" + 3 + 4 yields "3string34"
1 + (2 + "string") + (3 + 4) yields "12string7"
12:59 + 1 + "test" yields "13:00test"
12:59 + (1 + "test") yields "12:591test"
The logical operators are not so-called short-circuit operators, as
they are in C. Both operands are always evaluated. Thus, an
expression such as:
(f!=0) && (100/f <= 3)
will cause an error if f is zero.
VARIABLES
Remind allows you to assign values to variables. The SET command is
used as follows:
SET var expr
Var is the name of a variable. It must start with a letter or
underscore, and consist only of letters, digits and underscores. Only
the first 12 characters of a variable name are significant. Variable
names are not case sensitive; thus, "Afoo" and "afOo" are the same
variable. Examples:
SET a 10 + (9*8)
SET b "This is a test"
SET mydir getenv("HOME")
SET time 12:15
SET date today()
Note that variables themselves have no type. They take on the type of
whatever you store in them.
To delete a variable, use the UNSET command:
UNSET var [var...]
For example, to delete all the variables declared above, use:
UNSET a b mydir time date
SYSTEM VARIABLES
In addition to the regular user variables, Remind has several "system
variables" that are used to query or control the operating state of
Remind. System variables are available starting from version 03.00.07
of Remind.
All system variables begin with a dollar sign ’$’. They can be used in
SET commands and expressions just as regular variables can. All system
variables always hold values of a specified type. In addition, some
system variables cannot be modified, and you cannot create new system
variables. System variables can be initialized on the command line
with the -i option, but you may need to quote them to avoid having the
shell interpret the dollar sign. System variable names are not case-
sensitive.
The following system variables are defined. Those marked "read-only"
cannot be changed with the SET command. All system variables hold
values of type INT, unless otherwise specified.
$CalcUTC
If 1 (the default), then Remind uses C library functions to
calculate the number of minutes between local and Universal Time
Coordinated. This affects astronomical calculations (sunrise()
for example.) If 0, then you must supply the number of minutes
between local and Universal Time Coordinated in the $MinsFromUTC
system variable.
$CalMode (read-only)
If non-zero, then the -c option was supplied on the command
line.
$Daemon (read-only)
If the daemon mode -z was invoked, contains the number of
minutes between wakeups. If not running in daemon mode,
contains 0. For the MS-DOS version, always contains 0.
$DateSep
This variable can be set only to "/" or "-". It holds the
character used to separate portions of a date when Remind prints
a DATE or DATETIME value.
$DefaultPrio
The default priority assigned to reminders without a PRIORITY
clause. You can set this as required to adjust the priorities
of blocks of reminders without having to type priorities for
individual reminders. At startup, $DefaultPrio is set to 5000;
it can range from 0 to 9999.
$DontFork (read-only)
If non-zero, then the -c option was supplied on the command
line. For the MS-DOS version, always contains 1.
$DontTrigAts (read-only)
If non-zero, then the -a option was supplied on the command
line. For the MS-DOS version, always contains 0.
$DontQueue (read-only)
If non-zero, then the -q option was supplied on the command
line. For the MS-DOS version, always contains 1.
$EndSent (STRING type)
Contains a list of characters that end a sentence. The MSF
keyword inserts two spaces after these characters. Initially,
$EndSent is set to ".!?" (period, exclamation mark, and question
mark.)
$EndSentIg (STRING type)
Contains a list of characters that should be ignored when MSF
decides whether or not to place two spaces after a sentence.
Initially, is set to "’>)]}"+CHAR(34) (single-quote, greater-
than, right parenthesis, right bracket, right brace, and double-
quote.)
For example, the default values work as follows:
MSF He said, "Huh! (Two spaces will follow this.)" Yup.
because the final parenthesis and quote are ignored (for the
purposes of spacing) when they follow a period.
$FirstIndent
The number of spaces by which to indent the first line of a MSF-
type reminder. The default is 0.
$FoldYear
The standard Unix library functions may have difficulty dealing
with dates later than 2037. If this variable is set to 1, then
the UTC calculations "fold back" years later than 2037 before
using the Unix library functions. For example, to find out
whether or not daylight savings time is in effect in June, 2077,
the year is "folded back" to 2010, because both years begin on a
Monday, and both are non-leapyears. The rules for daylight
savings time are thus presumed to be identical for both years,
and the Unix library functions can handle 2010. By default,
this variable is 0. Set it to 1 if the sun or UTC functions
misbehave for years greater than 2037.
$FormWidth
The maximum width of each line of text for formatting MSF-type
reminders. The default is 72. If an MSF-type reminder contains
a word too long to fit in this width, it will not be truncated -
the width limit will be ignored.
$HushMode (read-only)
If non-zero, then the -h option was supplied on the command
line.
$IgnoreOnce (read-only)
If non-zero, then the -o option was supplied on the command
line, or a date different from today’s true date was supplied.
If non-zero, then ONCE directives will be ignored.
$InfDelta (read-only)
If non-zero, then the -t option was supplied on the command
line.
$LatDeg, $LatMin, $LatSec
These specify the latitude of your location. $LatDeg can range
from -90 to 90, and the others from -59 to 59. Northern
latitudes are positive; southern ones are negative. For
southern latitudes, all three components should be negative.
$Location (STRING type)
This is a string specifying the name of your location. It is
usually the name of your town or city. It can be set to
whatever you like, but good style indicates that it should be
kept consistent with the latitude and longitude system
variables.
$LongDeg, $LongMin, $LongSec
These specify the longitude of your location. $LongDeg can
range from -180 to 180. Western longitudes are positive;
eastern ones are negative.
The latitude and longitude information is required for the
functions sunrise() and sunset(). Default values can be
compiled into Remind, or you can SET the correct values at the
start of your reminder scripts.
$MaxSatIter
The maximum number of iterations for the SATISFY clause
(described later.) Must be at least 10.
$MinsFromUTC
The number of minutes between Universal Time Coordinated and
local time. If $CalcUTC is non-zero, this is calculated upon
startup of Remind. Otherwise, you must set it explicitly. If
$CalcUTC is zero, then $MinsFromUTC is used in the astronomical
calculations. You must adjust it for daylight savings time
yourself. Also, if you want to initialize $MinsFromUTC using
the -i command-line option, you must also set $CalcUTC to 0 with
the -i option.
$NextMode (read-only)
If non-zero, then the -n option was supplied on the command
line.
$NumQueued (read-only)
Contains the number of reminders queued so far for background
timed triggering. For MS-DOS, always returns 0.
$NumTrig (read-only)
Contains the number of reminders triggered for the current date.
One use for this variable is as follows: Suppose you wish to
shade in the box of a PostScript calendar whenever a holiday is
triggered. You could save the value of $NumTrig in a regular
variable prior to executing a block of holiday reminders. If
the value of $NumTrig after the holiday block is greater than
the saved value, then at least one holiday was triggered, and
you can execute the command to shade in the calendar box. (See
the section "Calendar Mode".)
Note that $NumTrig is affected only by REM commands; triggers in
IFTRIG commands do not affect it.
$PrefixLineNo (read-only)
If non-zero, then the -l option was supplied on the command
line.
$PSCal (read-only)
If non-zero, then the -p option was supplied on the command
line.
$RunOff (read-only)
If non-zero, the RUN directives are disabled.
$SimpleCal (read-only)
Set to a non-zero value if either of the -p or -s command-line
options was supplied.
$SortByDate (read-only)
Set to 0 if no -g option is used, 1 if sorting by date in
ascending order, or 2 if sorting by date in descending order.
$SortByPrio (read-only)
Set to 0 if no -g option is used, 1 if sorting by priority in
ascending order, or 2 if sorting by priority in descending
order.
$SortByTime (read-only)
Set to 0 if no -g option is used, 1 if sorting by time in
ascending order, or 2 if sorting by time in descending order.
$SubsIndent
The number of spaces by which all lines (except the first) of an
MSF-type reminder should be indented. The default is 0.
Note: If any of the calendar modes are in effect, then the values of
$Daemon, $DontFork, $DontTrigAts, $DontQueue, $HushMode, $IgnoreOnce,
$InfDelta, and $NextMode are not meaningful.
$TimeSep
This variable can be set only to ":" or ".". It holds the
character used to separate portions of a time when Remind prints
a TIME or DATETIME value.
BUILT-IN FUNCTIONS
Remind has a plethora of built-in functions. The syntax for a function
call is the same as in C - the function name, followed a comma-
separated list of arguments in parentheses. Function names are not
case-sensitive. If a function takes no arguments, it must be followed
by "()" in the function call. Otherwise, Remind will interpret it as a
variable name, and probably not work correctly.
In the descriptions below, short forms are used to denote acceptable
types for the arguments. The characters "i", "s", "d", "t" and "q"
denote INT, STRING, DATE, TIME and DATETIME arguments, respectively.
If an argument can be one of several types, the characters are
concatenated. For example, "di_arg" denotes an argument that can be a
DATE or an INT. "x_arg" denotes an argument that can be of any type.
The type of the argument is followed by an underscore and an identifier
naming the argument.
The built-in functions are:
abs(i_num)
Returns the absolute value of num.
access(s_file, si_mode)
Tests the access permissions for the file file. Mode can be a
string, containing a mix of the characters "rwx" for read, write
and execute permission testing. Alternatively, mode can be a
number as described in the UNIX access(2) system call. The
function returns 0 if the file can be accessed with the
specified mode, and -1 otherwise.
args(s_fname)
Returns the number of arguments expected by the user-defined
function fname, or -1 if no such user-defined function exists.
Note that this function examines only user-defined functions,
not built-in functions. Its main use is to determine whether or
not a particular user-defined function has been defined
previously. The args() function is available only in versions
of Remind from 03.00.04 and up.
asc(s_string)
Returns an INT that is the ASCII code of the first character in
string. As a special case, asc("") returns 0.
baseyr()
Returns the "base year" that was compiled into Remind (normally
1990.) All dates are stored internally as the number of days
since 1 January of baseyr().
char(i_i1 [,i_i2...])
This function can take any number of INT arguments. It returns
a STRING consisting of the characters specified by the
arguments. Note that none of the arguments can be 0, unless
there is only one argument. As a special case, char(0) returns
"".
Note that because Remind does not support escaping of characters
in strings, the only way to get a double-quote in a string is to
use char(34).
choose(i_index, x_arg1 [,x_arg2...])
Choose must take at least two arguments, the first of which is
an INT. If index is n, then the nth subsequent argument is
returned. If index is less than 1, then arg1 is returned. If
index is greater than the number of subsequent arguments, then
the last argument is returned. Examples:
choose(0, "foo", 1:13, 1000) returns "foo"
choose(1, "foo", 1:13, 1000) returns "foo"
choose(2, "foo", 1:13, 1000) returns 1:13
choose(3, "foo", 1:13, 1000) returns 1000
choose(4, "foo", 1:13, 1000) returns 1000
Note that all arguments to choose() are always evaluated.
coerce(s_type, x_arg)
This function converts arg to the specified type, if such
conversion is possible. Type must be one of "INT", "STRING",
"DATE", "TIME" or "DATETIME" (case-insensitive). The conversion
rules are as follows:
If arg is already of the type specified, it is returned
unchanged.
If type is "STRING", then arg is converted to a string
consisting of its printed representation.
If type is "DATE", then an INT arg is converted by interpreting
it as the number of days since 1 January baseyr(). A STRING arg
is converted by attempting to read it as if it were a printed
date. A DATETIME is converted to a date by dropping the time
component. A TIME arg cannot be converted to a date.
If type is "TIME", then an INT arg is converted by interpreting
it as the number of minutes since midnight. A STRING arg is
converted by attempting to read it as if it were a printed time.
A DATETIME is converted to a time by dropping the date
component. A DATE arg cannot be converted to a time.
If type is "DATETIME", then an INT arg is converted by
interpreting it as the number of minutes since midnight, 1
January baseyr(). A STRING is converted by attempting to read
it as if it were a printed datetime. Other types cannot be
converted to a datetime.
If type is "INT", then DATE, TIME and DATETIME arguments are
converted using the reverse of procedures described above. A
STRING arg is converted by parsing it as an integer.
current()
Returns the current date and time as a DATETIME object. This
may be the actual date and time, or may be the date and time
supplied on the command line.
date(i_y, i_m, i_d)
The date() function returns a DATE object with the year, month
and day components specified by y, m and d.
datetime(args)
The datetime() function can take anywhere from two to five
arguments. It always returns a DATETIME generated from its
arguments.
If you supply two arguments, the first must be a DATE and the
second a TIME.
If you supply three arguments, the first must be a DATE and the
second and third must be INTs. The second and third arguments
are interpreted as hours and minutes and converted to a TIME.
If you supply four arguments, the first three must be INTs,
interpreted as the year, month and day. The fourth argument
must be a TIME.
Finally, if you supply five arguments, they must all be INTs and
are interpreted as year, month, day, hour and minute.
dawn([dq_date])
Returns the time of "civil dawn" on the specified date. If date
is omitted, defaults to today(). If a datetime object is
supplied, only the date component is used.
day(dq_date)
This function takes a DATE or DATETIME as an argument, and
returns an INT that is the day-of-month component of date.
daysinmon(i_m, i_y)
Returns the number of days in month m (1-12) of the year y.
defined(s_var)
Returns 1 if the variable named by var is defined, or 0 if it is
not.
Note that defined() takes a STRING argument; thus, to check if
variable X is defined, use:
defined("X")
and not:
defined(X)
The second example will attempt to evaluate X, and will return
an error if it is undefined or not of type STRING.
dosubst(s_str [,d_date [,t_time]]) or dosubst(s_str [,q_datetime])
Returns a STRING that is the result of passing str through the
substitution filter described earlier. The parameters date and
time (or datetime) establish the effective trigger date and time
used by the substitution filter. If date and time are omitted,
they default to today() and now().
Note that if str does not end with "%", a newline character will
be added to the end of the result. Also, calling dosubst() with
a date that is in the past (i.e., if date < today()) will
produce undefined results.
Dosubst() is only available starting from version 03.00.04 of
Remind.
dusk([dq_date])
Returns the time of "civil twilight" on the specified date. If
date is omitted, defaults to today().
easterdate(dqi_arg)
If arg is an INT, then returns the date of Easter Sunday for the
specified year. If arg is a DATE or DATETIME, then returns the
date of the next Easter Sunday on or after arg. (The time
component of a datetime is ignored.)
filedate(s_filename)
Returns the modification date of filename. If filename does not
exist, or its modification date is before the year baseyr(),
then 1 January of baseyr() is returned.
filedatetime(s_filename)
Returns the modification date and time of filename. If filename
does not exist, or its modification date is before the year
baseyr(), then midnight, 1 January of baseyr() is returned.
filedir()
Returns the directory that contains the current file being
processed. It may be a relative or absolute pathname, but is
guaranteed to be correct for use in an INCLUDE command as
follows:
INCLUDE [filedir()]/stuff
This includes the file "stuff" in the same directory as the
current file being processed.
filename()
Returns (as a STRING) the name of the current file being
processed by Remind. Inside included files, returns the name of
the included file.
getenv(s_envvar)
Similar to the getenv(2) system call. Returns a string
representing the value of the specified environment variable.
Returns "" if the environment variable is not defined. Note
that the names of environment variables are generally case-
sensitive; thus, getenv("HOME") is not the same as
getenv("home").
hour(tq_time)
Returns the hour component of time.
iif(si_test1, x_arg1, [si_test2, x_arg2,...], x_default)
If test1 is not zero or the null string, returns arg1.
Otherwise, if test2 is not zero or the null string, returns
arg2, and so on. If all of the test arguments are false,
returns default. Note that all arguments are always evaluated.
This function accepts an odd number of arguments - note that
prior to version 03.00.05 of Remind, it accepted 3 arguments
only. The 3-argument version of iif() is compatible with
previous versions of Remind.
index(s_search, s_target [,i_start)
Returns an INT that is the location of target in the string
search. The first character of a string is numbered 1. If
target does not exist in search, then 0 is returned.
The optional parameter start specifies the position in search at
which to start looking for target.
isdst([d_date [,t_time]]) or isdst(q_datetime)
Returns a positive number if daylight savings time is in effect
on the specified date and time. Date defaults to today() and
time defaults to midnight.
Note that this function is only as reliable as the C run-time
library functions. It is available starting with version
03.00.07 of Remind.
isleap(idq_arg)
Returns 1 if arg is a leap year, and 0 otherwise. Arg can be an
INT, DATE or DATETIME object. If a DATE or DATETIME is
supplied, then the year component is used in the test.
isomitted(dq_date)
Returns 1 if date is omitted, given the current global OMIT
context. Returns 0 otherwise. (If a datetime is supplied, only
the date part is used.)
hebdate(i_day, s_hebmon [,idq_yrstart [,i_jahr [,i_aflag]]])
Support for Hebrew dates - see the section "The Hebrew Calendar"
hebday(dq_date)
Support for Hebrew dates - see the section "The Hebrew Calendar"
hebmon(dq_date)
Support for Hebrew dates - see the section "The Hebrew Calendar"
hebyear(dq_date)
Support for Hebrew dates - see the section "The Hebrew Calendar"
language()
Returns a STRING naming the language supported by Remind. (See
"Foreign Language Support.") By default, Remind is compiled to
support English messages, so this function returns "English".
For other languages, this function will return the English name
of the language (e.g. "German") Note that language() is not
available in versions of Remind prior to 03.00.02.
lower(s_string)
Returns a STRING with all upper-case characters in string
converted to lower-case.
max(x_arg1 [,x_arg2...)
Can take any number of arguments, and returns the maximum. The
arguments can be of any type, but must all be of the same type.
They are compared as with the > operator.
min(x_arg1 [,x_arg2...)
Can take any number of arguments, and returns the minimum. The
arguments can be of any type, but must all be of the same type.
They are compared as with the < operator.
minsfromutc([d_date [,t_time]]) or minsfromutc(q_datetime)
Returns the number of minutes from Universal Time Coordinated
(formerly GMT) to local time on the specified date and time.
Date defaults to today() and time defaults to midnight. If
local time is before UTC, the result is negative. Otherwise,
the result is positive.
Note that this function is only as reliable as the C run-time
library functions. It is available starting with version
03.00.07 of Remind.
minute(tq_time)
Returns the minute component of time.
mon(dqi_arg)
If arg is of DATE or DATETIME type, returns a string that names
the month component of the date. If arg is an INT from 1 to 12,
returns a string that names the month.
monnum(dq_date)
Returns an INT from 1 to 12, representing the month component of
date.
moondate(i_phase [,d_date [,t_time]]) or moondate(i_phase, q_datetime)
This function returns the date of the first occurrence of the
phase phase of the moon on or after date and time. Phase can
range from 0 to 3, with 0 signifying new moon, 1 first quarter,
2 full moon, and 3 third quarter. If date is omitted, it
defaults to today(). If time is omitted, it defaults to
midnight.
For example, the following returns the date of the next full
moon:
SET fullmoon moondate(2)
moontime(i_phase [,d_date [,t_time]]) or moontime(i_phase, q_datetime)
This function returns the time of the first occurrence of the
phase phase of the moon on or after date and time. Phase can
range from 0 to 3, with 0 signifying new moon, 1 first quarter,
2 full moon, and 3 third quarter. If date is omitted, it
defaults to today(). If time is omitted, it defaults to
midnight. Moontime() is intended to be used in conjunction with
moondate(). The moondate() and moontime() functions are
accurate to within a couple of minutes of the times in "Old
Farmer’s Almanac" for Ottawa, Ontario.
For example, the following returns the date and time of the next
full moon:
MSG Next full moon at [moontime(2)] on [moondate(2)]
moondatetime(i_phase [,d_date [,t_time]]) or moondatetime(i_phase,
q_datetime)
This function is similar to moondate and moontime, but returns a
DATETIME result.
moonphase([d_date [,t_time]]) or moonphase(q_datetime)
This function returns the phase of the moon on date and time,
which default to today() and midnight, respectively. The
returned value is an integer from 0 to 359, representing the
phase of the moon in degrees. 0 is a new moon, 180 is a full
moon, 90 is first-quarter, etc.
nonomitted(dq_start, dq_end [,s_wkday...])
This function returns the number of non-omitted days between
start and end. If start is non-omitted, then it is counted.
end is never counted.
Note that end must be greater than or equal to start or an error
is reported. In addition to using the global OMIT context, you
can supply additional arguments that are names of weekdays to be
omitted.
For example, the following line sets a to 11 (assuming no global
OMITs):
set a nonomitted(’2007-08-01’, ’2007-08-16’, "Sat", "Sun")
because Thursday, 16 August 2007 is the 11th working day (not
counting Saturday and Sunday) after Wednesday, 1 August 2007.
nonomitted has various uses. For example, many schools run on a
six-day cycle and the day number is not incremented on holidays.
Suppose the school year starts with Day 1 on 4 September 2007.
The following reminder will label day numbers in a calendar:
IF today() >= ’2007-09-04’
set daynum nonomitted(’2007-09-04’, today(), "Sat", "Sun")
REM OMIT SAT SUN SKIP CAL Day [(daynum % 6) + 1]
ENDIF
Here’s a more complex example: Suppose your normal garbage-
collection day is Thursday, but if any of Monday through
Thursday of a week is a holiday, the collection day moves to
Friday. Here’s one way to solve it:
FSET prev_monday(x) x - wkdaynum(x-1)
REM Thu Fri SATISFY [wkdaynum(trigdate()) == 4 && \
nonomitted(prev_monday(today()), today()+1) == 4 || \
wkdaynum(trigdate()) == 5 && \
nonomitted(prev_monday(today()), today()+1) <= 4] \
MSG Garbage Day
Whew! (You’ll need to see "THE SATISFY CLAUSE" later on.) We’d
better explain that one: The prev_monday helper function takes a
date and returns the date of the previous Monday. The REM
command will trigger on the first Thursday or Friday that
satisfies one of the following conditions:
1) Either it’s a Thursday and there are exactly four non-omitted
days between the previous Monday and tomorrow, or
2) It’s a Friday and there are four or fewer non-omitted days
between the previous Monday and tomorrow. We need the "or
fewer" condition to handle the case of more than one holiday in
a given week. If that happens, garbage day still only moves by
one day.
Obviously, the answer you get from nonomitted depends on the
global OMIT context. If you use moveable OMITs, you may get
inconsistent results.
now() Returns the current system time, as a TIME type. This may be
the actual time, or a time supplied on the command line.
ord(i_num)
Returns a string that is the ordinal number num. For example,
ord(2) returns "2nd", and ord(213) returns "213th".
ostype()
Returns "UNIX". Remind used to run on OS/2 and MS-DOS, but does
not any longer.
plural(i_num [,s_str1 [,s_str2]])
Can take from one to three arguments. If one argument is
supplied, returns "s" if num is not 1, and "" if num is 1.
If two arguments are supplied, returns str1 + "s" if num is not
1. Otherwise, returns str1.
If three arguments are supplied, returns str1 if num is 1, and
str2 otherwise.
psmoon(i_phase [,i_size [,s_note [,i_notesize]]])
[DEPRECATED] Returns a STRING consisting of PostScript code to
draw a moon in the upper-left hand corner of the calendar box.
Phase specifies the phase of the moon, and is 0 (new moon), 1
(first quarter), 2 (full moon) or 3 (third quarter). If size is
specified, it controls the radius of the moon in PostScript
units (1/72 inch.) If it is not specified or is negative, the
size of the day-number font is used.
For example, the following four lines place moon symbols on the
PostScript calendar:
REM [trigger(moondate(0))] PS [psmoon(0)]
REM [trigger(moondate(1))] PS [psmoon(1)]
REM [trigger(moondate(2))] PS [psmoon(2)]
REM [trigger(moondate(3))] PS [psmoon(3)]
If note is specified, the text is used to annotate the moon
display. The font is the same font used for calendar entries.
If notesize is given, it specifies the font size to use for the
annotation, in PostScript units (1/72 inch.) If notesize is not
given, it defaults to the size used for calendar entries. (If
you annotate the display, be careful not to overwrite the day
number -- Remind does not check for this.) For example, if you
want the time of each new moon displayed, you could use this in
your reminder script:
REM [trigger(moondate(0))] PS [psmoon(0, -1, moontime(0)+"")]
Note how the time is coerced to a string by concatenating the
null string.
psshade(i_gray) or psshade(i_red, i_green, i_blue)
[DEPRECATED] Returns a STRING that consists of PostScript
commands to shade a calendar box. Num can range from 0
(completely black) to 100 (completely white.) If three
arguments are given, they specify red, green and blue intensity
from 0 to 100. Here’s an example of how to use this:
REM Sat Sun PS [psshade(95)]
The above command emits PostScript code to lightly shade the
boxes for Saturday and Sunday in a PostScript calendar.
Note that psmoon and psshade are deprecated; instead you should
use the SPECIAL SHADE and SPECIAL MOON reminders as described in
"Out-of-Band Reminders."
realcurrent()
Returns (as a DATETIME) the true date and time of day as
provided by the operating system. This is in contrast to
current(), which may return a time supplied on the command line.
realnow()
Returns the true time of day as provided by the operating
system. This is in contrast to now(), which may return a time
supplied on the command line.
realtoday()
Returns the date as provided by the operating system. This is
in contrast to Remind’s concept of "today", which may be changed
if it is running in calendar mode, or if a date has been
supplied on the command line.
sgn(i_num)
Returns -1 if num is negative, 1 if num is positive, and 0 if
num is zero.
shell(s_cmd [,i_maxlen])
Executes cmd as a system command, and returns the first 511
characters of output resulting from cmd. Any whitespace
character in the output is converted to a space. Note that if
RUN OFF has been executed, or the -r command-line option has
been used, shell() will result in an error, and cmd will not be
executed.
If maxlen is specified, then shell() returns the first maxlen
characters of output (rather than the first 511). If maxlen is
specified as a negative number, then all the output from cmd is
returned.
strlen(s_str)
Returns the length of str.
substr(s_str, i_start [,i_end])
Returns a STRING consisting of all characters in str from start
up to and including end. Characters are numbered from 1. If
end is not supplied, then it defaults to the length of str.
sunrise([dq_date])
Returns a TIME indicating the time of sunrise on the specified
date (default today().) In high latitudes, there may be no
sunrise on a particular day, in which case sunrise() returns the
INT 0 if the sun never sets, or 1440 if it never rises.
sunset([dq_date])
Returns a TIME indicating the time of sunset on the specified
date (default today().) In high latitudes, there may be no
sunset on a particular day, in which case sunset() returns the
INT 0 if the sun never rises, or 1440 if it never sets.
The functions sunrise() and sunset() are based on an algorithm
in "Almanac for Computers for the year 1978" by L. E. Doggett,
Nautical Almanac Office, USNO. They require the latitude and
longitude to be specified by setting the appropriate system
variables. (See "System Variables".) The sun functions should
be accurate to within about 2 minutes for latitudes lower than
60 degrees. The functions are available starting from version
03.00.07 of Remind.
time(i_hr, i_min)
Creates a TIME with the hour and minute components specified by
hr and min.
today()
Returns Remind’s notion of "today." This may be the actual
system date, or a date supplied on the command line, or the date
of the calendar entry currently being computed.
trigdate()
Returns the calculated trigger date of the last REM or IFTRIG
command. If used in the body of a REM command, returns that
command’s trigger date. If the most recent REM command did not
yield a computable trigger date, returns the integer 0.
trigdatetime()
Similar to trigdate(), but returns a DATETIME if the most recent
triggerable REM command had an AT clause. If there was no AT
clause, returns a DATE. If no trigger could be computed,
returns the integer 0.
trigger(d_date [,t_time [,i_utcflag]]) or trigger(q_datetime
[,i_utcflag])
Returns a string suitable for use in a REM command, allowing you
to calculate trigger dates in advance. (See the section
"Expression pasting" for more information.) Note that trigger()
always returns its result in English, even for foreign-language
versions of Remind. This is to avoid problems with certain C
libraries that do not handle accented characters properly.
Normally, the date and time are the local date and time;
however, if utcflag is non-zero, the date and time are
interpreted as UTC times, and are converted to local time.
Examples:
trigger(’1993/04/01’)
returns "1 April 1993",
trigger(’1994/08/09’, 12:33)
returns "9 August 1994 AT 12:33", as does:
trigger(’1994/08/09@12:33’).
Finally:
trigger(’1994/12/01’, 03:00, 1)
returns "30 November 1994 AT 22:00" for EST, which is 5 hours
behind UTC. The value for your time zone may differ.
trigtime()
Returns the time of the last REM command with an AT clause. If
the last REM did not have an AT clause, returns the integer 0.
trigvalid()
Returns 1 if the value returned by trigdate() is valid for the
most recent REM command, or 0 otherwise. Sometimes REM commands
cannot calculate a trigger date. For example, the following REM
command can never be triggered:
REM Mon OMIT Mon SKIP MSG Impossible!
typeof(x_arg)
Returns "STRING", "INT", "DATE", "TIME" or "DATETIME", depending
on the type of arg.
tzconvert(q_datetime, s_srczone [,s_dstzone])
Converts datetime from the time zone named by srczone to the
time zone named by dstzone. If dstzone is omitted, the default
system time zone is used. The return value is a DATETIME. Time
zone names are system-dependent; consult your operating system
for legal values. Here is an example:
tzconvert(’2007-07-08@01:14’, "Canada/Eastern", "Canada/Pacific")
returns
2007-07-07@22:14
upper(s_string)
Returns a STRING with all lower-case characters in string
converted to upper-case.
value(s_varname [,x_default])
Returns the value of the specified variable. For example,
value("X"+"Y") returns the value of variable XY, if it is
defined. If XY is not defined, an error results.
However, if you supply a second argument, it is returned if the
varname is not defined. The expression value("XY", 0) will
return 0 if XY is not defined, and the value of XY if it is
defined.
version()
Returns a string specifying the version of Remind. For version
03.00.04, returns "03.00.04". It is guaranteed that as new
versions of Remind are released, the value returned by version()
will strictly increase, according to the rules for string
ordering.
wkday(dqi_arg)
If arg is a DATE or DATETIME, returns a string representing the
day of the week of the date. If arg is an INT from 0 to 6,
returns the corresponding weekday ("Sunday" to "Saturday").
wkdaynum(dq_date)
Returns a number from 0 to 6 representing the day-of-week of the
specified date. (0 represents Sunday, and 6 represents
Saturday.)
year(dq_date)
Returns a INT that is the year component of date.
EXPRESSION PASTING
An extremely powerful feature of Remind is its macro capability, or
"expression pasting."
In almost any situation where Remind is not expecting an expression,
you can "paste" an expression in. To do this, surround the expression
with square brackets. For example:
REM [trigger(mydate)] MSG foo
This evaluates the expression "trigger(mydate)", where "mydate" is
presumably some pre-computed variable, and then "pastes" the result
into the command-line for the parser to process.
A formal description of this is: When Remind encounters a "pasted-in"
expression, it evaluates the expression, and coerces the result to a
STRING. It then substitutes the string for the pasted-in expression,
and continues parsing. Note, however, that expressions are evaluated
only once, not recursively. Thus, writing:
["[a+b]"]
causes Remind to read the token "[a+b]". It does not interpret this as
a pasted-in expression. In fact, the only way to get a literal left-
bracket into a reminder is to use ["["].
You can use expression pasting almost anywhere. However, there are a
few exceptions:
o If Remind is expecting an expression, as in the SET command, or
the IF command, then no expression pasting takes place. The
expression is simply evaluated as if the square brackets were
not there.
o You cannot use expression pasting for the first token on a line.
For example, the following will not work:
["SET"] a 1
This restriction is because Remind must be able to unambiguously
determine the first token of a line for the flow-control
commands (to be discussed later.)
In fact, if Remind cannot determine the first token on a line,
it assumes that it is a REM command. If expression-pasting is
used, Remind assumes it is a REM command. Thus, the following
three commands are equivalent:
REM 12 Nov 1993 AT 13:05 MSG BOO!
12 Nov 1993 AT 13:05 MSG BOO!
[12] ["Nov " + 1993] AT [12:05+60] MSG BOO!
o You cannot use expression-pasting to determine the type (MSG,
CAL, etc.) of a REM command. You can paste expressions before
and after the MSG, etc keywords, but cannot do something like
this:
REM ["12 Nov 1993 AT 13:05 " + "MSG" + " BOO!"]
COMMON PITFALLS IN EXPRESSION PASTING
Remember, when pasting in expressions, that extra spaces are not
inserted. Thus, something like:
REM[expr]MSG[expr]
will probably fail.
If you use an expression to calculate a delta or back, ensure that the
result is a positive number. Something like:
REM +[mydelta] Nov 12 1993 MSG foo
will fail if mydelta happens to be negative.
FLOW CONTROL COMMANDS
Remind has commands that control the flow of a reminder script.
Normally, reminder scripts are processed sequentially. However, IF and
related commands allow you to process files conditionally, and skip
sections that you don’t want interpreted.
THE IF COMMAND
The IF command has the following form:
IF expr
t-command
t-command...
ELSE
f-command
f-command...
ENDIF
Note that the commands are shown indented for clarity. Also, the ELSE
portion can be omitted. IF commands can be nested up to a small limit,
probably around 8 or 16 levels of nesting, depending on your system.
If the expr evaluates to a non-zero INT, or a non-null STRING, then the
IF portion is considered true, and the t-commands are executed. If
expr evaluates to zero or null, then the f-commands (if the ELSE
portion is present) are executed. If expr is not of type INT or
STRING, then it is an error.
Examples:
IF defined("want_hols")
INCLUDE /usr/share/remind/holidays
ENDIF
IF today() > ’1992/2/10’
set missed_ap "You missed it!"
ELSE
set missed_ap "Still have time..."
ENDIF
THE IFTRIG COMMAND
The IFTRIG command is similar to an IF command, except that it computes
a trigger (as in the REM command), and evaluates to true if a
corresponding REM command would trigger. Examples:
IFTRIG 1 Nov
; Executed on 1 Nov
ELSE
; Executed except on 1 Nov
ENDIF
IFTRIG 1 -1 OMIT Sat Sun +4
; Executed on last working day of month,
; and the 4 working days preceding it
ELSE
; Executed except on above days
ENDIF
Note that the IFTRIG command computes a trigger date, which can be
retrieved with the trigdate() function. You can use all of the normal
trigger components, such as UNTIL, delta, etc in the IFTRIG command.
USER-DEFINED FUNCTIONS
In addition to the built-in functions, Remind allows you to define your
own functions. The FSET command does this for you:
FSET fname(args) expr
Fname is the name of the function, and follows the convention for
naming variables. Args is a comma-separated list of arguments, and
expr is an expression. Args can be empty, in which case you define a
function taking no parameters. Here are some examples:
FSET double(x) 2*x
FSET yeardiff(date1, date2) year(date1) - year(date2)
FSET since(x) ord(year(trigdate())-x)
The last function is useful in birthday reminders. For example:
REM 1 Nov +12 MSG Dean’s [since(1984)] birthday is %b.
Dean was born in 1984. The above example, on 1 November 1992, would
print:
Dean’s 8th birthday is today.
Notes:
o If you access a variable in expr that is not in the list of
arguments, the "global" value (if any) is used.
o Function and parameter names are significant only to 12
characters.
o The value() function always accesses the "global" value of a
variable, even if it has the same name as an argument. For
example:
fset func(x) value("x")
set x 1
set y func(5)
The above sequence sets y to 1, which is the global value of x.
o User-defined functions may call other functions, including other
user-defined functions. However, recursive calls are not
allowed.
o User-defined functions are not syntax-checked when they are
defined; parsing occurs only when they are called.
o If a user-defined function has the same name as a built-in
function, it is ignored and the built-in function is used. To
prevent conflicts with future versions of Remind (which may
define more built-in functions), you may wish to name all user-
defined functions beginning with an underscore.
PRECISE SCHEDULING
The WARN keyword allows precise control over advance warning in a more
flexible manner than the delta mechanism. It should be followed by the
name of a user-defined function, warn_function.
If a warn_function is supplied, then it must take one argument of type
INT. Remind ignores any delta, and instead calls warn_function
successively with the arguments 1, 2, 3, ...
Warn_function’s return value n is interpreted as follows:
o If n is positive, then the reminder is triggered exactly n days
before its trigger date.
o If n is negative, then it is triggered n days before its trigger
date, not counting OMITted days.
As an example, suppose you wish to be warned of American Independence
Day 5, 3, and 1 days in advance. You could use this:
FSET _wfun(x) choose(x, 5, 3, 1, 0)
REM 4 July WARN _wfun MSG American Independence Day is %b.
NOTES
1 If an error occurs during the evaluation of warn_function, then
Remind stops calling it and simply issues the reminder on its
trigger date.
2 If the absolute-values of the return values of warn_function are
not monotonically decreasing, Remind stops calling it and issues
the reminder on its trigger date.
3 Warn_function should (as a matter of good style) return 0 as the
final value in its sequence of return values. However, a
reminder will always be triggered on its trigger date,
regardless of what warn_function does.
Similarly to WARN, the SCHED keyword allows precise control over the
scheduling of timed reminders. It should be followed by the name of a
user-defined function, sched_function.
If a scheduling function is supplied, then it must take one argument of
type INT. Rather than using the AT time, time delta, and time repeat,
Remind calls the scheduling function to determine when to trigger the
reminder. The first time the reminder is queued, the scheduling
function is called with an argument of 1. Each time the reminder is
triggered, it is re-scheduled by calling the scheduling function again.
On each call, the argument is incremented by one.
The return value of the scheduling function must be an INT or a TIME.
If the return value is a TIME, then the reminder is re-queued to
trigger at that time. If it is a positive integer n, then the reminder
is re-queued to trigger at the previous trigger time plus n minutes.
Finally, if it is a negative integer or zero, then the reminder is re-
queued to trigger n minutes before the AT time. Note that there must
be an AT clause for the SCHED clause to do anything.
Here’s an example:
FSET _sfun(x) choose(x, -60, 30, 15, 10, 3, 1, 1, 1, 1, 0)
REM AT 13:00 SCHED _sfun MSG foo
The reminder would first be triggered at 13:00-60 minutes, or at 12:00.
It would next be triggered 30 minutes later, at 12:30. Then, it would
be triggered at 12:45, 12:55, 12:58, 12:59, 13:00, 13:01 and 13:02.
NOTES
1 If an error occurs during the evaluation of sched_func, then
Remind reverts to using the AT time and the delta and repeat
values, and never calls sched_func again.
2 If processing sched_func yields a time earlier than the current
system time, it is repeatedly called with increasing argument
until it yields a value greater than or equal to the current
time. However, if the sequence of values calculated during the
repetition is not strictly increasing, then Remind reverts to
the default behaviour and never calls sched_func again.
3 It is quite possible using sched_func to keep triggering a
reminder even after the AT-time. However, it is not possible to
reschedule a reminder past midnight - no crossing of date
boundaries is allowed. Also, it is quite possible to not
trigger a reminder on the AT time when you use a scheduling
function. However, if your scheduling function is terminated
(for reasons 1 and 2) before the AT time of the reminder, it
will be triggered at the AT time, because normal processing
takes over.
4 Your scheduling functions should (as a matter of good style)
return 0 when no more scheduling is required. See the example.
5 All scheduling functions are evaluated after the entire Remind
script has been read in. So whatever function definitions are
in effect at the end of the script are used.
THE SATISFY CLAUSE
The form of REM that uses SATISFY is as follows:
REM trigger SATISFY expr
The way this works is as follows: Remind first calculates a trigger
date, in the normal fashion. Next, it sets trigdate() to the
calculated trigger date. It then evaluates expr. If the result is not
the null string or zero, processing ends. Otherwise, Remind computes
the next trigger date, and re-tests expr. This iteration continues
until expr evaluates to non-zero or non-null, or until the iteration
limit specified with the -x command-line option is reached.
If expr is not satisfied, then trigvalid() is set to 0. Otherwise,
trigvalid() is set to 1. In any event, no error message is issued.
This is really useful only if expr involves a call to the trigdate()
function; otherwise, expr will not change as Remind iterates.
An example of the usefulness of SATISFY: Suppose you wish to be warned
of every Friday the 13th. Your first attempt may be:
# WRONG!
REM Fri 13 +2 MSG Friday the 13th is %b.
But this won’t work. This reminder triggers on the first Friday on or
after the 13th of each month. The way to do it is with a more
complicated sequence:
REM 13 SATISFY wkdaynum(trigdate()) == 5
IF trigvalid()
REM [trigger(trigdate())] +2 MSG \
Friday the 13th is %b.
ENDIF
Let’s see how this works. The SATISFY clause iterates through all the
13ths of successive months, until a trigger date is found whose day-of-
week is Friday (== 5). If a valid date was found, we use the
calculated trigger date (converted into a trigger format with the
trigger() function) to set up the next reminder.
We could also have written:
REM Fri SATISFY day(trigdate()) == 13
but this would result in more iterations, since "Fridays" occur more
often than "13ths of the month."
This technique of using one REM command to calculate a trigger date to
be used by another command is quite powerful. For example, suppose you
wanted to OMIT Labour day, which is the first Monday in September. You
could use:
# Note: SATISFY 1 is an idiom for "do nothing"
REM Mon 1 Sept SATISFY 1
OMIT [trigger(trigdate())]
CAVEAT: This only omits the next Labour Day, not all Labour Days in the
future. This could cause strange results, as the OMIT context can
change depending on the current date. For example, if you use the
following command after the above commands:
REM Mon AFTER msg hello
the result will not be as you expect. Consider producing a calendar
for September, 1992. Labour Day was on Monday, 7 September, 1992.
However, when Remind gets around to calculating the trigger for
Tuesday, 8 September, 1992, the OMIT command will now be omitting
Labour Day for 1993, and the "Mon AFTER" command will not be triggered.
(But see the description of SCANFROM in the section "Details about
Trigger Computation.")
It is probably best to stay away from computing OMIT trigger dates
unless you keep these pitfalls in mind.
For versions of Remind starting from 03.00.07, you can include a MSG,
RUN, etc. clause in a SATISFY clause as follows:
REM trigger_stuff SATISFY [expr] MSG body
Note that for this case only, the expr after SATISFY must be enclosed
in braces. It must come after all the other components of the trigger,
and immediately before the MSG, RUN, etc. keyword. If expr cannot be
satisfied, then the reminder is not triggered.
Thus, the "Friday the 13th" example can be expressed more compactly as:
REM 13 +2 SATISFY [wkdaynum(trigdate()) == 5] \
MSG Friday the 13th is %b.
And you can trigger a reminder on Mondays, Wednesdays and Thursdays
occurring on odd-numbered days of the month with the following:
REM Mon Wed Thu SATISFY [day(trigdate())%2] \
MSG Here it is!!!
DEBUGGING REMINDER SCRIPTS
Although the command-line -d option is useful for debugging, it is
often overkill. For example, if you turn on the -dx option for a
reminder file with many complex expressions, you’ll get a huge amount
of output. The DEBUG command allows you to control the debugging flags
under program control. The format is:
DEBUG [+flagson] [-flagsoff]
Flagson and flagsoff consist of strings of the characters "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 %"David’s birthday%" is %b
In the normal mode, Remind would print "David’s birthday is today" on 6
January. However, in the calendar mode, only the text "David’s
birthday" is inserted into the box for 6 January.
If you explicitly use the %"...%" sequence in a RUN-type reminder, then
the text between the delimiters is inserted into the calendar. If you
use the sequence %"%" in a MSG or CAL-type reminder, then no calendar
entry is produced for that reminder.
PRESERVING VARIABLES
Because Remind iterates through the script for each day in the
calendar, slow operations may severely reduce the speed of producing a
calendar.
For example, suppose you set the variables "me" and "hostname" as
follows:
SET me shell("whoami")
SET hostname shell("hostname")
Normally, Remind clears all variables between iterations in calendar
mode. However, if certain variables are slow to compute, and will not
change between iterations, you can "preserve" their values with the
PRESERVE command. Also, since function definitions are preserved
between calendar iterations, there is no need to redefine them on each
iteration. Thus, you could use the following sequence:
IF ! defined("initialized")
set initialized 1
set me shell("whoami")
set hostname shell("hostname")
fset func(x) complex_expr
preserve initialized me hostname
ENDIF
The operation is as follows: On the first iteration through the
script, "initialized" is not defined. Thus, the commands between IF
and ENDIF are executed. The PRESERVE command ensures that the values
of initialized, me and hostname are preserved for subsequent
iterations. On the next iteration, the commands are skipped, since
initialized has remained defined. Thus, time-consuming operations that
do not depend on the value of today() are done only once.
System variables (those whose names start with ’$’) are automatically
preserved between calendar iterations.
Note that for efficiency, Remind caches the reminder script (and any
INCLUDEd files) in memory when producing a calendar.
Timed reminders are sorted and placed into the calendar in time order.
These are followed by non-timed reminders. Remind automatically places
the time of timed reminders in the calendar according to the -b
command-line option. Reminders in calendar mode are sorted as if the
-g option had been used; you can change the sort order in calendar mode
by explicitly using the -g option to specify a different order from the
default.
REPEATED EXECUTION
If you supply a repeat parameter on the command line, and do not use
the -c, -p, or -s options, Remind operates in a similar manner to
calendar mode. It repeatedly executes the reminder script,
incrementing today() with each iteration. The same rules about
preserving variables and function definitions apply. Note that using
repeat on the command line also enables the -q option and disables any
-z option. As an example, if you want to see how Remind will behave
for the next week, you can type:
remind .reminders ’*7’
If you want to print the dates of the next 1000 days, use:
(echo ’banner %’; echo ’msg [today()]%’) | remind - ’*1000’
INITIALIZING VARIABLES ON THE COMMAND LINE
The -i option is used to initialize variables on the Remind command
line. The format is -ivar=expr, where expr is any valid expression.
Note that you may have to use quotes or escapes to prevent the shell
from interpreting special characters in expr. You can have as many -i
options as you want on the command line, and they are processed in
order. Thus, if a variable is defined in one -i option, it can be
referred to by subsequent -i options.
Note that if you supply a date on the command line, it is not parsed
until all options have been processed. Thus, if you use today() in any
of the -i expressions, it will return the same value as realtoday() and
not the date supplied on the command line.
Any variables defined on the command line are preserved as with the
PRESERVE command.
You should not have any spaces between the -i option and the equal
sign; otherwise, strange variable names are created that can only be
accessed with the value() or defined() functions.
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.
SORTING REMINDERS
The -g option causes Remind to sort reminders by trigger date, time and
priority before issuing them. Note that reminders are still calculated
in the order encountered in the script. However, rather than being
issued immediately, they are saved in an internal buffer. When Remind
has finished processing the script, it issues the saved reminders in
sorted order. The -g option can be followed by up to three characters
that must all be "a" or "d". The first character specifies the sort
order by trigger date (ascending or descending), the second specifies
the sort order by trigger time and the third specifies the sort order
by priority. The default is to sort all fields in ascending order.
In ascending order, reminders are issued with the most imminent first.
Descending order is the reverse. Reminders are always sorted by
trigger date, and reminders with the same trigger date are then sorted
by trigger time. Non-timed reminders are always issued after timed
reminders in this mode. If two reminders have the same date and time,
then the priority is used to break ties. Reminders with the same date,
time and priority are issued in the order they were encountered.
You can define a user-defined function called SORTBANNER that takes one
DATE-type argument. In sort mode, the following sequence happens:
If Remind notices that the next reminder to issue has a different
trigger date from the previous one (or if it is the first one to be
issued), then SORTBANNER is called with the trigger date as its
argument. The result is coerced to a string, and passed through the
substitution filter with the appropriate trigger date. The result is
then displayed.
Here’s an example - consider the following fragment:
# Switch off the normal banner
BANNER %
REM 11 March 1993 ++1 MSG Not so important
REM 17 March 1993 ++7 MSG Way in the future
REM 10 March 1993 MSG Important Reminder
REM 11 March 1993 ++1 MSG Not so important - B
FSET sortbanner(x) iif(x == today(), \
"***** THINGS TO DO TODAY *****", \
"----- Things to do %b -----")
Running this with the -gaa option on 10 March 1993 produces the
following output:
***** THINGS TO DO TODAY *****
Important Reminder
----- Things to do tomorrow -----
Not so important
Not so important - B
----- Things to do in 7 days’ time -----
Way in the future
You can use the args() built-in function to determine whether or not
SORTBANNER has been defined. (This could be used, for example, to
provide a default definition for SORTBANNER in a system-wide file
included at the end of the user’s file.) Here’s an example:
# Create a default sortbanner function if it hasn’t already
# been defined
if args("sortbanner") != 1
fset sortbanner(x) "--- Things to do %b ---"
endif
MSGPREFIX() AND MSGSUFFIX()
You can define two functions in your script called msgprefix() and
msgsuffix(). They should each accept one argument, a number from 0 to
9999.
In normal mode, for MSG- and MSF-type reminders, the following sequence
occurs when Remind triggers a reminder:
o If msgprefix() is defined, it is evaluated with the priority of
the reminder as its argument. The result is printed. It is not
passed through the substitution filter.
o The body of the reminder is printed.
o If msgsuffix() is defined, it is evaluated with the priority of
the reminder as its argument. The result is printed. It is not
passed through the substitution filter.
Here’s an example: The following definition causes priority-0
reminders to be preceded by "URGENT", and priority-6000 reminders to be
preceded by "(not important)".
fset msgprefix(x) iif(x==0, "URGENT: ", \
x==6000, "(not important) ", "")
In Calendar Mode (with the -c, -s or -p options), an analogous pair of
functions named calprefix() and calsuffix() can be defined. They work
with all reminders that produce an entry in the calendar (i.e., CAL-
and possibly RUN-type reminders as well as MSG-type reminders.)
NOTES
Normally, the body of a reminder is followed by a carriage return.
Thus, the results of msgsuffix() will appear on the next line. If you
don’t want this, end the body of the reminder with a percentage sign,
"%". If you want a space between your reminders, simply include a
carriage return (char(13)) as part of the msgsuffix() return value.
If Remind has problems evaluating msgprefix(), msgsuffix() or
sortbanner(), you will see a lot of error messages. For an example of
this, define the following:
fset msgprefix(x) x/0
FOREIGN LANGUAGE SUPPORT
Your version of Remind may have been compiled to support a language
other than English. This support may or may not be complete - for
example, all error and usage messages may still be in English.
However, at a minimum, foreign-language versions of Remind will output
names of months and weekdays in the foreign language. Also, the
substitution mechanism will substitute constructs suitable for the
foreign language rather than for English.
A foreign-language version of Remind will accept either the English or
foreign-language names of weekdays and months in a reminder script.
However, for compatibility between versions of Remind, you should use
only the English names in your scripts. Also, if your C compiler or
run-time libraries are not "8-bit clean" or don’t understand the ISO-
Latin character set, month or day names with accented letters may not
be recognized.
THE HEBREW CALENDAR
Remind has support for the Hebrew calendar, which is a luni-solar
calendar. This allows you to create reminders for Jewish holidays,
jahrzeits (anniversaries of deaths) and smachot (joyous occasions.)
THE HEBREW YEAR
The Hebrew year has 12 months, alternately 30 and 29 days long. The
months are: Tishrey, Heshvan, Kislev, Tevet, Shvat, Adar, Nisan, Iyar,
Sivan, Tamuz, Av and Elul. In Biblical times, the year started in
Nisan, but Rosh Hashana (Jewish New Year) is now celebrated on the 1st
and 2nd of Tishrey.
In a cycle of 19 years, there are 7 leap years, being years 3, 6, 8,
11, 14, 17 and 19 of the cycle. In a leap year, an extra month of 30
days is added before Adar. The two Adars are called Adar A and Adar B.
For certain religious reasons, the year cannot start on a Sunday,
Wednesday or Friday. To adjust for this, a day is taken off Kislev or
added to Heshvan. Thus, a regular year can have from 353 to 355 days,
and a leap year from 383 to 385.
When Kislev or Heshvan is short, it is called chaser, or lacking. When
it is long, it is called shalem, or full.
The Jewish date changes at sunset. However, Remind will change the
date at midnight, not sunset. So in the period between sunset and
midnight, Remind will be a day earlier than the true Jewish date. This
should not be much of a problem in practice.
The computations for the Jewish calendar were based on the program
"hdate" written by Amos Shapir of the Hebrew University of Jerusalem,
Israel. He also supplied the preceding explanation of the calendar.
HEBREW DATE FUNCTIONS
hebday(d_date)
Returns the day of the Hebrew month corresponding to the date
parameter. For example, 12 April 1993 corresponds to 21 Nisan
5753. Thus, hebday(’1993/04/12’) returns 21.
hebmon(d_date)
Returns the name of the Hebrew month corresponding to date. For
example, hebmon(’1993/04/12’) returns "Nisan".
hebyear(d_date)
Returns the Hebrew year corresponding to date. For example,
hebyear(’1993/04/12’) returns 5753.
hebdate(i_day, s_hebmon [,id_yrstart [,i_jahr [,i_aflag]]])
The hebdate() function is the most complex of the Hebrew support
functions. It can take from 2 to 5 arguments. It returns a
DATE corresponding to the Hebrew date.
The day parameter can range from 1 to 30, and specifies the day
of the Hebrew month. The hebmon parameter is a string that must
name one of the Hebrew months specified above. Note that the
month must be spelled out in full, and use the English
transliteration shown previously. You can also specify "Adar A"
and "Adar B." Month names are not case-sensitive.
The yrstart parameter can either be a DATE or an INT. If it is
a DATE, then the hebdate() scans for the first Hebrew date on or
after that date. For example:
hebdate(15, "Nisan", ’1990/01/01’)
returns 1990/03/30, because that is the first occurrence of 15
Nisan on or after 1 January 1990.
If yrstart is an INT, it is interpreted as a Hebrew year. Thus:
hebdate(22, "Kislev", 5756)
returns 1995/12/15, because that date corresponds to 22 Kislev,
5756. Note that none of the Hebrew date functions will work
with dates outside 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 three SPECIALs that all backends should attempt to
support. They are currently supported by Rem2PS, tkremind and
rem2html.
The SHADE special replaces the psshade() function. Use it like this:
REM Sat Sun SPECIAL SHADE 128
REM Mon SPECIAL SHADE 255 0 0
The SHADE keyword is followed by either one or three numbers, from 0 to
255. If one number is supplied, it is interpreted as a grey-scale
value from black (0) to white (255). If three numbers are supplied,
they are interpreted as RGB components from minimum (0) to maximum
(255). The example above shades weekends a fairly dark grey and makes
Mondays a fully-saturated red. (These shadings appear in calendars
produced by Rem2PS, tkremind and rem2html.)
The MOON special replaces the psmoon() function. Use it like this:
REM [trigger(moondate(0))] SPECIAL MOON 0
REM [trigger(moondate(1))] SPECIAL MOON 1
REM [trigger(moondate(2))] SPECIAL MOON 2
REM [trigger(moondate(3))] SPECIAL MOON 3
These draw little moons on the various calendars. The complete syntax
of the MOON special is as follows:
... SPECIAL MOON phase moonsize fontsize msg
Phase is a number from 0 to 3, with 0 representing a new moon, 1 the
first quarter, 2 a full moon and 3 the last quarter.
moonsize is the diameter in PostScript units of the moon to draw. If
omitted or supplied as -1, the backend chooses an appropriate size.
fontsize is the font size in PostScript units of the msg
Msg is additional text that is placed near the moon glyph.
Note that only the Rem2PS backend supports moonsize and fontsize; the
other backends use fixed sizes.
The COLOR special lets you place colored reminders in the calendar.
Use it like this:
REM ... SPECIAL COLOR 255 0 0 This is a bright red reminder
REM ... SPECIAL COLOR 0 128 0 This is a dark green reminder
Immediately following COLOR should be three decimal numbers ranging
from 0 to 255 specifying red, green and blue intensities, respectively.
The rest of the line is the text to put in the calendar.
The COLOR special is "doubly special", because in its normal operating
mode, remind treats a COLOR special just like a MSG-type reminder.
Also, if you invoke Remind with -cc..., then it approximates SPECIAL
COLOR reminders on your terminal.
MISCELLANEOUS
COMMAND ABBREVIATIONS
The following tokens can be abbreviated:
o REM can be omitted - it is implied if no other valid command is
present.
o CLEAR-OMIT-CONTEXT --> CLEAR
o PUSH-OMIT-CONTEXT --> PUSH
o POP-OMIT-CONTEXT --> POP
o DUMPVARS --> DUMP
o BANNER --> BAN
o INCLUDE --> INC
o SCANFROM --> SCAN
NIFTY EXAMPLES
This section is a sampling of what you can do with Remind.
REM 5 Feb 1991 AT 14:00 +45 *30 \
RUN mail -s "Meeting at %2" $LOGNAME </dev/null &
On 5 February, 1991, this reminder will mail you reminders of a 2:00pm
meeting at 1:15, 1:45 and 2:00. The subject of the mail message will
be "Meeting at 2:00pm" and the body of the message will be blank.
REM AT 17:00 RUN echo "5:00pm - GO HOME!" | xless -g +0+0 &
This reminder will pop up an xless window at 5:00pm every day. The
xless window will contain the line "5:00pm - GO HOME!"
REM AT 23:59 RUN (sleep 120; remind -a [filename()]) &
This reminder will run at one minute to midnight. It will cause a new
Remind process to start at one minute past midnight. This allows you
to have a continuous reminder service so you can work through the night
and still get timed reminders for early in the morning. Note that this
trick is no longer necessary, providing you run Remind in daemon mode.
remind -c12 /dev/null Jan 1993
This invocation of Remind will cause it to print a calendar for 1993,
with all entries left blank.
REM CAL [trigdate()-date(year(trigdate()), 1, 1)+1]
This example puts an entry in each box of a calendar showing the number
(1-365 or 366) of the day of the year.
REM Tue 2 Nov SATISFY (year(trigdate())%4) == 0
IF trigvalid()
REM [trigger(trigdate())] ++5 MSG \
U.S. Presidential Election!!
ENDIF
This example warns you 5 days ahead of each American presidential
election. The first REM command calculates the first Tuesday after the
first Monday in November. (This is equivalent to the first Tuesday on
or after 2 November.) The SATISFY clause ensures that the trigger date
is issued only in election years, which are multiples of 4. The second
REM command actually issues the reminder.
DETAILS ABOUT TRIGGER COMPUTATION
Here is a conceptual description of how triggers are calculated. Note
that Remind actually uses a much more efficient procedure, but the
results are the same as if the conceptual procedure had been followed.
Remind starts from the current date (that is, the value of today()) and
scans forward, examining each day one at a time until it finds a date
that satisfies the trigger, or can prove that no such dates (on or
later than today()) exist.
If Remind is executing a SATISFY-type reminder, it evaluates the
expression with trigdate() set to the date found above. If the
expression evaluates to zero or the null string, Remind continues the
scanning procedure described above, starting with the day after the
trigger found above.
The SCANFROM clause (having a syntax similar to UNTIL) can modify the
search strategy used. In this case, Remind begins the scanning
procedure at scan_date, which is the date specified in the SCANFROM
clause. For example:
REM Mon 1 SCANFROM 17 Jan 1992 MSG Foo
The example above will always have a trigger date of Monday, 3 February
1992. That is because Remind starts scanning from 17 January 1992, and
stops scanning as soon as it hits a date that satisfies "Mon 1."
The main use of SCANFROM is in situations where you want to calculate
the positions of floating holidays. Consider the Labour Day example
shown much earlier. Labour Day is the first Monday in September. It
can move over a range of 7 days. Consider the following sequence:
REM Mon 1 Sept SCANFROM [trigger(today()-7)] SATISFY 1
OMIT [trigger(trigdate())]
REM Mon AFTER MSG Hello
The SCANFROM clause makes sure that Remind begins scanning from 7 days
before the current date. This ensures that Labour Day for the current
year will continue to be triggered until 7 days after it has occurred.
This allows you to safely use the AFTER keyword as shown.
In general, use SCANFROM as shown for safe movable OMITs. The amount
you should scan back by (7 days in the example above) depends on the
number of possible consecutive OMITted days that may occur, and on the
range of the movable holiday. Generally, a value of 7 is safe.
The FROM clause operates almost like the counterpoint to UNTIL. It
prevents the reminder from triggering before the FROM date. For
example, the following reminder:
REM Mon Thu FROM 23 Jul 2007 UNTIL 2 Aug 2007 MSG Test
will trigger on Mondays and Thursdays between 23 July 2007 and 2 August
2007 inclusive.
FROM is really just syntactic sugar; you could implement the reminder
above as follows:
REM Mon Thu SCANFROM [trigger(max(today(), ’2007-07-23’))] \
UNTIL 2 Aug 2007 MSG Test
but that’s a lot harder to read. Internally, Remind treats FROM
exactly as illustrated using SCANFROM. For that reason, you cannot use
both FROM and SCANFROM.
Note that if you use one REM command to calculate a trigger date,
perform date calculations (addition or subtraction, for example) and
then use the modified date in a subsequent REM command, the results may
not be what you intended. This is because you have circumvented the
normal scanning mechanism. You should try to write REM commands that
compute trigger dates that can be used unmodified in subsequent REM
commands. The file "defs.rem" that comes with the Remind distribution
contains examples.
DETAILS ABOUT TRIGVALID()
The trigvalid() function returns 1 if Remind could find a trigger date
for the previous REM or IFTRIG command. More specifically, it returns
1 if Remind finds a date not before the starting date of the scanning
that satisfies the trigger. In addition, there is one special case in
which trigvalid() returns 1 and trigdate() returns a meaningful result:
If the REM or IFTRIG command did not contain an UNTIL clause, and
contained all of the day, month and year components, then Remind will
correctly compute a trigger date, even if it happens to be before the
start of scanning. Note that this behaviour is not true for versions
of Remind prior to 03.00.01.
AUTHOR
Remind is now supported by Roaring Penguin Software Inc.
(http://www.roaringpenguin.com)
David F. Skoll <dfs@roaringpenguin.com> wrote Remind. The moon code
was copied largely unmodified from "moontool" by John Walker. The
sunrise and sunset functions use ideas from programs by Michael
Schwartz and Marc T. Kaufman. The Hebrew calendar support was taken
from "hdate" by Amos Shapir. OS/2 support was done by Darrel
Hankerson, Russ Herman, and Norman Walsh. The supported foreign
languages and their translators are listed below. Languages marked
"complete" support error messages and usage instructions in that
language; all others only support the substitution filter mechanism and
month/day names.
German -- Wolfgang Thronicke
Dutch -- Willem Kasdorp and Erik-Jan Vens
Finnish -- Mikko Silvonen (complete)
French -- Laurent Duperval (complete)
Norwegian -- Trygve Randen
Danish -- Mogens Lynnerup
Polish -- Jerzy Sobczyk (complete)
Brazilian Portuguese -- Marco Paganini (complete)
Italian -- Valerio Aimale
Romanian -- Liviu Daia
Spanish -- Rafa Couto
Icelandic -- Björn Davíðsson
BUGS
There’s no good reason why read-only system variables are not
implemented as functions, or why functions like version(), etc. are
not implemented as read-only system variables.
Hebrew dates in Remind change at midnight instead of sunset.
Language should be selectable at run-time, not compile-time. Don’t
expect this to happen soon! Remind has some built-in limits (for
example, number of global OMITs.)
BIBLIOGRAPHY
Nachum Dershowitz and Edward M. Reingold, "Calendrical Calculations",
Software-Practice and Experience, Vol. 20(9), Sept. 1990, pp 899-928.
L. E. Doggett, Almanac for computers for the year 1978, Nautical
Almanac Office, USNO.
Richard Siegel and Michael and Sharon Strassfeld, The First Jewish
Catalog, Jewish Publication Society of America.
SEE ALSO
rem, rem2ps, tkremind