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.
Remind uses scripts to control its operation. 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 SKIP 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 most powerful command in a Remind script is the REM command. This command is responsible for issuing reminders. Its syntax is:
The parts of the REM command can be specified in any order, except that the body must come immediately after the MSG, RUN, CAL 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, RUN, CAL or SATISFY clause is called a trigger.
MSG, RUN, and CAL
The keywords MSG, RUN and CAL denote the type of the reminder. (SATISFY is more complicated and will be explained later.) A MSG type reminder simply prints a message to the standard output, after passing the body through a special substitution filter, described in the section "The Substitution Filter." 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 or -s options.
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:
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 which also satisfies the weekday constraint. It does this by picking the first date on or after the specified day which 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 which 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.
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 which 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 which 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 which 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.
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 which were in effect at the end of the reminder script. These definitions may not necessarily be those which were in effect at the time the reminder was queued.
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.)
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."
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."
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."
Notes:
In addition to being a keyword in the REM command, OMIT is a command in its own right. Its syntax is:
The OMIT command is used to "globally" omit certain days, which are 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 which occurs on the same date each year - New Year's Day. The second example specifies a holiday which 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 which 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:
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.
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 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 which 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 which would normally execute a system command is disabled. RUN ON will re-enable the execution of system commands. Note that the RUN 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.
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.
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
When Remind first issues a reminder, it prints a message like this:
Reminders for Friday, 30th October, 1992 (today):
The BANNER command lets you change the format. It should appear before any REM commands. The format is:
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:
Sometimes, it is necessary to temporarily change the global OMITs which are in force for a few reminders. Three commands allow you to do this:
For example, suppose you have a block of reminders which require a clear OMIT context, and that they also introduce unwanted global OMITs which 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
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 understand four types of objects:
CONSTANTS
The following examples illustrate constants in Remind expressions:
However, DATE constants are printed as yyyy/mm/dd.
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
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.
STRING + STRING - returns a STRING which is the concatenation of the two orignal STRINGs.
STRING + anything or anything + STRING - converts the non-STRING argument to a STRING, and then performs concatenation. See the coerce() function.
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.
DATE - INT - returns a DATE which is INT days earlier than the original DATE.
TIME - INT - returns a TIME which is INT minutes earlier than the original TIME.
NOTES
Operators of equal precedence are always evaluated from left to right, except where parentheses dictate otherwise. This is important, because the enhanced "+" and "-" operators are 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
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" and "t" denote INT, STRING, DATE and TIME arguments, respectively. If an argument can be one of several types, the characters are concatenated. For example, "di_arg" denotes an argument which can be a DATE or an INT. "x_arg" denotes an argument which can be of any type. The type of the argument is followed by an underscore and an identifier naming the argument, for convenience.
The built-in functions are:
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
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 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 DATE arg cannot be converted to a time.
If type is "INT", then DATE and TIME arguments are converted using the reverse of procedures described above. A STRING arg is converted by parsing it as an integer.
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.
If three arguments are supplied, returns str1 if num is 1, and str2 otherwise.
REM Mon OMIT Mon SKIP MSG Impossible!
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:
["SET"] a 1
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!
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.
Remind has commands which 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 which 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() > date(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.
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:
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.
The form of REM which 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 ommitting Labour Day for 1993, and the "Mon AFTER" command will not be triggered.
It is probably best to stay away from computing OMIT trigger dates unless you keep these pitfalls in mind.
Although the command-line -d option is useful for debugging, it is often overkill. For example, if you turn on the -dx option for a reminder file with many complex expressions, you'll get a huge amount of output. The DEBUG command allows you to control the debugging flags under program control. The format is:
DEBUG [+flagson] [-flagsoff]
Flagson and flagsoff consist of strings of the characters "extvl" which 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.
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 the -c or -s command-line option, the 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 which trigger are saved in internal buffers, and then inserted into the calendar in the appropriate places.
For example, if you have a reminder script called ".reminders", and you executed 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 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 which do not depend on the value of today() are done only once.
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.
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 whn you log out.
COMMAND ABBREVIATIONS
The following commands can be abbreviated:
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.
Date calculation is a bit "brute force."
The MS-DOS version of Remind does not support queuing or timed activation of reminders.
Remind has some built-in limits on total line length, substitution buffer length, number of global OMITs, etc.