 TSCoreVMˤĤ
ߤdirect interpretaterbytecode interpreterѹ롣
ޥåб򸫹ǡ1åɤб¹ԥƥȤ
뤴ɽTSVirtualMachine饹Ѱդ󥿥ץ꥿Ϥ˺
ࡣ

libtscoreǥݡȤޥåɤΥ᡼ϡ
(interaction-environment)ƤΥåɤǶͭʤȥåץ٥
syntax bindingȳǼƤͤޤ᤿ѿƤΥåɤǶͭ
롣ȥåץ٥ѿãǤƤΥ֥ȤƤΥ
ɤǶͭ롣

Schemeץμ¹˺ġenvironmentϥåɥ
ˤʤ롣ޤåɥҡפѰդ롣ƥåɤǤScheme
¹˥ȥåץ٥ѿؤä顢ͤҡ
פ˳ǼƤˤϥХҡפdeepԡԤ
ѥǥץʥꥷԤСdeepԡɬפˤ
ʤ֥ȤɤǹԤ뤫ʬȤƤϡ
deepԡɬפˤʤʤ̤˸¤äƥҡפ˥֥Ȥ
allocate뤳ȤˤСºݤdeepԡΥȤ¹Ի˻ʧɬ
ϤʤˤäƤϥХҡפ˳Ǽ뤬ˤǤϤʤȤ
硢ǽ餫饰Хҡפ˳ǼΤȡdeepԡΤ
Ǥɤ餬äʬʤġĤȤϤѥѰդޤǤϰ
̣ʤΤǡåɥҡפλѤϤҤȤޤfuture workȤ
ݤʡMemorySystemβ¤ɬפˤʤ뤷ʡ


 Schemeץμ¹ԤˤĤ
ƥåɤread-eval-print롼פ¹Ԥ뤬readprintˤVMͿ
ɬפʤꥸʥTinySchemeǤreadprintμˤ
ơꥹȤʤɤɤ߽񤭤Τ褦ܼŪ˺Ƶɬפʬnative
ο򥳥󥹥ȤݤĤˡʡˡread/printεǽμ⥤
ץ꥿롼פȤ߹ǤߤlibtscoreǤϡ줾Reader
Writer˵ǽʬΥƤ뤿ᡢread̤Ȥ֤֥
Ȥҡפ뤿ꥷƥؤΥɬפʤΤ̤Ȥ
VMɬפǤʤreadξ⡢Schemeץμ¹Ծ֤ˤϲδ
Ϳ⤷ʤ

ʾιͻ顢VMevalʬϤɤ


 proper tail-recursionˤĤ
᥿(C++٥)Ǥdatum(Cell *)eval硢󥿥ץ꥿ư
뤿ᡢɬŪnativeå롣ϵƤǤ롣

¹Schemeץफeval procedureƤФ줿⤷ϡ
compound datumʬevalˡnativeåä
ǤȡФproper tail-recursionϼ¸ǤʤʤΤǡeval
procedureμȡVMưȤdatumevalǽμΤ˶̤
ɬפ롣

applymapfor-each˴ؤƤƱͤεΩġ

ʲǤϵβΤˡVMưȤdatumevalǽñeval
R5RSƤprocedureȤƤevalˤĤƤeval procedureȸ
֤Ȥˤ롣applymapfor-each˴ؤƤƱͤɽ롣
ޤǤŪevalưSchemeץɽɽˡ
{}Ѥ뤳Ȥˤ롣


 evalˤĤ
evalϰȤdatum(Cell *)ļꡢSchemeexpressionȤ
ƸߤδĶɾ̤֤ǽǤ롣

proper tail-recursionδǤʼܻؤᡢevalμdatum(Cell
*)Ĥcontinuation(Cell *)ļꡢߤδĶdatumɾ
̤ȤcontinuationapplyΤȤƼ롣
ʤevalθƤӽФϡ
{eval datum continuation}Τ褦ˤʤ롣


ǡ᥿evalˡʲ̤procedureƳ롣

#<procedure: meta-return>
meta-returnϰļꡢͤreturn valueȤmeta
return롣

meta-returnϾ֤ʤΤǡsingleton instanceȤ󤹤Ȥ
롣ѤREPL

while (true)
  {
    Cell *datum = reader.read_datum(input_port);
    if (datum != NULL)
      {
        Cell *result = vm.eval(datum, global_env, meta_return);
        writer.write_datum(datum, output_port, false);
      }
    else
      {
        // error
      }
    if (datum == Cell::eof)
      break;
  }
ߤ˽񤱤롣


 {eval datum continuation}ưˤĤ
evaldatumμˤꡢʲΤ褦ɾԤ
- self evaluating
  datumǤ硢ɾη̤ϤͼȤȤʤΤǡ
  {apply continuation datum}
  ¹Ԥ롣


