greggirwin · May 25, 2016 02:58 · GiuseppeChillemi · Mar 11, 2019 · GiuseppeChillemi · Mar 11, 2019
diff --git a/scheduler.r b/scheduler.r
 REBOL [
 	Title: "Scheduler"
 	File: %scheduler.r
 	Purpose: "Dialected task scheduling library"
 	Author: ["SOFTINNOV / Nenad Rakocevic" "Pointillistic / Gregg Irwin"]
 	Copyright: ["2009 SOFTINNOV" "2013 SOFTINNOV/POINTILLISTIC"]
 	Email: [[email protected] [email protected]]
 	Date: 28-Oct-2013
 	Version: 0.9.5
 	License: "BSD - see %LICENCE.txt file"
 	Comments: {

 		Scheduler DSL quickstart
 		------------------------
 		
 		Legend:
 		- <value> means that the value is optional
 		- CAPITALIZED words are dialect keywords

 		o Event with a precise point in time :
 			<name:> AT time! DO action
 		  or
 			<name:> ON date! AT time! DO action

 		o Event with a delay :
 			<name:> IN n <unit> DO action

 		o Recurring event :
 			<name:> EVERY 
 				<n> <unit>		; recurring unit
 				<allowed>		; specific point(s) in time or duration(s) allowed
 				<NOT forbidden>	; specific point(s) in time or duration(s) forbidden
 				<OFFSET amount>	; date/time offset amount from unit
 				<AT moment>		; fixed time for each event (only the date changes)
 				<count TIMES>	; limit the number of event occurences
 				<USER-DATA value>	; any value you want to associate with the job
 				DO action		; action to execute
 		  with
 			<name:>: set-word! value for naming a task (for future access using the API).
 			<n>: integer! value for unit multiplying.
 			<unit>: any of 
 				s|sec|second|seconds
 				mn|min|minute|minutes
 				h|hr|hour|hours
 				d|day|days
 				w|wk|week|weeks
 				m|mo|month|months
 			<allowed>: any time (00:00:00), calendar day (#dd), weekday (mon|monday), 
 					   month (jan|january), range of time|calendar-days or block of any
 					   of theses options.
 			<forbidden>: same options as <allowed>.
 			<moment>: date! or time! value.
 			<t>: integer! value.
 			action: file!|url!|block!|function!|word! value to be evaluated when
 			        event is fired.
 			
 		Syntactic sugar
 		---------------
 		The default dialect is parsed in BLOCK! mode. That means that only REBOL values
 		are accepted, but some people may want to write calendar dates like: 1st, 2nd,...
 		instead or #1, #2,... So a preprocessor is included, allowing tasks to be passed 
 		as string! values, extending the accepted syntax for the following cases :
 				1st, 2nd, 3rd,..nth 	: accepted
 				12s, 12mn, 12h, 12d,...	: accepted

 		Scheduler API
 		-------------
 		scheduler/plan [spec]		; Add one or more tasks to the scheduler
 		scheduler/plan/new [spec]	; Same as above, but removes all previous tasks
 		scheduler/delete 'name		; Removes the named task from the scheduler
 		scheduler/wait				; Provides a global event loop

 		Examples
 		--------
 		scheduler/plan [
 			at 18:30 do http://domain.com/update.r
 			every 3 days not [#2 - #9 #12 sat sun] at 00:30 do %batch.r
 			smk: every friday at 13:00 do %test.r
 			cc: every 12 hours do %backup.r
 			every [sat sun] at 12:00 do %beep.r
 			every month on #01 do %check.r
 		]
 		scheduler/wait
 		
 		(See %test-scheduler.r for more examples)
 	}
    Gregg's-notes: {
        Dialect production rule names now all end with = as a naming convention.
        It's BNF-like, and helps distinguish them from other words.
        
        I know 'times matches the N TIMES dialect syntax, but to have a count
        value called 'times where time values are heavily used, seems confusing.
        It is now called 'count. 'Count is also used in iCal. I also changed
        the 'repeat field name to 'count, to match it. 'Count also seems clearer
        there.
     
        Added [on date! at time!] support to the dialect.
        
        Added user-data field to jobs.
        
        Code reorganization, to group things contextually, and comments.
        
        Added events-up-to, to get a list of upcoming events.
        
        Added error trap and log for actions.
    }
 ]
 		
 scheduler: context [
 	name: mult: unit: n: allow: forbid: on-day: at-time: offset: count: action: user-data: err:
 	type: 
 	_start: _end:   ; Where the event starts and ends in the dialected plan
 	s: e:           ; start/end values for restricted ranges
 	value:          ; Most recently parsed day, time, day-num, etc.
 	    none
 	
 	error-log: %scheduler-errors.log
 	last-error: none
 	last-exec-result: none  ; not sure we'll want to keep this. Just experimenting.
 	
 	; Jobs is a block of date!/spec pairs, where the date value is the 
 	; next time that job/task should run, and the spec block is the spec
 	; for that task as it was parsed from the dialected plan.
 	jobs:  make block! 8
 	; The queue contains only specs (? only one spec at a time, ever?)
 	queue: make block! 1
 	; Shortcut name (? is it worth it?)
 	wait-list:  system/ports/wait-list
 	
 	reset: does [
 		clear jobs
 		clear queue
 		remove find wait-list time!
 	]
 	
 	; Return the current date/time with no timezone information
 	get-now: has [n] [n: now  n/zone: 00:00  n]
 	; Some tests set NOW to a specific date, which makes sense, but that
 	; breaks /precise. Hence, sys-now and precise-now
 	;get-now: has [n] [n: now/precise  n/zone: 00:00  n]
 	sys-now: :now
 	precise-now: has [n] [n: sys-now/precise  n/zone: 00:00  n]
 	
 	; Execute the action for a given task
 	exec: func [task-spec /local action res] [
 	    last-error: none
 	    if error? set/any 'res try [
 	        ;print mold task-spec
    		action: select task-spec 'action
    		;?? Do we really need to switch on action type? Or can we just DO them 
    		;   (once we de-reference word actions)?
    		if word? :action [action: get :action]
    		either file? :action [
    		    call action
    		][
    		    set/any 'res do :action :task-spec
    		]
 ;    		switch type?/word :action [
 ;    			url!   	  [read action] ;?? READ, not DO?
 ;    			block! 	  [do action]
 ;    			file! 	  [do action]
 ;    			function! [do :action task-spec]
 ;    			word!	  [do get :action task-spec]
 ;    		]
            last-exec-result: either value? 'res [:res] [none]
    	][
    	    last-error: disarm res
    	    ;TBD: What should go in the error log?
    	    write/append error-log reform [
    	        newline now/precise remold [task-spec/source third last-error]
    	    ]
        ]
 	]

    ; Call on-timer when the job timer goes off for the next job. It works closely
    ; with update-sys-timer. On-timer is called when a timer expires, takes the next
    ; task spec from the queue, runs it, and updates the job list with the next time
    ; that task should run. If the job was set to run only once, it's removed from
    ; the job list.
 	on-timer: has [task job] [
 	    task: take queue
 		job: back find/only jobs task
 		; Set the time for the task running now, which is used by next-event?.
 		task/last: get-now
 		; Run the actual action for the task.
 		exec task
 		; Remove jobs that don't need to execute again.
 		if any [
 		    ; Have to confirm this. If task/at is a date, we want to bail,
 		    ; but if it's a time, we only want to bail if 'every hasn't been
 		    ; used in the spec.
 		    date? task/at
 			all [task/at  not task/unit]
 			
 			all [task/count  zero? task/count: task/count - 1]
 			none? job/1: next-event? task
 		][
 		    ;print ["SCHEDULER" "on-timer" "Removing task from job list:" mold job/2]
 			remove/part job 2
 		]
 		; Set up the next task timer
 		update-sys-timer
 	]

    ; Schedule a timer for the next task to execute, and put its spec in the queue.
 	update-sys-timer: does [
 	    ; Jobs are pairs of next-task-time/spec values. Sort them to put 
 	    ; the next upcoming task first.
 		sort/skip jobs 2
 		; Update our public interface copy of jobs.
 		job-list: copy/deep jobs
 		; Take the current timer out of the system port wait-list, if we find one.
 		remove find wait-list time!
 		; Jobs have been sorted, so the next upcoming time is first, followed by
 		; its spec. Put the spec in the queue for on-timer to use and put the
 		; time we want it to trigger in the system port wait-list (offset from
 		; the current system time).
 		
 		; It's possible that there was no next event for the first job, meaning
 		; it will be NONE. That won't work for setting a timer, but we can just
 		; remove all expired jobs at the head of the job list before trying.
        while [all [not empty? jobs  none? jobs/1]] [remove/part jobs 2]
        
 		if not empty? jobs [
 			append/only queue jobs/2
 			; If we don't use /precise, milliseconds creep up over time. An offset
 			; of 0.04. Task exec time doesn't seem to be the value though.
 			; By using /precise, our events are within a few ms of the target second.
 			; !! But if our intervals are longer (e.g. 5 minutes), using /precise can
 			;    cause the even to trigger up to a full second early.

 		    ; The MAX is here because I was getting some errors in calling code that
 		    ; had WAITs in it. e.g. id: 'invalid-arg arg1: -0:00:03. My guess was that
 		    ; very close timing on things could cause a negative result to get into 
 		    ; the list when other WAIT calls were used. I haven't seen one of those
 		    ; errors since I added MAX here.
 		    ;append wait-list difference jobs/1 get-now
 		    append wait-list max 0:0:0 difference jobs/1 get-now
 		]

 	]
 	
 	allowed?: func [spec [block!] time [time!]] [
 		foreach v spec [
 		    either time? v [
 		        if v = time [return yes]
 		    ][
 		        ; v is a block of two time values [start end].
 		        either v/1 <= v/2 [
 		            ; Start is less than end.
 		            if all [v/1 <= time  time <= v/2] [return yes]
 		        ][
                    ; Midnight rollover logic (start is greater than end).
                    if any [
                        all [time >= v/1  time <= 24:00] ; 23:59:59.999
                        all [time <= v/2  time >= 00:00]
                    ] [return yes]
 		        ]
 		    ]
 		]
 		no
 	]
 	
 	; This returns NONE if there is no next event for the spec.
 	next-event?: func [spec [block!] /local new time mult] [
 	    ; If they set a count for the event (number of times to exec), and
 	    ; it has reached zero, there is no next event for it.
 		if spec/count = 0 [return none]
 		; If the spec gave a relative time, make it an absolute time.
 		if spec/at = 'in [
 			spec/at: search-event/short spec get-now
 		]
 		either any [date? spec/at  none? spec/unit] [
 			;-- AT --
 			new: set-datetime spec/at get-now
 		][
 			;-- EVERY --
 			new: any [spec/last get-now]
 			; This logic for setting /offset isn't elegant, but the original
 			; logic just set the entire time value to the offset, which wasn't
 			; correct for some cases, and could cause plan failures.
 			;!! TBD: We may miss the first event if there's an offset, because
 			;        we are adding the mult, which may put us past the next time.
 			;        e.g., start plan at 6:05 with a 15 minute step and offset of
 			;        0:0, and it thinks we should start searching at 6:15, making 
 			;        the first event 6:30.
 			;        search-event calls next-new before checking, which is
 			;        part of this. It steps by spec/multiple.
 			;        It looks like setting mult to 0 when the new time unit is
 			;        less than the mult takes care of it.
 			if all [not spec/last  spec/offset] [
 			    ; new is set to NOW, and we have an offset to apply.
 			    time: new/time
 			    mult: any [spec/multiple 0]  ; any [spec/multiple 1]
 			    switch spec/unit [
 			        hour [
 			            ;print 'HOUR
 			            if time/hour <= mult [mult: 0]
 			            time/hour: spec/offset/hour + mult
 			            time/minute: spec/offset/minute
 			            time/second: spec/offset/second
 			        ]
 			        minute [
 			            ;print 'MINUTE
 			            if time/minute <= mult [mult: 0]
 			            time/minute: spec/offset/minute + mult
 			            time/second: spec/offset/second
 			        ]
 			        second [
 			            ;print 'SECOND
 			            if time/second <= mult [mult: 0]
 			            time/second: spec/offset/second + mult
 			        ]
 			    ]
 			    new/time: time
 			]
 			if spec/at [
 			    ; If it's our first time setting the event, and /at is not a
 			    ; full date, but just a time, and since /last isn't set, we
 			    ; know new/day=now/day, then, finally, if /at comes later in 
 			    ; the day than the current time, we want to step the day back
 			    ; one because search-event will always step it forward at least
 			    ; one day, which means we miss the event for today, which should
 			    ; happen later in this day, not tomorrow.
 			    if all [none? spec/last  time? spec/at  now/time <= spec/at] [
 			        new/day: new/day - 1
 			    ]
 			    new/time: spec/at
 			]
 			if spec/unit = 'month [
 				new/day: any [
 					spec/on
 					all [date? spec/offset  spec/offset/day]
 					1   ; Default to the first of the month if they didn't spec a day.
 				]
 			]
 			new: search-event spec new
 		]		
 		new
 	]
 	
 	search-event: func [
 	    "Find the next date-time for the event, given a starting point in time."
 	    spec [block!]
 	    new  [date!]  "Where to start searching"
 	    /short "Only create an absolute event time from a relative time. Do no contstraint checking."
 	    /local tests step next-new sa sf u list
 	           t-dbg-start t-dbg-end n-dbg-ct   ;<< Used to test search timing
 	][
 		u:  spec/unit

 		step: any [spec/multiple 1]
 		next-new: either find [day month] u [
 			[new/:u: new/:u + step]
 		][
 			step: step * select [hour 1:0 minute 0:1 second 0:0:1] u
 			[new/time: new/time + step]
 		]
 		;-- Shortcut exit
 		if short [do next-new  return new]


 		tests: clear []
 		sa: spec/allow
 		sf: spec/forbid

 		;-- Constraints compilation --
 		foreach [cond test] [
 			[sa  select sa 'cal-days] 	[find sa/cal-days  new/day]
 			[sa  select sa 'week-days]	[find sa/week-days new/weekday]
 			[sa  select sa 'months] 	[find sa/months    new/month]
 			[sa  select sa 'time] 		[allowed? sa/time  new/time]
 			[sf  select sf 'cal-days] 	[not find sf/cal-days  new/day]
 			[sf  select sf 'week-days] 	[not find sf/week-days new/weekday]
 			[sf  select sf 'months] 	[not find sf/months    new/month]
 			[sf  select sf 'time] 		[not allowed? sf/time  new/time]
 		][
 			if all cond [append tests test]
 		]
 		
 		;?? Is this the correct way to ensure that we don't trigger a timer
 		;!! event right away, which then messes up the other timer events
 		;   so they don't honor the offset? This only happens if we start up
 		;   at a time that is within the allowed range. That's a real problem
 		;   if timers run 24 hours a day.
 		insert tests [new >= get-now]
 		
 		;-- evaluation --
 		;!! This will fail to find the next event if it's too far out, based 
 		;!! on the unit type. e.g., more than 60 minutes away if your unit
 		;!! is 1 minute. That can easily happen if your allowed hours are over
 		;!! for the day when you schedule the plan.
 		;   The STEP value comes into play, because we increment by that each
 		;   time through our loop. e.g., a step of 30 minutes will let you have
 		;   a gap of 30 hours to the next event, a step of 15 minutes works up
 		;   to 15 hours, 5 minutes = 5 hours, etc. This might be where a NOT
 		;   rule should be used, so we don't have to increase our loop counts
 		;   too much. To support a 24 hour period, with a 5 minute step, we 
 		;   need to loop 288 times. A 1 minute step = 1440 loops max.
 		;   Using 3600 for the seconds loop lets us go a day at 30 sec steps.
 		n-dbg-ct: 0
 		t-dbg-start: precise-now
 		loop select [
 			second	86'400  ; 3600 ; 60     86'400 = 1 day  takes ~0.6 sec on my machine
 			minute	1'440   ; 288 ; 60      1'440 = 1 day
 			hour	24
 			day		366		; account for leap years
 			month	12
 		] u [
 		    n-dbg-ct: n-dbg-ct + 1
 			do next-new
 			if all tests [
 	    		t-dbg-end: precise-now
 	    		;print ["DEBUG search-event FOUND" "count:" n-dbg-ct "time:" difference t-dbg-end t-dbg-start]
 			    return new
 			]
 		]
 		t-dbg-end: precise-now
   		;print ["DEBUG search-event NOT FOUND" "count:" n-dbg-ct "time:" difference t-dbg-end t-dbg-start]
 		;?? TBD: Should this error out, or return NONE, if we want to have some kind of trace?
 		;print "Debug info:"
 		;print ["new:" new "step:" step "next-new:" mold next-new "spec:" mold spec "tests:" mold tests]
 		;make error! rejoin ["Can't find next event for rule " mold spec/source]
 		;print rejoin ["Can't find next event for rule " mold spec/source]
 		return none
 	]

    ; Set the dest date/time values in place, from the source value.
 	set-datetime: func [src [date! time!] dst [date!]] [
 		if date? src [
 			dst/date: src/date
 			; If no source time is set, dest/time will not be set.
 			if src/time [dst/time: src/time]
 			; Timezones are not accounted for in this library. 
 			dst/zone: 00:00
 		]
 		if time? src [dst/time: src]
 		dst
 	]

 	
    ;-- Dialect support
    
    ; TBD: There is some type/name confusion throughout the module. In the
    ;      parse rules, 'type is used for allow/forbid, but it's called
    ;      'name in the blockify/expand/store funcs. In the parse rules,
    ;      'type is set to units like 'week-days or 'month.
    
 	blockify: func [
 	    name [word!] "'allow or 'forbid"
 	    type [word!]
 	    /local blk
 	][
 	    if not find [allow forbid] name [
 		    make error! join "Blockify called with bad type:" type
 		]
 		if not block? get name [set name make block! 1]
 		name: get name
 		if not blk: select name type [
 			repend name [type blk: make block! 1]
 		]
 		blk
 	]
 	
 	expand: func [
 	    name [word!] "'allow or 'forbid"
 	    type [word!]
 	    start
 	    end
 	    /local list
    ][
 	    if not find [allow forbid] name [
 		    make error! join "Expand called with bad type:" type
 		]
 		list: blockify name type
 		start: -1 + to integer! form start
 		end: 1 + to integer! form end
 		repeat c min end - start 60 [insert list end - c]
 	]
 	
 	; This is used when starting to parse a dialected spec.
 	reset-locals: has [list] [
 		clear next find list: first self 'value
 		set next bind list self err: none
 	]
 	
 	; Unused at this time
 	;reset-series: func [s [series!] len [integer!]] [head clear skip s len]
 	
 	; Store an allow or forbid value
 	store: func [
 	    name [word!] "'allow or 'forbid"
 	    type [word!]
 	    value 
 	    /only 
 	    /local list
 	][
 	    if not find [allow forbid] name [
 		    make error! join "Store called with bad type:" type
 		]
 		list: blockify name type
 		if issue? value [value: to integer! form value]
 		either only [append/only list value] [append list value]
 	]

    ; Put a job, that we parsed from a plan, into the jobs list	
 	store-job: has [record al src] [
 		src: copy/part _start _end
 		if all [
 			block? allow
 			block? forbid
 			not empty? intersect allow forbid
 		][
 			make error! rejoin ["Bad specification for task (allow and forbid values intersect):" mold src]
 		]
 		record: reduce [
 			'name		all [name  to word! name]
 			'multiple	mult
 			'unit		unit        ; = ical FREQ
 			'allow		allow
 			'forbid		forbid
 			'on			on-day
 			'at			at-time
 			'offset		offset      ; = ical BY ?
 			'count		count       ; = ical COUNT
 			'action 	:action     ; get-word! to allow funcs
 			'last		none        ; The last time the event occurred
 			'log?		yes
 			'debug? 	no
 			'source		src
 			'user-data  user-data
 		]
 		;probe new-line/all copy/part record 20 off
 		repend jobs [next-event? record  record]
 	]

 	
 ;-------------------------------------------------------------------------------
 ;-- Block Dialect

 	digits=: charset "0123456789"

    ; Not used at this time
 	;cal-days=: [set n integer!]
 	
 	week-days=: [
 		  ['Monday		| 'Mon]	(n: 1)
 		| ['Tuesday		| 'Tue]	(n: 2)
 		| ['Wednesday 	| 'Wed]	(n: 3)
 		| ['Thursday	| 'Thu]	(n: 4)
 		| ['Friday		| 'Fri]	(n: 5)
 		| ['Saturday	| 'Sat]	(n: 6)
 		| ['Sunday		| 'Sun]	(n: 7)
 	]
 	months=: [
 		  ['January		| 'Jan]	(n: 1)
 		| ['February	| 'Feb]	(n: 2)
 		| ['March		| 'Mar]	(n: 3)
 		| ['April		| 'Apr]	(n: 4)
 		| ['May			| 'May]	(n: 5)
 		| ['June		| 'Jun]	(n: 6)
 		| ['July		| 'Jul]	(n: 7)
 		| ['August		| 'Aug]	(n: 8)
 		| ['September	| 'Sep]	(n: 9)
 		| ['October		| 'Oct]	(n: 10)
 		| ['November	| 'Nov]	(n: 11)
 		| ['December	| 'Dec]	(n: 12)
 	]
 	
 	delays=: [
 		  ['seconds | 'second	| 'sec | 's] (unit: 'second)
 		| ['minutes | 'minute 	| 'min | 'mn] (unit: 'minute)
 		| ['hours   | 'hour   	| 'hr  | 'h] (unit: 'hour)
 		| ['days    | 'day	   	| 'd] 		 (unit: 'day)
 		| ['weeks   | 'week   	| 'wk | 'w]	 (unit: 'day mult: 7 * any [mult 1])
 		| ['months  | 'month	| 'mo] 		 (unit: 'month) opt on-day=
 	   ;| 'last-day-of-month 				 (unit: 'ldom)	; unsupported	use every -1, -2...??
 	   ;| 'day-of-year 	  					 (unit: 'doy)	; unsupported
 	]
 	
 	on-day=: ['on set value issue! (unit: 'day  store 'allow 'cal-days value)]
 	
 	week-months=: [
 		week-days=	(unit: 'day  store type 'week-days n)
 		| months= 	(unit: any [unit 'month]  store type 'months n)
 		  opt on-day=
 	]
 	
 	restriction=: [
 		  opt 'from set s issue! ['- | 'to] set e issue! (expand type 'cal-days s e)
 		| opt 'from set s time!  ['- | 'to] set e time!  (store/only type 'time reduce [s e])
 		| set value time! 			 (store type 'time value) 
 		| set value issue! 			 (unit: 'day  store type 'cal-days value) 
 		| week-months=
 	]
 	
 	restrictions=: [restriction= | into [some restriction=]]
 	
 	count=: [set count integer! ['times | 'time]]
 	
 	at-time=: [
 	    'on set at-time date! 'at set value time! (at-time/time: value)
 	    | 'at set at-time [date! | time!]
 	]
 	
 	every-rule=: [
 	    ; Changed integer! to number! for mult, to allow for partial intervals
 	    ; e.g., sub-second timers. Need to test for regression errors.
 		opt [set mult number!]
 		[
 			(type: 'allow) restrictions= opt on-day=
 			| [delays= | (type: 'allow) week-months=] opt [(type: 'allow) restrictions=]
 		]
 		1 4 [
 			opt ['not (type: 'forbid) restrictions=]
 			opt ['offset set offset [date! | time!]]
 			opt at-time=
 			opt count=
 		]
 	]
 	
 	; 'With is a nicer word if user-data comes after the action.
    user-data=: [['user-data | 'with] set user-data any-type!]
    
    action=: [
        'do set action [file! | url! | block! | word! | function! | paren!]
    ]
    
 	dialect=: [
 		any [
 			(reset-locals)
 			err: _start:
 			opt [set name set-word!]
 			[
 				at-time=
 				| 'in set mult integer! delays= (at-time: 'in)
 				| 'every every-rule=
 			]
 			; User-data can come before or after the action.
 			opt user-data=
 			action=
 			opt user-data=
 			_end:
 			(store-job)
 		]
 	]
 	

 ;-- End Block Dialect
 ;-------------------------------------------------------------------------------
 ;-- String Dialect

    ; This is for internal use. It's not a public interface.
 	pre-process: func [src [string!] /local s e v fix out] [
 		fix: [e: (s: change/part s v e) :s]		
 		parse/all src [
 			any [
 				s: "1st"   (v: "#1")  fix
 				| "2nd"    (v: "#2")  fix
 				| "3rd"    (v: "#3")  fix
                | "21st"   (v: "#21") fix
 				| "22nd"   (v: "#22") fix
 				| "23rd"   (v: "#23") fix				
                | "31st"   (v: "#31") fix
 				| copy v 1 3 digits= [
 					"th"   (v: join "#" v) fix
 					| "s"  (v: join v " s")  fix
 					| "mn" (v: join v " mn") fix
 					| "h"  (v: join v " h")  fix
 					| "w"  (v: join v " w")  fix
 					| "m"  (v: join v " m")  fix
 				]
 				| skip
 			]
 		]		
 		if none? out: attempt [load/all src] [
 			make error! join "Scheduler input syntax error in: " src
 		]	
 		out
 	]

 ;-- End String Dialect
 ;-------------------------------------------------------------------------------
 ;-- Public Interface


 	delete: func [name [word!] /local job] [
 		job: jobs
 		forskip job 2 [
 			if job/2/name = name [
 				remove/part job 2
 				return true
 			]
 		]
 		make error! reform ["job" mold name "not found!"]
 	]

    ;!! Be careful calling this if you have events with very low intervals.
    ;   E.g., getting all events that happen every second for the next year
    ;   has to find a lot of events.
 	events-up-to: func [
 		"Return a block of upcoming events"
 		end [date!] "Return events that occur up to this point in time"
 		/local job-blk task next-evt res
 	][
 		sort/skip job-blk: copy/deep job-list 2     ;!! copy/deep is important here!
 		if empty? job-blk [return copy []]
 		res: copy []
 		while [
 		    all [
 		        not empty? job-blk
 		        next-evt: job-blk/1: job-blk/2/last: next-event? job-blk/2
 		        next-evt <= end
 		        next-evt >= get-now
 		    ]
 		][
 	        task: job-blk/2
    		if next-evt [
    		    repend res [next-evt new-line/all copy task off]
    		]
    		; Remove jobs that don't need to execute again.
    		if any [
    		    ; Have to confirm this. If task/at is a date, we want to bail,
    		    ; but if it's a time, we only want to bail if 'every hasn't been
    		    ; used in the spec. I think task/unit is the best way to check that.
    		    date? task/at
    			all [task/at  not task/unit]
    			
    			all [task/count  zero? task/count: task/count - 1]
    			none? next-evt
    		][
    			;print [next-evt  end  task/last  next-evt <= end]
    		    ;print "*** Removing task"
    			remove/part job-blk 2
    		]
 			sort/skip job-blk 2
 		]
        new-line/skip res on 2
 	]
 	
 	; Encourage people to use this, rather than 'jobs, so they can't screw
 	; things up by modifying it. It will be a deep copy of 'jobs.
 	job-list: copy/deep jobs
    
    ;?? Would plan-events be a better name?
 	plan: func [
 	    spec [block! string!]
 	    /new "Clear the current plan before setting up the new one."
 	][
 		if new [reset]
 		if string? spec [spec: pre-process spec]
 		
 		if not parse copy/deep spec dialect= [
 			print ["Error parsing schedule plan at rule:" mold copy/part err 10]
 		]
 		
 		update-sys-timer
 	]

    ;TBD: Make sure this doesn't set any vars during the parse that would mess
    ;     up a running plan, or one about to be scheduled.
 	plan-ok?: func [
 	    "See if a plan can be parsed successfully"
 	    spec [block! string!]
 	][
 		if string? spec [spec: pre-process spec]
 		parse copy/deep spec dialect= 
 		; Use scheduler/err to see the where the parse failed.
 	]
 	
    ;!! Use this in place of REBOL's standard WAIT func when using a scheduler.
 	wait: does [
 	    ; If (system) WAIT returns none, it means our next job timer went off.
 		while [none? system/words/wait []] [
 			on-timer
 			if empty? jobs [exit]
 		]
 	]


 ]