view Idea @ 680:f536897fa3cb

*** empty log message ***
author kono
date Sun, 29 Jul 2007 23:09:38 +0900 (2007-07-29)
parents cddab906095e
children e60c3d8dadd6
line wrap: on
line source

Thu Nov 25 17:27:12 JST 1999

subroutine call ���ʤ�
�ɽ��ѿ���ʤ�
�������ꡢ����ѿ���¿�Ѥ���
����ѿ��Υ������פ϶ɽ�Ū
Fortran ���Ѥ˶ɽ��ѿ�����Ū�˼��
recursion ������ˤϡ���ʬ����¸����
subroutine call���Υ쥸�����Υ����֤�ɽ�Ū�˹Ԥ�
����ϡ�����ä��Ѥ���ʤ�?
��äѤ�ǥե���ȤΥե졼��ϻ����⤯��?

recursive call �Ȥ����Ǥʤ��Τ���̤��뤫? 

fp ���Ѱդ��������ɤ�

�ؿ������Ʊ���ˡ��������Ѥ�fp�ι�¤�Τ��Ѱդ���

C ��compile������ˤϡ�stack������⤯
    fp = (struct func_state *)stack 
���äȡ��ɤ������������? ������������⤢��櫓�͡�
���㤢��fp������? ����ϵ�������ʤ��ʡ�static 
��fp�ˤ�����ɤ��櫓�͡�

func(void *stack) {
    static struct func_state {
	static struct func_state *fp;
	int local1;
	brahbrah...
    } func_state;     // �����ޤ� hidden
    func_state.fp = (stack -= sizeof(struct func_state));
}

func_state ��ȤäƤ���黻�Ҥ����ä������ɤ�? �����͡�
    func.state
���餤?

fp->local1 �ߤ����ʤ��Ȥ�������ʤ顢C ��Ʊ���ˤʤ롣

call �������argument �⡢
    static �� func_state ���֤�
    stack ��� func_state ���֤�
�Ȥ������̤������褬���롣C�ȸߴ��ʤ顢��������ԡ�

Recursive �ʤ��Ԥ��������θ���Ͼ������ܤ򵭽Ҥ��뤫�顢static
�ʤ�ΤǤ��ɤ��Ϥ���

Internal function ��? ���äƤ⤤���������...

Recursive call ������ˤϡ� fp ��save����ɬ�פ�����͡�
    (--(struct func_state *)stack) = fp;
    call callee(&fp->arg,continuation,stack);
call ���Ƥ⡢��ä���ʤ�����... continuation �ϰ���Ū�ˤ�code
������... ����� Internal function �ˤ��뤫��

continuation �˰���Ū��compile������ˡ��ͤ��ʤ��Ȥ����ʤ�����
self ��ɬ�פʤ櫓��?

�����̾����ͤ��ʤ��Ȥ�����ʤ���

C ����Υ���ѥ����񤫤ʤ��Ȥ����ʤ��Τ�...

Mon Dec 13 18:53:04 JST 1999

compiler based �ǡ������� partial evaluation �Ǥ���?

func ��database�Ȥ��ư����ʤ��ʤ顢����ϤǤ��ʤ���

���������������ܤȤ��Ƥϼ�갷���롣

    func.state
    func.code

�ߤ����ʷ��ˤ���partial evaluation������ɤ�

�Ǥ�ߤޤ�Τ�?

textual �Ǥʤ������Ū�ʥ�����ɽ�������ä������ɤ�? <-> interpreter?

Prolog �ǤϤʤ�Ǥ����ʤ���? --> Unification ���Ť�����

Sat Nov 27 13:50:41 JST 1999

func.state �Ȥ����Τ��ä��顢
    struct {
	struct {
	    int i;
	} state;
	state *code = {
	    i = i+1;
	};
    } name;
�ߤ����ʷ��ǡ����켫�Τ�¤�������? �ǡ������������ʬɾ������롣
�������ǽ���ʤ�ۤɡ�
	*name.code;
�ͤϤ���櫓? �ͤ� &state �Ǥ��礦�͡�
self �������
    struct {
	struct {
	    int i;
	} state,
	*code = {
	    self->i = self->i+1;
	};
    } name;
���ʡ�self = state ����͡�

union �γ�ĥ�⤢�碌�Ƶ��������...

Partial evaluator �򥻥ޥ�ƥ�������¹ԷϤˤ���Ƥ������Ȥϲ�ǽ��?

byte code �Ȥ����ۥޥ�����ä����ǽ�������Ǥʤ�����?

������ˤ��衢��¤�ΤΥ�����unique���������ʤ��Ȥ�����ʡ�

�إå��ե�����Ϥɤ������?

Mon Dec 13 18:53:18 JST 1999

library �Ȥ���������?

exec sequence �Ǥϡ�
    (--(struct func_state *)stack) = fp;
    call callee(&fp->arg);
�Ȥ�������pointer�����Ϥ���? ������Ѥ���͡�

���Ϥ��ˤ���Ȥ���С�ʣ�����ͤ��Ϥ����ۤ����ɤ���

    func(void *stack) {
	static struct func_state {
	    static struct func_state *fp;
	    int local1;
	    brahbrah...
	} func_state;     // �����ޤ� hidden
	func_state.fp = (stack -= sizeof(struct func_state));
    }

�ΰ������Τ�����¤�ΤǤ���٤���

    func(
	struct void *stack
	) {
	static struct func_state {
	    static struct func_state *fp;
	    int local1;
	    brahbrah...
	} func_state;     // �����ޤ� hidden
	func_state.fp = (stack -= sizeof(struct func_state));
    }

�ǡ���¤�Τ� register storage �������

    func(
	static struct argument {
	    register void *stack;
	    register void *continuation;
	}
	) {
	static struct func_state {
	    static struct func_state *fp;
	    int local1;
	    brahbrah...
	} func_state;     // �����ޤ� hidden
	func_state.fp = (stack -= sizeof(struct func_state));
    }

����ȡ�caller �����⡢��¤�Τ�����Ȥ���Τ�������

    call caller(
	static struct argument {
	    register void *stack;
	    register void *continuation;
	} arg = {a,b};
    )

�ߤ����ʡ�������󡢤��ι�¤�Τϥ��󥿥ե������ȸƤФ�롣

argument �ϡ�callee �ˤ��ä������ɤ����ɡ�caller ¦�ˤ��äƤ�
�ɤ���register �ʤ󤫤ϡ�������

	caller(interface caller_arg = {a,b,c})
�ߤ�����syntax ���ʡ�
	caller->interface = {a,b,c};
	*caller->code;
��
	caller(a,b,c);
�ȾΤ��롣

function �ˤϡ�interface �� code �� state �����뤳�Ȥˤʤ롣

state �˥��������������lock��? protected state? synchronized state ����?
�������sequential implementation�Ǥϡ�����ʤ�ΤϤ���ʤ���

function {
    interface:
	register int a;
	register struct self self;
    state:
	int b;
	serialized int c;
    code:
	b  = a;
}

int ��void value ��������롣�����ϽŤ��ʤ뤱��...

serialized �� semantics ��?

�⤦����micro-C�˶᤯! 

carrying state �� static state��

Mon Dec 13 19:42:41 JST 1999

interface �� register keyword ��Ȥ��Τϡ����ޤ��
������ꤹ���롣�Ǥ⡢�Ǥʤ��Ⱦ��֤ˤǤ��ʤ�?
����ʤ��ȤϤʤ�������äѤ�caller¦��static �ΰ��
ľ�ܽ񤭹���?

����C����٤������Ǥ⡢������40�ĤȤ������줿��...

Wed Dec 15 14:09:49 JST 1999

C �ȸߴ��ˤ���?
	goto function(arguments);
	goto *continuation(arguments);
�ߤ����ʴ����ǡ�

stack�δ�����? �ɤ�����library �Ȥθߴ��ϤȤ�ʤ���
�����ʤ��������...

local �ѿ���������� stack ��ư�������Ǥ⡢�᤹�ۤ����ʤ���
closure �����뤫?

return �������ε�ư��ʣ���ˤʤ롣���return����櫓���顣

arguments ��static �ΰ�ˤ��������������ȸߴ������Ȥ�ʤ���
stack ��� frame pointer ��ˤʤ��ȥ�������顣

ξΩ������Τ�̵����? �Ĥޤꡢ������ȡ��ƤӽФ��줿����
frame semantics �ϡ�C �ȸߴ��ˤʤ롣�����顢stack��ľ���
frame pointer ������ȻפäƤ��� (������? ) frame pointer
stack pointer �˱�äư�ư����ľ��ˡ����������offset
�ǰ��������뤳�Ȥˤʤ롣

�Ĥޤꡢ����Ϥ�����ä����Ȥ���ʤ�? �Ĥޤꡢgoto ���ȡ�
frame pointer �ϡ�stack ��ľ��Ȥϸ¤�ʤ����顣����
frame pointer ���Ф˰����˥����������Ƥ������̤����ɤ͡�

stack �˰������Ѥ�Τ���ǧ���ơ�goto �ξ��ϡ�������¦��
stack �����äƤΤ�?  �Ȥ������Ȥϡ����̤δؿ��������
��ˡ���Ѥ���äƤ��Ȥ����ޡ������Ϥʤ�����

����ȡ�goto ��semantics �ϡ�C �ȸߴ��ˤʤ롣����������
�����ۤʤ뤳�Ȥ򤹤롣����ϡ��ʤ󤫤��������ʡ�����ˡ�
������ȴؿ��ƤӽФ����ڤ��ʤ�ʤ�...

�Ȥ������Ȥϡ���ϤꡢC ��call �ϡ�call function ��
�¸����ơ�����¾�θƤӽФ��ϡ����٤ơ�goto ������
����������������������

����ϡ����θ���δؿ���call���줿�����ʡ�dual entry �ˤ��ơ�
call �λ��ȡ�goto �λ�����̤��뤫��
	func:	stack processing
	func_goto: normal processing
         ...
�ߤ����ʴ������Ǥ⡢return �Ϥʤ�����...

���Τ�����⼫ʬ�ǵ��ҤǤ������Ǥ���٤�����͡������̤ꡣ
�ĤޤꡢC �Ȥ�stub �⼫ʬ�ǵ��Ҥ���ȸ������Ȥ���

protocol function {
    interface c {
	register "%esp" struct {
	    entry code ret(int);
	    void *fp;
	} *sp;
	register "%ebp" void *fp;
    };
    code function_code {
	fp = sp;
	sp += sizeof(struct local);
	struct local *local = sp;

	local->i = 1;
	goto *fp->ret(local->i),sp=fp;  // return(local->i);
    };
}

