# Scan a line for various common date and time formats.
# Set REPLY to the number of seconds since the epoch at which that
# time occurs.  The time does not need to be matched; this will
# produce midnight at the start of the date.
#
# Absolute times
#
# The rules below are fairly complicated, to allow any natural (and
# some highly unnatural but nonetheless common) combination of
# time and date used by English speakers.  It is recommended that,
# rather than exploring the intricacies of the system, users find
# a date format that is natural to them and stick to it.  This
# will avoid unexpected effects.  Various key facts should be noted,
# explained in more detail below:
#
# - In particular, note the confusion between month/day/year and
#   day/month/year when the month is numeric; this format should be
#   avoided if at all possible.  Many alternatives are available.
# - However, there is currently no localization support, so month
#   names must be English (though only the first three letters are required).
#   The same applies to days of the week if they occur (they are not useful).
# - The year must be given in full to avoid confusion, and only years
#   from 1900 to 2099 inclusive are matched.
# - Although timezones are parsed (complicated formats may not be recognized),
#   they are then ignored; no time adjustment is made.
# - Embedding of times within dates (e.g. "Wed Jun 16 09:30:00 BST 2010")
#   causes horrific problems because of the combination of the many
#   possible date and time formats to match.  The approach taken
#   here is to match the time, remove it, and see if the nearby text
#   looks like a date.  The problem is that the time matched may not
#   be that associated with the date, in which case the time will be
#   ignored.  To minimise this, when the argument "-a" is given to
#   anchor the date/time to the start of the line, we never look
#   beyond a newline.  So if any date/time strings in the text
#   are on separate lines the problem is avoided.
# - If you feel sophisticated enough and wish to avoid any ambiguity,
#   you can use RFC 2445 date/time strings, for example 20100601T170000.
#   These are parsed in one go.
#
# The following give some obvious examples; users finding here
# a format they like and not subject to vagaries of style may skip
# the full description.  As dates and times are matched separately
# (even though the time may be embedded in the date), any date format
# may be mixed with any format for the time of day provide the
# separators are clear (whitespace, colons, commas).
#   2007/04/03 13:13
#   2007/04/03:13:13
#   2007/04/03 1:13 pm
#   3rd April 2007, 13:13
#   April 3rd 2007 1:13 p.m.
#   Apr 3, 2007 13:13
#   Tue Apr 03 13:13:00 2007
#   13:13 2007/apr/3
#
# Times are parsed and extracted before dates.  They must use colons
# to separate hours and minutes, though a dot is allowed before seconds
# if they are present.  This limits time formats to
#   HH:MM[:SS[.FFFFF]] [am|pm|a.m.|p.m.]
#   HH:MM.SS[.FFFFF] [am|pm|a.m.|p.m.]
# in which square brackets indicate optional elements, possibly with
# alternatives.  Fractions of a second are recognised but ignored.
# Unless -r or -R are given (see below), a date is mandatory but a time of day is
# not; the time returned is at the start of the date.
#
# Time zones are not handled, though if one is matched following a time
# specification it will be removed to allow a surrounding date to be
# parsed.  This only happens if the format of the timezone is not too
# wacky:
#   +0100
#   GMT
#   GMT-7
#   CET+1CDT
# etc. are all understood, but any part of the timezone that is not numeric
# must have exactly three capital letters in the name.
#
# Dates suffer from the ambiguity between DD/MM/YYYY and MM/DD/YYYY.  It is
# recommended this form is avoided with purely numeric dates, but use of
# ordinals, eg. 3rd/04/2007, will resolve the ambiguity as the ordinal is
# always parsed as the day of the month.  Years must be four digits (and
# the first two must be 19 or 20); 03/04/08 is not recognised.  Other
# numbers may have leading zeroes, but they are not required.  The
# following are handled:
#   YYYY/MM/DD
#   YYYY-MM-DD
#   YYYY/MNM/DD
#   YYYY-MNM-DD
#   DD[th|st|rd] MNM[,] YYYY
#   DD[th|st|rd] MNM[,]            current year assumed
#   MNM DD[th|st|rd][,] YYYY
#   MNM DD[th|st|rd][,]            current year assumed
#   DD[th|st|rd]/MM[,] YYYY
#   DD[th|st|rd]/MM/YYYY
#   MM/DD[th|st|rd][,] YYYY
#   MM/DD[th|st|rd]/YYYY
# Here, MNM is at least the first three letters of a month name,
# matched case-insensitively.  The remainder of the month name may appear but
# its contents are irrelevant, so janissary, febrile, martial, apricot,
# etc. are happily handled.
#
# Note there are only two cases that assume the current year, the
# form "Jun 20" or "14 September" (the only two commonly occurring
# forms, apart from a "the" in some forms of English, which isn't
# currently supported).  Such dates will of course become ambiguous
# in the future, so should ideally be avoided.
#
# Times may follow dates with a colon, e.g. 1965/07/12:09:45; this
# is in order to provide a format with no whitespace.  A comma
# and whitespace are allowed, e.g. "1965/07/12, 09:45".
# Currently the order of these separators is not checked, so
# illogical formats such as "1965/07/12, : ,09:45" will also
# be matched.  Otherwise, a time is only recognised as being associated
# with a date if there is only whitespace in between, or if the time
# was embedded in the date.
#
# Days of the week are not scanned, but will be ignored if they occur
# at the start of the date pattern only.
#
# For example, the standard date format:
#   Fri Aug 18 17:00:48 BST 2006
# is handled by matching HH:MM:SS and removing it together with the
# matched (but unused) time zone.  This leaves the following:
#   Fri Aug 18 2006
# "Fri" is ignored and the rest is matched according to the sixth of
# the standard rules.
#
# Relative times
# ==============
#
# The option -r allows a relative time.  Years (or ys, yrs, or without s),
# months (or mths, mons, mnths, months, or without s --- "m", "ms" and
# "mns" are ambiguous and are not handled), weeks (or ws, wks, or without
# s) and days (or ds, dys, days, or without s), hours (or hs, hrs, with or
# without s), minutes (or mins, with or without s) and seconds (or ss,
# secs, with or without s) are understood.  Spaces between the numbers
# are optional, but are required between items, although a comma
# may be used (with or without spaces).
#
# Note that a year here is 365.25 days and a month is 30 days.
#
# With -R start_time, a relative time is parsed and start_time is treated
# as the start of the period.  This allows months and years to be calculated
# accurately.  If the option -m (minus) is also given the relative time is
# taken backwards from the start time.
#
# This allows forms like:
#   30 years 3 months 4 days 3:42:41
#   14 days 5 hours
#   4d,10hr
# In this case absolute dates are ignored.