- symbol
  datumsymbolǤˤϸߤδĶǤbindingᡢvariable
  bindƤvariableͤvalueȤơ
  {apply continuation value}
  ¹Ԥ롣

  value#<unspecified>Ǥ뤫symbolvariablebindƤʤ
  ϡ`unbound variable: datum' 顼Ȥʤ롣


- compound datum
  datumꥹȤǤ硢CAR(datum)μˤꡢʲΤ褦ɾ
  Ԥ

  CAR(datum)
  * symbol
    ߤδĶǤbindingᡢsyntaxbindƤ顢
    closure = syntax->apply(datum, current_env);
    {apply closure continuation}
    ¹Ԥ롣

    variablebindƤ顢variableͤvalueȤơ
    {apply value evalΰ continuation}
    ¹Ԥ롣
̩ˤϰevalɬפΤǡ
    {apply value {eval CADR(datum) /cc} {eval CADDR(datum) /cc}
     ... continuation}
    Τ褦ˤʤ뤬ǤɽȤựåɤȤ
    ƤʤƤϡġġ

    VMŪ˼¹Ԥ³뤿ɬפʾϡ
    Хȥɥݥ: ¹ԤХȥɤؤΥݥ
    ե졼ݥ: ߤδĶ(variable slots)ؤΥݥ
    åݥ: eval̤ϥåѤޤΤȤȡ
    Ǥϡ
    ǽ(procedureǤȴԤ)variableͤåѤޤ
    ֤ǰܤΰevalѿliteralʤ顢򥹥
    Ѥɤcompound datumޤ̤expression
    ǡƵŪɾԤɬפ롣Ĥޤꡢ
    {eval  Ŭcontinuation}η֤Ƥΰɾǽ
    Ū
    {apply value evalΰ continuation}
    ¹ԤǤʤФʤʤ
    ΡŬcontinuationפϤcurrent-continuationˤʤ
    Υ֥ȤФ˥פʤ(referenceϳ
    뤳Ȥʤ)Τǰ¤ɽǤʤФʤʤ
    call-with-current-continuationǺ̾continuation
    äƤƱͤΰ¤ɽȤΤǡ̾CellȤɽ
    ϻפäinner syntaxФơּפؼ뤿˻Ȥ
    syntaxnesting٥ʬȤ뤷goto֤ꡢɬפΤʤ
    ΤäꤹΤݤġġ

    ʤߤˡǤΥåˤϡ
    value arg1 arg2 ... argN
    Ѥޤ줿֤ǺǽŪ{apply }¹ԤΤǡå
    valueΰ֤argNΰ֤ƱǧǽǤɬפ롣˲
    ߤTinySchemeͳΥ󥿥ץ꥿ǤϰɬꥹȤˤĤʤ
    Ǥ뤬(lambda (args) <body>)Τ褦Ĥΰ
    procedure䡢(lambda (args . rest-args) <body>)Τ褦ˡ
     + ѸĤΰprocedureƤӽФξˤϡ
    ĤʬܼŪ˥ꥹȤˤĤʤɬפϤʤΤapplyоݤȤʤ
    procedure׵᤹˱ƥåȰꥹȤĴ

    {eval }ϡǽŪtail callȤ
    {apply proc  continuation}⤷{apply continuation value}
    Τ줫¹Ԥ롣

  * compound datum
    {apply {eval CAR(datum) current-continuation} CDR(datum) continuation}
    ¹Ԥ롣


 {apply-syntax syntax datum continuation}ưˤĤ
datumsyntaxŬѤؼexpressionǤꥹȤǤꡢCAR(datum)
syntaxɾ벿Ǥ롣

apply-syntaxϰʲΤ褦˼¹ԤԤsyntaxSchemeγsyntax˺
륪֥ȤǤΤȤ롣


syntaxprimitivesyntaxʤ顢
{apply continuation syntax->apply(args) meta-return}

㤨andʤ顢
args
while (args->is_pair())
{
  Cell *arg = CAR(datum);
  {eval arg current-continuation};
  if (value == Cell::f())
    {apply value continuation};
  args = CDR(args);
}
{apply value continuation}

Τ褦ư롣evalä(call-with-current-continuation
...)äandμ¹continuationcaptureΤǡΤ褦
C++٥Ǽ뤳ȤϤǤʤġġ

Хȥɤ˥ѥ뤹뤳ȤꤹΤʤ顢
{eval arg1 /cc} (if (value == #f) (continuation #f)) ...
{eval last-arg (apply value continuation)}
ߤ˥ѥ뤷Ƥ¹ԤȤ⤢롣

ξ硢Хȥѥ뤷ƤޤäƤ⿼ˤϤʤʤ

ХȥѥλѤꤹ硢lambdaɾʳǡ
Хȥѥ뤷ơenvironment instanceʤclosure롣
ơclosureƤФʳenvironmentĥ졢ѿε
褬Ƥ뤳Ȥˤʤ롣

syntax->apply(args, env)continuationȤƼ#<closure>
̤Ȥ֤C++methodȤƼɤ

ξ硢
{apply-syntax syntax datum continuation}

{apply syntax->apply(CDR(datum), current_frame.environment) continuation}
Ǽ¹ԤǤ롣

syntaxglobalʴĶƤΤǡsyntax->apply
򤢤餫Τ뤳ȤϤǤʤ椨ˡsyntax->apply()ϰȤ
ߤδĶȤɬפ롣

interactiveʴĶǥ桼ץץȤФơ
> (and foo bar baz)
ŪʤΤϤˤ⡢Ūˤ(and foo bar baz)Фơ
and_syntax->apply('(foo bar baz), current_frame.environment)
¹Ԥ̤ȤclosureФ
(apply closure continuation)
¹Ԥɤ


 Хȥ
äѡ᡼ͯʤΤ˥Хȥɤͤ롣ʲǸ
off16off32ϼ¼ŪˤϻȤʤͽ󤷤Ƥ

OP_ICONST_mn
    
OP_ICONST_m3
OP_ICONST_m2
OP_ICONST_m1
OP_ICONST_0
OP_ICONST_1
OP_ICONST_2
OP_ICONST_3
    
OP_ICONST_n
-nnޤǤ򥹥åpush롣

OP_ICONST_I1 imm8
OP_ICONST_I2 imm16
OP_ICONST_I4 imm32
OP_ICONST_I8 imm64

OP_CONST_NULL
OP_CONST_T
OP_CONST_F
()#t#f򥹥åpush롣

OP_CONST_L_0
OP_CONST_L_1
OP_CONST_L_2
OP_CONST_L_3
    
OP_CONST_L_n
ľclosure template⥳󥹥ȥס0nܤǤ򥹥å
push롣

OP_CONST_L1 off8
OP_CONST_L2 off16
OP_CONST_L4 off32
ľclosure template⥳󥹥ȥסoff8off16off32ܤ
Ǥ򥹥åpush롣󥹥ȥסGCоݤˤᡢľ
closure templateȤȤˤȥåץ٥ˤ¸ߤʤΤǡľ
closure template¸ߤʤˤglobalΥ󥹥ȥסȤ
globalΥ󥹥ȥסϡûREPLiteration˴˥ꥢ
롣Хȥɤserialize򥵥ݡȤ硢եñ̤ǥ
ȥסѰդɬפ


OP_LOAD_L_0
OP_LOAD_L_1
OP_LOAD_L_2
OP_LOAD_L_3
    
OP_LOAD_L_n
ߤδĶѿå0nͤ򥹥åpush롣


OP_STORE_L_0
OP_STORE_L_1
OP_STORE_L_2
OP_STORE_L_3
    
OP_STORE_L_n
ߤδĶѿå0n˥åȥåפͤ롣


OP_LOAD_L1 off8
OP_LOAD_L2 off16
OP_LOAD_L4 off32
ߤδĶѿåoff8off16off32ͤ򥹥åpush롣


OP_STORE_L1 off8
OP_STORE_L2 off16
OP_STORE_L4 off32
ߤδĶѿåoff8off16off32˥åȥåפͤ
롣


OP_LOAD_G1 env8 off8
OP_LOAD_G2 env8 off16
OP_LOAD_G4 env8 off32
ߤδĶenv8ʾ̤δĶǤѿåoff8off16off32ͤ
åpush롣


OP_STORE_G1 env8 off8
OP_STORE_G2 env8 off16
OP_STORE_G4 env8 off32
ߤδĶenv8ʾ̤δĶǤѿåoff8off16off32˥
ȥåפͤ롣


OP_LOAD_T1 off8
OP_LOAD_T2 off16
OP_LOAD_T4 off32
ȥåץ٥Ķѿåoff8off16off32ͤ򥹥åpush
롣


OP_STORE_T1 off8
OP_STORE_T2 off16
OP_STORE_T4 off32
ȥåץ٥Ķѿåoff8off16off32˥åȥåפͤ
롣


OP_LOAD_F1 off8
OP_LOAD_F2 off16
OP_LOAD_F4 off32
ߤδĶǥ󥹥ȥסoff8off16off32˳Ǽ줿ܥ
bind줿ѿͤ򥹥åpush롣Хȥѥbind
ƤʤѿؤλȤФƤΤѤ롣


OP_STORE_F1 off8
OP_STORE_F2 off16
OP_STORE_F4 off32
ߤδĶǥ󥹥ȥסoff8off16off32˳Ǽ줿ܥ
bind줿ѿ˥åȥåפͤ롣Хȥѥ
bindƤʤѿؤФƤΤѤ롣¹Ի˥ܥ뤬
ѿbindƤʤä顢unbound variable顼򵯤


OP_DEFINE_F1 off8
OP_DEFINE_F2 off16
OP_DEFINE_F4 off32
ߤδĶǥ󥹥ȥסoff8off16off32˳Ǽ줿ܥ
bind줿ѿ˥åȥåפͤ롣Хȥѥ
bindƤʤѿؤФƤΤѤ롣¹Ի˥ܥ뤬
ѿbindƤʤä顢bindԤȥåץ٥Ǥ
defineμˤΤ߻Ѥ롣


OP_IF
OP_GOTO

OP_APPLY1 off8 nargs8 tail contextǤΤ߻Ȥ
OP_APPLY2 off16 nargs16 tail contextǤΤ߻Ȥ
OP_APPLY4 off32 nargs32 tail contextǤΤ߻Ȥ

OP_CALL_CC1 off8 nargs8
OP_CALL_CC2 off16 nargs16
OP_CALL_CC4 off32 nargs32

OP_NOP

closure templateˤϡ󥹥ȥס롢ХȥɤؤΥݥ󥿤
Ƥɬפ롣environment⵭Ƥɬפ
ƤפǤ뤳Ȥ餫ˤʤäХȥɤnativeݥ
ʤΤǡclosure templateˤCell *ʬζǤˤϡ
괺ѥ븵ΥɤǤǼƤġġ


󥿥ץ꥿Υե졼ˤϡVMΥ쥸˲äľclosure
environment instanceؤΥݥ󥿤򵭲ɬפ롣


 åե졼
VM륹åե졼ˤϡ̾bind줿ѿФstorage
syntaxμ¹ԤΤ˰Ū˻Ѥ(strictʰ̣LIFOŪ˻Ȥ)
åξɬפˤʤ롣call/cc򥵥ݡȤ뤿ˤϡξޤ
¸ɬפ롣

åϴؿƤӽФΰʤɡʬɾ̤ʣƱ¸
Фʤʤ˸¤äƻȤ롣ޤåȤϤäƤ⡢ɬפ
륹åοϥѥ˷롣

ʤΤǡ̾environment instancevectorȤƵ褬Ƥ
ѿåȤ³ʬ򥹥åŪѤ褦ˤŪ
ˤϡprocedureѿnĤȿdΥåɬפȤ
硢environment instance˳Ƥ뵭Ȥn+dĤѿʬ
ơåֹnn+d-1դ򥹥åŪ˻Ȥ

ºݤˤϡʬsyntaxбХȥɤϤʳǡ׻
줿ͤ¸٤֤ϸǤϤͣ쵭֤ƱǤ
ʤΤϡƤӽФ줿procedure֤ͤ¸꤫  VMΥå
졼ҡפ˳Ǽ硢åե졼ϢϢ³ΰ˳ݤ
뤳ȤǤʤΤǡcalleecallerؤͤμϤ˥å
ϻȤʤн褹뤿ˤϡ餯ǶʺǸˤɾͤ
̰ɬפ

㤨Фʸ̮ǡ
(foo (sub-exp1) (sub-exp2) ... (sub-expN))
ɾfooprocedurebindƤ顢R5RSɾ
unspecified(sub-exp1)˳ʬɾƥåѤߡ
줾ɾͤvalue1valueNȤȡåˡ
value1, value2, ..., valueNѤޤƤ֤procedure fooapply
뤳Ȥˤʤ롣㤨(sub-exp1)̤procedure callǤä硢
(sub-exp1)ɾvalue1γǼcallerǤ뤳ʸ̮Τ뤳
ȤǤ뤬calleeǤ(sub-exp1)procedureϥѤ
ʤˡ༡Ūˡɾ硢(sub-exp1)ɾ̤value1
ʤƥå˳Ǽ(sub-exp2)ɾ̤value2ȸʤ
ƥå˳Ǽġ(sub-expN)ɾ̤valueNȸʤƥ
˳ǼȤСǶʺǸˤɾͤǤ
Ȥˤʤ롣ʬ˺ƵŪprocedure callޤޤƤƤ⡢ɬ
LIFOνͤȤΤǺǶʺǸˤɾͤϰĤǤ
ɤ

environment templateεǽȤơ
long allocate_stack_slot(void);
frame򥹥åȸʤߤΥåȥåslot֤
void dispose_stack_slot(long depth);
frame򥹥åȸʤȤˡdepthslot̤
֤᤹

äƤΤɲä褦

 procedure callˤĤ
ʤäCPSˤΤǡSchemeǽ񤫤줿(bytecodeɽ줿)
procedureθƤӽФˤϡcall/returnŪưϤʤ
procedure callcalleeμ¹ԤΤVMξ֤ѹȤʤꡢ
줬ѤľGOTO_NEXT_BYTECODE()褬ưŪcallee
bytecodeˤʤ롣

continuationθƤӽФͤȤƤƱͤǡcontinuationpackage
줿֤ˤʤ롣

VMΥ󥿥ץ꥿롼procedureμˤĤƾʬΤ
ʤΤǡVirtualMachine &ȤͿBytecodeProcedure
ContinuationξVMξ֤ѹNativeProcedurenative
procedureºݤ˸ƤӽФ̤value˳Ǽ褦Ŭabstract
åɤProcedureƤȤ

native procedurecontinuationȤƼ褦ѹɬ
롣

void
Procedure::call(VirtualMachine &vm, Cell *procedure,
		Cell *environment, long frame_pointer, long nargs,
		Cell *continuation);

procedurecalleeenvironmentcallerenvironment
frame_pointerͿcaller environmentΥѿslot˽
nargsĳǼƤơprocedureμ¹ԽλˤϷ̤Ф
continuationapply롣


ƤprocedureϰۤΰȤcontinuation뤳Ȥˤʤ롣ΰ
ۤΰcontinuationˤĤƤϡ᥿٥ǺǽΰȤ뤫Ǹΰ
Ȥ뤫Ȥ褬뤬֤ꤵƤɤʷϵ
ʤΤǡǽΰȤ褦

㤨СScheme٥
(define (foo x) body)
Ȥclosure x줿顢Хȥѥ뤷ƤǤclosure
Ū(define (foo cont x) body)줿Τ褦closureˤ
롣


 environmentƤ
Хȥѥͤ硢äƳ
environment template  environment instance
δطɤʤäݤȤޤäƤʤä櫡

Хȥѥ¸ߤenvironmentϡȥåץ٥environment
ѥоݤSǿ롢տޤƤ̣Ǥ
environment templateϢΤߤǤ롣ޤǤΤޤäƤʤä
Τϡenvironment templateϢenvironment instanceϢ11
Ƥɬפäǡnested environmentФƤϡ¾e.t.
ľɬפäǤϻȤʪˤʤʤХȥ
뤹ˤenvironment templateϢϥѥˤΤɬפǡ
ġenvironment templateϢenvironment templateΤߤǹ
뤳ȤθʤФʤʤ

ȥåץ٥˴ؤƤϡХȥѥunboundvariableؤλ
¹Ի˲褹뤳Ȥ뤿ᡢѿεȤб
environment templateƱɬפǤ롣

ޤʤäǥǤϡenvironment templateparentȤ
environment instanceƤϰΡ༡Ūenvironment
ĥ롢¼ŪTinySchemeΤޤޤΥ󥿥ץ꥿̵Ȥ
िμäХȥѥ뤹ˤϡ༡Ūʳĥפ
Τǡenvironment templateϢϥѥˤΤߺäƻȤθ
ΤƤƤޤȤǤ롣

environment instanceбΤϡprocedureframeϢ
ΤǤꡢframeɬפʥ餫ˤʤäƤиġframeϺ
뤷ޤġframeǤδĶparentȤС
ѥenvironment templateϢбϢˤʤ롣

㤨
(define foo (lambda (x y)
  (letrec ((a (lambda (a1 a2) body_a))
	   (b (lambda (b1 b2) body_b)))
     body_foo)))
ߤʤΤХȥѥ뤹硢

ޤǽ(lambda (x y) <body>)бenvironment templateȥ
ץ٥parentȤƺ졢xybind졢ab⤳
environmentbind롣ʲenvironmentenv_fooȤ롣

ˡ(lambda (a1 a2) body_a)бenv_aenv_fooparentȤƺ
졢a1a2bind롣ޤ(lambda (b1 b2) body_b)бenv_b
Ʊͤenv_fooparentȤƺ졢b1b2bind롣

ǡ(lambda (x y) <body>)Ǻclosureˤcurrent frame
ʤξȥåץ٥ѿˤenv_foobodyprocedure
callʤɤˤ;ʬɬפѿͤʬframe׵᤹뤳
򵭲Ƥɤfooprocedure call줿ˤϡΤȤ
Ķˤϴطʤclosure˵줿current frameʥȥåץ٥ˤ
parentȤơѿͤʬframe_foo򿷤˳ơxyΤ
ε֡slot 0slot 1ˤ˳ǼƤprocedureμ¹Ԥ򳫻Ϥ롣
procedureμ¹Գϻˤϡletrecб(lambda (a1 a2) body_a)
(lambda (b1 b2) body_b)¹Ԥ졢줾frame_fooclosure
environmentȤƵ롣body_fooabprocedure callȡ
ΤӤˡframe_fooparentȤѿʬframe_aframe_b
˳Ƥ롣frame_fooframe_{a,b}δطϥѥ
env_fooenv_{a,b}οƻҴطбɬݤ롣

(define counter (lambda ()
	          (let ((x 0))
	            (lambda () (set! x (+ x 1)) x))))
ߤʤĤξ硢
(lambda () <body_counter>)
бenv_counterȥåץ٥parentȤƺ졢
(let ((x 0)) <body_let>)Τˡxbind롣

(lambda () (set! x (+ x 1)) x)
бenv_innerenv_counterparentȤƺ졢x򻲾ȤХ
ȥɤ1frame0slot򻲾ȤХȥɤȤɽ롣

(counter)ɾenv_counterѿʬΥե졼׵᤹Τǡ
˹碌frame_counterȥåץ٥parentȤƿ˳
졢(let ((x 0)) <body_let>)ɾ롣η̡
frame_counterenvironmentȤ褦procedure c_inst
(lambda () (set! (+ x 1)) x)롣
(c_inst)ɾȡѿ0ʬΥե졼frame_c_instframe_counter
parentȤƿ˳Ƥ졢((set! (+ x 1)) x)ɾ롣

environment˴ؤ뤳ޤǤεǤϡƤprocedureΰȤư
ɲäcontinuationˤĤƤ̵뤷Ƥ롣ºݤΥХȥ
ˤϤ줬ɲä뤿ᡢե졼ѿʬ礭ʤ롣


 Read-Eval-PrintƤ
VMμʤˡreplƹͤƤ

ReadreaderѤcurrent_input_portdatumɤ߽Ф

Evalɤ߽Фdatum򸽺ߤδĶɾ롣
Evalμ¹ԤϡdatumޤХȥѥ뤷顼ʤС
뤷ƤǤΤVMǼ¹Ԥ롣VMñ㲽뤿ᡢȥåץ٥ɾ
datum̵̾procedureȤƥѥ뤹뤳Ȥˤ롣㤨С
ȥåץ٥37ɾ硢Ūˤ
((lambda (continuation) (continuation 37)) meta_return)
¹Ԥ롣

meta_returnbytecodeȤOP_META_RETURNΤߤ̤procedureȤ
Ѱդ롣

Printμ¹ԤϡEvalη̤writerѤcurrent_output_port˽Ϥ롣

äƤΤǤ⽽ʬʵϤΤ̯
meta_returnfirst classprocedureȤѰդΤϤᡣ
ʤ

ɤȥåץ٥ǤdatumΥѥ̰ɬפʤΤǡ
((lambda (continuation) (continuation 37)) meta_return)
Τ褦ˤΤǤϤʤ
begin_syntax->emit_bytecode(buffer, datum, interaction_environment,
	                    toplevel_cpool, false);
buffer->append(OP_META_RETURN);
Τ褦˥ѥ뤹ɤ

ᡣ
äѤꡢmeta_returnconst char code[] = { (char)OP_META_RETURN };
pcȤƻȤcontinuation֥ȤˤTSCore˻Ƥ
ȤˤsingletonˤʤäƤΤǽʬ


 C++ APIˤĤ
ΥåɥݡȤ򸫿ơTSCore˺ޤƤ
ץ꥿ΥƥȤVirtualMachineʬΥʤΤǡSchemeץ
¹Ԥ뤿ˤVirtualMachineΥ󥹥󥹤ɬפˤʤ롣

åɥݡȤθ硢Scheme٥Υåɤlibtscore
ʤȤƻȤäƤC++٥ΥåɤƱ¸ߤ롣
SchemeץबФåɤϡΤȤʤ顢åɤμ
ԤΤ˥åVirtualMachine󥹥󥹤ɬפȤ롣
Schemeץ򥵥֥롼Ū˻ȤC++Υץबޥ
ɲƤ硢C++ץ¦¾Ԥʤ¤ꡢScheme
ʣΥåɤƱ˼¹Ԥ롣ξ硢Schemeץ
ΥȥΤӤˡVirtualMachine󥹥󥹤ɬפˤʤ롣

VirtualMachineϸǤŪ֥ȤʤΤǡȤΤƤˤ
Ȥˤͤ롣ʤ顢åΥҡפȥХ
ҡפʬǽŪɤʤΤǡޤǸ
VirtualMachineϻȤΤƤˤ٤ǤϤʤǡTSCore˥å夷
ƤȤˤå夬λˤϿVirtualMachine󥹥
뤳ȤˤȤäɬTSCore֤ȤȤߤˤʤ롣

C++SchemeץƤ־APIȤƤϡVirtualMachine󥹥
󥹤ȤäSchemeץ¹ԤȤͤ
뤬ɬװʾ¤μȤAPIȤΤǡޤ
ꡢTSCoreAPITSCore˼¹ԤꤷSchemeץμ¹Խλޤ
C++٥Υץϥ֥åȤˤ롣ޤǤȰۤʤ
ϡʤޤƤʤlibtscoreɬפ˱synchronization
ԤΤǡޥåɤC++ץफ鹥Schemeץ
¹Ԥ뤳ȤǤȤǤ롣


 ҡפʬˤĤ
ߤϥå̤ݡȤʤΤǸߤΤ褦ʡGenerational GCѤñ
ʥꥷƥǽʬåɥݡȤͤȡɤ
ꥷƥͤ롣

ݡȤͽΥåɥƥǤϡƥåɤϥХѿ
ޤĶͭʤʤʤ饹åɤǤ̣ʤˡξ硢
ХʴĶ黲Ȥ륪֥ȤǼҡפƤΥ
ɤǶͭɬפäƤ⡢ʳ϶ͭʤƤɤ˳ʤ
餳ޤǤηи顢Schemeץϼ¹Ԥνʳ᤮ȥ
Хѿ뤳ȤǤ뤳Ȥ狼äƤơºݡХ
ѿ黲Ȥ륪֥Ȥtenure줿Ǥۤɤ˥ץ
μ¹Ԥʤȡminor GCĤ륪֥Ȥ0.1%ˤ
ʤ롣ΤȤϡХҡפOld SpaceYoung Spaceϥå
Ω˻ĤȤäǥ󤬤⤷ΤǤϤʤ롣

ޤä



 tail-callκŬˤĤ
߷פǤƤΥե졼ϥҡפ˳ݤ롣ꥷƥμ
ʤˤ󤬤äΤǡ󥿥ץ꥿Ǥ뤳Ȥθȡե졼
ҡפ˳ݤ뤳ȼΤΥȤŪ¤ȤϤäƤ⡢(Scheme
)procedure callԤݤˡե졼ƤΤǤϡGC
٤ɬװʾ˹뤳Ȥˤʤ롣ߤΥե졼बclosurecloseƤ
ʤˤϡtail-call˿ե졼Ƥ˸ߤΥե졼
Ѥ뤳ȤŪˤϲǽǤ롣ϡե졼बҡפ˳
դƤ뤿ᡢʿΤƤ⤯Ĥ˥
ѹǤʤȤȡե졼ΥϿ˳Ƥоݤ
ʤprocedureɬפȤե졼ΥǷޤΤǡƱcall-chain
ǤϺѤǤˤϤĤǤ뤷ǤʤȤʤȤĤǤʤ
ȤȤˤʤ롣ǤϤ⤷ʤΤǡtail-call
callerp rocedure˺ˤcalleeɬפȤե졼Υ
caller procedure1ܤϾäȤƤ⼡ˤ­礭
ݤ褦caller procedureΥե졼ॵĥȤߤƳ
褦



 frameμˤĤ
ȥåץ٥ե졼ȡե졼Υinstantiateˤ
롣ʤΤǡߤμΤ褦variable storageȤ̥֥Ȥ
vectorȤΤѿȤΤӤ˴ܻ1ʬ;ʬʥȤ롣
٤Ȥ򤤤СvectorΥإåǻȤCellĹǤ롣

ߤvectorμǤΤ̰ƤơvectorΥإåɽ
֥ȡˤˤĹȤͰĤƤ롣Ĥޤꡢ2
ʬ;͵롣

scheme frame֥Ȥparent frameؤΥݥ󥿤vectorؤΥݥ
󥿤򵭲Ƥꡢ1ʬ;͵롣

ĤޤꡢvectorΥإå2ɤѤ뤳Ȥǥȥåץ٥Ǥʤscheme
framevectorΤΤˤƤޤȤǤϤȡѿ
ȤΤӤδܻ1CellʬΥҡץץåκ︺¸Ǥ롣
ͤϽʬ롣



closure
(define (counter x) (lambda () (set! x (+ x 1)) x))



 quasiquoteμˤĤ
appendconslist->vectorεǽɬפʹⵡǽΥХȥ
ɤɲäΤȡprocedure callΤȤɤ餬ɤġġ
car/cdrɲäȤơcons٤ʤХȥɤˤƤɤ
appendlist->vectorˤޤǹԤ餫ˤ櫡

褺procedureȤ󶡤Ƥ褦ʤΤϡѤprocedure
ӽФǼ褦Ķ˱ƤޤԹ礬Τǡ
toplevelĶǡܥŪü̾դѿbindƤ

quasiquote硢qq template 0ʳǤsyntaxŪ˴طΤʤ
ʬliteralqq template 1ʥƥȤ˸줿unquoteϡ
ʤѿȸʤɾꥹȤʤ鼰ȸʤɾ륳ɤФ
ޤqq template 1ʥƥȤlist qqˤvector qqˤ衢
öϥꥹȤ뤳Ȥˤʤ롣

ꥹȤϱñʤΤǡХȥѥˡꥹȤ
(car)'()⤷improper listκǸǤޤǥΥå
(vector<VMStackRoot>)˺ѤǤå˼


1) literal⤷ϡunquoteƥȤʤɾͤvalue˳Ǽ
   륳
2) L<Ŭʥѿ> = (cons value L)Υ
򥹥åˤʤޤǽ˽

äƤΤƵŪ˷֤ɤunquote-splicingбʬ
ϡ(cons value L)Ѥ(append! value L)Ϥɬפ롣
ˤбΤ餫ݤʤΤǡUnquoteSplicing syntax
emit_qq_templateˤǤˤ


list qqξ硢Ǹvalue = LΥ
vector qqξ硢Ǹvalue = (list->vector L)Υ
Ϥ顢1ʳμ롣outer mostquasiquote syntax
emit_bytecodeä顢temporarybind_syntaxunquote
unquote-splicingunbind롣qq template 0ƥȤǤunquote
бemit_qq_templateǤtemporaryunquote/unquote-splicing
unbind̤ˤbind_syntaxȤ礬פꤽ
qq template DD뤿ˤϡhintįȤ⤢뤬
ɤqq_templatebytecompile᥽åɰȯȤϹԤʤΤǡ
qq template 0Ǥunquote/unquote-splicingξƤsubform
Фemit_qq_templateƤӽФ褦ˤ롣


(quasiquote (foo (unquote <datum>) bar))
unquote줿硢<datum>ɾ̤valueȤȡ
(foo value bar)
ɾ롣㤨value(a b)ʤ顢(foo (a b) bar)Ȥʤ롣

(quasiquote (foo (unquote-splicing <datum>) bar))
ξ硢<datum>ɾvalueϥꥹȤǤʤФʤʤ
㤨value(a b)ʤ顢(foo a b bar)ɾ롣

unquoteΥvalue = (cons value '())ԤȤˤС
unquoteޤqq template٥ΥɤǤ
value = (append! value prev-value)
ɤġĤȰֻפäޥ


qq template򱦤ɾ硢
(quasiquote (foo (unquote <datum>) bar))
(unquote <datum>)ˤĤemit_qq_templateǡ¹Իѿ
ʤѿprev-valueˤbarǼƤȲǤ롣
ξ硢(unquote <datum>)emit_qq_template
bytecompile(... <datum> ...)
<datum>ɾvalue˳ǼХȥɤ
value = (cons* value prev-value)
ΥХȥɤɤqq templateΥϤθ
templateǤʤΤǡ
prev-value = value
value = literal foo
value = (cons* value prev-value)
³

emit_qq_templateǹԤΤ򵿻ɤǽ񤯤
prev-value = ()
emit_qq_template(bar)
emit: value = (cons* value prev-value) => value == (bar)
emit: prev-value = value
emit_qq_template((unquote <datum>))
emit: value = (cons* value prev-value) => value == (result<datum> bar)
emit: prev-value = value
emit_qq_template(foo)
emit: value = (cons* value prev-value) => value == (foo result<datum> bar)

qq templateimproper(quasiquote (foo (unquote <datum>) . bar))ξ
硢ǽʬѹ
emit_qq_template(bar)                  => value = bar
emit: prev-value = value
emit_qq_template((unquote <datum>))
emit: value = (cons* value prev-value) => value = (result<datum> . bar)
emit: prev-value = value
emit_qq_template(foo)
emit: value = (cons* value prev-value) => value = (foo result<datum> . bar)
Τ褦ˤ롣

list qqξ硢λǤvalueqqη̤Ȥʤ
vector qqξ硢
emit: (list->vector value)
Ȥɬפ롣

ʾϡunqutoteޤޤ٥ǡġûΤŪۤ˶ᤤ
naiveˤ㤨С
(quasiquote
  (a b
   (quasiquote
     (c d
      (unquote
	(e f
         (unquote (d e f))
	 g h))
      i j k))
   l m n))
Τ褦ʾ̤ΥꥹȤƤ¹Ի˺ľ뤳Ȥˤʤ롣
ǤϡunquoteΤϺ(unquote (d e f))Ǥꡢ
ʬϡѥǤ롣
㤨С(a b)(c d)(e f)(g h)(i j k)(l m n)ϡΤޤޥ
ƥȤƥ󥹥ȥסƤƻȤ

      (unquote
	(e f
         (unquote (d e f))
	 g h))
ʬˤȤȡunquoteqq 0ǤʤΤǥƥȤƽϤ
뤬unquote 0ΤΤƥȤ뤳ȤϤǤʤ
μФemit_qq_templateǽ˽륹åϡ

(e f (unquote (d e f)))
unquote

Τ褦ˤʤꡢ
prev-value = ()
emit_qq_template((e f (unquote (d e f))))
emit: value = (cons* value prev-value)
emit: prev-value = value
emit_qq_template(unquote)
emit: value = (cons* value prev-value)
򥳥ѥ˼¹Ԥ롣

emit_qq_template((e f (unquote (d e f))))μ¹Ԥnaive˹Ԥȡ
ϰʲΤ褦ˤʤ롣

(unquote (d e f))
f
e

θ塢
prev-value = ()
emit_qq_template((unquote (d e f))
emit: value = (cons* value prev-value)
emit: prev-value = value
emit_qq_template(f)
emit: value = (cons* value prev-value)
emit: prev-value = value
emit_qq_template(e)
emit: value = (cons* value prev-value)
emit: prev-value = value
ѥ˼¹Ԥ졢ФƤХȥɤ⤳˽सΤˤʤ롣

åǡñ
(unquote (d e f))
(e f)
ȤΤǤϡ((e f) (unquote (d e f)))ǤäΤ褦˿äƤ
ޤϴְ㤤Ǥ롣ŪsyntaxȤ@quote-splicingäƤΤ
åʲΤ褦˽롣
(unquote (d e f))
(@quote-splicing (e f))

(@quote-splicing <expression>)<expression>ꥹȤǤȲꤷ
unquote-splicing¹Իɾ̤갷ΤƱˡǥƥ
<expression>갷ΤȤ롣@quote-splicingquasiquotenesting
levelˤ餺ƯΤȤ롣̣Ūˤϡqq depth0ˤʤޤ
unquote-splicingŤͤ褦Ưunquote-splicingϢqq depth
0ʬǥƥunquote-splicingϤƤޤᡢΤޤ޻
ȤϤǤʤ

Ǥqq depth1ʤΤ
(@quote-splicing (e f))

(unquote-splicing (quote (e f)))
Ʊˤʤ뤬̤ˤƱˤʤʤ

quasiquote syntaxϼ


 primitive procedure
R5RSƤprocedureˤϡǽñ㤹뤿ᡢnative
Ƥˤե졼äؿƤӽФȤΤΤ
Τ롣

car
cdr
eq?
eqv?
꤬ɽŪȤϤбopcodeñVMɲäΤ
ϡ¼Ȥʪˤʤʤʤʤ顢ؿƤӽФcaller
inlineΤǤʤдؿƤӽФΥХإåɤϺ︺Ǥʤ顣

㤨СOP_CARȤopcodeɲä줿Ǥϡ
procedure `car'
{ OP_LOAD_L_1, OP_CAR, OP_APPLY_CONTINUATION0 }
ȼǤȤ̤˥󥿥ץ꥿Ǽ¹Ԥʤ顢
ߤΤ褦native procedureƤӽФnative procedureƤӽФ
ˤscheme٥Υե졼बʤʬ¤