�ߤ����ʴ����Ǥ������ä�����������֥顣���ޤ���return���������ɡ�
�ޤ���return �Ϥ��Τޤ�return�Ǥ⤤�����ɤ���

����������ɤ������Τ�ʤ���code ��ʣ�������뤫�顣

state �ʳ��ϡ�consistent state �Ǥ��뤳�Ȥ��ݾڤ��ʤ����äƤΤ�?
local �ѿ��ϻȤäƤ��ɤ����ɡ�call/goto ������ǡ��ͤ��ݾڤ��ʤ���...

�����󡢤�������������Ƥ�ʤ���

�����顢�쥸�������Ф���ޥåԥ󥰤ε��Ҥȡ������Ǥʤ���ʬ��
���Ҥ�ʬΥ����٤��Ǥ��礦�͡�


�������դ˼�������櫓�ˤϤ����ʤ����餡...

Thu Dec 16 13:44:21 JST 1999

lock �Ͼ������ܥ�٥�Ǽ¸�����Τ����顢self �ʤɤ�
�Ȥä�lock����ɬ�פϤʤ��Ϥ���

���Τ�ľ�󲽤ϡ��������ܥ�٥�ǡ�
	lock(storage) -> transition
�ߤ����ʷ��ǵ��Ҥ�����ɤ�������������򡢤ɤΤ褦�˵��Ҥ��뤫��
�⤦���������ꤷ�褦��


�����ϥ쥸�����Ϥ��ˤ��褦��Ĺ�������ϡ��ƤӽФ�¦���ΰ�ؤ�
�ݥ��󥿤Ȥ��롣�������ꤷ�Ƥ��ɤ�����������С�varargs
�ߤ����ʤ�ΤϤʤ��ʤ롣�����������ʤ�ǡ�����ʤ�Τ�����������?
������Ϥ��Ф��������

�ʤΤǡ������ϰ��(or ���)�˸¤�Ȥ�����ˡ�⤢�롣

�Ȥ���ȡ���Ϥꡢ����ä���Ū�ΰ��ưŪ�ΰ����ݤ��뤳�Ȥ�
�Ǥ��ʤ���

���θ���Ǥ�ưŪ�ΰ�ϼ�ʬ�dz��ݤ���櫓�����顢������������ʤ���

Thu Dec 16 20:24:55 JST 1999

�Ȥ���ȴؿ��ƤӽФ��ϡ�
	# register save
	# set 1st argument in register %eax
	# set 2nd argument in register %ecx
	# set extra arguments in save area
	# set extra argument pointer in %edx
	    jmp function
�Ȥ��������ˤʤ�櫓�͡�second ���������ΤϤ��ɤ�����������
�ˤ��褦��

�����ȡ�frame pointer �Ϥʤ����ɡ�����ѥ���μ�礫�餹���
���ä������ɤ�����������frame pointer ���Τ�Τ�static
�ˤȤ�ΤϤޤ����������顢frame pointer ��first argument
�Ȥ������Ȥˤ����������������Ȥ���Ȱ����ϡ�����ˡ�����
��ȸ����櫓����
	f(fp,argument)
fp ���Ϥ��Τˤ����argument ��쥸�������Ϥ��ΤϤ��������������������ɡ�
�ޡ��ɤ�����

return ���ʤ��ʤ顢return type �������Ȥ�Τ��Ѥ��ʡ�

f(fp,arg1,arg2,arg3) �Ȥ���ȡ����줾�줬��ޤä��쥸���������äơ�
¿��ʬ������ˤ���Ȼפ��롣�դ�դ�...
    fp->xx 
�ǥ�����������С����Τޤ޶ɽ��ѿ��ˤʤ롣�����������
���äƤ��ɤ���

  .set label,value

�� as ���ͤ򥻥åȤ���褦�Ǥ��͡�

�ؿ�������θ����ä���ʤ����������ο��ۤϤ��ʤ��Ƥ褤��
frame pointer ��Ȥä��鼫ʬ�����ݤ򸫤뤳�ȡ�

����
	a = atoi(s);
�ߤ����ʤ��ȤϤǤ��ʤ�...

���̤�C������ȸ򤸤�ȴְ㤤�䤹����

�Ȥ���ȡ�struct ��Ʊ�ͤˡ�
	protocol
	code
	interface
	state
���Ѱդ���櫓�͡����֤���Τ���?

�Ȥꤢ������register �Ϥ���function �����gotoʸ��������롣

code name(register "%ebp" void *arg) {
    goto name(arg);
}
 
���餤����? �ǡ�first argument ��ɬ��register�ˤΤ�褦�ˤ��ʤ���
�����ʤ���register storage class ������ơ�
    register "%ebp" void *arg
�Ȥ�����櫓�͡�

�äƤ��Ȥϡ��ޤ����쥸������������ʤ��Ȥ����ʤ��櫓�͡�

�ǡ�stack ��Ȥä��黻�ϡ���������Τޤޤˤ���? ����Ǥ�ư���Ϥ���
���������goto�ϻȤ��ʤ�������顢����Ǥ����Ϥ���

�ǡ����줫�顢������ĥ���Ƥ�����

interface c {
    register "%ebp" void *arg;
}
code name(interface c) {
    goto name(c.arg);  // c. �Ͼ�ά��ǽ
}

�Ȥ��͡�����ˡ�

protocol name {
    interface c {
	register "%ebp" void *arg;
    }
    code name(interface c) {
	goto name(arg);
    }
    code name1(interface c) {
	goto name(arg);
    }
}

�ʤɤȤ���櫓�����ʤ�ȡ����줬 C �ȶ�¸����櫓�͡�������

Fri Dec 31 11:44:03 JST 1999

code �Ǥʤ��ơ��̤�̾���Τۤ����ɤ��ʤ�? segment? action?

�쥸����̾������Τϡ���äѤꤤ�䡣optional�ˤϵ�����

interface �Ϲ�¤�ΤΤ褦�ʤ�Τ�����... ��¤�ΤǤ����󤸤�ʤ�?
��¤�Τξ���... malloc ����? ����������malloc ����Ȥ��ơ�
����free �����?

��������Ȥ��ˤϡ�����ƤƤ����󤸤�ʤ�? multi-thread �Ǥʤ���Ф͡�
multi thread �Ǥϡ����֤ϡ��쥸������ͳ�ޤ��ϡ�thread local �˻���
ɬ�פ����롣static �ϡ������� thread local �˻����ʤ��ƤϤʤ�ʤ���
����ѿ��˳�꿶�ä�����ᡣ�Ǥ⡢���ޤϡ�����

interface �ϡ��Ȥꤢ��������ĤޤǤ����Ϥ��ˤ��褦��
	self �� arg
�Ǥ��͡�

�⤦������ĥ���䤹������ѥ��餬�����ʤ���

    code name (c,a)
    struct state *c; struct arg *a;
    {
	goto name(arg);
    }

local �ѿ���? ���θߴ��������꤫����

KL/1 ��ռ����ơ�interface �� heap ���֤����Ȥˤ��Ƥ��ɤ���
GC �ϸ��������Ƥ����٤�������interface�� machine independent
�Ǥ���٤������Ȥ���� use/forget �ߤ�����ΤϤ����������
�Ǥ⺣�ΤȤ����Ϲͤ���ɬ�פϤʤ���

�����ȡ�
    code name (c,a)
    struct state *c; struct arg *a;
    {
	int i;
	goto name(arg);
    }
�λ��ΰ���ѿ�i�Ϥɤ������? ����Ū�ˤϥ쥸����������Ƥ�����...
���Ѥ����ʤ�? �󡼡������ʸ�ո����ޤ�����äѤ�heap�˳�����Ƥ��㤦
�Τ���ñ�����Ǥ⡢�ɤ���ȴ������ˤϤ���ʤ��ʤ�櫓������...

�ۤ�餤�������ѿ��ϡ�����call�Ǥ�ɬ��̵���ʤ�Τ����̡�

�Ȥˤ������쥸�����ѿ���ɬ�פʤ�Ǥ��礦?

�����顢GC �ȹ�碌�Ƹ�����߷פ��٤�����͡�API ���ꤷ�ơ�
�ۤʤ�GC������Ǥ���褦�ˤ��롣

Sat Jan  1 22:40:22 JST 2000

�ȡ��ˤ����� storage class register ��������褦��

    stmode=REGISTER

�ǡ�local storage �Ȥ��ʤ������Ȥ���
	static register? �ϡ��ʤ���

symbol table �� storage class �򤿤���? dsp==EXTRN ��Ƚ�ꤷ�Ƥ��뤫�顢
local �ѿ���36�ʾ夢��Ȥ��������ʤ뤾?

sc  �� GVAR/LVAR �����ɡ�register �� LVAR ���ü���ۤ����顢
sc �������ۤ�����������...

Sun Jan  2 01:47:17 JST 2000

register �ѿ��ϤǤ��ޤ��������ɡ�register ����ĻȤ��ȡ�
���դˤʤäƤ��ޤ��Τǡ�REGISTER6 �ǥ���ѥ��뤷�ʤ���
�빽�Ҥɤ�������register �ѿ���%esi,%edi �˳�����Ƥ��
��������

Sun Jan  2 04:43:04 JST 2000

�ǡ�
    code name (c,a)
    struct state *c; struct arg *a;
    {
	goto name(c);
    }
�ΰ���ѿ�̵���ϼ����Ǥ��ޤ�����������ĤޤǤ͡�

	.file "tmp.c"
	.version	"01.01"
gcc2_compiled.:
.text
# 
# code name(c,a)
	.align 2
.globl code
code:
	.type	code,@function
#    struct state *c; struct arg *a;
# {
#	goto name(c);
	movl %esi,%esi
	jmp	name
_5:
	.size	code,_5-code
	.ident "Micro-C compiled"

������������

goto ʸ�����ɤ�������stack �򤿤���ǡ�jmp �����
�褤��������..

Sun Jan  2 11:17:50 JST 2000

���̤�call��continuation base�ˤ��뤳�Ȥ��Ǥ���?

Sun Jan  2 20:28:45 JST 2000

goto ʸ�����ɡ���Ϥꡢ���١�expr ���������Ƥ��顢top level
�� jump code ���������褦��

Tue Jan  4 03:32:55 JST 2000

code ��type�ˤ��ʤ��ȡ�
	code *p;
�Ȥ��񤱤ʤ��͡�
	int *p();
��Ʊ�������ɤ���


    main(ac,av)
    int ac;
    char *av[];
    {
	goto code1(ac,av);
    }

    code code1(ac,av)
    int ac;
    char *av[];
    {
	if (ac)
	    goto code1(ac,av);
	else
	    goto ac(ac,av);
    }

Tue Jan  4 04:56:56 JST 2000

