C言語で継続の取得と呼び出し（前編）

(define list-length
 (lambda (obj)
    (call/cc (lambda (return)
        (letrec ((r
            (lambda (obj)
                (cond 
                    ((null? obj) 0)
                    ((pair? obj) (+ (r (cdr obj)) 1))
                    (else (return #f))))))
            (r obj))))))
         
(print (list-length '(1 2)))       ; => 2  (リストの長さは2)
(print (list-length '(1 2 . 3)))   ; => #f (リストではないので#f(false)が返される
(print (list-length '(1 2 (3 4)))) ; => 3  (リストの長さは3)

#ifndef CONTINUATION_H
#define CONTINUATION_H

#include <alloca.h>
#include <setjmp.h>
typedef struct {
    void *stack;
    unsigned long stacklen;
    void *rsp;
    jmp_buf cont_reg;
} continuation;

void init_continuation(void *rbp);
#define GETRSP(rsp) asm volatile("mov %%rsp, %0" : "=r"(rsp));
#define GETRBP(rbp) asm volatile("mov %%rbp, %0" : "=r"(rbp));
// main関数などの初めに記述
#define INIT_CONTINUATION()                                                    \
{                                                                            \
    void *main_rbp;                                                            \
    GETRBP(main_rbp);                                                          \
    init_continuation(main_rbp);                                               \
}
// 現在の継続を取得
int get_continuation(continuation *c);
// 継続を呼びだす
void call_continuation(continuation *c, int val);
// 取得した継続のメモリ領域
void free_continuation(continuation *c);

#endif

#include <stdlib.h>
#include <setjmp.h>
#include <string.h>
#include "continuation.h"
static void *main_rbp;

void init_continuation(void *rbp) {
    main_rbp = rbp;
}
int get_continuation(continuation *c) {
    void *rsp;
    GETRSP(rsp);
    c->rsp = rsp;
    c->stacklen = main_rbp - rsp + 1;
    c->stack = malloc(sizeof(char) * c->stacklen);
    memmove(c->stack, c->rsp, c->stacklen);
    return setjmp(c->cont_reg);
}
void _cc(continuation *c, int val) {
    memmove(c->rsp, c->stack, c->stacklen);
    longjmp(c->cont_reg, val);
}
void call_continuation(continuation *c, int val) {
    volatile void *q = 0;
    do {
        q=alloca(8);
    } while (q > c->rsp);
    _cc(c, val);
}
void free_continuation(continuation *c) {
    free(c->stack);
}

#include <stdio.h>
#include "continuation.h"

// 継続を保存する大域変数
continuation cont;
int func2() {
    puts("func2");
    if (get_continuation(&cont) == 0) {
        // 関数は継続を取得した場合0を返す
        return 0;
    } else {
        // 継続が呼び出された場合0以外を返す
        puts("func2 cont");
        return 1;
    }
}
int func() {
    puts("func");
    return func2();
}
int main(int argc, char *argv[]) {
    INIT_CONTINUATION();
    puts("main");
    int a = 0;
    if (func() == 0) {
        puts("main_1");
        a++;
        printf("a: %d\n", a);
        // 継続を呼び出す（第二引数はget_continuation()関数の返り値になる）
        call_continuation(&cont, 1);
    } else {
        puts("main_2");
        printf("a: %d\n", a);
    }
    free_continuation(&cont);
}

main 
func
func2
main_1
a: 1
func2 cont
main_2
a: 0