c[ad]+rΤ褦R5RSƤprocedureФ
ǽ񤯤褦ӤˤϻȤ뤬ġġ


cadar
{ OP_LOAD_L_1, OP_CAR, OP_CDR, OP_CAR, OP_APPLY_CONTINUATION0 }
ߤ˼Ǥ롣ȸߤΤ褦
(define (cadar x) (car (cdr (car x))))
줿cadar¹Ԥ¤ǽϤ뤬cadarnative
procedureȤƼƤnative procedure¤

ânative compilationޤǻƾκŬ򸫿ȡOP_CAR
OP_CDRƳ
procedure `car'
{ OP_LOAD_L_1, OP_CAR, OP_APPLY_CONTINUATION0 }
procedure `cdr'
{ OP_LOAD_L_1, OP_CDR, OP_APPLY_CONTINUATION0 }
Ǽ㤨cadar
(define (cadar x) (car (cdr (car x))))
ڤɤˤƤСnative compileľ
inliningǤξˤϡnative procedureȤƼΤƱ
ǽ롣native procedureȤƼƤޤȡnative compile
native procedureinliningΤ̤ˤϤǤʤʤΤǡcarcdr
褦äñʤΤϡǽʸ¤native procedureˤʤǤ

native compilationޤǹԤʤƤ⡢Τ褦carcdrμ򤷤
˥󥿥ץ꥿˼ǤŬܤ⤢ꤽʤȤ⡢
(define (cadar x) (car (cdr (car x))))
Хȥѥ
{ OP_LOAD_L_1, OP_CAR, OP_CDR, OP_CAR, OP_APPLY_CONTINUATION0 }
ȤƤޤȤϲǽûŪˤϡOP_CAROP_CDRŪʤΤƳ
ǡñnative procedureˤĤƤƱ˥ХȥɤǤμͿ
Ȥˤɤ㤨СNativeProcedure::Info¤Τ
const char * const bytecode;
Ȥեɤɲä