�����󡢤ʤ󤫥쥸�����ˤĤ������㤦
����ϡ�adecl ��reverse�ˤĤफ�顣

code ��return

��Ϥ�code��type�ˤ��ʤ��Ȥ��ᡣ

main()
{
    goto code1();
}

�Ȥ����ȡ�main ����ä����ʤ����������code1() �ʹߤǡ�
return ����櫓�ˤϤ����ʤ���(main �� disp ��code1 ���Τ����ʤ�)
goto label ��code1����������?

main()
{
    goto code1(ret);
ret:
}

������ȡ�ret ��forward label���ɤ���ʬ����ʤ�����?

code1 ��ǻȤ�����ѿ��� stack ��ˤȤ�Τϰ����ʤ����������������
%ebp ��ͳ�ǥ�����������Ȥ������Ȥϡ�main ������ѿ�������Ȥ������ȡ�
������ɤ��ˤϡ�main ���goto code�ǡ�%ebp �������Ƥ����ɤ���
(������ä���ʤ��Τ�����ʤ�)

code1 ��goto �Ǥϡ���ä���ʤ����顢����ɬ�פϤʤ�����������
label ��code1 ����Ϥ����ȡ�����äȵ��ޤ�����

�Ȥ���ȡ�����϶ػߤ��ơ�main() ���stack�򤿤���Ǥ���goto���뤫?
��������ȡ�̵�¸��ष�ơ���ɡ�����ʤ����Ȥˤʤ�... ������

main() ���local code ������С�����ϲ�褹�뤬..

main()
{
    goto code1(code2);
    code code2() {
	return;
    }
}

�ߤ����ʴ������Ǥ⡢���������scope rule ���Ѥ���ɬ�פ�����ΤǸ�������
�ޡ������Ϥʤ����ɤ͡�

continuation ������������ˡ�⤢�롣

main()
{
    goto code1(continuation);
}
code code1(ret) 
code (*ret)();
{
    goto *ret;
}

����? call/cc ?

label �ؤ�goto������Τ⤤�����ɡ�
�Ǥ⡢label ������ȡ�������spaghetti�ˤʤ�ʤ�?


Tue Jan  4 11:47:24 JST 2000

continuation ����ʤ��ơ�return keyword ��Ȥ�����
(�ºݡ�continuation �Ⱦ����㤦��)
type �������Ѥˤʤ뤱�ɡ��ޤ��ɤ���

int
main()
{
    goto code1(return);
}
code code1(ret) 
code (*ret)(int);
{
    goto *ret(3);
}

���ʡ�prototype ���դ��ʤ��Ȥ����ʤ�����

Tue Jan  4 12:21:44 JST 2000

�������method�����٤�static �ˤʤäƤ��ޤ���dynamic ��method
�ƤӽФ��ˤ���ˤ�? dispatcher ��ʬ�Ǻ�뤳�Ȥˤʤ롣���ʤ�
���ɤ�������...

code method(obj,arg)
{
}

�������뤤�ϡ�inline �ˤ��뤫... #define �Τ����� inline �ͤ���
����Ϥ��Ȥǹͤ����ɤ���

Tue Jan  4 14:22:19 JST 2000

main ���ѿ�����٤��Τȡ�goto (*reg)(123) �Ǥ��ͤϡ�
register �Ϥ��ǡ�current register �ˤΤ�ʤ��Τǡ�
��ɡ�return label �����Ѥ˺��ɬ�פ����롣

Tue Jan  4 18:14:07 JST 2000

stack ��Ѥ�­���ơ��ƤӽФ���������С�call by value
��register �Ϥ������¤���ɬ�פ�̵���ʤ롣

ʣ�����ͤ��֤����Ȥ��ưפ���

	.file "tmp.c"
	.version	"01.01"
gcc2_compiled.:
.text
# 
# code name(a,b,c,d,e,f)
	.align 2
.globl code
code:
	.type	code,@function
#    struct arg *a,*b,*c,*d,*e,*f;
# {
#	int g;
#	goto name(a,b,d,e,f);
	jmp	name
_5:
	.size	code,_5-code
	.ident "Micro-C compiled"

����?!
	%esp  new %esp = old %esp - 12 -4
	%ebp-4     = g
        %esi       = a
        %edi       = b
        %ebp = old %esp   0
        %ebp+4     = c       code_arg_offset=0
        %ebp+8     = d
        %ebp+12    = e
        %ebp+16    = f

interface ���դ��褦! �Ȥ�������
	goto name(struct {xxxx})
�ߤ����ʴ������ɤ��櫓�͡��ɤ��register�ˤ���뤫�ȸ�������Ϥ��뤬��

�ǡ��ɤ���ä�call����Ф����櫓? emit_push���뤫����push
����?

����������Ǥϡ����ᤫ��code argument �ο����Ѥ��ȡ�
ebp �򤤤�����ư�������Ȥˤʤ롣�����ˤ�old sp �����뤫��
�����Ĥ⥳�ԡ�����ɬ�פ����롣

	%esp  new %esp = old %esp - 20
	%ebp-20   = g
        %esi      = a
        %edi      = b
        %ebp-16   = c code_arg_offset= -16 ((nargs-max_reg)*int_size)
        %ebp-12   = d
        %ebp-8    = e
        %ebp-4    = f
        %ebp = old %esp   0

��������function ����call������ˤϡ�local �ѿ�����٤����ɤ���

#	goto name(a,b,d,e,f);

	%esp  new %esp = old %esp - 20
	%ebp-20   = g
        %esi      = a
        %edi      = b
        %ebp-16   = c code_arg_offset= -16 ((nargs-max_reg)*int_size)
        %ebp-12   = d
        %ebp-8    = e
        %ebp-4    = f
        %ebp = old %esp   0      disp=0 (*)
         local1 <----16 local variable      
        %edx        -12   <- disp_offset
        %ecx         -8
        %ebx         -4
        %ebp = %esp   0
        %eip          4   <- arg_offset

�Ȥʤ롣�Ȥ������Ȥϡ�pushl %ebp �ϡ��ְ㤤��

�����ɡ�%ebp �򤽤Τޤ޻Ȥ��Τ��ɤ��ʤ���disp_offset �������äƤ��뤫�顣
�����顢�⤦���� pushl %ebp �����ۤ����褤����������push ������ϡ�
���(*)��
	leave           movl %ebp,%esp
			popl %ebp
����ʤ��ä���?

Thu Jan  6 13:00:33 JST 2000

�Ǥ����͡�����ǤȤꤢ����ư���Ϥ���®�٤��������...
���Ȥϡ�
	ANSI-C prototype
	ANSI-C prototype check
	Interface Definietion
	GC support
	Direct handling of Frame
���͡���ñ�˽��褽��? ���֤�...

Fri Jan  7 09:42:53 JST 2000

goto ʸ��ư���Ƥʤ��ä������� peep hole optimization version ��
��뤫?

continuation �Ȥ��� label �������褦�ˤ���٤���?
��������������ʤ�����ɡ�����äȡ������ץ�����ब
�����褦�ˤʤ롣���ȡ�����¦�δĶ�(frame)��ݻ�����
ɬ�פ����롣�ޡ��Ǥ��ʤ��Ϥʤ���...

��������ȡ�label ���ͤ���Ĥ褦�ˤʤ롣
	a = label:;
�Ȥ���������label:(a,b,c) {}; �ߤ����ʷ��ǡ�parallel ����������ȸ���
��⤢��͡�

�����������C�Ȥ��������ɤ���... main() { label:(){ ... } }
�ߤ�����nest��������ɤ����ȸ������꤬���롣
�ѿ��λ��Ȥ�����ʤ���С��ä�����Ϥʤ���

a = label: �ϡ���Ťΰ�̣������ʤ���

�����̾����DinnerBell II �Ȥ�? join �������?
	code entry_a().entry_b() {}
�Ǥ���? parallel call ��?

Fri Jan  7 19:53:53 JST 2000

���ޤΤޤޤ��� return ���Ķ�����äƤʤ����顢���æ�ФǤ��ʤ���
�ޤ����Ķ�������Ƥ⤤��������ɡ��ɤ����֤����ȸ������꤬
����͡�

��������ʤ��ơ�return ¦��Ƚ�Ǥ��뤫? 
	return(ID)
�ߤ����ʷ���ID��Ƚ�Ǥ��롣��������С�return ¦��ID
�򸫤�Ƚ�ǤǤ��롣����...

�ޤ����Ϥ�ꡢ�Ķ�����ä��⤯�����������ʤ����Ǥ⡢
�����Ϥ��Ƥ��뤫�顢��İ����Ϥ��ơ�������Ȥ�줿�Ȥ��ˡ�
ȿ��¦���ä��Ƥ��ޤ��ΤϤ�������͡����Τޤޤʤ�С�
�����������Ȥϵ�����ʤ���

continuation ��ͭ��������򤱤�ʤ顢���ΤޤޤǤ⤤�������...
continuation ��Ķ��ϡ����Υ����ƥ�Ǥϼ�ʬ�Ǻ�뤳�Ȥ�
�Ǥ��뤫��͡�

�����ʤ������.... retlabel �� retcont �ϼ¤ϥ��֥�������
���Τ˰�Ĥ�����ɤ���

�������Ϥ��Ȥ��ˡ������˴Ķ��ؤΥݥ��󥿤򤤤�Ƥ����ɤ��Τǡ�
���ϳ�ȴ�ñ��������������ȡ���ι�¤�Τ�������Ϥ��ȸ���
������褹��ɬ�פ����롣

�Ǥ⡢���μ����ʤ�С��ޤä���Ʊ���ѿ��ι����ʤ�Х��ԡ���
�ºݤˤϵ�����ʤ��櫓����������ʤ��Ϥ����äˡ�������ݾڤ��뤿��ˡ�
interface ���������ɬ�פ����롣

return ->
	(void *)old bp
	return address

bp ��ľ�����Ǥ���褦�ˤ���Ȥ����������.... 

Sat Jan  8 08:49:59 JST 2000

���ϡ�code ��Ǥ�return�Ǥ��ʤ��櫓�����ɡ��¤ϡ�return �äơ�
	code return0(i) int i; { return(i); }
��? ���϶ػߤ��Ƥʤ�����񤱤��㤦��͡��ɤ�����code���Ф�������?

doreturn() �Ǥ� retpending �򥻥åȤ��Ƥ�����������顢control=1
�Τޤޡ��ǡ�code �ν���ˤ���Τǥ��顼�ˤʤ롣checkret �ϡ�
statement �ΰ�����Ƚ�Ǥ���褦�ˤ����ۤ�������Ū��������

���æ�ФϷ빽����������͡�����򥹥��åפ���Ƥ��줷����?
destructor ��Ʊ���ǡ������code�������ƤӤ����Τ����̤�������

