
                            SECDRޥˤĤ

                                                     ʿ5ǯ620

            Copyright (C) 1990, 1991, 1992, 1993  Shoichi Hayashi ( Ͱ),
                                                  Atsushi Moriwaki ( )


1. ۥޥγ

SchemeνϤǤϡSchemeΥץϲۥޥε˥ѥ뤵
Ƥ顢ۥޥˤäƼ¹ԤԤʤޤǤϼˡβۥޥ
ĤƽҤ٤뤳Ȥˤޤ

̤˴ؿμ¸ǥϡĶåǥ, ǡեǥ, 
ǥʬह뤳ȤǤޤ

Ķåǥϡѿηȼ¹Խξ"Ķ"ȤƼ¸
μ¹Խ˽äƴĶ򥹥å뤳Ȥˤꡢؿμ¹ԥᥫ˥
¸׻ǥǤΤ褯Τ줿ɽŪΰĤȤSECDޥ
ޤ

SECDR-Schemeβۥޥϡ̾ưפǤޤ褦ˡ
SECDޥѷΰĤǤ

ĶåޥϥϡɥåؿΥå̿
ɤѰդ뤳Ȥˤؿμ¹Ԥ®׻ǤδĶ
ޥǤϡåѤ뤳ȤˤꡢѿηĶ¹ԾΨ褯
뤳ȤǤޤؿ¹Ԥ䡢ٱɾⳬؿǽμ
ФƤɬΨŪʤΤǤϤޤ

ĶåޥξҤηФͭʤΤȤơ㤨LazyMLΥ
ץȤѤƤG-ޥ󤬤ޤG-ޥϥǥ
ĤǤꡢSGCDޥȸƤФ뤳Ȥ⤢ޤĤޤSECDޥE(Ķ)
G()եԤʤޥǤ

ơǤSECDR-SchemeľܴطĶåǥSECD(SECDR)ޥ
ˤĤƤΤߴñ˲⤹뤳ȤˤޤΤǡե䤽μ
ˤⶽ̣򤪻ˤʤä顢㤨[2]ɤߤˤʤäƲ


ǽSECDޥˤñ˿֤äƤޤ礦

Peter Landinνʸǡ˻ˡȵӹ(äALGOL60)
δطƤޤSECDȸƤݵˤäƼɾɤͤ˵
Ū˹ԤΤҤ٤Ƥޤ1966ǯLandinϰĤθ(ΰ²)Iswim(If You 
See What I Meanά)Ƴ¿νפʹʸι̣ͤιͤ
ޤĤޤSECDϡLandiṇγ׿ФӤǡؿ
ץ¹Ԥ뤿ñݵȤ󼨤ΤǤ

θPeter HendersonLispkit Lisp(ֱ黻ҤŪʹʸäLisp
ΰ)ΥץȤΤˡѷΤǤSECDޥ
ƤޤHenderson[1]ˤϡSECDޥβȼˡܤ⤵
ƤޤäSECDޥˤĤƾܺ٤Τꤿϡɤޤ
Ǥ礦

ơSECDR-SchemeβۥޥǤSECDRޥϡHendersonμ
SECDޥ˴Ťƺ줿ΤǤƵн褹뤿
ˡޥΤĤξܤϰۤʤäΤȤʤäƤޤĤޤꡢ
ΤΰĤȤʤäƤȤȤǤ

褦ˡ⤽⤳SECDRޥκǽθǤSECDޥϡLandin
äƴؿIswim䤽ηŪỤ̄Τ˹ͰƤ줿ݵ
ǤäΤǤSECDR-SchemeνϤϡỤ̄Ϳ뤳
ΤޤưƤ褦ʤΤǤ(SchemeɽỤ̄ϡΰĤλ
ͽǤR4RSˤƷŪͿƤޤ)


2. SECDRޥΥƥ

SECDRޥϡʲΤ褦ˣĤΥ쥸ĴĶåޥǤ

----------------------------------------------------------------------------
S: stack
        ͤ׻ַ̤롣
E: environment
        ׻ǳѿ«ͤ롣
C: control list
        ¹Ԥ٤ץ롣
D: dump
        ؿƤӽФä¾Υ쥸Ƥ򤷤ޤäƤ
        åΰ
R: return
        ͤǼ롣
----------------------------------------------------------------------------

SECDRޥ19Ĥ̿ȳơξܤ򡢰ʲɽ˼ޤ­
Ǥʤʬ뤫Τޤ󤬡ξϾҤ[1]򻲹ͤˤƲ