carcdr
{ &R5RSListProcedure::car,
  "car", TST_PAIR, 1, 1,
  { (char)OP_LOAD_L_1, (char)OP_CAR, (char)OP_APPLY_CONTINUATION0 }},
{ &R5RSListProcedure::cdr,
  "cdr", TST_PAIR, 1, 1,
  { (char)OP_LOAD_L_1, (char)OP_CDR, (char)OP_APPLY_CONTINUATION0 }},
ˤФ褤C++ǹ¤Τ˥Хȥɤ򤳤Τ褦˽񤱤뤫ɤ
տޤϤΤˤʤϡѥξ
˲᤮ʤΤǡǤϲνˤʤʤȤ˺ƤϤʤ
¾ˡʥѥ餬ˤΤ뤳ȤΤǤʤnative procedure
ؤ륳ѥͿ뤳ȤΤǤȤƤϡpure function
ɤȤ󤲤롣pure functionǤСcommon
subexpression eliminationоݤˤꡢ̤Ȥʤˤ
deadcode eliminationоݤˤǤ롣

㤨ĤΰʰʳΡ˥ѿƳʤ
tailǤOP_APPLY_CONTINUATION0¾δؿƤӽФʤˤȤ
褦˹ԵɤؿƤӽФˤϡե졼򤵤ܤ褦ʺ
Ŭ;Ϥꤽ



 apply,call/cc,evalμ