bp ��Ʊ���ˤʤ�ޤ� return ������ɤ��櫓����͡�
return ��Ʊ���ǡ�����Ū�˴Ķ�������Ϥ��褦�ˤ��뤫��
type �� void * ���ɤ�?

return �������stack�ξ�¤�ۤ��Ƥ��뤫�ɤ�����ʬ�ǥ����å�����
ɬ�פ�����͡�ï��return���뤫��code������������ɤ��櫓�����ɡ�

	code return0(i) int i; { return(i); }

������ơ������ǡ�frame pointer ����褢�뤤���Ϥ���������
��Ӥ��ƽ�������?
	code return0(i,env) int i; env *env; { 
		if (env==self) return(i); 
	}
����? ����Ϥ���������͡�
	code return0(i,env) int i; env *env; { 
		if (env!=self) {
		    env->return();
		    return(i); 
		}
	}
�⡢�ʤ��Ѥ���ʤ����ƤӽФ��ȵս�˵��ꤿ���櫓����...
�ºݡ��ս�ˤϵ��äƤ���櫓����͡�

return ����Ǥ���������Ӥ���Ȥ������⤢�뤱�ɡ�

����ϡ�destructor ���Ϥ��������͡��������self ���ɤ��櫓������
���Τ�����ϡ����쳰������ǡ����������Ū�ˤ��������顢���θ����
��äƤ���櫓�ʤΤ����顢����������ǽ�������ΤϤ���������

	code return0(i) int i; { return(i); }

������ȡ�return �η������ʤ��ȸ������꤬������ʡ���ñ�ˤ�
�����å��Ǥ��ʤ���
	int
	main() {
	    code a() {
	    }
	    code b() {
		return(i);
	    }
	}
�ˤ���С�check �ϤǤ���褦�ˤʤ롣�Ǥ⡢������ȡ�
	int
	main() {
	    a: {
	    }
	    b: {
		return(i);
	    }
	}
�Ⱥ����ʤ���module ������쳰�Ǥ��Ȥ����Τ���ݤʤΤ����顢����Ǥ�
�ޤ���������Ϲ�饢����֥�ʤΤ����顣

����������return �ȡ����æ�л���abort�Ȥϡ��������㤦�������顢
�̤�code ��ƤӽФ��ʤ��Ȥ��ᡣ���뤤�ϡ��ͤǶ��̤��뤫������ϡ�
logic programming ��fail/success �Ȼ��Ƥ��롣
	main() { } abort { ... }
�Ǥ⤤������?
	main() {  code abort { ... }; code return { ... }}
����?

���衢subroutine call���Τ������ʤ�ξ�ά���ʤ櫓�����顢�����
�������ʤ������Τޤޤ��̾��subroutine call�򥷥ߥ�졼�ȤǤ���Τ�?
	code (struct arg {...},void *sp) {
	    struct env;
	    push(sp,arg);
	    push(env,arg);
	}
�Ǥ��뤱�ɡ�����äȽŤ�����Ϥꡢframe pointer ��ľ�����ʤ���
���ᡣ

goto ʸ�Τۤ��ˡ�env ����������Τ��ä��ۤ��������Τ��⡣
	goto (*ret)(),environment;
���ʡ�type ��? (void *)?
	goto ret(),environment;
�ˤϤʤ�ʤ���? ��������С���ʬ��thread������Ǥ��롣environment
����������ɾ�����ʤ����ɤ���? �ޤ����ͤ���

����ϼ������ưפ���... goto �Ȥ��������񤯤Τ������ˤ����Τ�?
env ���Ф���operation�����ä����������ʤ���push �Ȥ�?

	code return0(i) int i; { return(i); }

��ǧ���С�return ���ѿ��Ϥ���ʤ��ʤ롣

�Ǥ⡢�¤ϡ�return �ϡ�caller �ΰ����ο��Ȱ��פ��Ƥʤ��Ȥ����ʤ�
�櫓�����顢 code return0(i) int i; { return(i); } �Ϥ��ᡣenv
�Ȱ��פ��Ƥʤ��Ȥ����ʤ����Ȥ������Ȥ�ʬΥ����Ȥޤ����󤸤�ʤ�?
����? ����ʤϤ��ʤ��ʡ�

Sun Jan  9 01:15:56 JST 2000

��ϤꡢʬΥ���ƤϤޤ�������Ȥ�ȡ�
	goto func(arg);
������
	goto func(arg) with current.env
�ߤ����ʤ�Τ����Ĥޤꡢ����ϡ�DinnerBell �Ρ�
	self message: arg
��Ʊ����self->func(arg); �Ǥ��ɤ�������function call�ȶ��̤��դ��ʤ��Τ�
�ɤ��ʤ���

��������ȡ�type code ��size int �Ǥʤ��ʤ롣
	code *p = func;
�ǤϤ����ʤ��ơ�
	code p = {func,env};
�Ǥʤ��Ȥ����ʤ����ºݡ�
	goto func(arg)
�Ǥϡ�current environment �� pushl %ebp ��stack = current env
���Ѥ�Ǥ���櫓�����顣

������ˤ��衢
	struct p = q;
�ϼ�������ɬ�פ����롣local�ʡ�
	code p = {func,env};
��ư���Ϥ�����...

	code (*p)();
	goto (*p)(arg);

�Ϥ����龯����������������ϡ�goto ��env ����äƤ���ȹͤ���٤���

���Τ褦�ˤ���ȡ���ˡ�
	func,env
���Ȥ�code�Ȥߤʤ����Ȥˤʤ롣����ϡ�object �ȸƤ֤٤�����
��������¸��object�Ȥ��̤���ʡ�actor �������ɤ�?

�����󡢤����join�������С�������DinnerBell���ʡ����������Ϥʤ����ɡ�

Sun Jan  9 01:40:05 JST 2000

local �ѿ��ν������allocation �θ���٤餻��ɬ�פ����롣
nptr ���������Ϥ������? nptr �˽�����ե饰��­����?

ʸ����ǽи�����local�ѿ��ν������������ư���Ƥ����?

��¤�Τ�copy�ϡ�lcheck �������٤��Ǥʤ���

Sun Jan  9 08:49:43 JST 2000

�����󡢤ʤ󤫽�����¿���ʤ������ȡ��ؿ��ƤӽФ���goto ʸ��
��¤�Τؤ��б�����

	goto (*code)();

����self env ��Ȥ��Τ���code ������ͤ�Ȥ��Τ�����̤���
ɬ�פ����롣�⤷*��Ȥ�ʤ��Ȥ����label(FNAME)�Ȥζ��̤�
�Ĥ��ʤ����������Ǥ⡢�Ķ�������⤯���Ȥˤ������顢label
�ؤ�jump���褦�Ȼפ��ФǤ���͡�

���������Ϥʤ��Ƥ⡢���ι����ʤ��statementñ�̤��������򸡽Ф���Τ�
�ưפ�������

���ФǤ��뤱�ɡ����ν������̤���1�����㽪��ʤ����ʤ���
��ư�������������ΤǤ��礦?

Mon Jan 10 09:00:12 JST 2000

�����˹�¤�Τ�����ˤϡ�ɬ��ANSI-C�ˤ���ɬ�פ����롣�񤷤���
�ʤ���...

goto ʸ�ˤ� label, code, continuation ��3�Ĥ���롣
	continuation = code + env
			| label +env
�ʤΤ�����code/label �Ǥϡ�env �����Ƥ��ۤʤ롣�Ǥ�������򤤤���
���β��ͤϤ���Τ�?

��������code , env ��ʬΥ����Ȥ��ޤ�˴��������롣�ɤ���goto
�������ʤ�����餤����? ����������ñ����ñ�ʤ顢���ä�����ˡ��
�Ȥ�٤�����ʤ�? ������

return �δؿ���¸���Ϥʤ����������ɤ���
��Ĥˤ���Τϡ�pop �����꤬����Τ��ɤ��ʤ���...

��������ret ��env����ꤷ�����褦�ˤ������顢leave ����ɬ�פ�
�ʤ��ʤä��������ơ�push %ebp ������������ʬ�ϡ�lea -disp(%ebp),%sp
�Ǿõ��Ƥ��롣�Ȥ������Ȥϡ�jump ��function��¸��ʬ�Ϥ���ʤ�
�Ȥ������Ȥ��͡�

�Ǥ⡢�����ʤ���read only°����hardware support�Ǥ���Фʤ���

sched_yeilds() ������񤱤뤫��? lock ��?

������Ǥ������ɡ���äѤ������

Wed Jan 12 16:12:27 JST 2000

���ϡ�ANSI prototype �Ϥ��ɤ���
	bexpr()
�ǡ��ؿ��Ǥΰ����ν���ȡ����Τ��Ȥ�����ν�����Ѥ�뤳�Ȥ����롣
��������ȡ�������������ͥ�褵��Ƥ��ޤ�������ϡ����ޤ롣

��������code_arg_offset �Τ褦����ˡ���ȡ�ANSI style �Ǥϡ�
���äƤ��ޤ���

Thu Jan 13 04:46:12 JST 2000