emulate -L zsh
setopt extendedglob # xtrace

zmodload -i zsh/datetime || return 1

# separator characters before time or between time and date
# allow , - or : before the time: this allows spaceless but still
# relatively logical dates like 2006/09/19:14:27
# don't allow / before time !  the above
# is not 19 hours 14 mins and 27 seconds after anything.
local tschars="[-,:[:blank:]]"
# start pattern for time when anchored
local tspat_anchor="(${tschars}#)"
# ... when not anchored
local tspat_noanchor="(|*${tschars})"
# separator characters between elements.  comma is fairly
# natural punctuation; otherwise only allow whitespace.
local schars="[.,[:space:]]"
local -a dayarr
dayarr=(sun mon tue wed thu fri sat)
local daypat="${schars}#((#B)(${(j.|.)dayarr})[a-z]#~month*)"
# Start pattern for date: treat , as space for simplicity.  This
# is illogical at the start but saves lots of minor fiddling later.
# Date start pattern when anchored at the start.
# We need to be able to ignore the day here, although (for consistency
# with the unanchored case) we don't remove it until later.
# (The problem in the other case is that matching anything before
# the day of the week is greedy, so the day of the week gets ignored
# if it's optional.)
local dspat_anchor="(|(#B)(${daypat}|)(#b)${schars}#)"
local dspat_anchor_noday="(|${schars}#)"
# Date start pattern when not anchored at the start.
local dspat_noanchor="(|*${schars})"
# end pattern for relative times: similar remark about use of $schars.
local repat="(|s)(|${schars}*)"
# not locale-dependent!  I don't know how to get the months out
# of the system for the purpose of finding out where they occur.
# We may need some completely different heuristic.
local monthpat="(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]#"
integer daysecs=$(( 24 * 60 * 60 ))
local d="[[:digit:]]"