ʤФʤʤˡ󥿥ץ꥿ꥨȥȤˤ
ŪˤϡVirtualMachineΥեɤ˳ǼƤ
current_procedure
current_frame
current_constant_pool
current_input_port
current_output_port
pc
value

դ򥤥󥿥ץ꥿롼Υѿ˥ԡƻȤ褦ˤ
ɤΥեɤϡprocedure callη̤Ȥơ󥿥ץ
롼פγ饤󥿥ץ꥿ξ֤ѹˤΤ߻Ȥɤ
procedure callΰ֤ͤȤƿ֤ͿȤˤͭ
롣
㤨С󥿥ץ꥿
class Register
{
  Cell *procedure;
  Cell *frame;
  Cell *constant_pool;
  Cell *input_port;
  Cell *output_port;
  const char *pc;
  Cell *value;
} vm_state;

Τ褦ʥѿߤ
Cell *Procedure::call(VirtualMachine &vm, Cell *procedure,
		      long args_pointer, long nargs);
Ȥprocedure callΥ󥿥ե
Cell *Procedure::call(VirtualMachine &vm, Cell *procedure,
		      Register &caller_context,
		      long args_pointer, long nargs);
Τ褦ˤȤ꤬롣

񤤤Ƥߤճ˰ʤpointer
Ĺnative procedureƤӽФλ˲ĹʬꥹȤˤ褦
ʼ֤ʤnative procedureȤɬפ˱Ƽ¹ԤȤ褦
trivialʺŬǤ롣
ѹnative procedureμβϤޤ

