Source Code 1992 March/Source_Code_CD-ROM_Walnut_Creek_March_1992.iso/usenet/altsrcs/3/3862

Internet Message Format | 1991-08-22 | 48.2 KB

Path: wupost!cs.utexas.edu!uwm.edu!linac!att!cbnews!jbr0
From: [e-mail] (joseph.a.brownlee)
Newsgroups: alt.sources
Subject: Pcal v4.1, part 2 of 6
Keywords: pcal calendar postscript
Message-ID: <[e-mail]>
Date: 19 Aug 91 12:13:27 GMT
Followup-To: alt.sources.d
Organization: AT&T Bell Laboratories
Lines: 1387

#!/bin/sh
# This is part 02 of a multipart archive
# ============= Pcal.hlp ==============
if test -f 'Pcal.hlp' -a X"$1" != X"-c"; then
    echo 'x - skipping Pcal.hlp (File already exists)'
else
echo 'x - extracting Pcal.hlp (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'Pcal.hlp' &&
1 PCAL
X        Pcal generates PostScript  to  produce  landscape  or portrait
X    calendars for any month  and  year.  The arguments month,year, and
X    nmonths, if provided, should be  numeric.   The month value should
X    be in the range 1 -  12, and the year value should be specified as
X    1  or 2 digits or as the  full  4  digit  year.    If  no  numeric
X    arguments  are  provided, the calendar for the current  month  and
X    year will be generated.
X
X        If one numeric argument is provided, it is interpreted  as the
X    year  value, and calendars for the entire year will be  generated.
X    Otherwise,  nmonth  months,  starting with month and year, will be
X    generated.
X
X        For whole-year calendars (i.e.  the  -w  option is given), the
X    command line arguments are interpreted somewhat differently.    By
X    default, all months in the current year are printed, starting with
X    January.  If the month argument alone is given,  it is expected to
X    be the desired year to print, and prints all of  the months in the
X    given year.  If both month and year are given, then 12 consecutive
X    months  are printed starting at the given month and year.  If  the
X    month,  year, and nmonths  arguments  are  all  present,  printing
X    begins  with the given month  and  year  and  nmonths  months  are
X    printed, rounded up to the nearest multiple of 12.
X
X        VMS Version
X        Execution format:
X
X            pcal [options] [mm yy] [n]
X
2 Parameters
X  mm yy n
X        "mm" and "yy"  are numeric values of the month (1-12) and year
X    (0-99) (i.e., July 1990  would  be 7 90).  If you just include the
X    "yy" option, an entire 12  months  of calendars will be generated.
X    A specific month can be produced  by including the "mm" parameter.
X    The  "n"  parameter will  produce the "n"  consecutive  months  of
X    calendars starting with the requested month.
X
X        The following  flags  may be specified (in increasing order of
X    precedence) in global symbol PCAL_OPTS, in "opt" lines in the date
X    file (all but -e, -f, -h, -v, -"D", -"U"), or on the command line.
X    Any flag which normally takes an argument may be specified without
X    the  argument;  this resets its  value  to  the  program  default.
X    (-"D" alone thus clears all defined symbols;    -"U"  alone has no
X    effect.)
X
X        The "-" flag has  been added to  disambiguate  cases  where an
X    argument-less flag has been specified immediately before a numeric
X    parameter:
X
X        pcal -t - 9 90
X
2 Options
X        Pcal  accepts  several  command  line  options  (or  from  the
X    CALENDAR.DAT file).  The uppercase options  should  be enclosed in
X    quotes as pcal is case-sensitive and the  VMS  command line parser
X    will  convert  the  string to upper case otherwise.    The  quoted
X    strings  are  not  needed if the options are included  within  the
X    CALENDAR.DAT file.
X
3 -e
X        Print an  empty  calendar (i.e., do not  print entries  from a
X    CALENDAR.DAT file.)
X
3 -f <FILE>
X        Directs pcal to use the  file name <FILE> as the input file in
X    place  of the  default  CALENDAR.DAT  file  in  the  callers  home
X    directory or in the  directory specified by logical name PCAL_DIR.
X
3 -o <FILE>
X        Directs  pcal to  write  the  PostScript  calendar  into  FILE
X    (default: CALENDAR.PS in the current directory.)
X
3 -j
X        Directs pcal to print  the  Julian  (Day Of Year, DOY) in each
X    calendar box.
X
3 -"J"
X        Directs pcal to print the Julian  (Day  Of  Year, DOY) and the
X    number of days remaining in the year in each calendar box.
X
3 -l
X        This will cause the  output  to  come  out  in  landscape mode
X    (This is the default).
X
3 -p
X        This will cause  the  output  to  come  out  in  portrait mode
X    instead of landscape mode.
X
3 -m
X        This option causes a  moon to be printed on days corresponding
X    to a full, half, or new moon (default: no moons).
X
3 -"M"
X        This option causes a fractional moon to be printed on all days
X    (default:  no moons).
X
3 -b <DAY> | all
X        This  will cause  all dates  on weekday  DAY to be  printed in
X    black;  "-b all" causes  all dates  to be printed  in black unless
X    explicitly flagged as a holiday.
X
3 -g <DAY> | all
X        This  will cause  all dates  on weekday  DAY to be  printed in
X    gray; "-g all" causes all dates to be printed in gray.  Default is
X    to print Saturdays  and Sundays in gray and  other dates in black.
X
3 -"O"
X        Causes  pcal to  print  "gray"  dates  as outlined characters.
X
3 -"G"
X        Causes  pcal  to  print  "gray"  dates  as outlined characters
X    filled with gray.
X
3 -"F" <DAY>
X        This will cause  the weekday  DAY  to be the first day of each
X    week;  weekday  DAY  will appear in  the left-most  column of each
X    calendar.
X
3 -"A" | -"E"
X        Directs  pcal    to  use  either  American  or  European  date
X    conventions.  Use  one  of these options to select the date format
X    for the calendar file.    The  -"A"  option  (the default) selects
X    American-style dates like "10/19/90" or  "Sep  19 1990", while the
X    -"E" option selects European-style dates like  "17/10/90"  or  "19
X    Sep 1990".
X
3 -t <FONT>
X        This option can be used  to  change  the  font  the  title  is
X    printed in  (ie. pcal -t Times-Roman).  The default is Times-Bold.
X
3 -d <FONT>
X        This option is the same as  -t  except  that  the font used to
X    print the  day  numbers is  changed.  The  default is  Times-Bold.
X
3 -n <FONT>
X        This option is the same as  -n  except  that  the font used to
X    print the notes in the calendar boxes is  changed.  The default is
X    Helvetica-Narrow.
X
3 -"L" <STRING>
X        This will cause STRING to be printed as a left footer.
X
3 -"C" <STRING>
X        This will cause STRING to be printed as a center footer.
X
3 -"R" <STRING>
X        This will cause STRING to be printed as a right footer.
X
3 -"D" <SYM>
X        This will define symbol SYM prior to  reading  the  date file;
X    -"D" alone clears all defined symbols.
X
3 -"U" <SYM>
X        This will undefine symbol  SYM prior to reading the date file.
X
3 -x xscale
X        Specifies the x-axis scaling factor for the calendar size.
X
3 -y yscale
X        Specifies the y-axis scaling factor for the calendar size.
X
3 -"X" xtrans
X        Specifies  the  x-axis  translation  value for positioning the
X    output on the page.
X
3 -"Y" ytrans
X        Specifies  the  y-axis  translation  value for positioning the
X    output on the page.
X
3 -"I"
X        Resets all parameters to the program defaults.
X
3 -"B"
X        Causes pcal to leave  unused  calendar boxes blank (default is
X    gray).
X
3 -w
X        Causes pcal  to print a calendar for 12 consecutive months:  3
X    rows / 4 columns in landscape mode, 4 rows / 3 columns in portrait
X    mode.  This option  effectively  disables  the  -"M"|m (moons) and
X    -"J"|j (Julian dates) flags, and  also  suppresses the text in the
X    calendar boxes.  The numeric parameters work slightly differently:
X
X            yy              print Jan/yy .. Dec/yy
X            mm yy           print 12 months starting with mm/yy
X            mm yy n         print n months (rounded up to multiple of 12)
X                                starting with mm/yy
X            (default)       print Jan .. Dec of current year
X
X        Note that "-w" in conjunction with "-p" overrides any  Y-scale
X    factor  (default  or  set  with  "-y")  in order to use  the  full
X    portrait page.
X
3 -h
X        This prints version AND usage information only. (LONG)
X
3 -v
X        This prints version information only.
X
2 Calendar_File
X        By default,  pcal  simply  prints an empty calendar.  Its real
X    power is in  its  ability to place "events" in appropriate days on
X    the  calendar,  thus allowing  the  user  to  create  personalized
X    calendars.  This is achieved through the use of the "date file".
X
X        The date file is named  CALENDAR.DAT Pcal will look in several
X    places for such a file.   First,  if  a  file  called CALENDAR.DAT
X    exists in the caller's home directory, it  is used.  Next, if such
X    a  file  exists  in the directory indicated by  the  logical  name
X    PCAL_DIR  (or  the  current  directory  if  no  such  variable  is
X    defined),  it  is  used.    Finally, the directory where the  pcal
X    executable resides will be checked.  If no date file is  found, an
X    empty calendar is printed.
X
X        If  a  date file is found, it will be searched for lines  with
X    leading dates matching  the  requested  month  and year.  Any text
X    following the dates found  will  be  printed on the calendar under
X    the appropriate day of the  month.  Dates in the CALENDAR.DAT file
X    may be expressed in any of several formats:
X
X          <ordinal> <day_spec> in <month_spec>{*} {<text>}
X          <day_spec> <prep> <date_spec>{*} {<text>}
X          <date_spec>{*} {<text>}
X
X    Where:
X
X      <month_spec>  := first 3+ characters of name of month or "all"
X      <day_spec>    := first 3+ characters of name of weekday, "day",
X                       "weekday", "workday", "holiday",
X                       "nonweekday", "nonworkday", or "nonholiday"
X      <ordinal>     := "first", "1st", ... "fifth", "5th",
X                       "last", "odd", "even", or "all"
X      <prep>        := "before", "preceding", "after", "following",
X                       "on_or_before" ("oob"), or
X                       "on_or_after" ("ooa")
X      <sep>         := 1 or more non-numeric, non-space, non-"*" characters
X      <month>       := day of month (1-31)
X      <day>         := a numeric month (1-12)
X      <year>        := a numeric year
X
X     If the -"A" option (American date formats, the default) is given:
X
X      <date_spec>   := [<month_spec><day> | <month><sep><day>{<sep><year>}]
X
X     If the -"E" option (European date formats) is given:
X
X      <date_spec>   := [<day><month_spec> | <day><sep><month>{<sep><year>}]
X
3 Text_Format_Description
X        Pcal also allows format  specifiers  in both the text and foot
X    strings (see the -L, -C,  and  -R  options  below);   each will be
X    replaced by a corresponding string as outlined in the table below.
X    Most of these are derived from the  strftime()  function;   the %l
X    and %[o0+--] format specifiers are specific to pcal:
X
X                %a     abbreviated weekday
X                %A     full weekday
X                %b     abbreviated month name
X                %B     full month name
X                %d     day of month (1-31)
X                %j     day of year (1-366)
X                %l     days left in year (0-365)
X                %m     month (1-12)
X                %U     week number (0-53)
X                %W     week number (0-53)
X                %y     year w/o century (00-99)
X                %Y     year w/century
X                %%     % character
X
X                %o     print number as ordinal
X                %0     print number with leading zeroes
X                %+     use following month or year
X                %-     use previous month or year
X
X        The %U  format  specifier  considers  the first logical Sunday
X    (the first day  of  the week as printed;  see the -F option below)
X    of the year as  the  first day of week number 1;  the %W specifier
X    uses the first logical Monday  instead.    This is an extension of
X    the behavior of the strftime() function.
X
X        The %o format specifier prints a  number  as  an ordinal, with
X    the  appropriate  suffix ("st", "nd", "rd", or  "th"  in  English)
X    appended;  for example, %od prints the day  of the month as "1st",
X    "2nd", "3rd", etc.
X
X        Unlike  strftime(), pcal's default is to print numbers (except
X    %y)  without  leading zeroes.  If leading zeroes are desired,  the
X    "0" prefix may be used;  for example, %0j prints the  day  of year
X    as 001-365.
X
X        The  %+ and %- format specifiers direct pcal to substitute the
X    following or  previous  month  or  year  for the following [bBmyY]
X    specifier;  for  example,  %+B  prints  the  name of the following
X    month.
X
3 Date_Syntax_Description
X        Any  non-numeric  character  may  separate    numeric   dates.
X    Holidays may be flagged by following the date immediately with "*"
X    as in the examples above;   this will cause the date to be printed
X    in gray.  "Each" and "every" are  accepted  as synonyms for "all",
X    and any word may be used in place  of  "in".    The  abbreviations
X    "oob"  and  "ooa"  may  be  used  in  place  of    the    keywords
X    "on_or_before" and "on_or_after", respectively.
X
X        Wildcard  day  names are also provided.  The keyword "weekday"
X    applies to  any  days  which  are normally printed in black on the
X    calendar.  The keyword "workday" is the same, but does not include
X    any holidays.  The  keyword  "holiday"  includes  only  those days
X    flagged as holidays.  The keywords "nonweekday", "nonworkday", and
X    "nonholiday" are also recognized as negations  of  the above.  See
X    the Caveats below for important notes on using these keywords.
X
X        Ordinal  day  numbers may be used  to  specify  dates,  either
X    relative to the month or to the  year.    Either  words or numeric
X    abbreviations  may  be used for "first" through "fifth";    higher
X    numbers must be given using the numeric equivalent (e.g.   100th).
X    Negative  ordinal numbers may even be used.  For example,  "-2nd"
X    means "next to last".
X
X        "Odd" and "even" do not refer  to  the  actual date;  instead,
X    "odd" means "alternate, starting with the first", and "even" means
X    "alternate,  starting  with  the second".  Thus, "odd  Fridays  in
X    March" refers to the first, third, and (if present)  fifth Fridays
X    in March - not to those Fridays falling on odd dates.
X
X        "All" refers to each individual month;    "year" refers to the
X    year as an entity.  Thus "odd Fridays in all" refers to the first,
X    third, and fifth Friday of each month, while "odd Fridays in year"
X    refers  to  the  first  Friday of January and every  other  Friday
X    thereafter.
X
X        Text in the date file may use C-like escape sequences (i.e.  a
X    "\" followed by a character, 1--3 octal digits, or "x" followed by
X    1--2 hexadecimal digits).  Escaped  whitespace (including newline)
X    and the standard ANSI character escapes  ("\a",  "\b", "\f", "\n",
X    "\r", "\t", "\v") are all replaced by a single blank.
X
X        Lines in the CALENDAR.DAT file consisting  of year #### (where
X    #### is a numeric year) can be  used to set the year for following
X    entries.  This assumes that the following entries do not contain a
X    year;  any date entries containing year information will  set  the
X    remembered year to that year.
X
X        Lines in the CALENDAR.DAT file consisting of opt <options> can
X    be used to override the  defaults  for  any  command-line  options
X    except -e, -f, -h, -"D", and  -"U".  Any options specified in this
X    manner are, in turn, overridden by those  specified  explicitly on
X    the command line.  Note that the upper  case letter options do NOT
X    need to be enclosed in quotes if they are  put in the CALENDAR.DAT
X    file.  Enclose the upper case letters in quotes only when they are
X    used on the DCL.
X
X        Lines in the CALENDAR.DAT file consisting of note  <month> can
X    be used to place notes regarding the entire month  is  one  of the
X    unused  blocks  of  the  calendar.   The <month> indicator may  be
X    either  a  number  1  through  12  or an alphabetic month name  as
X    described above;  "note all" will place the associated text in the
X    notes block for each month in the current year.
X
X        Comments  are   supported  in  the  CALENDAR.DAT  file.    Any
X    characters following a  "#"  character through the end of the line
X    are ignored.
X
X        Pcal  supports rudimentary cpp-like functionality in the  date
X    file, allowing the following constructs:  define | undef, if{n}def
X    ...  {else ...} endif,  and  include.    Note  that  these are not
X    preceded  by  "#" as they are in C.  Symbol  names  defined  using
X    these  keywords (or via the -"D" option) are case-insensitive.  It
X    is not  an  error  to  undef  an undefined symbol, nor to define a
X    previously-defined one.   An  ifdef  alone  is  always  false;  an
X    ifndef alone is always true.
X
X        The  name  of the file in the include directive may optionally
X    be surrounded by either "" or <>, both of which are ignored.    If
X    the  name  is not an absolute path, it is taken to be relative  to
X    the directory where the file containing the directive is located.
X
X        In  addition  to  pre-processing keywords, pcal  also  accepts
X    boolean  expressions in if{n}def directives.    These  expressions
X    consist of symbol names joined by  the  boolean operators !, &, ^,
X    and |, in order of precedence, high to low.   Parentheses  may  be
X    used to alter the precedence.  The synonyms && and || are accepted
X    for  &  and  |.    A  symbol  name evaluates to true if  currently
X    defined, false if not;  thus:
X
X                              ifdef A | B | C
X
X    ...is true if any of the symbols A, B, and C is defined, and:
X
X                              ifdef A & B & C
X
X    ...is true if they all are.  Note that ifndef <expr> is equivalent
X    to ifdef !( <expr> ).
X
3 Example
X    Date File Example:
X
X    # A sample "opt" line to change the fonts and output file names,
X    # to print only Sundays in gray, and to print moons on all days:
X    #
X    opt -d Helvetica-Bold -t Helvetica-Bold -o myfile.ps -b all -g sun -M
X
X    year 1990               # set year explicitly
X    1/1*                    New Year's Day
X    ifndef Arizona
X        3rd Mon in Jan*     Martin Luther King's Birthday
X    endif
X    2/2                     Groundhog Day
X    Feb 14                  Valentine's Day
X    3rd Monday in Feb*      Presidents' Day
X    3/17                    St. Patrick's Day
X    last Monday in May*     Memorial Day
X    7/4*                    Independence Day
X    1st Monday in Sep*      Labor Day
X    second Monday in Oct*   Columbus Day (observed)
X    first workday in all    %-B progress report due
X    all Fridays in Oct      Status Meeting, 11 AM
X    all Fri in all          Time card due, 3 PM
X    all Monday in all       Fiscal week %0W
X    -2nd workday in all     Schedule for %+B due
X    Fri on_or_before all 15 Pay Day
X    even Fridays in year    Pay Day
X    183rd day of year       mid-year (%l days left)
X    10/12                   Columbus Day (traditional)
X    10/31                   Halloween
X    Tue after first Mon in Nov      Election Day
X    second Monday in Nov*           Veterans' Day (observed)
X    11/11*                          Veterans' Day (traditional)
X    fourth Thu in Nov*              Thanksgiving
X    Fri after 4th Thu in Nov*       Day after Thanksgiving
X    day after fourth Thu in Nov*
X    12/24*                  Christmas Eve
X    12/25*                  Christmas
X    last day in Dec*        New Year's Eve
X    last workday in all     Status reports due
X    note Dec                Office closed throughout week of Christmas
X    1/1/91*                 New Year's Day      # set new year implicitly
X
2 Moon_File
X        If  a  file  of the name MOON##.DAT (where ## is the last  two
X    digits  of  the calendar year) exists in the same directory as the
X    date file, pcal uses the information contained within to calculate
X    the phase of  the  moon.    If  no  such file exists, pcal uses an
X    extreamly reliable algorithm.  This is the prefered method of use.
X
X        Entries in the moon file must conform to the following syntax:
X
X        If the -"A" option  (American  date  formats,  the default) is
X    given:
X
X              <quarter> <month><sep><day> {<hour><sep><min>}
X
X        If the -"E" option (European date formats) is given:
X
X              <quarter> <day><sep><month> {<hour><sep><min>}
X
X        Where:
X
X            <quarter>   := "nm", "fq" or "1q", "fm", "3q" or "lq"
X                           (new moon,first quarter,full moon,last quarter)
X            <hour>      := number 0-23 (24-hour clock)
X            <min>       := number 0-59
X
X        This file must contain entries for  all  quarter  moons in the
X    year, in chronological order;  if any errors are encountered, pcal
X    will revert to using its default algorithm.
X
X        As in the date file, comments start with  "#"  and run through
X    end-of-line.
X
3 Example
X        The following  is  a  short example of an European style (-"E)
X    moon data file.    It  is  taken from the MOON91.DAT file supplied
X    with pcal.
X
X        3q 01/07 13:37        # third quarter
X        nm 01/15 18:51        # new moon
X        1q 01/23 09:23        # first quarter
X        fm 01/30 01:10        # full moon
X
2 Logical_Names
X        Pcal optionally uses two (2)  logical  names during execution.
X    A user may define them or let the administrator set them up.
X
3 Pcal_Dir
X        Pcal logical name for the location  of the directory for input
X    and output files.  In this way,  a  user can over-ride the current
X    default location for the source  of  the  CALENDAR.DAT input file
X    and the CALENDAR.PS output file.
X
3 Pcal_Opts
X        Pcal  also  looks for a logical name "Pcal_Opts;  if  defined,
X    its contents  are  parsed  as command-line flags.  These over-ride
X    the program defaults,  but  are  over-ridden  by any specified via
X    "opt" lines in the date file or on the command line.  Example:
X
X        Define Pcal_Opts "-n Helvetica -D meetings"     ! login.com
X        pcal -"U" meetings 9 90       ! un-define symbol at runtime
X
2 Caveats
X        The "workday" and "holiday" keywords are aware  of  only those
X    holidays which have already been flagged at the  point  where they
X    appear.  For example, consider January 1990:
X
X                        January 1990
X                     S  M Tu  W Th  F  S
X                        1  2  3  4  5  6
X                     7  8  9 10 11 12 13
X                    14 15 16 17 18 19 20
X                    21 22 23 24 25 26 27
X                    28 29 30 31
X
X        If the CALENDAR.DAT file looked like this:
X
X            workday on_or_before all 15         payday
X            3rd Mon in Jan*                     MLK day
X
X    then Pcal would mark the 15th as "payday" since  at  that point in
X    the CALENDAR.DAT file it has no way of knowing that  January  15th
X    will  later  be  flagged  as  a  holiday.  If the two  lines  were
X    reversed, such that  the  holiday preceded the "workday" wildcard,
X    then Pcal would work  as  intended,  marking  instead  the 12th as
X    "payday".    Also, beware of  year  boundaries  which  affect  the
X    handling of all of the day  wildcard  keywords.  In general, it is
X    best to place monthly wildcards such as  the  example above at the
X    end of each year to acheive the desired effect.
X
X        When the -w and -p options are used together, pcal revises the
X    y-scale   factor  in  order  to  use  the  entire  portrait  page;
X    therefore, the user should avoid using use  the  -y using both the
X    -w and -p options.  Use of the  -w  option in any case effectively
X    disables the -m, -"M", -j, and -"J" options.
X
2 Authors
X        The original  PostScript  code  to  generate the calendars was
X    written by Patrick  Wood  (Copyright  (c)  1987 by Patrick Wood of
X    Pipeline Associates, Inc.), and  authorized  for  modification and
X    redistribution.    The  CALENDAR.DAT  file    inclusion  code  was
X    originally written in "bs(1)" by Bill  Vogel  of  AT&T.  Patrick's
X    original  PostScript  was modified and enhanced several  times  by
X    others  whose names have regrettably been lost.   Ken  Keirnan  of
X    Pacific Bell assembled the original "C" version upon which this is
X    based;  additional modifications and enhancements were the work of
X    Joseph P.    Larson,  Ed Hand, Andrew W.  Rogers, Mark Kantrowitz,
X    Joe Brownlee, Jamie  Zawinski and Floyd Miller.  The moon routines
X    were  originally  written  by   Mark  Hanson,  were  improved  and
X    incorporated  into  this  version  by  Jamie  Zawinski,  and  were
X    translated from PostScript to C by  Andrew  Rogers.    VMS and TeX
X    support was provided by Richard Dyson and  updated  by  Andrew  W.
X    Rogers and Joe Brownlee.  The Amiga support  was  supplied by Bill
X    Hogsett.
X
2 Version
X        This help file  currently reflects pcal v4.1 dated 15-AUG-1991
X    and was updated by Richard Dyson on 15-AUG-1991.
SHAR_EOF
chmod 0644 Pcal.hlp ||
echo 'restore of Pcal.hlp failed'
Wc_c="`wc -c < 'Pcal.hlp'`"
test 24613 -eq "$Wc_c" ||
    echo 'Pcal.hlp: original size 24613, current size' "$Wc_c"
fi
# ============= SetUp.com ==============
if test -f 'SetUp.com' -a X"$1" != X"-c"; then
    echo 'x - skipping SetUp.com (File already exists)'
else
echo 'x - extracting SetUp.com (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'SetUp.com' &&
$ Write Sys$Output "SETting UP Pcal (v4.1)..."
$ THIS_PATH = F$Element (0, "]", F$Environment ("PROCEDURE")) + "]"
$ PCAL :== $ 'THIS_PATH'PCAL.EXE
$ Define Pcal_Dir 'THIS_PATH'
$!
$!  Put the help library into the next available help library slot
$!
$ LIB = "Hlp$Library"
$ X = F$Trnlnm (LIB, "Lnm$Process")
$ If X .eqs. "" Then GoTo INSERT
$ If X .eqs. "''THIS_PATH'PCAL.HLB" Then GoTo EXIT
$ BASE = LIB + "_"
$ N = 1
$NEXTLIB:
$   LIB := 'BASE''N'
$   X = F$Trnlnm (LIB, "Lnm$Process")
$   If X .eqs. "" Then GoTo INSERT
$   If X .eqs. "''THIS_PATH'PCAL.HLB" Then GoTo EXIT
$   N = N + 1
$   GoTo NEXTLIB
$INSERT:
$   Define 'LIB' 'THIS_PATH'PCAL.HLB
$EXIT:
$   Exit
SHAR_EOF
chmod 0644 SetUp.com ||
echo 'restore of SetUp.com failed'
Wc_c="`wc -c < 'SetUp.com'`"
test 670 -eq "$Wc_c" ||
    echo 'SetUp.com: original size 670, current size' "$Wc_c"
fi
# ============= VaxCrtl.opt ==============
if test -f 'VaxCrtl.opt' -a X"$1" != X"-c"; then
    echo 'x - skipping VaxCrtl.opt (File already exists)'
else
echo 'x - extracting VaxCrtl.opt (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'VaxCrtl.opt' &&
Sys$Library:VAXCRTL.EXE /Share
SHAR_EOF
chmod 0644 VaxCrtl.opt ||
echo 'restore of VaxCrtl.opt failed'
Wc_c="`wc -c < 'VaxCrtl.opt'`"
test 31 -eq "$Wc_c" ||
    echo 'VaxCrtl.opt: original size 31, current size' "$Wc_c"
fi
# ============= calendar ==============
if test -f 'calendar' -a X"$1" != X"-c"; then
    echo 'x - skipping calendar (File already exists)'
else
echo 'x - extracting calendar (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'calendar' &&
# Sample date file for Pcal: this should be called .calendar for Un*x,
# CALENDAR.DAT for VMS, and should live in the user's home directory.
#
# Date file syntax:
#
#    The following rules describe the syntax of date file entries:
#
#      year <year>
#
#      opt <options>
#
#      note <month_spec> <text>
#      note <month> <text>
#
#      if -A flag (American date formats) specified:
#        <month_name> <day>{*} {<text>}
#        <month><sep><day>{<sep><year>}{*} {<text>}
#
#      if -E flag (European date formats) specified:
#        <day> <month_name>{*} {<text>}
#        <day><sep><month>{<sep><year>}{*} {<text>}
#
#      <ordinal> <day_name> in <month_spec>{*} {<text>}
#      <day_name> <prep> <date_spec>
#
#    where
#
#      {x}          means x is optional
#
#      <date_spec> := any of the above date specs (not year, note, or opt)
#      <month_name> := first 3+ characters of name of month, or "all"
#      <month_spec> := <month_name>, or "year"
#      <day_name> := first 3+ characters of name of weekday, "day",
#                    "weekday", "workday", "holiday", "nonweekday",
#                    "nonworkday", or "nonholiday"
#      <ordinal> := ordinal number ("1st", "2nd", etc.), "first" .. "fifth",
#                    "last", "even", "odd", or "all"
#      <prep> := "before", "preceding", "after", "following", "on_or_before",
#                    or "on_or_after"
#      <sep> := one or more non-numeric, non-space, non-'*' characters
#      <month>, <day>, <year> are the numeric forms
#
#      <options> := any command-line option except -e, -f, -h, -D, -U
#
#    Comments start with '#' and run through end-of-line.
#
#    Holidays may be flagged by specifying '*' as the last character of
#    the date field(s), e.g. "10/12* Columbus Day", "July 4* Independence
#    Day", etc.  Any dates flagged as holidays will be printed in gray, and
#    any associated text will appear adjacent to the date.
#
#    Note that the numeric date formats (mm/dd{/yy}, dd.mm{.yy}) support
#    an optional year, which will become the subsequent default year.  The
#    alphabetic date formats (month dd, dd month) do not support a year
#    field; the "year yy" command is provided to reset the default year.
#
#    "Floating" days may be specified in the date file as "first Mon in
#    Sep", "last Mon in May", "4th Thu in Nov", etc.; any word may be
#    used in place of "in".  "Relative floating" days (e.g. "Fri after 4th
#    Thu in Nov") are also accepted; they may span month/year bounds.
#    Pcal also accepts date specs such as "all Friday{s} in October", "last
#    Thursday in all", etc., and produces the expected results; "each" and
#    "every" are accepted as synonyms for "all".  Negative ordinals are
#    allowed; "-2nd" means "next to last".
#
#    The words "day", "weekday", "workday", and "holiday" may be used as
#    wildcards: "day" matches any day, "weekday" matches any day normally
#    printed in black, "workday" matches any day normally printed in black
#    and not explicitly flagged as a holiday, and "holiday" matches any
#    day explicitly flagged as a holiday.  "Nonweekday", "nonworkday",
#    and "nonholiday" are also supported and have the obvious meanings.
#
#    "Odd" and "even" do not refer to the actual date; instead, "odd"
#    means "alternate, starting with the first"; "even" means "alternate,
#    starting with the second".  Thus, "odd Fridays in March" refers to
#    the first, third, and (if present) fifth Fridays in March - not to
#    those Fridays falling on odd dates.
#
#    "All" refers to each individual month; "year" refers to the year
#    as an entity.  Thus "odd Fridays in all" refers to the first/third/
#    fifth Friday of each month, while "odd Fridays in year" refers to
#    the first Friday of January and every other Friday thereafter.
#
#    Additional notes may be propagated to an empty calendar box by the
#    inclusion of one or more lines of the form "note <month> <text>",
#    where <month> may be numeric or alphabetic; "note all <text>"
#    propagates <text> to each month in the current year.
#
#    Pcal also allows format specifiers in the text (and foot strings -
#    cf. the -L, -C, and -R options); each will be replaced by its
#    equivalent string as outlined in the table below.  (Most of these are
#    derived from the strftime() function; %[lo0+-] are Pcal-specific.)
#
#        %a : abbreviated weekday
#        %A : full weekday
#        %b : abbreviated month name
#        %B : full month name
#        %d : day of month (1-31)
#        %j : day of year (1-366)
#        %l : days left in year (0-365)
#        %m : month (1-12)
#        %U : week number (0-53)
#        %W : week number (0-53)
#        %y : year w/o century (00-99)
#        %Y : year w/century
#        %% : '%' character
#
#        %o : print number as ordinal
#        %0 : print number with leading zeroes
#        %+ : use following month or year
#        %- : use previous month or year
#
#    %U considers the first logical Sunday (the first day of the week as
#    printed; cf. the -F flag) of the year as the first day of week 1;
#    %W uses the first logical Monday instead.  This is an extension of
#    strftime()'s behavior.
#
#    %o prints a number as an ordinal, with the appropriate suffix ("st",
#    "nd", "rd", or "th" in English) appended; for example, "%od" prints
#    the day of the month as "1st", "2nd", "3rd", etc.
#
#    Unlike strftime(), Pcal's default is to print numbers (except %y)
#    without leading zeroes.  If leading zeroes are desired, the '0'
#    prefix may be used; for example, "%0j" prints the day of year as
#    001-365.
#
#    %+ and %- direct Pcal to substitute the following/previous month/year
#    in the following [bBmyY] specifier; for example, %+B prints the name
#    of the next month.
#
#    Simple cpp-like functionality is provided.  The date file may include
#    the following commands, which work like their cpp counterparts:
#
#            define <sym>
#            undef <sym>
#
#            if{n}def <expr>
#               ...
#            { else
#               ... }
#            endif
#
#            include <file>
#
#    Note that these do not start with '#', which is reserved as a comment
#    character.
#
#    <sym> is a symbol name consisting of a letter followed by zero or
#    more letters, digits, or underscores ('_').  Symbol names are always
#    treated in a case-insensitive manner.
#
#    <expr> is an expression consisting of symbol names joined by the logical
#    operators (in order of precedence, high to low) '!' (unary negate), '&'
#    (and), '^' (exclusive or), and '|' (inclusive or).  '&&' and '||' are
#    accepted as synonyms for '&' and '|' respectively; the order of
#    evaluation may be altered by the use of parentheses.  A symbol whose
#    name is currently defined evaluates to TRUE; one whose name is not
#    currently defined evaluates to FALSE.  Thus "ifdef A | B | C" is TRUE
#    if any of the symbols A, B, and C is currently defined, and
#    "ifdef A & B & C" is TRUE if all of them are.
#
#    "ifndef A | B | C" is equivalent to "ifdef !(A | B | C)" (or, using
#    DeMorgan's Law, "ifdef !A & !B & !C") - in other words, TRUE if none of
#    the symbols A, B, and C is currently defined.
#
#    "define" alone deletes all the current definitions; "ifdef" alone is
#    always false; "ifndef" alone is always true.
#
#    The file name in the "include" directive may optionally be surrounded
#    by "" or <>.  In any case, path names are taken to be relative to
#    the location of the file containing the "include" directive.
X
X
# "opt" lines to override program defaults
X
opt -d Helvetica-Bold -t Helvetica-Bold -n Helvetica    # override default fonts
opt -M                             # moon icons on all days
opt -O                            # print outlined characters
X
year 1991            # set year explicitly
X
# note to be propagated to "Notes" box for all months
X
note all            Engineering staff meeting every Tuesday, 1:30 PM
X
# examples of format specifiers
X
all Monday in all        Fiscal week %W.%y    # e.g. 26.91
last workday in all        %B status meeting    # substitute month name
2nd workday in all        %-B status report due    # use previous month
X
# some sample holidays (flagged by '*') and other days of note
X
1/1*                New Year's Day
X
# if "AZ" or "MT" defined, holiday definition will be skipped
ifndef AZ || NH || MT
3rd Monday in Jan*        Martin Luther King Day (except AZ, NH, MT)
endif
X
3rd Monday in Feb        Presidents' Day
Feb 14                Valentine's Day
X
# any Pcal users in Alaska?
ifdef AK
first Sat in March        Iditarod starts
endif
X
3/17                St. Patrick's Day
X
# another local holiday - included only if "MA" or "ME" defined
ifdef MA || ME
3rd Monday in Apr        Patriots' Day (MA, ME)
endif
X
last Monday in May*        Memorial Day
X
6/14                Flag Day
X
7/4*                Independence Day
X
1st Monday in Sep*        Labor Day
X
second Monday in Oct        Columbus Day (observed)
10/31                Halloween
X
Tue after first Mon in Nov    Election Day
second Mon in Nov        Veterans' Day # (observed)
fourth Thu in Nov*        Thanksgiving
day after fourth Thu in Nov*
X
12/24*                Christmas Eve
12/25*                Christmas
last day in Dec*        New Year's Eve
X
# if the symbol "paydays" has been defined, print text on alternate
# Fridays (starting with the first Friday of the year)
ifdef paydays
odd Fridays in year        Pay Day
endif
X
# if the symbol "meetings" has been defined, print text on the next-to-last
# Monday of each month
ifdef meetings
-2nd Monday in all        Monthly staff meeting
endif
X
1/1/92*                New Year's Day        # reset year implicitly
SHAR_EOF
chmod 0666 calendar ||
echo 'restore of calendar failed'
Wc_c="`wc -c < 'calendar'`"
test 9144 -eq "$Wc_c" ||
    echo 'calendar: original size 9144, current size' "$Wc_c"
fi
# ============= exprpars.c ==============
if test -f 'exprpars.c' -a X"$1" != X"-c"; then
    echo 'x - skipping exprpars.c (File already exists)'
else
echo 'x - extracting exprpars.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'exprpars.c' &&
/*
X * exprpars.c - Pcal routines concerned with parsing if{n}def expressions
X *
X * Contents:
X *
X *        do_xxx
X *        lookup_token
X *        next_token
X *        parse_expr
X *
X * Revision history:
X *
X *    4.0    AWR    02/06/91    Author
X *
X */
X
/*
X * Standard headers:
X */
X
#include <ctype.h>
#include <string.h>
#include <stdio.h>
X
/*
X * Pcal-specific definitions:
X */
X
#include "pcaldefs.h"
#include "pcalglob.h"
X
/*
X * Macros:
X */
X
/*
X * token type code definitions:
X */
X
#define TK_UNKNOWN     0        /* codes returned by next_token() */
#define TK_IDENT     1
#define TK_LPAREN     2
#define TK_RPAREN     3
#define TK_UNARYOP     4
#define TK_BINARYOP     5
#define TK_ENDINPUT     6
#define TK_STARTINPUT     7        /* special code for start symbol */
X
/* bit position for token type codes (cf. where_ok[] below) */
#define ID_OK        (1 << TK_IDENT)
#define LP_OK        (1 << TK_LPAREN)
#define RP_OK        (1 << TK_RPAREN)
#define UO_OK        (1 << TK_UNARYOP)
#define BO_OK        (1 << TK_BINARYOP)
#define ST_OK        (1 << TK_STARTINPUT)
#define NEVER_OK    0
X
/* is token "curr" legal after "prev"? (cf. where_ok[] below) */
#define IS_LEGAL(curr, prev)    (where_ok[curr] & (1 << (prev)))
X
/*
X * operator-related definitions:
X */
X
#define OP_AND        0    /* operator subcodes */
#define OP_OR        1
#define OP_XOR        2
#define OP_NEGATE    3
X
#define ENDINPUT_PREC    -1    /* arbitrary number < lowest op. prec  */
#define OR_PREC         1    /* operator precedence levels */
#define XOR_PREC     2
#define AND_PREC     3
#define NEGATE_PREC     4
#define PAREN_PREC     8    /* arbitrary number > highest op. prec */
X
/* lower bits of operator stack entry are code; higher are precedence */
#define OPR_BITS    4
#define OPR_MASK    ((1 << OPR_BITS) - 1)
#define PREC(op)    ((op) >> OPR_BITS)
#define OPCODE(op)    ((op) & OPR_MASK)
#define MAKE_OPR(p, o)    (((p) << OPR_BITS) | (o))
X
#define MAX_OP        20    /* size of operand and operator stacks */
X
/*
X * Globals:
X */
X
typedef short OPERAND;        /* types for operand and operator stacks */
typedef short OPERATOR;
X
X
typedef struct {
X    char    *name;        /* token spelling */
X    short    type;        /* token type code */
X    short    value;        /* associated value */
X    } TOKEN;
X
/* token table - note that substrings must follow longer strings */
X
TOKEN token_tbl[] = {
X    "&&",    TK_BINARYOP,    OP_AND,        /* synonym for "&" */
X    "&",    TK_BINARYOP,    OP_AND,
X    "||",    TK_BINARYOP,    OP_OR,        /* synonym for "|" */
X    "|",    TK_BINARYOP,    OP_OR,
X    "!",    TK_UNARYOP,    OP_NEGATE,
X    "^",    TK_BINARYOP,    OP_XOR,
X    "(",    TK_LPAREN,    0,
X    ")",    TK_RPAREN,    0,
X    NULL,    TK_UNKNOWN,    0        /* must be last entry */
X    };
X
X
typedef struct {
X    short prec;        /* precedence */
X    short type;        /* token type (TK_UNARYOP or TK_BINARYOP) */
#ifdef PROTOS
X    OPERAND (*pfcn)(OPERAND *);    /* dispatch function */
#else
X    OPERAND (*pfcn)();        /* dispatch function */
#endif
X    } OPR;
X
/* operator table - entries must be in same order as OP_XXX */
X
#ifdef PROTOS
static OPERAND do_and(OPERAND *);
static OPERAND do_or(OPERAND *);
static OPERAND do_xor(OPERAND *);
static OPERAND do_negate(OPERAND *);
#else
static OPERAND do_and(), do_or(), do_xor(), do_negate();   /* dispatch fcns */
#endif
X
OPR opr_tbl[] = {
X    AND_PREC,    TK_BINARYOP,    do_and,        /* OP_AND    */
X    OR_PREC,    TK_BINARYOP,    do_or,        /* OP_OR    */
X    XOR_PREC,    TK_BINARYOP,    do_xor,        /* OP_XOR    */
X    NEGATE_PREC,    TK_UNARYOP,    do_negate    /* OP_NEGATE    */
X    };
X
X
/* set of tokens which each token may legally follow (in TK_XXX order) */
X
int where_ok[] = {
X    NEVER_OK                                      ,     /* TK_UNKNOWN    */
X    ST_OK         | LP_OK         | UO_OK | BO_OK ,     /* TK_IDENT    */
X    ST_OK         | LP_OK         | UO_OK | BO_OK ,     /* TK_LPAREN    */
X            ID_OK | LP_OK | RP_OK                 ,     /* TK_RPAREN    */
X    ST_OK         | LP_OK                 | BO_OK ,     /* TK_UNARYOP    */
X            ID_OK         | RP_OK                 ,     /* TK_BINARYOP    */
X    ST_OK | ID_OK         | RP_OK                    /* TK_ENDINPUT    */
X    };
X
X
/*
X * do_xxx - dispatch functions for operators
X */
X
#ifdef PROTOS
static OPERAND do_and(OPERAND *ptop)
#else
static OPERAND do_and(ptop)
X    OPERAND *ptop;
#endif
{
X    return ptop[0] & ptop[-1];
}
X
X
#ifdef PROTOS
static OPERAND do_or(OPERAND *ptop)
#else
static OPERAND do_or(ptop)
X    OPERAND *ptop;
#endif
{
X    return ptop[0] | ptop[-1];
}
X
X
#ifdef PROTOS
static OPERAND do_xor(OPERAND *ptop)
#else
static OPERAND do_xor(ptop)
X    OPERAND *ptop;
#endif
{
X    return ptop[0] ^ ptop[-1];
}
X
X
#ifdef PROTOS
static OPERAND do_negate(OPERAND *ptop)
#else
static OPERAND do_negate(ptop)
X    OPERAND *ptop;
#endif
{
X    return ! ptop[0];
}
X
X
/*
X * lookup_token - look up token in table; return pointer to table entry
X */
#ifdef PROTOS
static TOKEN *lookup_token(char *p)
#else
static TOKEN *lookup_token(p)
X    char *p;
#endif
{
X    TOKEN *ptok;
X
X    for (ptok = token_tbl;
X         ptok->name && strncmp(p, ptok->name, strlen(ptok->name));
X         ptok++)
X        ;
X
X    return ptok;
}
X
X
/*
X * next_token - fetch next token from input string; fill in its type and value
X * and return pointer to following character
X */
#ifdef PROTOS
static char *next_token(char *p,
X            int *ptype,
X            int *pvalue)
#else
static char *next_token(p, ptype, pvalue)
X    char *p;
X    int *ptype;
X    int *pvalue;
#endif
{
X    TOKEN *ptok;
X    char tokbuf[STRSIZ], *pb;
X
#define NT_RETURN(p, t, v) \
X    if (1) { *ptype = t; *pvalue = v; return p; } else
X
X    while (*p && isspace(*p))    /* skip whitespace */
X        p++;
X
X    if (*p == '\0')            /* end of input? */
X        NT_RETURN(p, TK_ENDINPUT, 0);
X
X    if (isalpha(*p)) {        /* identifier? */
X
X        pb = tokbuf;        /* make local copy and look up */
X        while (*p && (isalpha(*p) || isdigit(*p) || *p == '_'))
X            *pb++ = *p++;
X        *pb = '\0';
X
X        NT_RETURN(p, TK_IDENT, find_sym(tokbuf));
X    }
X
X    ptok = lookup_token(p);        /* other token */
X    NT_RETURN(p + (ptok->name ? strlen(ptok->name) : 1), ptok->type,
X        ptok->value);
}
X
X
/*
X * parse_expr - parses expression consisting of identifiers and logical
X * operators; return TRUE if expression is true (identifier defined => true);
X * FALSE if false; EXPR_ERR if syntax error in expression
X */
#ifdef PROTOS
int parse_expr(char *pbuf)
#else
int parse_expr(pbuf)
X    char *pbuf;
#endif
{
X    OPERAND opd_stack[MAX_OP];    /* operand stack - TRUE/FALSE values */
X    OPERATOR opr_stack[MAX_OP];    /* operator stack - precedence | op */
X    int value, token, plevel, prec, result, npop, opr, opd, prev_token, op;
X
X    plevel = 0;            /* paren nesting level */
X    opd = opr = -1;            /* indices of stack tops */
X    prev_token = TK_STARTINPUT;    /* to detect null expressions */
X
X    do {
X        pbuf = next_token(pbuf, &token, &value);
X
X        /* check that the current token may follow the previous one */
X        if (! IS_LEGAL(token, prev_token))
X            return EXPR_ERR;
X
X        switch(token) {
X
X        case TK_IDENT:        /* identifier => 1 if def, 0 if not */
X            opd_stack[++opd] = value != PP_SYM_UNDEF;
X            break;
X
X        case TK_LPAREN:        /* left paren - bump nesting level */
X            ++plevel;
X            break;
X
X        case TK_RPAREN:        /* right paren - decrement nesting */
X            if (--plevel < 0)
X                return EXPR_ERR;
X            break;
X
X        case TK_ENDINPUT:    /* end-of-input - treat as operator */
X            if (prev_token == TK_STARTINPUT)
X                return FALSE;    /* null expr => FALSE */
X            /* fall through */
X
X        case TK_UNARYOP:
X        case TK_BINARYOP:
X
X            /* get precedence of operator, adjusting for paren
X             * nesting (TK_ENDINPUT has the lowest precedence
X             * of all, to unwind operand/operator stacks at end)
X             */
X
X            prec = token == TK_ENDINPUT ? ENDINPUT_PREC :
X                (plevel * PAREN_PREC) + opr_tbl[value].prec;
X
X            /* pop (and perform) any equal- or higher-precedence
X             * operators on operator stack: extract operator,
X             * check for operand stack underflow, execute
X             * operator, adjust operand stack height and place
X             * result of operator on top
X             */
X
X            for ( ;
X                 opr >= 0 && PREC(opr_stack[opr]) >= prec;
X                 opr--) {
X                op = OPCODE(opr_stack[opr]);
X                npop = opr_tbl[op].type == TK_UNARYOP ? 0 : 1;
X                if (opd < npop)
X                    return EXPR_ERR;
X                result = (*opr_tbl[op].pfcn)(opd_stack + opd);
X                opd_stack[opd -= npop] = result;
X            }
X
X            /* push operator (if any) onto stack */
X
X            if (token != TK_ENDINPUT)
X                opr_stack[++opr] = MAKE_OPR(prec, value);
X
X            break;
X
X        default:        /* should never get here */
X            return EXPR_ERR;
X            break;
X
X        }
X
X        prev_token = token;
X
X    } while (token != TK_ENDINPUT);
X
X    /* done - check for dangling parens, and leftover operand/operators */
X
X    return plevel != 0 || opd != 0 || opr != -1 ?
X        EXPR_ERR :        /* leftover junk - return error */
X        opd_stack[0];        /* all OK - return final value */
}
X
SHAR_EOF
chmod 0666 exprpars.c ||
echo 'restore of exprpars.c failed'
Wc_c="`wc -c < 'exprpars.c'`"
test 8311 -eq "$Wc_c" ||
    echo 'exprpars.c: original size 8311, current size' "$Wc_c"
fi
# ============= moon91 ==============
if test -f 'moon91' -a X"$1" != X"-c"; then
    echo 'x - skipping moon91 (File already exists)'
else
echo 'x - extracting moon91 (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'moon91' &&
# 1991 moon phase information for Pcal (from Old Farmer's Almanac)
#
# This file is to be called .moon91 (or moon91) for Un*x, moon91.dat for VMS;
# it is to live in the same directory as the .calendar file.
#
# Pcal originally used an extremely simplistic moon phase algorithm; this file
# (and the code to read it - cf. moonphas.c) was added to v4.0 to enable Pcal
# to interpolate the phase of the moon from the (presumably more accurate)
# information within.  More recently, the original moon phase algorithm was
# superseded by an astronomer-quality version (courtesy of Richard Dyson),
# largely obviating the need for this file; however, it will continue to be
# supported for the foreseeable future.
#
# Moon file syntax:
#
#    Entries in the moon file must conform to the following syntax:
#
#      if -A flag (American date formats) specified:
#        <quarter> <month><sep><day> {<hour><sep><min>}
#
#      if -E flag (European date formats) specified:
#        <quarter> <day><sep><month> {<hour><sep><min>}
#
#    where
#
#      <quarter> := "nm", "fq" or "1q", "fm", "lq" or "3q" (new
#                    moon, first quarter, full moon, last quarter)
#      <hour>    := number 0-23 (24-hour clock)
#      <min>     := number 0-59
#
#    As in the date file, comments start with '#' and run through
#    end-of-line.
#
#    This file must contain entries for all quarter moons in the year,
#    in chronological order; if any errors (e.g., invalid date, date
#    or phase out of sequence, unrecognizable line) are encountered,
#    Pcal will revert to using its default algorithm.
#
# Dates and times below are for Boston (EST), in -A format; you may wish to
# adjust these dates and times to conform to your location.
X
3q 01/07 13:37        # third quarter
nm 01/15 18:51        # new moon
1q 01/23 09:23        # first quarter
fm 01/30 01:10        # full moon
X
3q 02/06 08:53
nm 02/14 12:33
1q 02/21 17:59
fm 02/28 13:26
X
3q 03/08 05:33
nm 03/16 03:11
1q 03/23 01:03
fm 03/30 02:18
X
3q 04/07 01:47
nm 04/14 14:38
1q 04/21 07:40
fm 04/28 16:00
X
3q 05/06 19:48
nm 05/13 23:37
1q 05/20 14:47
fm 05/28 06:38
X
3q 06/05 10:31
nm 06/12 07:07
1q 06/18 23:20
fm 06/26 22:00
X
3q 07/04 21:51
nm 07/11 14:07
1q 07/18 10:12
fm 07/26 13:25
X
3q 08/03 06:27
nm 08/09 21:28
1q 08/17 00:02
fm 08/25 04:08
X
3q 09/01 13:17
nm 09/08 06:02
1q 09/15 17:02
fm 09/23 17:41
3q 09/30 19:31
X
nm 10/07 16:39
1q 10/15 12:34
fm 10/23 06:09
3q 10/30 02:12
X
nm 11/06 06:12
1q 11/14 09:02
fm 11/21 17:58
3q 11/28 10:22
X
nm 12/05 22:57
1q 12/14 04:33
fm 12/21 05:24
3q 12/27 20:56
SHAR_EOF
chmod 0666 moon91 ||
echo 'restore of moon91 failed'
Wc_c="`wc -c < 'moon91'`"
test 2504 -eq "$Wc_c" ||
    echo 'moon91: original size 2504, current size' "$Wc_c"
fi
true || echo 'restore of moonphas.c failed'
echo End of part 2, continue with part 3
exit 0
--
   ^      _   Joe Brownlee, Analysts International Corporation @ AT&T Bell Labs
  /_\  @ / `  471 E Broad St, Suite 2001, Columbus, Ohio 43215   [phone]
 /   \ | \_,  E-mail: [e-mail]     Who pays attention to what _I_ say?
 "Scotty, we need warp speed in 3 minutes or we're all dead!" --- James T. Kirk