#       goto name(a,b,d,e,f);
        code name { int g; ...

        %esp  new %esp = old %esp - 20
        %ebp-20   = g code's local variable
        %ebp-12   = f <- new_disp
        %ebp-8    = d
        %ebp-4    = d
        %ebp-0    = c
        %edi      = b
        %esi      = a
        %ebp = old %esp   0      disp=0 new env
         local1 <----16 old local variable       ( to be erased )
        %edx        -12   <- disp_offset
        %ecx         -8
        %ebx         -4
        %ebp = %esp   0   <- old env
        %eip          4   <- arg_offset


Thu Jan 13 13:38:24 JST 2000

���������Ǥ������ɡ�test/tmp7.c ��printf ��type mismatch ��
�ʤ�ʤ������?  ASNI �������Ѥ������ʤ���

������ȡ��ץ����������ؤ��ΤȤ��ˤϡ��빽���̤Υǡ�����
���ԡ����뤳�Ȥˤʤ롣����Ǥ⤤���������...

���줴�ȡ��ɤä��ˤȤä��֤���continuation�ؤλ��Ȥߤ����ʤ��
���Ǥ��ʤ����ʡ�

���ԡ����Ǥ���С�environment/return ���Ȥ�ư���櫓�����顢
����ؤλ��Ȥ����ؤ������äƤ��ɤ���͡�

Fri Jan 14 12:03:35 JST 2000

Libretto ��keyboard�����줿... control key �������ʤ�...

printf �λ��Ȥ�����ϲ�褷�ޤ�����list2 ��local��heap
�˳�����ƤƤ���Τ������ʤ��ä��͡�

return �ν����ϡ�goto ʸ�ǽ��������ꡢenvironment ��
returnto ���������ɤ��Ϥʤ���?

environment �ϼ¤�������Ǥ���ʤ�ν�����ɬ�ס�
new-environment() �ߤ�����library ������С�thread �ˤǤ��롣

join ��?

funcall ���Ѱդ�����ɤ��͡�

Mon Jan 17 15:23:34 JST 2000

    struct aa f1() {
	return bb;
    }

�ߤ����ʤΤ�? �ؿ��η��������η��򸫤ơ�crn ��pointer���Ϥ��ơ�
���Ȥ�copy���Ƥ��� stack ����ࡣ

    # 	bb=f1(aaa);
	    movl $bb,%eax
	    pushl %eax
	    movl $aaa,%eax
	    pushl %eax
	    call	main2
	    popl %edx
	    copy %eax,%edx,$400
	    addl $400,%esp
    #     return a1;

�����Ǥ⡢������ȡ�local�ѿ����֤����Ȥ��˺���͡�leave; ret;
���ƤϤ����ʤ���...

������äѤꡢ�����������ϥ��ԡ����main2�˰����Ϥ��Ƥ���ߤ����͡�
    void f1(struct aa *ret) {
	*ret = bb ;
	return;
    }
��Ʊ����������ϴ�ñ��
	f1().a[55]
�ߤ����ʾ��ϡ��ɽ��ѿ��˶���Ū�˼�äƤ��ޤ��ߤ����͡�����Ϥ�����...
���������μ������Ȥ���äȸ���������
	leal $-sizeof(struct),%esp
	pushl %esp
�ʤ�����ɡ��ؿ��ƤӽФ�������ǤϤǤ��ʤ�����....

    # main(ac,av)
    # int ac;
	    .align 2
    .globl main
    main:
	    .type	main,@function
	    pushl %ebp
	    movl %esp,%ebp
	    pushl %ebx
	    pushl %ecx
	    pushl %edx
    # char *av[];
    # {
    #     register int i;
    #     register char *p;
    #     int j = 3;
    #     struct { int b; void (*c)(struct aa); } q = {3,main1},r;
    # 
    #     j = 3;
	    subl $20,%esp

����subl��夫����ꤷ�Ƥ���Ok��

�Ǥ⡢������� jump �λ��ˤ���ʤ�? ����뤫? �����͡�������
�¹Ի��˥����å����Ƥ��Τ��Ѥ�����

�ޤ�������ۤ�ɬ�פʵ�ǽ�ǤϤʤ�������ɡ�

�����continuation���Ϥ��Ƥ��ȸ�����ˡ���Ȥ��ʤ����ȤϤʤ������...

�ؿ��ƤӽФ��κǽ�ˤ�äƤ��Ф�����������ǤǤ��뤫��?


Sun Feb 20 23:59:16 JST 2000

MIPS ��call frame

	$sp = $fp 
			local variables
        		saved register (including $31 = return address)

mask  �ϻ��Ѥ����쥸������bit pattern
 -4 �ϲ�?

  18                            .mask   0xc0000000,-4
  19                            .fmask  0x00000000,0
  20 0000 D0FFBD27              subu    $sp,$sp,48
  21 0004 2C00BFAF              sw      $31,44($sp)
  22 0008 2800BEAF              sw      $fp,40($sp)
  23 000c 0000000C              move    $fp,$sp
  24 0010 21F0A003              jal     __main
  25 0014 03000224              li      $2,0x00000003           # 3
  26 0018 000082AF              sw      $2,a
  27 001c 04000224              li      $2,0x00000004           # 4
  28 0020 00C082AF              sw      $2,b
  29 0024 05000224              li      $2,0x00000005           # 5
  30 0028 000082A3              sb      $2,c
  31 002c 06000224              li      $2,0x00000006           # 6
  32 0030 08C082A3              sb      $2,d
  33                    $L1:
  34 0034 21E8C003              move    $sp,$fp                 # sp not trusted
 here
  35 0038 2C00BF8F              lw      $31,44($sp)
  36 003c 2800BE8F              lw      $fp,40($sp)
  37 0040 0800E003              addu    $sp,$sp,48
  38 0044 3000BD27              j       $31
  39                            .end    main

�����Ʊ���褦�ˤ���ʤ�С�regiter�λ��ѿ���ǽ��Ĵ�٤�ɬ�פ�
����Τ����ɡ�one path compiler �Ǥ��� micro-C �Ǥϡ������
�Ǥ��ʤ����������äơ�enter �ϸ���Ǥ��������ɤ���
Mon Jan 20 18:25:27 JST 2003

3ǯ�֤���äƤʤ��Τ��衣����äƤ��?

goto ʸ�ΥХ���Ȥ�ʤ��Ȥ����ʤ���

�ޤ����ؿ������ι�¤�Τ�Ÿ��������ϡ��ɤ��äƤ��Ȥʤ��Ϥ���

   goto (*code)(i+1,j,...)

�ޤ���������ʤ��Ƥ����ѿ���Ŧ�Ф��롣

   foreach arg 
      compare

ñ��黻 ( op+const , pointer , const assign ) �ʤɤϡ������Ǹ��Ф��롣
��Ⱦ�ϡ����Τ褦�ˤʤ�Ϥ���
�쥸�����˾褻��ʬ�����뤫��... ����ˤϿ���ʤ��Ȥ���...

ʣ���ʤ�Τϡ�����äƷ׻����Ƥ�����(get_register ����)
�����å��夫�쥸������˺�롣

�Ĥ�����������Ȥʤ롣�Ƶ�Ū�˷׻����롣

�����ȡ��礭�ʽ�ˤ�����ä�? �����ʽ�ˤ�����ä�?
    code f( int a, int b, int c ) {
        goto g(b,c,a);
    }
�ߤ����ʤ�Ĥ���͡�

    ��ư�����Τ��ĸ��Ф��롣
    ���Τ���˰�ư��ɬ�פʤ�Τ��ư���Ƥ���(�Ƶ�)
    ��������

����ʤ�Ǥ����Τ�? �롼�פ��ʤ�? �����͡��롼�פ�����
get_register ���롣

��������ȡ�

    g(b,c,a) ��b�����ܤ��롣
    b���������륳���ɤ�Ф��ȡ�a ������롣
    a ��ɬ�פ��ɤ�����Ĵ�٤롣����ϡ������Υꥹ�Ȥ򸫤�Ф狼�롣
    �������ˡ�a ���ư���롣a �ΰ�ư��򸫤ơ�
       �����Ƥ���С���ư����Ok����������c 
    �ʤΤǡ� c �򸫤롣�� b �ˤʤ�Τǡ��롼�פ���Τ��狼��Τǡ�
    b �� get_register ���롣
    �ǡ�c ����ư�Ǥ��롣�ǡ�a���ư���ơ��ȤäƤ�����b��������

Tue Jan 21 22:45:09 JST 2003

�Ȥꤢ������jump ��ʣ�������롣��äȴ�ñ�ˤ��뤳�Ȥ�ͤ��롣
parser ¦�Ǥ������ٽ����Ǥ��ʤ�?

     goto f(a+3,b(),c);

�ʤɤ�

     a = a+3;
     b = b();
     goto f(a,b,c);

���٤˴�ά�����롣���λ���f(a,b,c) ��(�Ǥ������)������
�ؿ��ΰ����ꥹ�Ȥ˶��դ��롣�Τ�̵���ʤΤǡ�ñ���ѿ�
�ޤ����

���ޤ�ط��ʤ���������ѿ��Ϥɤ�������櫓�������äƤ���
�ߤ����͡�

���Ȥ���ȡ����Υ����ɤȡ������Ѥ���͡����Τ⡢����ʤ�
�����ʤ��äƤ��Ȥ���

Wed Jan 22 14:33:12 JST 2003

��äѤꡢ����Ƕɽ��ѿ������䤷������͡�

Fri Jan 31 20:30:36 JST 2003

�ʤ� #ifdef / #if ���ʤ��Ȥ�����ʡ���������?
���ޤ�����

Tue Feb  4 01:04:12 JST 2003

##      while ((*chptr++ = c = getc(filep->fcb)) != '\n') { 
_1120:
        movl $10,%eax
        movl $8,%ecx
        movl filep,%edx
        addl %ecx,%edx
        movl (%edx),%edx
        pushl %edx
        xchg %edx,%eax     .... edx ��$10������ (�ʤ��xchg?)
        call    getc
        addl $4,%esp
        movl %eax,-20(%ebp)  c ������
        movl $chptr,%ecx
        pushl %ecx
        popl %ebx
        movl (%ebx),%ecx      ecx ��chptr�����
        addl $1,(%ebx)
        movb %al,(%ecx)
        subl %edx,%eax         eax-edx ($10)
        je      _1119

���������ͳ�ʤ������...

edx,ecx ���˲�������㤦�ߤ����͡�

Tue Feb  4 12:17:07 JST 2003

�褦��ä�ľ������...

use_pointer �äơ��ʤˤ⤷�ʤ��Ƥ���������? eax,ebx ���򤱤�
�äƤ��Ȥ餷�����ɡ�

inline/�����դ� #define �ߤ����ʤ�? �֤������ϡ�local name stack ���Ѥ󤸤㤦��
Ÿ���� function  �ǹԤ���

getch ���פ���ɬ�פϤ��뤬���֤����������å���ɬ�ס�


Wed Feb  5 01:16:00 JST 2003

����������줿 struct field ������ѿ��ȽŤʤäƤ��������롣
����㤽�������ɡ��ɤ������? (ľ�������������������ɤʤ�...)
struct ��� field ̾��offset/type ���Ȥ���ƤФ��ɤ������͡�

�ʤ�����ɡ�����̵���ι�¤�Τ⤢�뤫�顢��̾�������դ���ɬ��
�⤢�롣�Ȥ����Τϡ���̾�Τʤ���¤�Τ⤢�뤫�顣����̾�ˤϡ�
������ꥹ�Ȥ��Ĥ��Ƥ��롣�ʤ󤫤˻Ȥ�ɬ�פ����ä���Ǥ��礦
�͡��������ɤ���̵���ˤ�äƤ�����ѿ�̾������Τ�ľ����
���񤷤���

����äȡ���������ɡ��ַ�̾.�ե������̾�פ���Ͽ���Ƥ��ޤ��ΤϤɤ�?
��̾����ǽФ����Ȥ��������ޤ�����...

def ����Ͽ����Ȥ��ˡ�nptr��disp�����������ˡ�struct field list
(����ѿ�) ������ơ�type �����ˡ�field list (list3(nptr,offset,
type)) ���������ɤ���

���Ȥϡ�strop ������type��list�򸫤�褦�ˤ�����ɤ��櫓����

����ʤ顢��ñ��ľ����Ϥ���LUSTR/GUSTR�ʤɤζ��̤�ʤ��ʤ뤷��

Wed Feb  5 02:10:14 JST 2003

��ư�������ͤ���������ANSI C�ˤ���Τ����ѡ��Ǥ⡢
��ư���������餤�ʤ��ȡ�

code generation part �򡢤����ʬ�䤷�ơ�
ʣ���Υ������б��ˤ��䤹���褦�ˤ��롣
�����餯������ۤɶ�ͭ������ʬ�Ϥʤ����ɤ͡�

Sample C code �򥳥�ѥ��뤷�ơ����η�̤���(Ⱦʬ��ư��)
Micro CbC code generation part ������������ˡ���Ѱդ��롣



Thu Feb  6 11:47:03 JST 2003

Code Segment ��ñ�̤Ȥ��ƻȤ��Ȥ��ˡ�����ѿ��Ϥɤ�����
�褦��ʬ�����? static �ʤ󤫤ϰ�̣�ʤ���͡�

������󡢼����˥��롼��ʬ�������櫓�����ɡ�

���ȥǡ����ե�������͡��ǡ����ե����˴ؤ��Ƥϡ�
����ޤ��äƤʤ��ʤ�

Fri Feb  7 14:36:15 JST 2003

inline �Ǥϡ�ɬ�餺���ɽ��ѿ������ä����롣�ޤ���inline
�����̤δؿ��Ȥ���Ÿ�����Ƥ���ɬ�פ⤢��餷����(����?)

#define �ͤ���

   #define c(a,b)  g(a+1,b+1)
   #define g(a,b)  printf("%d %d\n",a+1,b+1);

   main() {
       int a,b;
       a =1; b = 3;
       c(a,b);
   }

local #define ����������͡�g ����� a ���Ф��褿���ˤϡ�
c ��a ���֤������ϵ����äƤϤ����ʤ����Ȥ������Ȥϡ�c
���֤�������g ���Ϥޤ����˽��äƤ���ɬ�פ����롣dynamic
scope �ʤ�����顢assoc �ξ�褻���ɤ��Ϥ���
macro ��level��������ơ������٥�Ǥϡ����������Ÿ��
��Ԥ�ʤ��Ȥ�����ˡ���ɤ����ʡ�

   c(a,b) =>  a=>"a+1", b=>"b+1"
   g(a,b) =>  (a=>"a+1+1",a=>"a+1"), (b=>"b+1+1",a=>"a+1")

�ߤ����ʴ���?

��äѤ�ؿ����Ϥǥޥ����������餻��Τ�̵������? ���ɤߤ�����㤦����

Sat Feb  8 00:53:52 JST 2003

macro ������ޤǽ񤭤ޤ������֤�������ޥ������ƤӽФ��줿
������ cheap ���֤��ȡ�������ä��륿���ߥ󥰤��ʤ���
��������malloc���Ƥ��ɤ���..

chptrsave ��list�ˤ���ɬ�פ����롣list ���ɤ���

��äѤ�macro level�򸫤ơ���ʬ�Ȱ��פ���assoc value�ޤ�
�귫�ä��ִ������Ǥ��礦����������С��֤�������ɬ�פ�̵����
�Ȥ������Ȥϡ�local_define ��mflags���Ǽ����ɬ�פ����롣

   c(a,b) =>  a=>"a", b=>"b"
        a=>"a" .. mflag == 1
   g(a,b) =>  (a=>"a+1+1",a=>"a+1"), (b=>"b+1+1",a=>"a+1")
        a=>"a+1" .. mflag == 2
        
macro �Τ�Ȥ�nptr ���ĤäƤʤ��ȡ����ꥸ�ʥ���֤��ʤ�����
�ꥸ�ʥ�ϡ�sc �ʤɤ��˲�����Ƥ��ޤ����äƤ��Ȥϡ�local macro
�ϡ�local table ������ƤϤ����ʤ��äƤ��Ȥ���͡��äƤ��Ȥϡ�
macro table �ϡ���ȤΤȤ��̤��Ѱդ���ɬ�פ����롣

#define c(a,b)  g(a+1,b+1)
#define g(a,b)  printf("%d %d\n",a+2,b+2);

main() {
   int a,b;                  a ... local
   a =1; b = 3;
#ifndef a
   c(a,                 a = "a".. macro mflag==1
                        g(a,
                               a="a+1"  mflag==2
                                  ^  a = "a" mflag==1
                        While replacing a in g's body, a should not
                           be replaced to  (original) "a", should be c's a.
      b);                
   /* 3,5 expected */
#endif
}

�����ࡣ��䤳������

    main() 
	c(a,b)    mflag++
                         a=>"a" mflag ==1
           g(a,b) mflag++;
                         a=>"a+1" mflag ==2
                             ^ is replaced by c's "a" not g's a;
���ä��� mflag level n ��Ÿ�������顢����� mflag level n-1 �Ȥʤ롣

Sat Feb  8 18:13:43 JST 2003

����������mflag �ޤǤϥǥХå�������....  mflag ���ᤷ�Ƥʤ��󤸤�ʤ���?

     ---c(a,b)-----------------------  mflag ==1
          a=>hoge, b=>hoga (mflag==1)
        ----g(ac,bc)-----------------  mflag ==2
              ac=>goge, bc=>goga(mflag==2)
            ----printf(a,b)----------  mflag ==3
                a=>poge, b=>poga(mflag==3)

g ���ƤӽФ����ȡ�ac,bc �� mflag==1 �ǤΤ��ִ�����롣

����ƥ����Ȥ��֤�������ȡ�������֤��������ޥ�����mflag level
(�Ĥޤ��ľ��ʤ���٥�)�ˤʤ롣
�֤��������ä��顢����level���᤹��

mflag==2��level �Ǥϡ�mflag==2��local macro��Ÿ���������ʤ���

�֤�������ȡ�mflag level 1 �ˤʤ�Τǡ������� mflag==1 ��local
macro ��Ÿ�����롣mflag==0 �Ͼ��Ÿ����Ԥ���

Sun Feb  9 11:35:23 JST 2003

�����󡢤ʤ�type����list ��CHAR�ʤɤ��������äƤ��뤸���
    int save = chptrsave;
�ǡ�chptrsave ����$chptrsave �ˤʤäƤ��ޤ���

Sun Feb  9 22:33:36 JST 2003


#define car(e) (heap[(int)(e)])
#define cadr(e) (heap[((int)(e))+1])
    car(cadr(e))

������
    car ->  
       #define e cadr(e) (mleve=1)
    cadr ->  
       #define e e (mleve=2)

�थ�����졢���ޤ������ʤ��󤸤�󡣤��ޤä��ʤ���

#define c(a,b)  g(a+1,b+1)
#define g(a,b)  printf("%d %d\n",a+1,b+1);
   c(a, b);

���ä�����ᤸ��󡣤ա��ࡣlisp interpreter �Τ褦��
���Ф����Ϥ��ʤ�����ɡ�

Mon Feb 10 08:10:25 JST 2003

��ɡ�list base ��interpreter ��������ޤ�����������ʤ�����
������ˡ�Ǥ⡢��ĥ��ФǤ����Ǥ��礦���ɤ͡�

Tue Feb 11 13:50:03 JST 2003

struct copy ������... �ؿ���struct���֤��Ȥ��ˡ�����������ä�
�Ѥ�Ǥ����ΤǤϡ��������ͤ����ԡ�����Ƥ��ޤ��������Ȥǡ�
�����å��򤿤�����֤��Ȥ��ˤ��ޤ�����

function call �λ��ˡ������η��Υ����å��򤷤Ƥʤ�

type �� -1 ��heap�ΰ��������ߤ��Ƥ����Ĥ�����..
��äѤޤ����󤸤�ʤ���?

temporal struct �Ϻ����ѤǤ��������ɡ�disp���ѹ����Ǥ��ʤ��Τ�
��������뤷���ʤ����礭���Ȥ��������������ʤ�Ƥ���������
���Ϥ��뤱�ɡ�(��������ȡ����ä��褿�ͤؤΥݥ��󥿤�Ȥ��ʤ�
�ʤ뤬.... �̤ˤ�����͡�����ͤ��켫�Ȥ�ľ�� return ����
����������礦�֤ʤϤ�)

��ɡ��ƽ�¦�ǡ��ΰ����ݤ��ư����Ϥ����Ȥˤ��ޤ�����������ˡ���ȡ�
�����ΤȤ������٥��ԡ�����ɬ�פ�ʤ���

register  ����Ѥ��Ƥ��뤫��������ʤ��ơ��ºݤ�creg/dreg��
�ͤ����뤫�ɤ����򵭲�����ɬ�פ����롣

Wed Feb 12 11:09:22 JST 2003

��������ɤ�... ��äѤꥢ�ɥۥå��˼¸�����Τ��񤷤��󤸤�ʤ���?

�ޤ��ͤ���register �ξ��γ��ݤȡ���̿���̤����顢�����
����������ɡ�regs flag �����Ǥʤ�Ȥ��ʤ�ʤ��Τ��ʡ�
���������ѹ��ϤϤޤ뤬��������

Thu Feb 13 18:37:36 JST 2003

���ơ��������� jump  �ˤȤ꤫����ޤ�����

��¤�Τΰ����Ϥ��Υ��������󥹤˻Ȥ��ɽ��ѿ��ΰ��֤�gcc�Ȱ㤦...

�������� register �Ϲ�¤�Τˤ��٤����͡�
    struct register {
        int used;
        int valued;
        char *name;
        char *wname;
        char *bname;
        int type; /* register variable or not */
        int number;
    }
virtual/real �ϡ��ɤ����롣

Sat Feb 15 14:00:03 JST 2003

fdecl_struct ��ʸŪ�˰������и�����Ȥ��˹Ԥ��ȡ�int *f(int
a) �ʤɤǡ�* ��ɾ�����������ˡ�int a��ɾ�����줷�ޤ���*obj 
��obj ��ɾ��������ʤ���f�Υ����פ����ꤷ�ʤ���int*f()[] ��
�����ʾ�礬���뤫�顣(?) �ʤΤǡ�gcc �ȡ��������뤿��ˤϡ�
arg ����Ƭ�� fdecl_struct ��Ԥ���ˡ�ǤϤ���ǡ�fdecl ��Ǥ�
�Ȥ��齤�����������ɤ���

fix ���褦�ˤ�����ꥹ�Ȥʤ�ơ�¸�ߤ��ʤ������!

varargs ���������ΤϤ��ɤ���������...

rvalue(expr(),type) �Ǥϡ�expr() ��type��rvalue�˰����Ϥ���
�����Ǥ⡢type ������ѿ��ˤ���ȡ�rvalue��ۤʤ륿���פǸ�
�ӽФ��Ȥ���type���ѹ�����ɬ�פ����롣����rvalue��type �ΰ�
���ϡ����ʤ�Ϥޤä����Ȥ�����Τǡ�rvalue(int e,int type)��
�����ɤ����ȤϳΤ��ʤ����... 

struct_push ��register�ΰ�����ʣ���������ʤ󤫡���ä�
��ñ�ˤʤ�ʤ���?

Sun Feb 16 07:58:23 JST 2003

�������ʤ����ɤ�����ȸ��äơ�������
�Υꥹ�Ȥ�������Ƥϡ���񤭤��ɤ��ʤ���

Sun Feb 16 22:55:58 JST 2003

vdisp �äƤʤ���ä����?

Mon Feb 17 12:35:39 JST 2003

���������Ͻ��褿�ߤ����������Ͼ�������Τ���ˤ��٤��ʤΤ�?
�ޤ����Ǥ���㤤��������ɡ������򤱤��Τ��礭���ΤϤ���
����͡�

Tue Feb 18 11:56:10 JST 2003

overlapped �Ѥ� emit_copy
float/double
long long

Tue Feb 18 19:34:31 JST 2003

code argument ������ȿž������ȡ�list2(LVAR,offset)
��offset�����ɥ쥹�������Ȱ��פ��Ƥ���Ȥ�������
����롣����ǡ���¤�Τγ�Ǽ���������Ƥ��ޤ�...

�Ȥ������Ȥ�... def(n) ��code�λ���argument�ϡ��ɽ��ѿ���Ʊ��
�����ǥޥ��ʥ����ǽ������������ɤ���

�Ǥ����ߤ������Ǥ⤵��
   
int main( int ac, char *av[])
{
    int n;
    goto arg1(0,1,2,3,4,return,environment);
}

�äơ����ä� return ʸ���ʤ��ȡ�ʸ���
�������͡����ࡣ

post processing �������overlap���Ƥʤ��Ȥ����ݾڤ��ʤ���

Wed Feb 19 15:38:55 JST 2003

��ʬ���ȤȤ�overlap�򸫤Ƥʤ��Τǡ�
    struct a a,int i
    int i,struct a a
�ߤ����ʻ��˼�ʬ���Ȥ�����Ƥ��ޤ����ʤΤǡ�emit_copy
���������������򸫤Ʋ����ʤ��褦�˽�������ɬ�פ����롣

call bcopy �Ǥ�������󡣤ޤ͡�

Wed Feb 19 20:42:07 JST 2003

�̤���� C2CbC �� CbC2C ��micro C �˼����ࡣ�ƽ�ˡ�
conv->func(); �������ࡣconv �ϡ���¤�Ρ�

    conv:   original
            c2cbc
            cbc2c

�Ȥ��롣�ʤ�ۤɡ�

Thu May  6 08:32:05 JST 2004

��äѤ� library �⼫ʬ�Ǻ��ʤ��Ȥ͡���������С�
CbC only �Ǻ��뤫�顣

conv �ϡ�����ޤ��ɤ������ǥ��ǤϤʤ��ߤ�������뤫������

Thu May 13 12:59:16 JST 2004

byte code interpreter �� CbC ���Ȥǽ񤤤���?

����Ǥ��äѤ�ư���ʤ����顢����ޤ��̣�Ϥʤ��������...

C �ǽ񤤤Ƥ⤤������

Wed Dec 22 15:17:49 JST 2004

   reset {
         shift;
   }

�ͤ��� �ʤ�ǡ�return ��ʸ�ˤ����Τ����������̡��ˤ����Τ���

  goto ret(value),env;

�ޤ����ͤ���
   try {
       .... goto event ....
   } catch (event) {
   }
�򤤤�Ƥ⤤��������ɡ�

�����ࡢ���ޤ������ʡ�

inline function ��return,env ���������äƤ������⤢�뤱�ɡ�

��äѤꡣsetjmp = return �ߤ����ˤ���? ����Ϥ���ǡ�
�䤵�����������....


Fri Jan  6 20:26:24 JST 2006

environment = interface frame �����ؤ����Ѱդ��ʤ��Ȥ͡�

Mon Jan 30 21:53:11 JST 2006

    packet_put  .....   fork
	packdet_put(interface hoge);
    packet_get  .....   join
	interface hoga = packdet_get();

      ----> distributed CbC

   Synatx
         code a() { }

         code a(a):b(b) {... }
         ->
             code a() {
                if (b = packet_get() {
                     .....
		} else goto a();
             }

         code a() {
               goto b();
         }

         code a() {
               goto b():d()@dest;
         }
         ->
	     code a() {
		   packet_put(d(),dest);
		   goto b();
	     }





Wed Sep  6 14:59:09 JST 2006

      code hoge(int a, code f(int k,...), ...)
      {
           goto f(a,...);
      }

syntax ������... type �λ���Ϥʤ�Ȥ����ʤ��Ȥ�����͡�

      ...

      int a,

���줿�Ȥ��Υ����Ȥ��ʤ����ɤ������ʤ������͡�

��ǽ���Ȥϻפ�������ɡ�

      __meta goto {
      }

�ߤ����ʴ���?

Sun Nov 26 21:14:57 JST 2006

      | frame pointer               | stack pointer
      v----> argument      local <--|-----v
                                    caller_arg

�ǤϤʤ��ơ�

      | previous $fp
      |<-intr_size---><--------r1_offset----------->|
      |               | frame pointer               | stack pointer
      v<--- interface-+---- local ----->|<--------->v
              <0          >0              caller_arg

�ʤ顢�����󤸤�ʤ�? caller_arg �� sp ���Ф��Ѥ���ɤ���
local �ѿ��� max_caller_arg ������ʤΤ� sp ���ФǤ��Ѥ�ʤ���

������ȡ�frame pointer ��goto �Dz��Ѥˤʤ롣interface ��arugment
�����ˤʤ�Τǡ��¤�ʤ�subroutine call �˶᤯�ʤ뤱�ɡ�
(�ޤ�����������ʡ�����������������...)

���ä��顢������function call�˹�碌�뤳�Ȥ��ǽ�ʤ󤸤�ʤ���?
����Ĺ�����ξ��Ȥޤä���Ʊ���ˤʤ롣gcc ��(ͽ�ꤷ���Ƥ������Ʊ��)
������ȡ�C-- �� paraterized goto �ȡ��ޤä���Ʊ���ˤʤ롣

      | previous $fp
      |<-intr_size---><-------------r1_offset------------>|
      |               |frame pointer                      | stack pointer
      v<--- interface-+-------|--- local ----->|<-------->v
              <0      >0  xxx                    caller_arg
                         |frame pointer                      | stack pointer
      v<--- interface----+-------|--- local ----->|<-------->v
              <0         >0  xxx                    caller_arg

caller_arg ��sp����Ѥ�ȡ���������С�alloca ������ʤ���

�������Ѥ��ʤ��ä��Τϡ����֤�fp ���ư���ʤ���Фʤ��
���Τ���ä���������ʡ����ϡ�parse tree ��äƤ��顢code 
�������ǽ�ʤΤǡ��������Ƥ��ɤ��������

�Ǥ⡢���ɤ������衣���ɤ����������ɤ������Ǥ���
�Ǥ⡢��뤷���ʤ���

����򡢤��С�C ������Ѵ��⤫�ʤ�䤵�����ʤ뤫���Τ�ʤ���

Sun Nov 26 19:41:38 JST 2006

max interface �ߤ����ʤΤ�ɬ�פǡ���������С�local �ѿ��Ȥ�
��ߺ��Ѥ��򤱤��롣�դ˸����С����ѤϽ���ʤ���

�Ǥ⡢max_interface ��1 path �ǤϷ�ޤ�ʤ��������顢long offset
�λ��ϡ�����äȤϤޤ롣�ä�ARM�ξ�硣��äѤꡢmax_interface
�Ϸ���Ǥ��������Τ���? ��������ȡ�function call ����Ƥ�
�Ȥ��ˤϤޤ뤬... 

offset �� 0 ¦����ˤ���С�max_interface ��fp������Τߤ�
�ʤ뤬����������ȡ�interface ���ѹ������Ȥ���copy��ȯ�����䤹��
�ʤ롣���䡢����ʤ��ȤϤʤ��Τ���?

      __code f(int a,int b) {
	goto g(int c,int b,int a);
      }

      v<---|----+----local ----->|<-------->v                before f
        a,b
      v<--- interface-+-------|--- local ----->|<-------->v  f
        a,b
      v<--- interface-+-------|--- local ----->|<-------->v  goto g
        a,b,c

�ߤ����ʴ����Ǥ���? ����򤽤�����櫓�͡�����������������

������ȡ���äѤꡢmax_interface ������ˤʤ롣��äѤꡢ����ǡ�
fp �򲼤ˤ��Ƥ����������ʡ�

      __code f(int a,int b) {
	goto g(int c,__code *f,int a,int b);
      }

      __code g(int c,__code (*n)(...),...) {
	goto n(...);
      }

      |<----------------------------r1_offset------------>|
      |frame pointer                                      | stack pointer
      v<--- interface---------|--- local ----->|<-------->v  f
        a,b,(n,c)
      |frame pointer                                      | stack pointer
      v<--- interface---------|--- local ----->|<-------->v  goto g
        a,b,fp,n,c
            |frame pointer                                | stack pointer
            v<-interface-+-------|-- local --->|<-------->v  g
        a,b,fp,n,c
       |frame pointer                                     | stack pointer
      v<--- interface---------|--- local ----->|<-------->v  goto n
        a,b

�����ȡ�goto n(...); �ǡ��ɤ���ä�fp �򸵤��᤹��? ... �ΰ��֤ǡ�
���� fp ��Ф��Ƥ������ɤ���(*)

������ȡ�function call �򡢤��Τޤ޼¸��Ǥ�����������? �ߤ������͡�

      __code f(int a,int b,...) {
	goto g(int c,f,int a,int b,...);
      }

      __code g(int c,__code *n(int a,int b,...),...) {
	goto n(int d,int e,int g,...);
      }

�Ȥ�����ȡ�̵�¤�stack����Ӥ롣�ա���

      __code g(int c,__code *n(...),...) {
	goto n(int d,int e);
      }

�ϡ��ɤ�����? fp �ϡ����Τޤޤʤ�������͡�

      |<----------------------------r1_offset------------>|
      |frame pointer                                      | stack pointer
      v<--- interface-+-------|--- local ----->|<---------v  f
        a,b,(n,c)
      |frame pointer                                      | stack pointer
      v<--- interface-+-------|--- local ----->|<---------v  goto g
        a,b,fp,n,c
            |<----------------------r1_offset------------>|
            |frame pointer                                | stack pointer
            v<-interface----+----|-- local --->|<---------v  g
        a,b,fp,n,c
               v<-interface-+----|-- local --->|<---------v  g
               d,e

�ǡ�fp �Ͼ�񤭤�������ϡ��ɤ��ʤ����ʤΤǡ�fp ��ʬ���餹��
�Ȥ������ϡ�fp �μ���ؤ��褦�ˤ���Τ��ɤ��Τ���

      __code f(int a,int b,...) {
	goto g(int c,__code *f,int a,int b,...);
      }

      __code g(int c,__code (*n)(...),...) {
	goto n(...);
      }

      |<----------------------------r1_offset------------>|
      |frame pointer                                      | stack pointer
      v---- interface-+-------|--- local ----->|<---------v  f
        a,b,(n,c)
      |frame pointer                                      | stack pointer
      v---- interface-+-------|--- local ----->|<---------v  goto g
        a,b,fp,n,c
               |<-------------------r1_offset------------>|
               |frame pointer                             | stack pointer
               v<-interface-+----|-- local --->|<---------v  g
        a,b,fp,n,c
      |frame pointer                                      | stack pointer
      v---- interface-+----------|-- local --->|<---------v  goto n
        a,b

�Ȥ����櫓����frame pointer �Υ��ץ���󤬤��ä������ɤ��櫓���͡�

������ȡ����Τ��ѹ��⾯�ʤ��ƺѤߤ�������(�ۤ�Ȥ���?)

g �� ... �ΰ��֤�����ä��Τ뤳�Ȥ�ɬ�ܡ����ʤꥳ���ɤ��˻���
�ʤ뤱�ɡ�
      __code g(int c,__code n,...) {
�������ɤ�����������ȡ����Υ����å�������ʤ����ºݤˤϡ�
���ʤ��˻��ʷ���񤯱��ܤˤʤ롣typedef ����Ф���������ɤ͡�

__code �ϰ��ۤ�typedef �ˤ���?


����������max_interface�����¤ϸ���Ū�ǤϤʤ�? �Ǥ�ʤ���...
����code�ǥ��������³�������͡����ä��顢max_interface ��
��äơ�(1024����?)  ���䡢��äѤ� fp ��ư�����ʤ��Ȥ���
�ʤΤǡ��ɤ��ʤ���

fp ���Ѥ���ȡ��᤹���Ȥζ��̤�? �빽��̯����
    goto ¦����� ...�����(��Ʊ����)�褿���᤹
    goto ¦����� ...���°���������褿���Ѥ�
�ǡ������櫓��?

����äȡ�Semantics ��ʣ���ˤʤꤹ���롣��ǽ�ʤ�����ɡ�
environment �Ǥ� goto �Ǥ��ޤ˥ꥻ�åȤ��ʤ��Ȥ��������ʤꤽ����
Stack �����Ƥ�����ϡ�Warning ���餤�����������������⡣
���Ū�˸��ʤ��Ȥ狼��ʤ���ͭ�¤��ɤ����⡣

������tail recursive call �Ǥ��Τȡ����ޤ��Ѥ��ʤ����ʡ�
��������ȡ�c-- ��parametarized goto �Ⱥ����ʤ����⡣


������������

      __code g(int c,__code *n(int a,int b,...),...) {
	goto n(int d,int e,int g,...);
      }

�� n �ϡ���ưŪ��������줿����������������

      __code g(int c,...) {
	goto __cotinuation(int d,int e,int g,...);
      }

�ߤ����ʴ�����

      go g(int c,int b,...) to hoge(...);

�Ǥ���? ����ϡ����ᤫ... ����Ǥ�ʤ�������ɡ��������꤬
�񤷤����롣

K&R style ��������������ʤΤ�...

Sun Nov 26 21:53:05 JST 2006

(*) interface ���礭���������ϡ���ʬ��interface �򸫤��
�狼��Ϥ������? �����顢fp ��save��ɬ�פʤ��Ϥ�����...

      __code f(int a,int b,...) {
	goto g(int c,__code *f,int a,int b,...);
      }

      __code g(int c,__code (*n)(...),...) {
	goto n(...);
      }

�Τ��ˤ狼�������ɡ������ְ㤨���Ȥ��ˡ��������ˤʤ롣
�ɤ���������ǤϤ��������������η��ϰ��ʳ��ޤǤ�����
�����å����ʤ��Τǡ�������͡�


���Τ����ꡢ����Ū�����꤬����ߤ������ʡ�

    stack ��ޤ᤿ͭ�¤ʷ��դ�
    �ȡ�����ɽ��

�ä����꤬����櫓��?

��������parallel assignment �Ǥϡ�Ʊ����ʬ������ä�õ����
������Ψ���褤�櫓����(�ɤ�������äƤ��뤳�Ȥ���)

Sun Nov 26 23:22:12 JST 2006

fp ��save ��ɬ�ס����Τ��ȸ����ȡ�
    goto f(a,b,...)
�ǡ��������ʬ���ɤ�������뤫�ϡ�����Ū�ʰ����Ǥ�
����ǤϤ狼��ʤ����顣

stack ������� interface ������ʤ顢�ɤ�����
��ʬ�� register �˾�äƤ��롣

    goto f(a,b,c,...)

�Ȥ����Ȥ��ˡ�... �ΰ�����register�˾�äƤ��롣�ɤ����
��äƤ���Τ����Τ�ɬ�פ����뤬�������fp����仡����
���ȤϤǤ��ʤ�����ư�������Ȥ��ΰۤʤ뷿�����ߤ��Ƥ���
���顣

... �ǰ����Ϥ������ϡ�����˾�äƤ���ɬ�פ����롣
��������ʤ顢�쥸������Ǥ��������֤ʤϤ�������

����Ū�ʰ��������Ū�ˤ��Ѵ��Ǥ���Ϥ������ɡ�open 
�ʴĶ��Ǥϡ�����ϤǤ��ʤ���

���Ȥ���С�
    __code f(int a, int b : int h, ...) {
       ...
	goto g(a,b,c : d,e,f,...)
    }
�ߤ����ʷ��ǡ�stack ��˾褻���������������ɬ�פ����롣

����ϡ��ʤ�ʤ�?

    : �����ΰ����ϲ��Ѥ˽���ʤ�
    : �θ�ޤǤϲ��Ѥ˽����

�äƤ������Ȥ���

��¤�Τϡ������˼��Ȥ��Ƥ�..

�ޤ���...   �ΤȤ����ޤǥ쥸�����ǡ�����ʹߤϡ�����Ǥ�
��ʬ�����ɤ͡�������ˤ��衢ʣ�������뤳�ȤϳΤ���

      __code g(int c,__code (*n)(int a,int b,int d,...),...) {
	goto n(int d,int e,int c,...);
      }

�ǡ�����... �ϡ����٤ơ�Ʊ����Τ��֤������Ϥ��� ... ��
������⤢�뤬��

����¦��
	__code c(int d,int e,int c,int k,int j) {}
���������Ƥ���Ȥ��ˡ�k,j ���쥸�����˾�äƤ��뤫���Τ줺��
��äƤ����������ᡣ�ʤΤǡ����Ѥˤʤ���ʬ����������ɬ�פ����롣

Mon Nov 27 11:17:39 JST 2006

��ɡ�����n ������ȡ��ºݤ�n �����������뤳�Ȥ�����ʤ����͡�
	__code c(int d,int e,int c,...) {}
�ǡ������뤳�Ȥ⤢��С�
	__code c(int d,int e,int c,int k,int j) {}
�Ǽ����뤳�Ȥ⤢�롣���뤤�ϡ�
	__code c(int d,int e,int c,int k,int j,...) {}
�Ȥ��⡣

implements �Ȥ�������accetps �Ȥ�����������ʷ����̤�
����������Τ��ʡ�
    __code f(int a, int b : int h, ...) {
�Ǥ⤤�������...

Mon Nov 27 11:34:33 JST 2006

      __code f(int a,int b,...) {
	goto g(int c,__code *f,int a,int b,...);
      }

      __code g(int c,__code (*n)(...),...) {
	goto n(...);
      }


g ������Ȥ��ˡ�fp �ϡ�n ��Ƭ�ˤʤ���Фʤ�ʤ��������
��ư����Τϡ�f ����䡣�ФƹԤ��Ȥ��ˤϡ�b ��Ƭ��
��碌��ɬ�פ����롣����ϡ�g ����䡣g �ϡ�����Ƭ(fp)
���Τ�ʤ����顢����ϼ�äƤ���ɬ�פ����롣���Ǥ�
Ƚ�ǤǤ��ʤ���g ¦�Ǽ�äƤ������Ȥϲ�ǽ����������
���ˤ⡢f ¦���餺�餹�礭�����Ϥ�ɬ�פ����롣

�������Ƥ��ɤ�������ɤ�...
	goto g(int c,__code *f,__environment,interface &rest),
		__envronment+sizeof(interface);
      __code g(int c,__code (*n)(...),(void*)parent,...) {
	goto n(...),parent;
      }
�ߤ����ʷ��Ǥ�... �������������Τ��ʡ��˻������ɡ�: ��꤫�ޤ�?

: ��Ȥ���ˡ���ȡ�: �� fp �ߤ����ʴ����ˤʤ롣

�񤷤��͡����줤��syntax�ˤʤ�ʤ���

Wed Jul 25 14:48:16 JST 2007

inline code __goto �ߤ����ʷ��ˤ���ȡ�

    __goto  hoge();

goto �� reflection ����롣

meta �ʡ�interface �Ϥɤ������? 

�ǥե���Ȥǡ�,.... �����äƤ���Ȼפ������ɤ���

     goto hoge(hoge.... , __code (*cont)(i) : meta ...);

             goto cont(i);  -> goto cont(i: meta...);

�Ȥ���������?  ���줬�ʤ��ȡ����Ҥ����ʤ����ݡ�subroutine �Ȥ�
�㤦��?

env �����ؤ�����������ʤ���? ����뤱�ɡ��˻��ʤΤ���

gcc �Ȥ��������ɤ��ʤ��Τ���...

__code ���������Ĥ餹���롣script ���������뤫��compiler ��
��ư��褹�������ɤ���

tcc ������  goto f(); �ǤϤʤ��ơ�goto (*f)(); ��
�������롣����ϡ����ä��������ɤ�������

 ... �äƤΤ�����ѿ��ߤ����ʤ�Τ����? ������stack scope �����롣
�ʤΤǡ�sub routine ��Ʊ���ʤΤǤ�?