ƤӽФprocedurecall/ccΤ褦ʹԵΰprocedureȤ
Ϳ̤ΤprocedureƤӽФꤷʤŪԵɤprocedure
Ǥˤϡtail contextʳǤprocedure callǥ󥿥ץ꥿˺
ƤޤȤǡȤone shotʤΤŪ¤ɽȤäƤ뤱
ɡۤcontinuation֥ȤʤǺѤޤäƤȤ
롣Τ褦ʹԵɤprocedureˤϡˡscheme frame֥
Ȥnativeå˳դȤŬǤ롣


 apply/call-with-current-continuationμˤĤ
nativeå񤷤ʤ˥ȥݥɬסȤߤΤ
ޤǤϾ꤯ǤʤʤΤǡȥݥѤεǽɲäɬפ
롣

ȥݥǤꤿ
㤨applyξ(apply proc argument-list)Τ褦ŪʰĤ
ۤcontinuation餤caller
袭,@Ͻ񤱤ʤ
(proc ,@argument-list)
Τ褦procƤӽФΤ褦˿ɬפ롣
procϲǤ⤢ΰ̤procedureʤΤǡꥹȤͿ줿
argument-listscheme framevectorѴƤǤʤ̾
invokerȤʤapplyΤtail-callǡġcallerscheme
procedureġcallerscheme frameʬ礭Ȥ褦̤ʾ
ȡargument-listŸ뤿˿scheme frameѰդ
ɬפ롣ʲǤapplycallerframecaller-frameargument-list
Ÿinvoker뤿˻Ȥ٤frametrampoline-
frameȸƤ֤Ȥˤ롣

