daScript/daslib/coroutines.das at master · feiyunwill/daScript · GitHub

History

131 lines (119 loc) · 5.19 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

options gen2

options indenting = 4

options strict_smart_pointers = true

module coroutines shared public

//! Coroutine and generator support.

//!

//! Provides the ``[coroutine]`` function annotation that transforms a function into

//! a generator-based state machine, plus helper macros:

//! * ``yeild_from(iter)`` — yield all values from a sub-iterator

//! * ``co_continue()`` — yield true (continue running)

//! * ``co_await(sub)`` — wait for a sub-coroutine to finish

//! And runner functions ``cr_run`` and ``cr_run_all`` for executing coroutines.

require daslib/ast_boost

require daslib/templates_boost

require daslib/macro_boost

require daslib/defer

//! A coroutine is a generator that yields bool to indicate if it is still running.

typedef Coroutine = iterator<bool>

//! An array of coroutines.

typedef Coroutines = array<Coroutine>

[macro_function]

def private verify_inside_coroutine(prog : ProgramPtr; call : ExprCallMacro?&) : bool {

//! Verifies that a call macro is being used inside a [coroutine] or [async] annotated function.

if (call.inFunction == null) return true

for (ann in call.inFunction.annotations) {

if (ann.annotation.name == "coroutine" || ann.annotation.name == "async") return true

}

macro_error(prog, call.at, "{call.name}() can only be used inside a [coroutine] or [async] function")

return false

}

[call_macro(name="yeild_from")]

class private YieldFrom : AstCallMacro {

//! This macro converts a ``yeild_from(THAT)`` expression into equivalent inline code.

def override visit(prog : ProgramPtr; mod : Module?; var call : ExprCallMacro?) : Expression? {

//! Visits the yeild_from macro call and rewrites it into a for-yield loop.

macro_verify(call.arguments |> length == 1, prog, call.at, "expecting yeild_from(iterator)")

macro_verify(call.arguments[0]._type != null, prog, call.at, "expecting iterator")

macro_verify(call.arguments[0]._type.isIterator, prog, call.at, "expecting iterator")

let iname = make_unique_private_name("_yield_from_iterator", call.at)

return qmacro_block() {

for ($i(iname) in $e(call.arguments[0])) {

yield $i(iname)

}

[call_macro(name="co_continue")]

class private CoContinue : AstCallMacro {

//! This macro converts co_continue to yield true.

//! The idea is that coroutine without specified type is underneath a coroutine which yields bool.

//! That way co_continue() does not distract from the fact that it is a generator<bool>.

def override visit(prog : ProgramPtr; mod : Module?; var call : ExprCallMacro?) : Expression? {

//! Visits the co_continue macro call and rewrites it to ``yield true``.

macro_verify(empty(call.arguments), prog, call.at, "expecting co_continue()")

if (!verify_inside_coroutine(prog, call)) return null

return qmacro_expr() {

yield true

}

[call_macro(name="co_await")]

class private CoAwait : AstCallMacro {

//! This macro converts ``co_await(sub_coroutine)`` into equivalent inline code.

def override visit(prog : ProgramPtr; mod : Module?; var call : ExprCallMacro?) : Expression? {

//! Visits the co_await macro call and rewrites it into a for-yield loop over the sub-coroutine.

macro_verify(call.arguments |> length == 1, prog, call.at, "expecting co_await(subroutine)")

if (!verify_inside_coroutine(prog, call)) return null

let iname = make_unique_private_name("_co_await_iterator", call.at)

return qmacro_block() {

for ($i(iname) in $e(call.arguments[0])) {

yield $i(iname)

}

[function_macro(name="coroutine")]

class private CoroutineMacro : AstFunctionAnnotation {

//! This macro converts coroutine function into generator, adds return false.

def override apply(var func : FunctionPtr; var group : ModuleGroup; args : AnnotationArgumentList; var errors : das_string) : bool {

//! Transforms the annotated function into a generator-based coroutine.

var retT : TypeDeclPtr

if (func.result.baseType == Type.tVoid || func.result.baseType == Type.autoinfer) {

retT = qmacro_type(type<bool>)

} else {

retT = clone_type(func.result)

}

var blk = qmacro_block() {

return <- generator<$t(retT)> {

$e(func.body)

return false // nolint:LINT001,LINT019 - safety net; LINT001 fires only for bodies that already end in return, so most compiles leave the directive unconsumed

}

func.body = blk

func.result = qmacro_type(type<iterator<$t(retT)>>)

return true

}

def public cr_run(var a : Coroutine) {

//! This function runs coroutine until it is finished.

for (_t in a) {

pass

}

def public cr_run_all(var a : Coroutines) {

//! This function runs all coroutines until they are finished.

while (true) {

var i = length(a)

if (i == 0) break

while (i > 0) {

i --

var t : bool

next(a[i], t)

if (empty(a[i])) {

delete a[i]

a |> erase(i)

}

daScript/daslib/coroutines.das at master · feiyunwill/daScript · GitHub

Expand file tree

Breadcrumbs

coroutines.das

Latest commit

History

Breadcrumbs

coroutines.das

File metadata and controls