integer year year2 month month2 day day2 hour minute second then nth wday wday2
local opt line orig_line mname MATCH MBEGIN MEND tz test rest_line
local -a match mbegin mend
# Flags that we found a date or a time (maybe a relative time)
integer date_found time_found
# Flag that it's OK to have a time only
integer time_ok
# Indices of positions of start and end of time and dates found.
# These are actual character indices as zsh would normally use, i.e.
# line[time_start,time_end] is the string for the time.
integer time_start time_end date_start date_end
integer anchor anchor_end debug setvar
integer relative relative_start reladd reldate relsign=1 newadd h1 h2 hd

while getopts "aAdmrR:st" opt; do
  case $opt in
    (a)
    # anchor
    (( anchor = 1 ))
    ;;

    (A)
    # anchor at end, too
    (( anchor = 1, anchor_end = 1 ))
    ;;

    (d)
    # enable debug output
    (( debug = 1 ))
    ;;

    (m)
    # relative with negative offsets
    (( relsign = -1 ))
    ;;

    (r)
    # relative with no fixed start
    (( relative = 1 ))
    ;;

    (R)
    # relative with fixed start supplied
    (( relative_start = OPTARG, relative = 2 ))
    ;;

    (s)
    (( setvar = 1 ))
    ;;

    (t)
    (( time_ok = 1 ))
    ;;

    (*)
    return 1
    ;;
  esac
done
shift $(( OPTIND - 1 ))

line=$1