applyθƤӽФnative stackϡ
{ applyμ applyinvoker applycaller(󥿥ץ꥿) ... }
Τ褦ˤʤäƤ롣λscheme frameϢ
{ caller-frame ... }
ȤʤäƤ롣ȥݥapplyμ饤󥿥ץ꥿ޤnative
äȤƯɬפ롣ʳΥߥ󥰤Ǥnative
ξ֤ˤʤ뤫ʤȤϲ񤵤롣

ϡ̾invokerƯǤϡ󥿥ץ꥿ľˤޤ
caller-frameؤƤcaller_context.frameƤcaller-frame0
åȤ˳ǼƤۤcontinuationˤ֤Ȥ
ȤȡöäƤޤapplyμǺätranpoline-frame⤷
caller-frameΤ줫˥ǤʤʤäƤޤȤ

Τˤϡ
Cell *Procedure::call(VirtualMachine &vm, Cell *procedure,
		      Register &caller_context,
		      long args_pointer, long nargs);
Ƚ񤭴invokerAPI򹹤
Cell *Procedure::call(VirtualMachine &vm, Cell *procedure,
		      Register &caller_context, Cell *caller_frame,
		      long args_pointer, long nargs);

Τ褦֤̾OP_APPLYOP_CALL_CCǤcaller_frameȤ
context.frameͿȥݥǤcontext.trampoline_frameͿ
褦ˤ롣ˡframeƤ뤿parent frameȤƻȤ
ꡢOP_CALL_CCб뤿continuationäȤ褦ˡ
invokerǰμʳŪcaller frameȤˤϡ
caller_frameǤϤʤcaller_context.frame򻲾Ȥ褦ˤ롣



 macroŸ񤷤