----------------------------------------------------------------------------
LD: #0
 S E (LD (i . j) . C) D R ==> S E C D r
  where r = (list-ref (list-ref E i) j)

TLD: #1
 S E (TLD (i . j) . C) D R ==> S E C D r
  where r = (list-tail (list-ref E i) j)

GLD: #2
 S E (GLD sym . C) D R ==> S E C D r
  where r = gloabl value of sym

LDC: #3
 S E (LDC const . C) D R ==> S E C D const

LDF: #4
 S E (LDF code . C) D R ==> S E C D (closure of code and E)

AP: #5
 (args . S) E (AP . C) D op ==>
  case: op is closure
    () (args . env) code (S E C . D) NIL
    where code is closure code of op and
    env is closure environment of op.
  case: op is primivite procedure
    First, execute primitive procedure op with arguments args
    and set registers to S E C D r, where r is the return
    value of primitine procedure op.
  case: op is continuation
    s e c d r
    where r is first element of args and
    s e c d are saved registers in op.

TAP: #6
 (args . S) E (TAP . C) D op ==>
  case: op is closure
    () (args . env) code D NIL
    where code is closure code of op and
    env is closure environment of op.
  case: op is primivite procedure
    First, execute primitive procedure op with arguments args
    and set registers to S E C D r, where r is the return
    value of primitine procedure op.
  case: op is continuation
    s e c d r
    where x is the first element of args and
    s e c d r are saved registers in op.

PUSH: #7
 S E (PUSH . C) D R ==> (R . S) E C D R

RTN: #8
 S E (RTN . C) (s e c . d) R ==> s e c d R

SEL: #9
 S E (SEL ct cf . C) D test ==> S E cx (S E C . D) test
  where cx = (if test ct cf)

TSEL: #10
 S E (TSEL ct cf . C) D test ==> S E cx D test
  where cx = (if test ct cf)

ASSIG: #11
 S E (ASSIG (i . j) . C) D R ==> S E' C D R
  where E' is made by
    (set-car! (list-tail (list-ref E i) j) R)

TASSIG: #12
 S E (TASSIG (i . j) . C) D R ==> S E' C D R
  where E' is made by
    (if (zero? j)
      (set-car! (list-tail E i) R)
      (set-cdr! (list-tail (list-ref E i) (- j 1)) R))

GASSIG: #13
 S E (GASSIG sym . C) D R ==> S E C D R
  where global value of sym = R

DEF: #14
 S E (DEF sym . C) D R ==> S E C D sym
  where global value of sym = R

PUSHCONS: #15
 (s . S) E (PUSHCONS . C) D R ==> ((R . s) . S) E C D R

SAVE: #16
 S E (SAVE C1 . C2) D R ==> S E C1 (S E C2 . D) R

EXEC: #17
 S E (EXEC . C) D code ==> NIL NIL code (S E C . D) NIL

STOP: #18
 S E (STOP . C) D R ==> Stop SECDR execution
----------------------------------------------------------------------------

ͤޤǤ˰ʲHendersonSECDޥξܤ⼨Ƥޤ

----------------------------------------------------------------------------
LD: load
        S E (LD i . C) D --> (x . S) E C D  where x=locate(i, e)

LDC: load constant
        S E (LDC x . C) D --> (x . S) E C D

LDF: load function
        S E (LDF C' . C) D --> ((C' . E) . S) E C D