local dspat dspat_noday tspat
if (( anchor )); then
  # Anchored at the start.
  dspat=$dspat_anchor
  dspat_noday=$dspat_anchor_noday
  if (( relative )); then
    tspat=$tspat_anchor
  else
    # We'll test later if the time is associated with the date.
    tspat=$tspat_noanchor
  fi
  # We can save a huge amount of grief (I've discovered) if when
  # we're anchored to the start we ignore anything after a newline.
  # However, don't do this if we're anchored to the end.  The
  # match should fail if there are extra lines in that case.
  if [[ anchor_end -eq 0 && $line = (#b)([^$'\n']##)($'\n'*) ]]; then
    line=$match[1]
    rest_line=$match[2]
  fi
else
  dspat=$dspat_noanchor
  dspat_noday=$dspat_noanchor
  tspat=$tspat_noanchor
fi
orig_line=$line

# Look for a time separately; we need colons for this.
# We want to look for the first time to ensure it's associated
# with a date at the start of the line.  Of course there may be
# a time followed by some other text followed by a date, but
# in that case the whole thing is too ambiguous to worry about
# (and we don't need to worry about this for a calendar entry where
# the date must be at the start).
#
# We do this by minimal matching at the head, i.e. ${...#...}.
# To use a case statement we'd need to be able to request non-greedy
# matching for a pattern.
local rest
# HH:MM:SECONDS am/pm with optional decimal seconds
rest=${line#(#ibm)${~tspat}(<0-12>):(<0-59>)[.:]((<0-59>)(.<->|))[[:space:]]#([ap])(|.)[[:space:]]#m(.|[[:space:]]|(#e))}
if [[ $rest != $line ]]; then
  hour=$match[2]
  minute=$match[3]
  second=$match[5]
  [[ $match[7] = (#i)p ]] && (( hour <= 12 )) && (( hour += 12 ))
  time_found=1
fi
if (( time_found == 0 )); then
  # no seconds, am/pm
  rest=${line#(#ibm)${~tspat}(<0-12>):(<0-59>)[[:space:]]#([ap])(|.)[[:space:]]#m(.|[[:space:]]|(#e))}
  if [[ $rest != $line ]]; then
    hour=$match[2]
    minute=$match[3]
    [[ $match[4] = (#i)p ]] && (( hour <= 12 )) && (( hour += 12 ))
    time_found=1
  fi
fi
if (( time_found == 0 )); then
  # no colon, even, but a.m./p.m. indicator
  rest=${line#(#ibm)${~tspat}(<0-12>)[[:space:]]#([ap])(|.)[[:space:]]#m(.|[[:space:]]|(#e))}
  if [[ $rest != $line ]]; then
    hour=$match[2]
    minute=0
    [[ $match[3] = (#i)p ]] && (( hour <= 12 )) && (( hour += 12 ))
    time_found=1
  fi
fi
if (( time_found == 0 )); then
  # 24 hour clock, with seconds
  rest=${line#(#ibm)${~tspat}(<0-24>):(<0-59>)[.:]((<0-59>)(.<->|))(.|[[:space:]]|(#e))}
  if [[ $rest != $line ]]; then
    hour=$match[2]
    minute=$match[3]
    second=$match[5]
    time_found=1
  fi
fi
if (( time_found == 0 )); then
  rest=${line#(#ibm)${~tspat}(<0-24>):(<0-59>)(.|[[:space:]]|(#e))}
  if [[ $rest != $line ]]; then
    hour=$match[2]
    minute=$match[3]
    time_found=1
  fi
fi
if (( time_found == 0 )); then
  # Combined date and time formats:  here we can use an anchor because
  # we know the complete format.
  (( anchor )) && tspat=$tspat_anchor
  # RFC 2445
  rest=${line#(#ibm)${~tspat}(|\"[^\"]##\":)($~d$~d$~d$~d)($~d$~d)($~d$~d)T($~d$~d)($~d$~d)($~d$~d)([[:space:]]#|(#e))}
  if [[ $rest != $line ]]; then
    year=$match[3]
    month=$match[4]
    day=$match[5]
    hour=$match[6]
    minute=$match[7]
    second=$match[8]
    # signal don't need to take account of time in date...
    time_found=2
    date_found=1
    date_start=$mbegin[3]
    date_end=$mend[-1]
  fi
fi
(( hour == 24 )) && hour=0

if (( time_found && ! date_found )); then
  # time was found; if data also found already, process below.
  time_start=$mbegin[2]
  time_end=$mend[-1]
  # Remove the timespec because it may be in the middle of
  # the date (as in the output of "date".
  # There may be a time zone, too, which we don't yet handle.
  # (It's not in POSIX strptime() and libraries don't support it well.)
  # This attempts to remove some of the weirder forms.
  if [[ $line[$time_end+1,-1] = (#b)[[:space:]]#([A-Z][A-Z][A-Z]|[-+][0-9][0-9][0-9][0-9])([[:space:]]|(#e))* || \
        $line[$time_end+1,-1] = (#b)[[:space:]]#([A-Z][A-Z][A-Z](|[-+])<0-12>)([[:space:]]|(#e))*  || \
        $line[$time_end+1,-1] = (#b)[[:space:]]#([A-Z][A-Z][A-Z](|[-+])<0-12>[A-Z][A-Z][A-Z])([[:space:]]|(#e))* ]]; then
     (( time_end += ${mend[-1]} ))
     tz=$match[1]
  fi
  line=$line[1,time_start-1]$line[time_end+1,-1]
  (( debug )) && print "line after time: $line"
fi

if (( relative == 0 && date_found == 0 )); then
  # Date.
  case $line in
  # Look for YEAR[-/.]MONTH[-/.]DAY
  ((#bi)${~dspat}((19|20)[0-9][0-9])[-/](<1-12>)[-/](<1-31>)*)
  year=$match[2]
  month=$match[4]
  day=$match[5]
  date_start=$mbegin[2] date_end=$mend[5]
  date_found=1
  ;;

  # Same with month name
  ((#bi)${~dspat}((19|20)[0-9][0-9])[-/]${~monthpat}[-/](<1-31>)*)
  year=$match[2]
  mname=$match[4]
  day=$match[5]
  date_start=$mbegin[2] date_end=$mend[5]
  date_found=1
  ;;

  # Look for DAY[th/st/nd/rd] MNAME[,] YEAR
  ((#bi)${~dspat}(<1-31>)(|th|st|nd|rd)[[:space:]]##${~monthpat}(|,)[[:space:]]##((19|20)[0-9][0-9])*)
  day=$match[2]
  mname=$match[4]
  year=$match[6]
  date_start=$mbegin[2] date_end=$mend[6]
  date_found=1
  ;;

  # Look for MNAME DAY[th/st/nd/rd][,] YEAR
  ((#bi)${~dspat}${~monthpat}[[:space:]]##(<1-31>)(|th|st|nd|rd)(|,)[[:space:]]##((19|20)[0-9][0-9])*)
  mname=$match[2]
  day=$match[3]
  year=$match[6]
  date_start=$mbegin[2] date_end=$mend[6]
  date_found=1
  ;;

  # Look for DAY[th/st/nd/rd] MNAME; assume current year
  ((#bi)${~dspat}(<1-31>)(|th|st|nd|rd)[[:space:]]##${~monthpat}(|,)([[:space:]]##*|))
  day=$match[2]
  mname=$match[4]
  strftime -s year "%Y" $EPOCHSECONDS
  date_start=$mbegin[2] date_end=$mend[5]
  date_found=1
  ;;

  # Look for MNAME DAY[th/st/nd/rd]; assume current year
  ((#bi)${~dspat}${~monthpat}[[:space:]]##(<1-31>)(|th|st|nd|rd)(|,)([[:space:]]##*|))
  mname=$match[2]
  day=$match[3]
  strftime -s year "%Y" $EPOCHSECONDS
  date_start=$mbegin[2] date_end=$mend[5]
  date_found=1
  ;;

  # Now it gets a bit ambiguous.
  # Look for DAY[th/st/nd/rd][/]MONTH[/ ,]YEAR
  ((#bi)${~dspat}(<1-31>)(|th|st|nd|rd)/(<1-12>)((|,)[[:space:]]##|/)((19|20)[0-9][0-9])*)
  day=$match[2]
  month=$match[4]
  year=$match[7]
  date_start=$mbegin[2] date_end=$mend[7]
  date_found=1
  ;;

  # Look for MONTH[/]DAY[th/st/nd/rd][/ ,]YEAR
  ((#bi)${~dspat}(<1-12>)/(<1-31>)(|th|st|nd|rd)((|,)[[:space:]]##|/)((19|20)[0-9][0-9])*)
  month=$match[2]
  day=$match[3]
  year=$match[7]
  date_start=$mbegin[2] date_end=$mend[7]
  date_found=1
  ;;

  # Look for WEEKDAY
  ((#bi)${~dspat_noday}(${~daypat})(|${~schars})*)
  integer wday_now wday
  local wdaystr=${(L)match[3]}
  date_start=$mbegin[2] date_end=$mend[2]

  # Find the day number.
  local -a wdays
  # This is the ordering of %w in strtfime (zero-offset).
  wdays=(sun mon tue wed thu fri sat sun)
  (( wday = ${wdays[(i)$wdaystr]} - 1 ))

  # Find the date for that day.
  (( then = EPOCHSECONDS ))
  strftime -s wday_now "%w" $then
  # Day is either today or in the past.
  (( wday_now < wday )) && (( wday_now += 7 ))
  (( then -= (wday_now - wday) * 24 * 60 * 60 ))
  strftime -s year "%Y" $then
  strftime -s month "%m" $then
  strftime -s day "%d" $then
  date_found=1
  ;;

  # Look for "today", "yesterday", "tomorrow"
  ((#bi)${~dspat_noday}(yesterday|today|tomorrow|now)(|${~schars})*)
  (( then = EPOCHSECONDS ))
  case ${(L)match[2]} in
    (yesterday)
    (( then -= daysecs ))
    ;;

    (tomorrow)
    (( then += daysecs ))
    ;;

    (now)
    time_found=1 time_end=0 time_start=1
    strftime -s hour "%H" $then
    strftime -s minute "%M" $then
    strftime -s second "%S" $then
    ;;
  esac
  strftime -s year "%Y" $then
  strftime -s month "%m" $then
  strftime -s day "%d" $then
  date_start=$mbegin[2] date_end=$mend[2]
  date_found=1
  ;;
  esac
fi

if (( date_found || (time_ok && time_found) )); then
  # date found
  # see if there's a day at the start
  if (( date_found )); then
    if [[ ${line[1,$date_start-1]} = (#bi)${~daypat}${~schars}# ]]; then
	    date_start=$mbegin[1]
    fi
    line=${line[1,$date_start-1]}${line[$date_end+1,-1]}
  fi
  if (( time_found == 1 )); then
    if (( date_found )); then
      # If we found a time, it must be associated with the date,
      # or we can't use it.  Since we removed the time from the
      # string to find the date, however, it's complicated to
      # know where both were found.  Reconstruct the date indices of
      # the original string.
      if (( time_start <= date_start )); then
	# Time came before start of date; add length in.
	(( date_start += time_end - time_start + 1 ))
      fi
      if (( time_start <= date_end )); then
	(( date_end += time_end - time_start + 1 ))
      fi

      if (( time_end + 1 < date_start )); then
	# If time wholly before date, OK if only separator characters
	# in between.  (This allows some illogical stuff with commas
	# but that's probably not important.)
	if [[ ${orig_line[time_end+1,date_start-1]} != ${~schars}# ]]; then
	  # Clearly this can't work if anchor is set.  In principle,
	  # we could match the date and ignore the time if it wasn't.
	  # However, that seems dodgy.
	  return 1
	else
	  # Form massaged line by removing the entire date/time chunk.
	  line="${orig_line[1,time_start-1]}${orig_line[date_end+1,-1]}"
	fi
      elif (( date_end + 1 < time_start )); then
	# If date wholly before time, OK if only time separator characters
	# in between.  This allows 2006/10/12:13:43 etc.
	if [[ ${orig_line[date_end+1,time_start-1]} != ${~tschars}# ]]; then
	  # Here, we assume the time is associated with something later
	  # in the line.  This is pretty much inevitable for the sort
	  # of use we are expecting.  For example,
	  #   2006/10/24  Meeting from early, may go on till 12:00.
	  # or with some uses of the calendar system,
	  #   2006/10/24 MR 1 Another pointless meeting WARN 01:00
	  # The 01:00 says warn an hour before, not that the meeting starts
	  # at 1 am.  About the only safe way round would be to force
	  # a time to be present, but that's not how the traditional
	  # calendar programme works.
	  #
	  # Hence we need to reconstruct.
	  (( time_found = 0, hour = 0, minute = 0, second = 0 ))
	  line="${orig_line[1,date_start-1]}${orig_line[date_end+1,-1]}"
	else
	  # As above.
	  line="${orig_line[1,date_start-1]}${orig_line[time_end+1,-1]}"
	fi
      fi
    else
      # Time only.
      # We didn't test anchors for time originally, since it
      # might have been embedded in the date.  If there's no date,
      # we need to test specially.
      if (( anchor )) &&
	[[ ${orig_line[1,time_start-1]} != ${~tschars}# ]]; then
	# Anchor at start failed.
	return 1
      fi
      strftime -s year "%Y" $EPOCHSECONDS
      strftime -s month "%m" $EPOCHSECONDS
      strftime -s day "%d" $EPOCHSECONDS
      # Date now handled.
      (( date_found = 1 ))
    fi
    if (( debug )); then
      print "Time string: $time_start,$time_end:" \
	"'$orig_line[time_start,time_end]'"
      (( date_ok )) && print "Date string: $date_start,$date_end:" \
	"'$orig_line[date_start,date_end]'"
      print "Remaining line: '$line$rest_line'"
    fi
  fi
fi

if (( relative )); then
  if (( relative == 2 )); then
    # Relative years and months are variable, and we may need to
    # be careful about days.
    strftime -s year "%Y" $relative_start
    strftime -s month "%m" $relative_start
    strftime -s day "%d" $relative_start
    strftime -rs then "%Y:%m:%d" "${year}:${month}:${day}"
  fi
  if [[ $line = (#bi)${~dspat}(<->|)[[:space:]]#(y|yr|year|yearly)${~repat} ]]; then
    [[ -z $match[2] ]] && match[2]=1
    if (( relative == 2 )); then
      # We need the difference between relative_start & the
      # time ${match[2]} years later.  This means keeping the month and
      # day the same and changing the year.
      (( year2 = year + relsign * ${match[2]} ))
      strftime -rs reldate "%Y:%m:%d" "${year2}:${month}:${day}"

      # If we've gone from a leap year to a non-leap year, go back a day.
      strftime -s month2 "%m" $reldate
      (( month2 != month )) && (( reldate -= daysecs ))

      # Keep this as a difference for now since we may need to add in other stuff.
      (( reladd += reldate - then ))
    else
      (( reladd += relsign * ((365*4+1) * daysecs * ${match[2]} + 1) / 4 ))
    fi
    line=${line[1,$mbegin[2]-1]}${line[$mend[4]+1,-1]}
    time_found=1
  fi
  if [[ $line = (#bi)${~dspat}(<->|)[[:space:]]#(mth|mon|mnth|month|monthly)${~repat} ]]; then
     [[ -z $match[2] ]] && match[2]=1
     if (( relative == 2 )); then
       # Need to add on ${match[2]} months as above.
       (( month2 = month + relsign * ${match[2]} ))
       if (( month2 <= 0 )); then
	 # going backwards beyond start of given year
	 (( year2 = year + month2 / 12 - 1, month2 = month2 + (year-year2)*12 ))
       else
	 (( year2 = year + (month2 - 1)/ 12, month2 = (month2 - 1) % 12 + 1 ))
       fi
       strftime -rs reldate "%Y:%m:%d" "${year2}:${month2}:${day}"

       # If we've gone past the end of the month because it was too short,
       # we have two options (i) get the damn calendar fixed (ii) wind
       # back to the end of the previous month.  (ii) is easier for now.
       if (( day > 28 )); then
	 while true; do
	   strftime -s day2 "%d" $reldate
	   # There are only up to 3 days in it, so just wind back one at a
           # time.  Saves counting.
	   (( day2 >= 28 )) && break
	   (( reldate -= daysecs ))
	 done
       fi

       (( reladd += reldate - then ))
     else
       (( reladd += relsign * 30 * daysecs * ${match[2]} ))
     fi
     line=${line[1,$mbegin[2]-1]}${line[$mend[4]+1,-1]}
     time_found=1
  fi
  # For the next three items we accumulate adjustments in "newadd".
  # See note below for why they are special.
  if [[ $relative = 2 && $line = (#bi)${~dspat_noday}(<->)(th|rd|nd|st)(${~daypat})(|${~schars}*) ]]; then
     nth=$match[2]
     test=${(L)${${match[4]##${~schars}#}%%${~schars}#}[1,3]}
     wday=${dayarr[(I)$test]}
     if (( wday )); then
       line=${line[1,$mbegin[2]-1]}${line[$mend[4]+1,-1]}
       time_found=1
       # We want weekday 0 to 6
       (( wday-- ))
       (( reldate = relative_start + reladd ))
       strftime -s year2 "%Y" $reldate
       strftime -s month2 "%m" $reldate
       # Find day of week of the first of the month we've landed on.
       strftime -rs then "%Y:%m:%d" "${year2}:${month2}:1"
       strftime -s wday2 "%w" $then
       # Calculate day of month
       (( day = 1 + (wday - wday2) + (nth - 1) * 7 ))
       (( wday < wday2 )) && (( day += 7 ))
       # whereas the day of the month calculated so far is...
       strftime -s day2 "%d" $reldate
       # so we need to compensate by...
       (( newadd += (day - day2) * daysecs ))
     fi
  fi
  if [[ $line = (#bi)${~dspat}(<->|)[[:space:]]#(w|wk|week|weekly)${~repat} ]]; then
     [[ -z $match[2] ]] && match[2]=1
     (( newadd += relsign * 7 * daysecs * ${match[2]} ))
     line=${line[1,$mbegin[2]-1]}${line[$mend[4]+1,-1]}
     time_found=1
  fi
  if [[ $line = (#bi)${~dspat}(<->|)[[:space:]]#(d|dy|day|daily)${~repat} ]]; then
     [[ -z $match[2] ]] && match[2]=1
     (( newadd += relsign * daysecs * ${match[2]} ))
     line=${line[1,$mbegin[2]-1]}${line[$mend[4]+1,-1]}
     time_found=1
  fi
  if (( relative == 2 && newadd )); then
    # You thought a day was always the same time?  Ho, ho, ho.
    # If the clocks go forward or back, we can gain or lose
    # an hour.  Check this by seeing what the hour is before
    # and after adding the number of days.  If it changes,
    # remove the difference.
    #
    # We need this correction for days (including days of a given
    # month) and weeks.
    # We don't need it for years and months because we calculated
    # those by actually looking at the calendar for a given
    # time of day, so the adjustment came out in the wash.
    # We don't need it for hours or smaller periods because
    # presumably if a user asks for something in 3 hours time
    # they don't mean 4 hours if the clocks went back and
    # 2 hours if they went forward.  At least, I think so.
    # Consider:
    #   % calendar_showdate +2d,1hr
    #   Sun Mar 25 00:37:00 GMT 2007
    #   % calendar_showdate +2d,2hr
    #   Sun Mar 25 02:37:09 BST 2007
    # At first sight that looks wrong because the clock appears
    # to jump two hours.  (Yes, it took me all of 9 seconds to
    # edit the line.)  But actually it's only jumped the hour
    # you asked for, because one is in GMT and the other in BST.
    # In principle you could say the same thing about days:
    # Sun Mar 25 00:00:00 GMT 2007  and  Mon Mar 26 01:00:00 BST 2007
    # are a day apart.  But usually if you say "same time next Tuesday"
    # you mean "when the clock says the same time, even if someone
    # has nipped in and adjusted it in the mean time", although
    # for some reason you don't usually bother saying that.
    #
    # Hope that's clear.
    strftime -s h1 "%H" $(( relative_start + reladd ))
    strftime -s h2 "%H" $(( relative_start + reladd + newadd ))
    (( hd = h2 - h1 ))
    # and of course we might go past midnight...
    if (( hd > 12 )); then
      (( hd -= 24 ))
    elif (( hd < -12 )); then
      (( hd += 24 ))
    fi
    (( newadd -= hd * 3600 ))
  fi
  (( reladd += newadd ))
  if [[ $line = (#bi)${~dspat}(<->|)[[:space:]]#(h|hr|hour|hourly)${~repat} ]]; then
     [[ -z $match[2] ]] && match[2]=1
     (( reladd += relsign * 60 * 60 * ${match[2]} ))
     line=${line[1,$mbegin[2]-1]}${line[$mend[4]+1,-1]}
     time_found=1
  fi
  if [[ $line = (#bi)${~dspat}(<->)[[:space:]]#(min|minute)${~repat} ]]; then
     (( reladd += relsign * 60 * ${match[2]} ))
     line=${line[1,$mbegin[2]-1]}${line[$mend[4]+1,-1]}
     time_found=1
  fi
  if [[ $line = (#bi)${~dspat}(<->)[[:space:]]#(s|sec|second)${~repat} ]]; then
     (( reladd += relsign * ${match[2]} ))
     line=${line[1,$mbegin[2]-1]}${line[$mend[4]+1,-1]}
     time_found=1
  fi
fi

if (( relative )); then
  # If no date was found, we're in trouble unless we found a time.
  if (( time_found )); then
    if (( anchor_end )); then
      # must be left with only separator characters
      if [[ $line != ${~schars}# ]]; then
	return 1
      fi
    fi
    # relative_start is zero if we're not using it
    (( reladd += (hour * 60 + minute) * 60 + second ))
    typeset -g REPLY
    (( REPLY = relative_start + reladd  ))
    [[ -n $setvar ]] && typeset -g REPLY2="$line$rest_line"
    return 0
  fi
  return 1
elif (( date_found == 0 )); then
  return 1
fi

if (( anchor_end )); then
  # must be left with only separator characters
  if [[ $line != ${~schars}# ]]; then
    return 1
  fi
fi

local fmt nums
if [[ -n $mname ]]; then
  fmt="%Y %b %d %H %M %S"
  nums="$year $mname $day $hour $minute $second"
else
  fmt="%Y %m %d %H %M %S"
  nums="$year $month $day $hour $minute $second"
fi

strftime -s REPLY -r $fmt $nums

[[ -n $setvar ]] && typeset -g REPLY2="$line$rest_line"

return 0