task! is not needed if tasks.$T.path is specified

macros/src/check.rs

@@ -18,6 +18,7 @@ pub type Tasks = HashMap<Ident, Task>;
 
 pub struct Task {
     pub enabled: Option<bool>,
+    pub path: Option<Path>,
     pub priority: u8,
     pub resources: Idents,
 }
@@ -71,6 +72,7 @@ fn task(task: syntax::check::Task) -> Result<Task> {
     if let Some(priority) = task.priority {
         Ok(Task {
             enabled: task.enabled,
+            path: task.path,
             priority,
             resources: task.resources,
         })

macros/src/trans.rs

@@ -1,4 +1,5 @@
 use quote::{Ident, Tokens};
+use syn::{Lit, StrStyle};
 
 use analyze::{Ownership, Ownerships};
 use check::App;
@@ -497,9 +498,17 @@ fn tasks(app: &App, ownerships: &Ownerships, root: &mut Vec<Tokens>) {
 
         let mut lifetime = None;
         let mut needs_reexport = false;
+        let mut needs_threshold = false;
+        let has_resources = !task.resources.is_empty();
+
+        if has_resources {
             for name in &task.resources {
                 match ownerships[name] {
-                Ownership::Shared { ceiling } if ceiling > task.priority => {
+                    Ownership::Shared { ceiling }
+                        if ceiling > task.priority =>
+                    {
+                        needs_threshold = true;
+
                         fields.push(quote! {
                             pub #name: super::_resource::#name,
                         });
@@ -571,15 +580,66 @@ fn tasks(app: &App, ownerships: &Ownerships, root: &mut Vec<Tokens>) {
                     }
                 }
             });
+        }
+
+        if let Some(path) = task.path.as_ref() {
+            let mut tys = vec![];
+            let mut exprs = vec![];
 
             let priority = task.priority;
+            if needs_threshold {
+                tys.push(quote!(&mut Threshold));
+                exprs.push(quote!(&mut Threshold::new(#priority)));
+            }
+
+            if has_resources {
+                tys.push(quote!(#name::Resources));
+                exprs.push(quote!(#name::Resources::new()));
+            }
+
+            let _name = Ident::new(format!("_{}", name));
+            let export_name = Lit::Str(name.as_ref().to_owned(), StrStyle::Cooked);
+            root.push(quote! {
+                #[allow(non_snake_case)]
+                #[allow(unsafe_code)]
+                #[export_name = #export_name]
+                pub unsafe extern "C" fn #_name() {
+                    let f: fn(#(#tys,)*) = #path;
+
+                    f(#(#exprs,)*)
+                }
+            });
+        } else if !has_resources {
+            items.push(quote! {
+                pub struct Resources {
+                    _0: (),
+                }
+
+                impl Resources {
+                    pub unsafe fn new() -> Self {
+                        Resources { _0: () }
+                    }
+                }
+            });
+            // the `task!` macro will be used so the `#NAME::Resources` type
+            // must exist
+        }
+
+        let priority = task.priority;
+        if task.path.is_none() {
+            // This `const`ant is mainly used to make sure the user doesn't
+            // forget to set a task handler using the `task!` macro. They'll get
+            // an error if they do.
+            items.push(quote! {
+                #[deny(dead_code)]
+                pub const #name: u8 = #priority;
+            });
+        }
+
         root.push(quote!{
             #[allow(non_snake_case)]
             #[allow(unsafe_code)]
             mod #name {
-                #[deny(dead_code)]
-                pub const #name: u8 = #priority;
-
                 #[allow(dead_code)]
                 #[deny(const_err)]
                 const CHECK_PRIORITY: (u8, u8) = (

src/lib.rs

@@ -191,6 +191,10 @@ impl Threshold {
 impl !Send for Threshold {}
 
 /// Sets an interrupt as pending
+///
+/// If the interrupt priority is high enough the interrupt will be serviced
+/// immediately, otherwise it will be serviced at some point after the current
+/// task ends.
 pub fn set_pending<I>(interrupt: I)
 where
     I: Nr,