AP: apply function
        ((C' . E') v . S) E (AP . C) D --> NIL (v . E') C' (S E C . D)

RTN: return
        (x) E' (RTN) (S E C . D) --> (x . S) E C D

DUM: create dummy environment
        S E (DUM . C) D --> S (O . E) C D

RAP: recursive apply
        ((C' . E') v . S) (O . E) (RAP . C) D 
                                  --> NIL rplaca(E', v) C' (S E C . D)

SEL: select subcontrol
        (x . S) E (SEL cT cF . C) D --> S E Cx (C . D)

JOIN: rejoin main control
        S E (JOIN) (C . D) --> S E C D

CAR:
        ((a . b) . S) E (CAR . C) D --> (a . S) E C D

CDR:
        ((a . b) . S) E (CDR . C) D --> (b . S) E C D

ATOM:
        (a . S) E (ATOM . C) D --> (t . S) E C D

CONS:
        (a b . S) E (CONS . C) D --> ((a . b) . S) E C D

EQ:
        (a b . S) E (EQ . C) D --> (b=a . S) E C D

ADD:
        (a b . S) E (ADD . C) D --> (b+a . S) E C D

SUB:
        (a b . S) E (SUB . C) D --> (b-a . S) E C D

MUL:
        (a b . S) E (MUL . C) D --> (b*a . S) E C D

DIV:
        (a b . S) E (DIV . C) D --> (b/a . S) E C D

REM:
        (a b . S) E (REM . C) D --> (b rem a . S) E C D

LEQ:
        (a b . S) E (LEQ . C) D --> (b=<a . S) E C D

STOP:
        S E (STOP) D --> S E (STOP) D
----------------------------------------------------------------------------


3. SECDRޥScheme

SECDR-SchemeΥѥSchemeȤǽ񤫤Ƥޤޤѥ̤Ǥ
֥ɤϡƥȥեˤʤޤǥ֥ޤޤƤޤ
Τǡѥ̤ưפ򤹤뤳ȤǤǤ礦

Ȥǡľܤ֥ɤƥȤϤ¹Ԥ뤳ȤǤޤޤ
MANUALˤ⵭Ҥޤ褦ˡܽϤǤϲۥޥMasterSlave2
¸ߤޤMasterΥޥϡ顼䥤󥿥ץȤȯˤϡ
ξ֤¸ޤߤޤSlaveΥޥưФޤΤǡ
Slave¦MasterΥ쥸򻲾Ȥѹꤹ뤳ȤǤޤ
(Init.scmerror hookδؿ򻲹ͤˤƲ)
տԤʤȤɬפǤƤߤȲۥޥ˲
Τɤ狼ϤǤ

ʲ򼨤ޤ


> (define code 
     (compile '(define (fact n)(if (zero? n) 1 (* n (fact (1- n)))))))
; Evaluation took 0.049998 Seconds (0 in gc).
code
> code
; Evaluation took 0 Seconds (0 in gc).
(#4 (#3 () #7 #0 (0 . 0) #15 #2 zero? #5 #10 (#3 1 #8) (#3 () #7 #3 () #7 #3
 () #7 #0 (0 . 0) #15 #2 1- #5 #15 #2 fact #5 #15 #0 (0 . 0) #15 #2 * #6 #8)
 #8) #14 fact #8)
> (disassemble code)

  ************ DisAssemble Code ************

    (
    LDF       (
        LDC       ()
        PUSH
        LD        (0 . 0)
        PUSHCONS
        GLD       zero?
        AP
        TSEL      (
            LDC       1
            RTN
            )
            (
            LDC       ()
            PUSH
            LDC       ()
            PUSH
            LDC       ()
            PUSH
            LD        (0 . 0)
            PUSHCONS
            GLD       1-
            AP
            PUSHCONS
            GLD       fact
            AP
            PUSHCONS
            LD        (0 . 0)
            PUSHCONS
            GLD       *
            TAP
            RTN
            )
        RTN
        )
    DEF       fact
    RTN
    )
  ************ END DisAssemble ************

; Evaluation took 0.116662 Seconds (0 in gc).

> (exec code)
; Evaluation took 0.016666 Seconds (0 in gc).
fact
> (fact 5)
; Evaluation took 0 Seconds (0 in gc).
120

> (compile '(lambda (m n)(+ m n)))
; Evaluation took 0.033332 Seconds (0 in gc).
(#4 (#3 () #7 #0 (0 . 1) #15 #0 (0 . 0) #15 #2 + #6 #8) #8)
> ((lambda (m n)(+ m n)) 3 2)
; Evaluation took 0.016666 Seconds (0 in gc).
5
> ((exec '(#4 (#3 () #7 #0 (0 . 1) #15 #0 (0 . 0) #15 #2 + #6 #8) #8)) 3 2)
; Evaluation took 0.033332 Seconds (0 in gc).
5


4. 

1ǽҤ٤褦ˡνϤỤ̄Ϳ뤿ݥޥ󤬡Τޤ
ưƤ褦ʤΤǤƤΤ狼פͥ褷ᡢ®٤˴ؤƤ
̤θԤʤäƤޤ󡣤Ǥ®٤ˤĤƤϡϤäꤤä®Ϥ
ޤ󡣤SchemeˤĤƤ⽼ʬʳؽ¸Ԥ褦ˡR4RS
ͤ˽򤷤ϤˤʤäƤޤ


<ʸ>

[1] Peter Henderson , ƣ˧ͺڸ :
    Functional Programming -- Application and Implementation,
    ؿץߥ,
    ܥԥ塼, 1985.

[2] Peyton Jones:
    The Implementation of Functional Programming Languages,
    Prentice Hall, 1987.