Cell *
MacroSyntax::find_ellipsis_pattern(VirtualMachine &vm,
				   const Cell *pattern, const Cell *templ);

ϡ
templ ...
ȤtemplateŸ뤿ɬפȤʤpatterninner mostsub
pattern֤

ʲñΤᡢvectorϤʤΤȤƽ񤯡
㤨С
variable ...
ȤtemplateŸ뤿ˤϡ
(<pattern>* variable ...)
⤷ϡ
(<pattern without variable>* (<pattern include variable>) ...)
Ȥʤinner mostsub patternɬס


ޤʤ꤬ȯФdoΥޥξ硢
(do ((var init step ...) ...)
    (test expr ...)
  command ...)
ȤpatternФ

var ...
ȤtemplateŸǤʤŸ뤿ˤϡ
((var init step ...) ...)
Ȥsub pattern˥ޥåsub formޤĤɬפ롣

Ūˤ㤨
(do ((x 0 (+ x 1))
     (y 0 (+ y 1)))
    (= (+ x y) 10)
  (display "Hello, ")(display "World!\n"))

ˤĤ
var ...
ȤtemplateŸ硢
((var init step ...) ...)
˥ޥåsub form
((x 0 (+ x 1))
 (y 0 (+ y 1)))
Ȥʤ롣
λǡsub form
sub sub patternǤ
(var init step ...)
˥ޥåsub formΥꥹȤˤʤäƤΤǡꥹȤγǤ
Ūpattern variableǤvarФƷ̤ΥꥹȤ˷Ҥ
Ǥϡ
(x 0 (+ x 1))x
(y 0 (+ y 1))y
Ф̤Ȥ
(x y)ȤꥹȤФ褤

doޥ
command ...
ȤtemplateŸ
ҤȤޤsub patternȤ
(do ((var init step ...) ...) (test expr ...) command ...)
matchsub formȤ
(do ((x 0 (+ x 1))
     (y 0 (+ y 1)))
    (= (+ x y) 10)
  (display "Hello, ")(display "World!\n"))
롣
command ...
sub patternʤΤǡsub formб̤򤽤ΤޤȴФ
褤


...nesttemplateμ갷񤷤
do macroǤϡ
(loop (do "step" var step ...) ...)
ȤtemplateŸǤɬפ롣
ξ硢
(do "step" var step ...)
ŸΤɬפsub patternȤ
(var init step ...)
(1)
((var init step ...) ...)
˥ޥåsub form
Ȥ
((x 0 (+ x 1))
 (y 0 (+ y 1)))

ΥꥹȤγǤˤĤơ
(do "step" var step ...)ŸΤꥹȤ˷ҤȤήˤʤ롣
񤯤
var ...
ξ礷Ѥʤġġ
äѡ(1)ʬ񤷤Τ


list templateξ硢
listγǤˤĤбinner mostsub patternᡢ
Ƥޤinner mostsub patternȤˤʤꤽ

templateŸΤӤˤΤϼϼˡtemplate
硢inner mostsub patternpatternΤȸʤ뤬
(<pattern> ...)
ŸǤʤΤǡsyntax-rulesβϻ˥顼
Ĥޤꡢ
syntax-rulesβϻ
sub templateɬפsub pattern
Ȥơ֥(assqбǤalistɤ)ѰդƤޤΤɤ
ȤƤϻȤʤޥˤĤƤ⤳Υơ֥뤬Ƥ
Ȥġġդlazyˤ뤳ȤǤ롣ɽŪˤϡޥ
ƻȤˡsyntax-rulesбƤsyntax-ruleˤ
ƥơ֥Ȥʣsyntax-rulesθġsyntax-rule
Ĥơ줾ƻȤȤ˥ơ֥Ȥ̯Ĵϲ
ǽtemplateǤ뤳ȤȽ륿ߥ󥰤ۤʤΤǡɤ
٥ȤȤϰ쳵ˤϤʤ


ȤꤢeagerˤˤǹԤ

Ȥơߤmacro transformer CellrulesͤѤɬפ롣

ߤ
((pattern template) ...)
ȤꥹȤˤʤäƤΤǡ
((pattern template . table) ...)
ѹ롣

tableϳǤ(<sub template> . <sub pattern>)ȤʤäƤalistȤ롣

Ĥޤбsub pattern򸫤ĤɽƤߤ褦
parserѹ褦



const Cell *
SyntaxRules::find_inner_most_sub_pattern(VirtualMachine &vm, Cell *templ,
					 const Cell *pattern,
					 bool with_ellipsis);
إѡ̯̾with_ellipsistrueξˤϡ
templȤбsub patternͿ뤳ȤƤӽФ¦ݾڤ롣
with_ellipsistrueȤ褦ʸƤӽФ¦ϡ...ޤꥹȤ⤷ϥ
бparse_templateǤꡢɤtemplateФinner
mostsub pattern뤿ˡǤˤĤinner mostsub pattern
ɬפΤǤAPIɬ׽ʬǤ롣
㤨С
parse_template(foo bar ...)ȤtemplateϤ硢
1. fooˤĤparse_templateƵŪ˸ƤӽФȤfooбsub
   patternfoo_patternˤ롣
2. barˤĤparse_templateƵŪ˸ƤӽФȤbarбsub
   patternbar_patternˤ롣
3. ...³ƤΤǡľbar_patterntemplȤ
   bar_pattern = find_inner_most_sub_pattern(vm, bar_pattern, pattern, true);
   ƤӽФ
4. foo_patternbar_patternξޤinner mostsub patternᡢ
   ֤
Ȥˤʤ롣


Cell *
SyntaxRules::parse_template(VirtualMachine &vm, Cell *templ,
			    const Cell *pattern,
			    const vector<Cell *> &pattern_variables);
ϡ
templŸݤɬפȤʤsub form˥ޥåinner mostsub
pattern֤templtemplate datumliteral identifier
identifierǤˤCell::nil()бsub pattern¸ߤʤ
ʥޥŸ˼ԤtemplateǤˤNULL֤




MacroSyntax::match_ellipsis_form(VirtualMachine &vm,
				 const Cell *expression, const Cell *pattern,
				 const Cell *sub_pattern);
pattern˥ޥåƤexpression顢
sub_pattern ...
˥ޥåsub formꥹȤȤ֤


