�ץ�����ߥ󥰸���Ȥϥ����ƥಽ�����о�ʪ����ݲ���������ԥ塼���ǽ�����ǽ�ʥ����ɤòµ½Ò¤ï¿½ï¿½ë¤¿ï¿½ï¿½ï¿½ï¿½Ñ¤ï¿½ï¿½ï¿½Í¹ï¿½ï¿½ï¿½ï¿½ï¿½Ç¤ï¿½ï¿½ë¡£ï¿½×¥ï¿½ï¿½ï¿½ï¿½ï¿½ß¥ó¥°¸ï¿½ï¿½ï¿½Ï¥ï¿½ï¿½ï¿½Ô¥å¡¼ï¿½ï¿½ï¿½Îµï¿½ï¿½ï¿½ï¿½ï¿½È°ï¿½ï¿½Ð°ï¿½ï¿½ï¿½Ð±ï¿½ï¿½ï¿½ï¿½Ã¤ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ö¥é¤«ï¿½ï¿½Ï¤Þ¤ê¡¢ï¿½ï¿½ï¿½ï¿½Ñ¥ï¿½ï¿½ï¿½ï¿½ï¿½Ñ¤ï¿½ï¿½Æµï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ë¤³ï¿½È¤ï¿½ï¿½ï¿½ï¿½ï¿½È¤ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ñ¥ï¿½ï¿½ï¿½ï¿½ï¿½ì¡¢ï¿½ï¿½ï¿½ó¥¿¥×¥ê¥¿ï¿½È¸Æ¤Ð¤ï¿½ï¿½×¥ï¿½ï¿½ï¿½ï¿½ï¿½à¤¬ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½É¤ï¿½ï¿½á¤·ï¿½Â¹Ô¤ï¿½ï¿½ë¥¹ï¿½ï¿½ï¿½ï¿½×¥È¸ï¿½ï¿½ï¿½È¡ï¿½ï¿½ï¿½ï¿½Ò¤Ç¤ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ù¤ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ø¤È¿Ê²ï¿½ï¿½ï¿½ï¿½Æ¤ï¿½ï¿½ï¿½ï¿½ï¿½
�ץ�����ߥ󥰸���Ϥ���¸����ͳ���顢�������٤ι⤤���Ҥ��Ԥ��뤳�ȡ����Ф䤤��ȯ��Ԥ�����������롣����٤ι⤤���ҤȤϡ��ץ�����ब�ɤ�����������Ԥ���(HOW)�ǤϤʤ����ν�����Ԥ���(WHAT)�òµ½Ò¤ï¿½ï¿½ä¤¹ï¿½ï¿½ï¿½ï¿½Ê¸ï¿½ï¿½ï¿½ï¿½Ç½ï¿½ï¿½ï¿½ï¿½Ã¤Æ¤ï¿½ï¿½ë¤³ï¿½È¤ò¡¢¤ï¿½ï¿½Ð¤ä¤¤ï¿½ï¿½È¯ï¿½È¤Ïµï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Î¹â¤µï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½É¤ï¿½Ì©ï¿½Ù¤Î¹â¤µï¿½ï¿½ï¿½Ð¥ï¿½ï¿½ï¿½È¯ï¿½ï¿½ï¿½ï¿½ï¿½Ë¤ï¿½ï¿½ï¿½ï¿½ï¿½Ê¸ï¿½ï¿½ï¿½ï¿½Ç½ï¿½ï¿½ï¿½ï¿½Ã¤Æ¤ï¿½ï¿½ë¤³ï¿½È¤ò¤µ¤ï¿½ï¿½ï¿½
��������٤ι⤤���ҡ����Ф䤤��ȯ��Ԥ�˸���ˤʤ�Τ������ΰ�δ����Ǥ��롣�����ΰ��ưŪ���ݤ�Ԥ����ʤɡ�����ԥ塼������ݲ�����Ƥ��ʤ���ʬ��ľ�ܥץ�����ޤ�����ɬ�פ������롣�����ΰ�������ΰ��������������������˺��ˤ�����꡼���ʤɤΥХ��Ⱦ���٤��碌�Ǥ��롣��������Ϥι�ʸ�ڤʤɡ�ʣ���ʻ��Ȥ��Ԥ��Ƥ���ǡ�����¤�ǤϤȤ��˵����ΰ�γ���������Ȥʤ롣
������������褹�뤿��ε��������١������쥯�����Ǥ��롣���١������쥯�����ϵ����ΰ��ưŪ���ݡ���������ݲ������ץ�����ޤ�����Ū�˴�����Ԥ�ɬ�פ򸺤餹���ܸ���Ǥϡ����١������쥯������LISP�Ȥ����ץ�����ߥ󥰸�������Ϥ˼������뤳�Ȥˤ�ꡢ������ˡ�ʤɤθ�Ƥ��Ԥä���
���١������쥯������GC��ά���ˤϥץ�����ߥ󥰸�������ϡʰʲ���������ϡˤΰ����⤷���ϥ饤�֥��Ȥ����󶡤���롢ưŪ�˳��ݤ��������ΰ�Τ������Ѥ���Ƥ��ʤ������ΰ��ưŪ�˲�����������Ѥޤ��ϳ�����Ԥ������Ǥ��롣
GC��Ƴ�����뤳�Ȥˤ��ץ�����ޤϼ�ư�Ǥε����ΰ�δ������鳫������롣
GC�϶�ǯ�θ�������ϤǤ�ɬ�ܤε�ǽ�Ȥ����󶡤���Ƥ��뤬�������װ��Ȥ��Ƥϡ�
�ʤɤ��ͤ����롣
�㳰�Ȥϥץ������¹���ˤ��������Թ��������뤿���ʬ���Ǥ��롣���Թ���н褵���Ȥν��������Ф褤�����ե���������ʤɤλ񸻳��ݤμ��Ԥʤɼ���֤��ΤĤ��ʤ����Թ���Ф��ƤϽ����η�³�򤢤����ʤ���Фʤ�ʤ������ξ�硢����ޤǤν����dz��ݤ����񸻤γ���������Ȥʤ롣
�����Ǥ�GC��¸�ߤ��㳰�����Ѥ����ץ�����ߥ󥰤ˤɤΤ褦�ʱƶ���Ϳ���뤫��Ҥ٤롣�ץ���������Ȥ���C++��Java�򤢤����㳰�����Ѥ����ץ������Ȥ��ƥ��󥹥ȥ饯�����㳰��ȯ�������륯�饹��������롣
Figure 1.��Figure 2.�ϥե������������륯�饹�����Ѥ����ץ������Ǥ��롣
C++��ɸ��饤�֥��Ͻ������Ǥ��㳰��ȯ�������뤳�Ȥ�̵�����ᡢ�̾���㳰��ȯ�������ʤ�Figure 1.�Τ褦�ʥץ�����ߥ󥰥������뤬��ή�Ǥ��뤬�������Ǥ�Figure 2.�Τ褦�˰տ�Ū���㳰��ȯ������Ĥ��Ƥ��롣Figure 2.�����Ƥ��㳰����ª���ƥ��󥹥ȥ饯�������㳰��ϳ��ʤ��褦���Ҥ��Ƥ��롣
C++�Ǥϥ��󥹥ȥ饯�����㳰��ȯ�����ƽ��������Ǥ��Ƥ��ޤä����˥ǥ��ȥ饯�����ƤӽФ���ʤ��Ȥ���Í̾�ʥХ���¸�ߤ��롣�ޤ����ǥ��ȥ饯�����㳰��ȯ��������硢�㳰���饹������㳰��ȯ���������Ƹ����ñ¤·¤ï¿½ï¿½Ð¥ï¿½ï¿½Ë¤Ê¤ë¡£ï¿½ã³°ï¿½ï¿½ï¿½é¥¹ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ã³°ï¿½ï¿½È¯ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½É½Åªï¿½ï¿½ï¿½ï¿½È¤ï¿½ï¿½Æ¤Ï¡ï¿½bad_alloc�㳰��ȯ�����������ǡ��㳰���֥������Ȥ�������뤿���new��Ȥ�������bad_alloc��ȯ����������ʤɤ����롣�����ΥХ���ȯ�����뤳�Ȥ��ñ¤·¤ï¿½ï¿½ï¿½
���Τ��ᡢ���󥹥ȥ饯�����ǥ��ȥ饯���ν������㳰�ˤ�����Ǥ��뤳�Ȥϵ�����ʤ����ĤޤꡢC++�Ǥ��㳰����(�㳰��ȯ�����Ƥ���������Ǥ���ʤ�����)�ʥ��󥹥ȥ饯�������饹��������뤳�Ȥ������ʥץ��������������ɬ�׾��Ǥ��롣�����Τ��Ȥ��顢C++���㳰�Ȥ��������������줿��������㳰�����Ѥ��뤿��λ񸻴�����ץ�����ޤ˶�����褦�ˤʤäƤ��ޤä�����
�����ϻ񸻴�����ץ�����ޤ��Ԥ�ɬ�פ��������롣GC��¸�ߤ���Ф��Τ褦�˻񸻤β����ˤĤ������դ�����륳���Ȥ��ڸ�����롣
#include <iostream>
#include <fstream>
#include <string>
class file_io {
private:
std::ifstream *ifs_;
std::ofstream *ofs_;
bool is_fail_;
public:
file_io() : is_fail_(false), ifs_(NULL), ofs_(NULL) {}
file_io(std::string input_file, std::string output_file)
: is_fail_(false) , ifs_(NULL), ofs_(NULL)
{
ifs_ = new std::ifstream();
ofs_ = new std::ofstream();
if (ifs_ == NULL || ofs_ == NULL) {
is_fail_ = true;
return ;
}
ifs_->open(input_file.c_str());
ofs_->open(output_file.c_str());
if (ifs_->fail() || ofs_->fail()) {
is_fail_ = true;
}
}
~file_io() { delete ifs_; delete ofs_; }
bool fail() { return is_fail_; }
/* and more definitions ... */
};
int main(int argc, char **argv) {
if (argc < 3) { return -1; }
file_io fio = file_io(argv[1], argv[2]);
std::cout << fio.fail() << std::endl;
}
#include <iostream>
#include <fstream>
#include <string>
#include <new> // new �黻�Ҥ��㳰ȯ������Ĥ���
class file_io {
private:
std::ifstream *ifs_;
std::ofstream *ofs_;
bool is_fail_;
public:
file_io() : is_fail_(false), ifs_(NULL), ofs_(NULL) {}
file_io(std::string input_file, std::string output_file)
: is_fail_(false) , ifs_(NULL), ofs_(NULL)
{
try {
ifs_ = new std::ifstream();
ofs_ = new std::ofstream();
} catch (std::bad_alloc) {
is_fail_ = true;
return ;
}
// �㳰����Ĥ���
ifs_->exceptions(std::ios_base::failbit);
ofs_->exceptions(std::ios_base::failbit);
try {
ifs_->open(input_file.c_str());
ofs_->open(output_file.c_str());
} catch (std::ios_base::failure) {
is_fail_ = true;
}
}
~file_io() { delete ifs_; delete ofs_; }
bool fail() { return is_fail_; }
/* and more definitions ... */
};
int main(int argc, char **argv) {
if (argc < 3) { return -1; }
file_io fio = file_io(argv[1], argv[2]);
std::cout << fio.fail() << std::endl;
}
Figure 3.��Java�Ǥ���Ǥ��롣���Υץ������Ǥ�FileIO���饹�Υ��֥������Ȥ�����Ȥ��˥��󥹥ȥ饯�����ƤФ�롣���󥹥ȥ饯���ϥե�����̾������˼�ꡢFileInputStream��������롣�ե����뤬¸�ߤ��ʤ����ˤ�java.io.FileNotFoundException��ȯ�����롣Java�Ǥϥ��󥹥ȥ饯����Ǥ��㳰�θƤӽФ�������Ƥ�ǥ��ȥ饯���Ժߤˤ褦����꡼����GC��¸�ߤ��뤿��ȯ�����ʤ���
import java.io.*;
class FileIO {
FileInputStream fis;
FileOutputStream fos;
FileIO(String input, String output)
throws Exception
{
fis = new FileInputStream(input);
fos = new FileOutputStream(output)
}
}
class ExceptionWithGC {
static public void main(String[] args) {
try {
FileIO fio = new FileIO(args[0], args[1]);
} catch (Exception e) {
System.out.println("Exception occurred");
System.out.println(e);
}
}
}
ʸ����γ�ĥ�����󤲤롣Java�Ǥ�ʸ����γ�ĥ��C�Ǥγ�ĥ����򼨤���
Figure 4.��ɸ�����Ϥ�����ʸ������ɤ߹���ץ������Ǥ��롣
���Υץ������ϰ�ʸ���ɤ߹������Хåե����ĥ���ơ���ʸ���ɲä��Ƥ��������Ԥ⤷����EOF��ã�����顢�Хåե�����strdup��ʸ�����ʣ����������ʣ������ʸ������֤��Ƥ��롣
C�Υץ������Ǥ�ʸ����ؤ�ʸ�����ɲäȵ����ΰ�δ�����ʬΥ�Ǥ����ˡ�����ΰ�̣������Ƥ��ޤäƤ��롣
#include <stdio.h>
#include <stdlib.h>
/* read line */
char *freadline(FILE* in)
{
char *buffer, *tmp;
int c;
buffer = malloc(1);
if (buffer == NULL) goto END;
buffer[0] = ��\0��;
while ((c = fgetchar(in)) != EOF) {
tmp = realloc(buffer, strlen(buffer) + 2);
if (tmp == NULL) break;
buffer = tmp;
tmp = tmp + strlen(buffer);
*tmp++ = c;
*tmp = ��\0��;
if (c == ��\n��) break;
}
END:
return buffer;
}
int main(void)
{
char * line = readline(stdin);
printf(��%s��, line);
free(line);
}
Figure 5.��Figure 4.��Java�ǽ�ľ�����ץ������Ǥ��롣
��ʸ���ɤ߹��ऴ�Ȥ˲��Ѥ�ʸ�����ʸ�����ɲä��Ƥ��������ʬ�ɤ߹���������Ĺʸ���󤫤�ʸ������Ѵ���Ԥäơ�ʸ������֤��Ƥ��롣���Υץ������Υ���������ϥ��������ԤäƤ�����ʬ�ϱ��ä��졢���ˤ狼��䤹�������������ɤȤʤäƤ��롣
class ReadLine {
static public String readline(InputStream is) {
StringBuilder sb = new StringBuilder();
int ch = 0;
while((ch = is.read()) != -1 || ch == '\n') {
sb.appned((char)ch);
}
return sb.toString();
}
static public void main(String [] args) {
Stirng line = ReadLine.readline(System.in);
System.out.println(line);
}
}
������Ǥϥץ������ε���������������������֤��Ƥ��롣�ºݤΥץ�����೫ȯ�Ǥϥץ��������ݼ顢��ĥ�ʳ��Ǥ�����Ĥ����Ǥ��礤�˱ƶ����Ƥ��롣�ݼ��Ԥ��ˤ��ݼ餹��ץ�����������ɬ�פȤʤ롣Figure 5.�Τ褦�˵����ΰ�δ��������ä���Ƥ���ȡ�����Υץ������ΰ�̣�����򤷤䤹���ʤ롣
������Ĥ���ΤȤ��ꡢGC�����Ѥ��뤳�Ȥˤ��ץ�����ߥ󥰤μ�֤������˾ʤ��졢GC�Τʤ���������ϤǤϹԤ��ˤ�������Ū�ν������������ܤ����ץ�����ߥ󥰤����ѤǤ���褦�ˤʤ롣
�ޤ������������GC�˰�Ǥ���뤳�Ȥˤ�ꡢʸ�������ʤɤ������䤹���ץ�����ޤΥߥ��ˤ�������ΰ�ؤΥ�����������������ΰ�γ������ΰ����ų���������꡼����ڸ��Ǥ��뤳�Ȥ�Ǥ��롣������ˤ�ꡢ��������ѥ����ɤ�ɬ�פʤ��ʤ뤳�Ȥˤ�륽���������ɤδʷ餵�θ��塢�����Ϣ�ΥǥХå��Υ����Ȥηڸ��ʤɳ�ȯ��Ψ�θ��夬�����롣
����Ū��malloc/free�����Ѥ�����ư�ǤΥ�����������GC����������®�٤��٤��ȹͤ���줬����������ϴְ㤤�Ǥ��롣���곫���Υ����Ȥ��Ѳ�����ΤǤϤʤ�����ư�ǥ��������Ԥ������Ȥ�ʬ�����뤫��GC�����Ѥ��ƽ��椷�ƹԤ����κ��Ǥ��롣�������äơ�®�٤Τ褷������ʬ��������ˤ����åȤ���Ӥ�������˰�¸���롣
����Ȥ��̤ˡ�����ξ�ﲼ�Ǥ�GC��malloc/free�ȤǤ�®�٤κ��������˸�����㤬���롣
GC��®�٤��Ǥ���Ȥ��Ƥ�malloc/free�μ����˼��Ԥ��Ƥ��Ƥ����礬���롣�̾�GC�Ǥϵ���ʵ����ΰ����ݤ��Ƥ����ΰ�Τ���ɬ�פ��ΰ��GC���ڤ���ꤷ�ƴ�����Ԥ������Τ���malloc/free�μ����˺������줺�������ǽ���������ǽ�����⤤��
malloc/free���ᤤ��Ȥ��Ƥϡ����̤ε����ΰ�����Ѥ�������ˤ��ε����ΰ�ΤۤȤ�ɤ����Ѥ������Ǥ��롣���ξ�硢GC��ȯ�������٤����̤ε����ΰ���������ʤ���Фʤ�ʤ������ξ�硢malloc/free��ɬ�פʤ��ΰ��������������ˡ��®�٤������롣
���Τ褦�ˡ����򤽤�����к��������뤬�������Ȥ������̤�Ϥ��������ˤ��뤿�ᡢ�������줿�����ǤϺ��������ʤ��ȹͤ��뤳�Ȥ��Ǥ��롣
GC�δ���Ū�ʥ��르�ꥺ����ç¤ï¿½ï¿½Ê¬ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ä¤ï¿½Ê¬ï¿½ï¿½ï¿½ï¿½ï¿½ë¡£
���ȥ������(Reference counting)�ϥ��֥������ȡ�ưŪ�˳��ݤ��������ΰ��ñ�̡ˤ����Ȥ���Ƥ�����򸵤��ΰ�γ�����Ԥ�GC�Ǥ��롣���ƤΥ��֥������Ȥ��Ф��ƻ��ȥ�����ȤȸƤФ�������ͤ��ղä��롣���ȥ�����Ȥϥץ���������Τˤ��Υ��֥������Ȥ�ؤ������ݥ��󥿤�������¸�ߤ��뤫��Ͽ�����Τǡ��ѿ��������ʤɤˤ�ä��Ѳ����롣�����ơ����λ��ȥ�����Ȥ�0�ˤʤä���硢�Ĥޤꡢ�ɤ�����⻲�Ȥ���ʤ��ʤä����ˤ��Υ��֥������Ȥ�������Ȥ�����ΤǤ��롣
���ȥ�����Ȥ������Ȥ��Ƥϰʲ��Τ��Ȥ��������롣
�դ˷����Ȥ��Ƥϡ�
�ʤɤ������롣
Tracing collectors�ϼ��Τ褦���ʳ���ޤ�GC�ǡ�����Ū��GC�ȸƤФ�Ƥ���ΤϤ�����Υ��르�ꥺ��Ǥ��롣
Tracing collectors��̾���ΤȤ��ꥪ�֥������Ȥ˴ޤޤ��ݥ��󥿤�ȥ졼���������Ѥ��Ƥ��륪�֥������ȡ����Ƥ��ʤ����֥������Ȥ�Ƚ�̤��롣���ΤȤ����ȥ졼���ΤϤ���Ȥʤ륪�֥������Ȥ�롼��(Root)�ȸƤӡ���ã�Ǥ������֥������Ȥϥץ�����ब������Υ��֥������ȡ���ã�Ǥ��ʤ��ä����֥������ȤϤ��ߤȤߤʤ������Ԥ����������äơ����르�ꥺ��β���ʳ��Ǥϳ��ݤ������ƤΥ��֥������Ȥ˲��餫����ˡ�ǥ��������Ǥ���ɬ�פ����롣
�ȥ졼���Υ��르�ꥺ��ˤϥޡ�������ɥ�������(Mark and Sweep)�����ԡ�(Copying)�Ȥ�����Ĥ���ˡ��¸�ߤ��롣
�ޡ�������ɥ������פϥȥ졼���ʳ��Ȳ���ʳ������Τ�ʬ���줿���르�ꥺ��Ǥ��롣
���르�ꥺ��1�Υȥ졼���ʳ��Ǥϥ롼�Ȥ�����ã�Ǥ��륪�֥������Ȥ˰���Ĥ��Ƥ�����
���르�ꥺ��1�β���ʳ��Ǥϡ����ƤΥ��֥������Ȥ�Ĵ�٥ޡ����ΤĤ��Ƥ��ʤ����֥������Ȥ������롣
�ޡ�������ɥ���������GC�������Ȥ��Ƥϰʲ��Τ��Ȥ��������롣
�����Ȥ��Ƥϡ�
�ʤɤ����롣
����ʸ�ǤϤ��Υޡ�������ɥ������פ������Ǥ����ݼ�Ū�ޡ�������ɥ������פ����Ѥ��Ƥ��롣�ݼ�Ū�ޡ�������ɥ������פˤĤ��ƤϽ����Ϥμ����ι�Ǻ��ټ��夲�롣
���ԡ����ΰ��Ⱦʬ�ˤ���GC��Ԥ����르�ꥺ��Ǥ��롣
���르�ꥺ��1�Υȥ졼���ʳ��Ǥϥ롼�Ȥ�����ã�Ǥ��륪�֥������Ȥ򿷤����ΰ�˥��ԡ����Ƥ������ȥ졼��������ꡢ����������ƤΥ��֥������Ȥ򿷤����ΰ�˥��ԡ��Ǥ����顢�Ť��ΰ����Ƥ��˴�����(���르�ꥺ��1�β���ʳ�)��
���֥������Ȥ��ư�����뤿�ᡢ�ݥ��󥿤��դ��ؤ���Ԥ������ץ��������Ǥϥݥ��󥿤Ȥ��̤�ID���Ѥ���ɬ�פ����롣
���ԡ�GC�������Ȥ��Ƥϰʲ��Τ��Ȥ��������롣
�����Ȥ��Ƥϡ�
�ʤɤ����롣
���Ѥ��Ƥ��륪�֥������Ȥ򤿤ɤ���ˡ�Ȥ��̤ˡ����Ѥ��Ƥ��륪�֥������Ȥ�Ƚ��ˡ�ˤĤ������Τ�GC(precise GC)���ݼ�ŪGC(conservative GC)�Ȥ������̤����롣
���Τ�GC�ϡ�������Υ��֥������Ȥ����Τ˵�ᡢ���Ѥ��Ƥ��ʤ����֥������Ȥ����Ʋ������GC�Ǥ��롣�̾�GC�Ȥ��������Τ�GC�򼨤���
�ݼ�ŪGC��������餷��ۣ��ʥ��֥������Ȥ��ݻ����Ʋ����Ԥ�ʤ�GC�Ǥ��롣����Ū�ˤϥ��֥������ȤΥ롼�Ȥ˴������륪�֥������Ȥ��ΰ�(�ҡ��פʤ�)�򤵤��ݥ��󥿤��˴ޤޤ줿���ˤϡ����Υݥ��󥿤��������֥������Ȥβ���ϹԤ�ʤ��ʤɤ����ˤ�Τ롣��̤Ȥ������襴�ߤǤ��륪�֥������Ȥ��ݻ����Ƥ��ޤ��������Υ��֥������Ȥ�̵���ʥݥ��󥿤򤵤����ȤϤʤ��ΤǼ㴳�Υ���꡼���������뤬��ñ��ʳ��˰����Ǥ��롣�̾�롼�Ȥϥ쥸�����������å�������ΰ衢�ҡ����ΰ�ʤɤ����뤬����������Ƥ�ۣ��Ȥ����ݼ�ŪGC��Ԥ������ä����ݼ�(fully conservative)��������ۣ��Ȥ��ƹԤ�����Ⱦ�ݼ�(partially conservative)�Ȥ�����
�ݼ�Ū�����ΤȤ����ͤ����ϵ����ΰ��ޡ����������ˤǤ��뤿�ᡢ����Ū�ʥ��르�ꥺ��ϵ��ꤷ�ʤ���
�ݼ�ŪGC�ϥޡ�������ɥ�������GC���Ȥ߹�碌�����Ѥ���뤳�Ȥ�¿�����ޤ�������GC�򥵥ݡ��Ȥ��ʤ�C�ʤɤθ���Ǥμ������ưפǤ��뤿�ᡢRuby�ʤɤθ�������ϤǤϤ����ݼ�Ū�ޡ�������ɥ�������GC�����Ѥ���Ƥ��롣
�ܸ���ǤϤ��ޤ��ޤ�GC�θ�Ψ��Ĵ�٤뤿��˥ץ�����ߥ󥰸�����ꡢGC��������롣�����ƥ٥���ޡ����ƥ��Ȥˤ�ä���Ӥ�Ԥ��������ǡ�GC����ǽ��ȿ�Ǥ���䤹���������䤵������¤����LISP������������
LISP(LISt Processing��ά)��1958ǯ�˥���󡦥ޥå��������ˤ�ä�ȯ�����줿�ץ�����ߥ󥰸���Ǥ��롣�����黻�η׻���ǥ���ξ��ɽ�����뤿��ε�ˡ��FORTRAN�ξ�˰ܿ����뤳�Ȥˤ����LISP���󥿥ץ꥿������������
����LISP��Common Lisp��Scheme�Ȥ�����Ĥ���������ή�Ǥ��뤬�������Ǥ�LISP���Ƥ����ƤϤޤ��������夲�롣
LISP�ǰ����ǡ�������ǡ��ͤ��Τ�Τ򼨤��ǡ�����Atom�ȸƤ֡�Atom�ˤ�̾���򤢤�魯����ܥ�(Symbol)�������͡����ͤ�ɽ���������Τ�Ρ�ʸ���󡢴ؿ��򤢤�魯�ץ���������(Procedure)�ʤɤ��ޤޤ�롣
Atom��LISP�ץ�������ľ�ܥ�ƥ��Ȥ��Ƶ��ҤǤ�����(���͡�ʸ������)�䡢LISP�μ���¹Ԥ�����̤Ȥ����������Ρʥ���ܥ롢�ץ���������ˡ�����¾LISP�����Ϥγ�ĥ���Ѱդ��줿�ǡ�����¤�ʤɤ��ޤޤ�롣
��ƥ��⤷���ϼ� | �¹Ԥ������ | Atom�μ��� |
---|---|---|
10 | 10 | ���� |
"the string" | "the string" | ʸ���� |
'symbol | symbol | ����ܥ� |
(quote symbol) | symbol | ����ܥ� |
(lambda (x) x) | procedure(���餫������ɽ��) | �ץ��������� |
LISP�ˤϤ⤦�ҤȤ�Cons Cell(�⤷����Pair)�ȸƤ֥ǡ�����¸�ߤ��롣Cons Cell����ĤΥǡ�����ޤȤ��ǡ����Ǥ��롣Cons Cell����Ƭ��Car�ʥ����ˡ��Ǹ��Cdr(������)�ȸƤ֡�Car��Cdr��Atom�� Cons Cell�ɤ���Υǡ����⼨�����Ȥ��Ǥ��롣
A��B��Cons�ʤ⤷����Pair�ˤȸ��ä���硢Car��A��Cdr��B�򼨤�Cons Cell�Τ��Ȥ������Cons Cell��������뤳�Ȥ�cons����ȸ�����
LISP�ϥץ������ε���ˡ��S��(Symbol-Expression)�ȸƤФ�ëµï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ñ¤ï¿½ï¿½Æ¤ï¿½ï¿½ë¡£S���ϼ��Τ褦���������롣
S�� ::= Atom S�� ::= S����S����Cons
S����Atom��ޤबcons����Ƥ����Τ�Atom�ǤϤʤ���S���òµ½Ò¤ï¿½ï¿½ï¿½ï¿½ç¡¢ï¿½ï¿½Æ¥ï¿½ï¿½É½ï¿½ï¿½ï¿½Ç¤ï¿½ï¿½ï¿½Atom�Ϥ��Τޤ޵��Ҥ���Cons Cell�ϥɥå���(A . B)�Τ褦��ɽ�����롣A��Car��B��Cdr�ˤ����롣
LISP�Ǥ�Cons Cell��ɥå��Ф�ɽ������S�����⼡�Τ褦��Ϣ³����". ("���б�����")"���ά�����ꥹ��ɽ���������Ѥ��롣�ꥹ��ɽ�����줿S���Τ�����(<S��> ... <S�� n>)�Ȥ������ˤʤäƤ����Τ�ꥹ�ȤȸƤӡ��ꥹ�ȤκǸ夬�ɥå��ФˤʤäƤ����Τ�ɥåȥꥹ�ȤȸƤ֡�
S�� | �ꥹ��ɽ�� | ���� |
---|---|---|
(a . b) | (a . b) | �ɥåȥꥹ�� |
(a . (b . c)) | (a b .c) | �ɥåȥꥹ�� |
(a . (b . ())) | (a b) | �ꥹ�� |
((a . b) . (c . (d . e))) | ((a . b) c d . e) | �ɥåȥꥹ�� |
((a . b) . (c . (d . ()))) | ((a . b) c d) | �ꥹ�� |
((a . (b . ())) . (c . (d . ()))) | ((a b) c d) | �ꥹ�� |
���̤���Ȥ��Ƥϡ�����ʤ��ꥹ�Ȥ�nil��Common Lisp�Ǥ�ɽ�����˥�ˤ�()��Scheme�Ǥ�ɽ�������ꥹ�ȡˤʤɤ�ɽ����nil��()��Atom�Ǥ⤢�롣
LISP�Ǥ�S���ʥꥹ�Ȥ�Atom�ˤ򼰤Ȥ���ɾ��(Eval)���Ƥ�����ɾ���Ȥϼ������ͤ���뤳�Ȥ������LISP�Ǥϼ��μ���˱����Ƽ��Τ褦��ɾ����Ԥ���
���μ��� | ɾ������ˡ |
---|---|
�ꥹ�� | (<�ؿ�> <����> ... <����>)�Τ褦�ʴؿ��ƤӽФ��Ȥߤʤ���ɾ�����롣 |
����ܥ� | ����ܥ���б��դ���줿�ͤ���Ф��� |
����ܥ�ʳ���Atom | Atom���Ȥ��֤��� |
�ؿ��ˤϰ��������Ƥ�ɾ�����ʤ��ü����(special form, macro)�Ȱ���������ɾ������ץ��������������ब¸�ߤ��롣�ؿ��˰������Ϥ����ͤ���뤳�Ȥ������ؿ���Ŭ��(apply)���롢�⤷����ñ��Ŭ������ȸ�����
��ɽŪ���ü�����ˤ�quote��set!��cond��lambda�ʤɤ�¸�ߤ��롣��ʸ(syntax)�Ȥ�ƤФ�롣
quote������ɾ�������ˤ��Τޤ��֤��ü�����Ǥ��롣�������ĤȤ롣�ꥹ�Ȥ�ǡ�����¤�Ȥ��ư���������硢����ܥ뼫�Τ���Ф��������ʤɤ����Ѥ��롣'(��������)�����Ѥ�����ά��ˡ�򥵥ݡ��Ȥ���LISP�����Ϥ�¿����
(quote 10) ; =>10
(quote a) ; => a
(quote (this is the list)) :=> (this is the list)
'symbol ; => symbol
'(another list) ; => (another list)
set!�ϥ���ܥ���ͤ��б��դ����ü�����Ǥ��롣�������Ȥ롣�������ϥ���ܥ��Ȥꡢ���������ɾ�������ͤ��������Υ���ܥ���б��դ��롣�ʤ�LISP�Ǥ��ͤ򥷥�ܥ���б��դ��뤳�Ȥ�«������Ȥ�����
(set! a 10)
a ; => 10
(set! b '(the list))
b ;=> (the list)
cond��ʬ����ɽ���ü�����Ǥ��롣ʣ���ΰ�����Ȥꡢ�����ι�¤�ϼ��Τ褦�ˤʤäƤ���ɬ�פ����롣
(cond <condition clause1> <condition clause> ...)
<condition clause n> := (<condition> <expression> ...)
cond�Ǥ�<condition clause>����֤�ɾ�����Ƥ�����<condition clause>�Τ�����<condition>��ɾ�����ƿ��򼨤��ͤǤ����³��<expression>����֤�ɾ������<condition>�����򼨤��ͤǤ����³��<expression>��ɾ�������˼���<condition clause>��ɾ�����롣
�Ǹ��<condition clause>��<test>��else�ʤɤ����̤ʥ���ܥ뤬�Ȥ�����������Ƥ��ꡢ���ξ���̵����³��<expression>��ɾ������롣
(set! a 10)
(cond ((<= 1 a) 1)
((= 0 a) 0)
(else -1)) ; => 1
(set! b -1)
(cond ((<= 1 b) 1)
((= 0 b) 0)
(else -1)) ; => -1
lambda�ϥץ�������������ü�����Ǥ��롣�������ˤϥץ���������ΰ����Υꥹ�Ȥ���������ʹߤˤϥץ������������Ȥòµ½Ò¤ï¿½ï¿½ë¡£ï¿½×¥ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Æ¤Ó½Ð¤ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ï¡ï¿½ï¿½ï¿½È¤Î¤ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ÖºÇ¸ï¿½ï¿½É¾ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Í¤ï¿½ï¿½Ö¤ï¿½ï¿½ï¿½lambda���Ȥ������
(lambda (x) x) ; => procedure
(set! identity (lambda (x) x))
(identity 10) ; => 10
((lambda (x y) (+ x y)) 10 20) ; => 30
((lambda (x y) x (+ x y) y) 10 20) ; => 20
�ץ�����������ü�����Ȥϰۤʤ������ɾ����ԤäƤ���ؿ����ͤ����ؿ��Τ��ȤǤ��롣�ץ���������ˤ��ç¤ï¿½ï¿½Ê¬ï¿½ï¿½ï¿½ï¿½Cons Cell���������cons����§�黻��+��*����Ӵؿ�<�Ȥ��ä���������Ϥ��Ȥ߹��ޤ�Ƥ����Ȥ߹��ߥץ���������ȡ��ץ�����ޤ�lambda���Ǻ�����������ץ������������Ĥμ��ब¸�ߤ��롣
�ץ���������Ǥ����Ƥΰ�����ɾ�����Ƥ���ؿ���ɾ����Ԥ����ᡢ�ü�����Ȱۤʤ깽ʸ�ǤϤʤ���LISP�ˤ��ü�����ȥץ���������������δؿ�����¸�ߤ��ʤ��Ȥ⤤���롣
(set! a 10)
(cons 'a 'b) ; => (a . b)
(cons a (cons 'b nil)) ; => (10 b)
(* a 4) ; => 40
(< a 2) ; => ����ɽ����(nil��#f�ʤ�)
(+ a (* 3 4)) ; => 22
(set! add-1 ((lambda (x) (lambda (y) (+ x y))) 1))
(add-1 10) ; => 11
LISP�Ǥ�C����ʤɤǸ����������פ�Ķ��ȸƤӡ��ޤ����ֳ�¦�δĶ���ȥåץ�٥�(Top-Level)�ȸƤ֡�LISP�Ǥ�lambda�Ǻ�������ץ���������Τߤ��������Ķ���������롣
�ץ���������Ϻ������줿�Ȥ��δĶ���������ץ��������㤬���IJ������ȡ��°�����«����������Ĥޤ�ɾ��������˺������줿�Ȥ��δĶ����ĥ������ǿ������Ķ���������롣
���ߤ�LISP�Ǥϥ����ƥ��å��������פ����Ѥ���Ƥ��뤬�������ƥ��å��������פ�������줿���δĶ���ץ��������㤬��¸���뤳�Ȥˤ��¸����Ƥ��롣Figure 23��x��y�ʤɡ��ȥåץ�٥�ʳ����������Ƥ���lambda�β������ȤʤäƤ����ѿ���ì¥ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ñ¿ï¿½ï¿½È¸Æ¤Ö¡ï¿½
�ì¥ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ñ¿ï¿½x��(lambda (y) (+ x y))����������ץ��������㤬�˴������ޤǥץ�������������Ⱦ�ʵ�Ū�����ѤǤ��뤬�����Τ褦�˥ì¥ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ñ¿ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ñ¤ï¿½ï¿½Æ¤ï¿½ï¿½ï¿½×¥ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ã¤Ë¥ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½È¸Æ¤Ö¡ï¿½
GC��LISP��Ʊ�����������������Ǥ��롣LISP�Ǥϥץ��������ɤ߹��ߡ��ꥹ�Ȥ�����������Υꥹ�Ȥ�ɾ�����ƥץ�������¹Ԥ��롣ɾ��������Υꥹ�Ȥ䡢ɾ�������Ѥ�������ΰ�Ϥ��ߤȤʤ뤬��LISP�Ǥϥץ�����ޤ�����Ū�˥������ݡ�����������ˡ���Ѱդ���Ƥ��ʤ����ᤳ���Τ��ߤϤ�����Ϸ׻����λ񸻤򿩤��Ĥ����Ƥ��ޤ��������������Υꥹ�Ȥ�������Cons Cell��Atom�Ϥ��ߤȤʤäƤ�����Ѥ���ǽ�Ǥ���ΤǺ����Ѥ�Ԥ���
LISP�ʳ��Υ��󥿥ץ꥿�θ�������Ϥ�Ʊ�ͤ˥ץ��������ɤ߹��ߡ��¹Ԥ���ݤ˸�����Í�Υǡ�����¤(ʸ���󡢥ե�����ݥ��󥿡���ʸ�ڤʤ�)��������롣�����ǹ�ʸ�ڤȤ�Ϳ����줿�ץ��������᤹�뤿��˥��󥿥ץ꥿������ΰ�˺��ǡ�����¤�Ǥ��롣̾�����ѿ������󡢴ؿ������ȶ��̤����ꡢ���ä���̵���Ƥ�黻�Ҥ�ͥ���̤����ò¤·¤Æ¿ï¿½ï¿½ï¿½ï¿½Î²ï¿½á¤·ï¿½ï¿½ï¿½ê¤¹ï¿½ë¡£
��ʸ�ڤ�LISP�Ϥ��Ǥ˼������褦�ˤ��ä����ڹ�¤�Τߤǹ�ʸ�����ꤵ��뤿�ᡢ¿����Ȱ㤤��ʸ���Ϥ��ä�ɽ���������ꥹ�ȹ�¤���Ѵ���������Ǥ��롢�Ĥޤ깽ʸ�ڤϥꥹ�Ȥˡ���ʸ�ڤ�������ǡ�����¤��Cons Cell�����Ǥ�Atom���������롣LISP��Ʊ�ͤ˥��󥿥ץ꥿�θ�������Ϥ����Ѥ�����ˤϹ�ʸ�ڤ��������ɬ�פ����롣���δ����ˤ��Ф���GC�����Ѥ���롣
�ꥹ�ȡ���ʸ�ڤϥץ�����ޤ�ľ�ܴ�����Ԥ����Ȥ��ǽ�ʾ�礬���롣�����������ξ��ϸ�������Ϥ������˼��ä��뤳�Ȥˤʤ��������Ϥ򤷤�����٤���夵������Ū��ȿ���Ƥ��ޤ���
���Τ褦�ˡ�����٤ι⤤���󥿥ץ꥿�θ�������Ϥ����Ѥ�������٤ι⤤�ץ����������������ˤ�GC��ɬ�ܤε�ǽ�ȤʤäƤ��롣
����ʸ�Ǥ�GC��°��LISP�����Ϥκ������롣LISP�����Ϥλ��ͤ�Scheme�Υ��֥��åȤȤ��롣�����Ϥι�¤�ˤϸ�ŵŪ��S���Υ��󥿥ץ꥿�ʲ��ϡˡ�GC�Υ��르�ꥺ��ˤ��ݼ�ŪMark and Sweep����Ѥ��롣
��ŵŪ��S���Υ��󥿥ץ꥿�Ȥ��Ƥ�LISP�����Ϥ����������˴ΤȤʤ뵡ǽ��read-eval-print-loop(repl��ά��)��GC�Ǥ��롣����repl�Ϥ���̾�ΤȤ��ꡢ���Ϥ��ɤ߼�ꡢɾ��(evalute)�������Ϥ��뤳�Ȥ򷫤��֤������Ǥ��롣
read��Ԥ�reader��ʸ����Ȥ��Ƥ�S�����ɤ߼�ꡢLISP�����Ϥ�����ɽ���Ȥ��Ƥ�S��(�ꥹ��)���Ȥ�Ω�Ƥ롣eval��reader�����Ф����ꥹ�Ȥ��ᤷ�ץ�������¹Ԥ��롣print�ϼ¹Է�̤��ܤ˸�������ǽ��Ϥ��롣
�ܸ���Ǥ�GC��������뤳�Ȥ⤢�ꡢ���餫����GC����ܤ��줿�ץ�����ߥ󥰸���ǤϤʤ�C����ˤ�äƺ�����Ԥä���C++�������Ѥ��ʤ��ä���ͳ�ϡ��ݼ�ŪGC�ȥ��󥹥��󥹤Υե����ʥ饤���ζ�Ĵ��Ԥ����Ȥˤ�ꡢ�ܼ��Ǥʤ���ʬ�����դ򤽤�����Ƥ��ޤ��Τ��ɤ�����Ǥ��롣
�ܸ���Ǻ�������LISP������(�ʲ�������)�β����Ԥ���
�����������������Τ����Ѥ���ǡ�����¤��scheme.h��������Ƥ��롣��ŵŪ��LISP�����ϤǤ�Cell�ȸƤФ��ʣ���Υǡ�����¤��union�ǤޤȤ᤿���ФȤ���union���̤�����Ф���ĥǡ�����¤�����Ѥ���Τ���ή�Ǥ��롣
Cell�����union�ǤޤȤ᤿���ФΥǡ�����¤�ˤ�S���ι�ǽҤ٤�cons(Cell�Υݥ��󥿤���Ļ��ĥǡ�����¤)��atom��ޤࡣ���������������Ϥ�atom��symbol��integer�� primitive��closure��macro�Ǥ��롣
Cell��LISP�����Ϥ����Ѥ���ǡ�����¤��ͤ������ͳ�ˤϡ�Cell�Ȥ����ҤȤĤΥǡ�����¤�ǽ����Ϥ����Ѥ���S��������ɽ���Ǥ��뤳�Ȥ�¾�ˡ��ǡ����Υ����������ˤ���GC�ǤΥ����ΰ�����Ҳ����ɤ���̣��ޤޤ�Ƥ롣
�������������ϤǤ�Cell��SCM�Ȥ���̾����typedef���Ƥ���
typedef struct _Cell* SCM; /* scheme cell object interface */
struct _Cell {
struct _Header {
enum SchemeCellType type;
short gc_flag;
} header; /* cell header */
union {
struct _Cons {
SCM car;
SCM cdr;
} cons;
struct _Integer {
int value;
} integer;
struct _Symbol {
char *name;
int length;
SCM value;
} symbol;
struct _Primitive {
enum PrimitiveType type;
char *name;
SCM (*proc)();
} primitive;
struct _Closure {
SCM args;
SCM body;
SCM env;
} closure;
struct _Macro {
SCM closure;
} macro;
/* more ... */
} object; /* cell object */
};
�ʤ�Cell�Τ���ε����ΰ�γ��ݤˤ�GC������������äƤ���롣���ʳ��Ǥ����̤ʴ���������malloc�ΤߤǺѤޤ��롣Cell�γ��ݤˤĤ��Ƥ�GC�ι�(4.4.1)�Ǿܤ����Ҥ٤롣
����ܥ�Ȥ����ǡ�����¤��scheme.h�ǡ�����ܥ롢����ܥ�ơ��֥�Ȥ�������Ԥ��ؿ���symbol.c�ˤ�������Ƥ��롣
����ܥ�Ȥ�LISP��atom��̾����Ĥ����ɤ�ǡ�����¤�Ǥ��롣Ʊ��̾������ĥ���ܥ�Ͼ��Ʊ�����֥������Ȥ����Ѥ��뤳�ȡ��Ĥޤ�Ʊ������ܥ��Ʊ�����ɥ쥹����Ĥ��Ȥ�LISP�����ϤǤϵ����롣�����¸����뤿��˥���ܥ�ơ��֥�����Ѥ��롣�ܽ����ϤǤϥ���ܥ�ơ��֥�ϥ�������ϥå���Ǽ¸����Ƥ��롣����ܥ��̾��(ʸ����)������롣�Ϥ����̾���Υϥå����ͤ��ᡢ��������ϥå���ΰ��֤���ꤹ�롣����S����Ʊ�ͤ�Cons Cell�����Ѥ��Ƥ��������ꥹ�Ȥ򤿤ɤꡢʸ�����Ʊ�ͤ�̾������ĥ���ܥ����롣̾�����б����륷��ܥ뤬¸�ߤ��ʤ����Ͽ����˥���ܥ��������ƥ���ܥ�ơ��֥���ɲä�Ԥ���
̾�����饷��ܥ����뤳�Ȥ�intern�ȸƤ֡�
reader��read.c��������Ƥ��롣S�����ɤ߼��Cell�����Ѥ��ƥꥹ�Ȥ�������롣
�ɤ߹����S���λ�����ϤˤĤ��Ƥ�R5RS[1]�򻲹ͤ˺����������Ƶ��߲����Υѡ����ȤʤäƤ��롣������reader����������ꥹ�Ȥ��̾�primitive��closure��macro�ʤɤΤ�ޤޤʤ�Cell�����ǤǤ�����Τ��֤���primitive��closure��macro�ʤɤ�4.3.5����������eval�ˤơ�symbol��«�����줿�ͤ���Ф����ꡢ�ؿ���¹Ԥ��뤳�Ȥˤ���������Τ���Ǥ��롣
print��print.c��������Ƥ��롣
print��S����ɽ�����뤿��ε����Ǥ��롣print�����Τϵ����if-elseʸ�Ǥ��롣�����Ȥ���Ϳ����줿S�������Ǥˤ��碌�ư�����Ԥ������Ǥ�Atom�ξ���print������Atom���б����������Ԥ��������Ǥ�Cons Cell�ꥹ�Ȥ�ɽ���ξ���pirnt��print_list��������Ϥ���(Figure 27. (1))��
print_list��Cons Cell�򤿤ɤꤽ�줾������Ǥ������print���Ӥ������ꥹ�Ȥ�ɽ����Ԥ�(Figure 28. (1))��
SCM print(SCM sexp, FILE *file)
{
if (SCM_CONSTANT_P(sexp)) {
switch(AS_UINT(sexp)) {
case AS_UINT(SCM_NULL): fprintf(file, "()"); break;
case AS_UINT(SCM_FALSE): fprintf(file, "#f"); break;
case AS_UINT(SCM_TRUE): fprintf(file, "#t"); break;
case AS_UINT(SCM_EOF): fprintf(file, "#eof"); break;
case AS_UINT(SCM_UNDEFINED):
fprintf(file, "#undefined"); break;
default:
scheme_error("bad constant"); break;
}
return SCM_UNDEFINED;
}
if (SYMBOL_P(sexp)) {
fprintf(file, "%s", SYMBOL_NAME(sexp));
} else if (INTEGER_P(sexp)) {
fprintf(file, "%d", INTEGER_VALUE(sexp));
} else if (STRING_P(sexp)) {
fprintf(file, "\"%s\"", STRING_VALUE(sexp));
} else if (CONS_P(sexp)) {
print_list(sexp, file); /* (1) */
} else if (PRIMITIVE_P(sexp)) {
fprintf(file, "#<primitive %s>", PRIMITIVE_NAME(sexp));
} else if (CLOSURE_P(sexp)) {
fprintf(file, "#<closure>");
print(CLOSURE_ARGS(sexp), file);
print(CLOSURE_BODY(sexp), file);
} else if (MACRO_P(sexp)) {
fprintf(file, "#<macro>");
print(MACRO_CLOSURE(sexp), file);
} else {
printf("print unsupported: %p", sexp);
}
return SCM_UNDEFINED;
}
static SCM print_list(SCM sexp, FILE *file)
{
SCM lst = sexp;
putc('(', file);
for(;;) {
print(CAR(lst), file);
lst = CDR(lst);
if (NULL_P(lst)) break;
else if (CONS_P(lst)) putc(' ', file);
else { fprintf(file, " . "); print(lst, file); break;} /* (1) */
}
putc(')', file);
return SCM_NULL;
}
�Ķ��ˤĤ��Ƥμ�����env.c��������Ƥ��롣eval�ǥץ�������ɾ������ݤ��ѿ����ͤ���Ф��褬�Ķ��Ǥ��롣���Τ���Ķ��ϥ������פ������Ǥ���Ȥ⤤���롣
���ֳ�¦�δĶ��ϥȥåץ�٥�ȸƤФ�LISP�����Ϥ���ǥ������Х�ʤ�ΤǤ��롣�ȥåץ�٥�Ǥϥ���ܥ���ͤ����а�δط��Ȥʤ뤿�ᡢ����ܥ뤽�Τ�Τ��ͤ��Ϣ�դ��뤳�Ȥˤ��ȥåץ�٥�Ķ���¸����롣�ȥåץ�٥�ʳ��δĶ��ˤĤ��Ƥϡ�Figure 30.�Τ褦�˥���ܥ���ͤΥꥹ�ȤΥڥ���ꥹ�ȤȤ��ƻ��Ĥ��Ȥˤ��¸����롣�������Ķ���lambda���ǥץ�����������������Ȥ��˺�������롣
environment = ((var1 var2 var3 ...)
(val1 val2 val3 ...))
environments = (environmentN environmentN-1 ... )
�Ķ������Figure 31.�ˡ����ΤȤ��δĶ��Υꥹ��ɽ����Figure 32.�ˡ�Atom��Cons Cell���Ѥ����ǡ�����¤��Figure 33.�˼�����(lambda (x) ...)�����Ф��Ķ���Ķ�����(lambda (y) ... )�����Ф��Ķ���Ķ�2�Ȥ��롣������ǤϴĶ�1�ˤ�x��20���б��դ���졢�Ķ�2�ˤ�y��10���б��դ�����롣���δĶ�����(+ x y)��ɾ����Ԥ��ȼ���(+ 20 10)�Ȥʤꡢ30�������롣
( ((y) . (10)) // �Ķ�2
((x) . (20)) // �Ķ�1
)
�����ƥ��å���������(Static scope)�Ȥ�4.3.5�Ǽ������Ķ���Ȥä��ѿ����ͤ���Ф���ˡ�Ǥ��롣�����������Ǥ⼨�����Ȥ��ꡢ�����ƥ��å��������פǤ�ʣ���δĶ���Ʊ�ͤ��ѿ����Ȥ��Ƥ������ϡ����˰��ֶᤤ�Ķ����ͤ����Ѥ��롣�ޤ��������ƥ��å��������פ�lambda�����ͤ���������Ȥ��δĶ�����¸����Τǡ��ץ������������ȤǤϡ���������Ȥ��δĶ����ѿ������ѤǤ��롣Scheme��LISP�����ϤȤ��ƤϤ���ƥ����ƥ��å��������פ���Ѥ��ư��衢���ߤǤϥ����ƥ��å��������פ���ή�Ǥ��롣
����Ȥϰۤʤꡢ�����LISP�ϥ����ʥߥå��������פ���Ѥ��Ƥ�����lambda���ǥץ���������Ϥ����Υ����ɤ����ҤȤ��ư���������������δĶ�����¸������Ŭ���������δĶ����ѿ������Ѥ��Ƥ�����
�ܽ����ϤǤϥ����ƥ��å��������פ�¸����뤿��ˡ�lambda�������Ф��ץ��������㤬�Ķ�����¸���롣�ץ��������㤬�Ķ�����¸���뤳�Ȥˤ�ꡢ���������Τ�ư��򥹥��ƥ��å��������פˤ��뤳�Ȥ��Ǥ��롣
eval��apply��eval.c��������Ƥ��롣�����Ϥο�¡��ʬ�Ǥ��롣reader�����������ꥹ�Ȥ��ᡢɾ����evaluation�ˡ��ؿ���Ŭ����apply�ˤ�Ԥ���3.1.4��Figure 17.����ټ�����
���μ��� | ɾ������ˡ |
---|---|
�ꥹ�� | (<�ؿ�> <����> ... <����>)�Τ褦�ʴؿ��ƤӽФ��Ȥߤʤ���ɾ�����롣 |
����ܥ� | ����ܥ���б��դ���줿�ͤ���Ф��� |
����ܥ�ʳ���Atom | Atom���Ȥ��֤��� |
eval�ǤϿ��ͤΤ褦��¨�ͤ䥷��ܥ��«�����줿�ͤ���Ф����ꤹ��(Figure 35. (1),(2))��
�ޤ����ꥹ�Ȥ���Ƭ��atom��ɾ�������Ȥ����ͤ��ؿ��Ȥ��Ƽ¹Ԥ��뤬�����δؿ��������Ŭ��������ˤ�apply�����Ѥ���(Figure 35. (3))��apply�Ϥ������apply_primitive(Figure 36.)��apply_closure(Figure 37.)��ƤӽФ��������δؿ�����Ǥ����eval���ƤӽФ���롣eval��apply����ߺƵ��ƤӽФ���Ԥ��ʤ���ץ�������¹Ԥ��롣
SCM eval(SCM sexp, SCM env)
{
SCM kar = SCM_NULL;
SCM result = NULL;
struct EvalState state = { env, EVAL_STATUS_RETURN_VALUE};
eval_loop:
set_current_sexp(sexp);
if (SYMBOL_P(sexp)) return symbol_value(sexp, state.env); /* (2) */
if (! CONS_P(sexp)) return sexp; /* (1) */
if (CONS_P(sexp)) {
SCM subr;
state.status = EVAL_STATUS_RETURN_VALUE;
kar = CAR(sexp);
if (SYMBOL_P(kar)) { subr = symbol_value(kar, state.env); }
else if (CONS_P(kar)) { subr = eval(kar, state.env); }
result = apply(subr, CDR(sexp), &state, SCM_TRUE); /* (3) */
sexp = result;
if (state.status == EVAL_STATUS_NEED_EVAL) {
goto eval_loop;
}
}
return sexp;
}
static SCM apply(SCM subr, SCM arg, struct EvalState *state, SCM need_argument_eval)
{
if (PRIMITIVE_P(subr)) {
return apply_primitive(subr, arg, state, need_argument_eval);
} else if (CLOSURE_P(subr)) {
return apply_closure(subr, arg, state, need_argument_eval);
}/* ... */ else {
scheme_error("subroutine type error");
return NULL;
}
}
static SCM apply_closure(SCM closure, SCM arg, struct EvalState *state, SCM need_argument_eval)
{
SCM closure_env = NULL;
SCM result = SCM_NULL;
SCM evaled_arg = SCM_NULL;
SCM body = CLOSURE_BODY(closure);
if (length(CLOSURE_ARGS(closure)) > length(arg)) {
scheme_error("argument error");
}
if (FALSE_P(need_argument_eval) ) { evaled_arg = arg; }
else { evaled_arg = eval_list(arg, state->env); }
closure_env = extend_environment(CLOSURE_ARGS(closure), evaled_arg, CLOSURE_ENV(closure));
while (! NULL_P(body)) {
// need_argument_eval�������Ƶ� /* (1) */
if (LIST_1_P(body) && FALSE_P(need_argument_eval)) {
state->status = EVAL_STATUS_NEED_EVAL;
state->env=closure_env;
result = CAR(body);
break;
}
result = eval(CAR(body), closure_env);
body = CDR(body);
}
return result;
}
static SCM apply_primitive(SCM subr, SCM arg, struct EvalState *state, SCM need_argument_eval)
{
if (SPECIAL_FORM_P(subr)) {
return PRIMITIVE_PROC(subr)(arg, state);
} else if (LIST_EXPR_P(subr)) {
SCM evaled_arg;
if (FALSE_P(need_argument_eval) ) { evaled_arg = arg;
} else { evaled_arg = eval_list(arg, state->env); }
return PRIMITIVE_PROC(subr)(evaled_arg);
} else {
SCM result, evaled_arg;
if (FALSE_P(need_argument_eval) ) { evaled_arg = arg;
} else { evaled_arg = eval_list(arg, state->env); }
switch(PRIMITIVE_TYPE(subr)) {
case PRIMITIVE_TYPE_EXPR_0:
if (length(arg) != 0) goto ARG_ERROR;
result = PRIMITIVE_PROC(subr)();
break;
/* ... */
case PRIMITIVE_TYPE_EXPR_4:
if (length(arg) != 4) goto ARG_ERROR;
result = PRIMITIVE_PROC(subr)(CAR(evaled_arg),
CADR(evaled_arg), CADDR(evaled_arg), CAR(CDDDR(evaled_arg)));
case PRIMITIVE_TYPE_EXPR_5:
if (length(arg) != 5) goto ARG_ERROR;
default:
return SCM_NULL;
}
return result;
ARG_ERROR:
scheme_error("eval unsupported :");
}
return SCM_NULL;
}
Lisp����Scheme�Ǥϡ������Ƶ��κ�Ŭ����������ѤȤ��ƴޤޤ�Ƥ��ꡢ��Ŭ���Τ���Υ��르�ꥺ��Ϥ���eval��apply�˵��Ҥ��롣
����ѥ��뤷��VM��CPU�Ǽ¹Ԥ�������ϤʤɤǤϡ��Ƶ���롼�פ��Ѵ��������Ū�ʥ��르�ꥺ�ब���ѤǤ��롣�����������������������ϤΤ褦��S����ľ�ܲ�ᤷ���Ƶ��˥ͥ��ƥ��֥����å������Ѥ�������ϤǤϤ�����ˡ�����ѤǤ��ʤ���
��äơ�����κ�Ŭ���ˤϡ�SIOD�ʤɸŤ������ϤǺ��Ѥ���Ƥ�����ˡ�����Ѥ��롣���르�ꥺ��ϡ��Ǹ��ɾ������ꥹ�Ȥ򤤤ä���eval���֤������Υꥹ�Ȥ����eval���뤳�Ȥˤ�äƼ¸�����(Figure 38. (1))��Figure 39.�Ϥ��Υ��르�ꥺ��Υ����å��Ǥ��롣
�ꥹ�Ȥκ�ɾ����ɾ����ɬ�פ��ɤ����Υե饰�Ǵ������롣�ե饰���ͤ򼨤����(Figure39,40.�Ǥ�is as value���ץ������Ǥ�EVAL_STATUS_RETURN_VALUE�ˤξ���apply�ؿ�������ͤ��ͤȤߤʤ����Τޤޡ�eval�ؿ�������ͤȤ�����ɾ���򼨤����(Figure 39,40.�ξ���is need eval���ץ������Ǥ�EVAL_STATUS_NEED_EVAL�ˤξ��Ϻ�ɾ����Ԥ���
���κ�ɾ���δĶ��ϺǸ�Υꥹ�Ȥ�ɾ��������δĶ��Ȱ��פ��Ƥ���ɬ�פ����뤿�ᡢ���餫����ˡ�����Ѥ���Ķ��򿷤����Ķ��˹�������ɬ�פ����롣����������������ϤǤ�eval�ؿ��ΰ����ˤϴĶ��������eval�ؿ����餤�ä����᤹���˴Ķ��򹹿����Ƥ���(Figure 40.)��
LISP���������Τ������Ƶ��κ�Ŭ�����б�����ˤϡ��ü�������Ƥȥץ���������������Ƶ��κ�Ŭ����Ԥ��褦���ѹ�����Ф褤������ϡ�LISP�Υץ������Ϻǽ�Ū�ˤ��ü�����ȥץ������������Ĥδؿ��μ¹Ԥ˴��󤵤�뤫��Ǥ��롣
4.3.1�����������褦��Cell�γ��ݤ˴ؤ��Ƥ�������������롣����Ū�ˤ�alloc.c�ˤ�����Cell�γ��ݤ�GC��Ԥ���³���òµ½Ò¤ï¿½ï¿½ë¡£ï¿½Ê¤ï¿½GC�ˤ��ݼ�Ū�ޡ�������ɥ���������GC����Ѥ��롣
GC�Ǥ�ưŪ�˳��ݤ����ǡ��������ƴ�������ɬ�פ����롣���Τ��ᡢGC�����Ѥ�����ˤ�GC���б��������ѤΥ��ꥢ������������������Υ��������������Ѥ���ɬ�פ��롣���Τ���Cell����ݤ������ѤΥ�����������������롣
����Cell�����������ϰ��٤����̤Υҡ��פ���ݤ���Cell��ñ�̤��ڤ���ꤹ����Ȥߤ�������Ƥ��롣�ҡ��פκǽ�����Ǥ�ƥҡ��ץڡ�����free Cell�δ��������Ѥ��Ƥ��롣
Cell�����������Ǥ�free Cell�λĤ�������0�ˤʤ�Ȥޤ�GC��Cell�������롣���θ�free Cell������ʾ����Ǥ��ʤ��ä���硢malloc�ǥҡ��פ��ɲó��ݤ��ơ�free Cell���ɲä��롣
GC�μ����ˤ��ݼ�Ū�ޡ�������ɥ��������פ����Ѥ��롣�ݼ�Ū��GC�μ���ˡ�ˤĤ��Ƥϼ��ξϤ�������Ԥ��������ǤϤ��δ��äǤ���ޡ�������ɥ��������פμ����ˤĤ���������Ԥ���
�ޡ�������ɥ���������GC�Ȥϼ������ʳ��Υ��르�ꥺ������Ѥ���GC�Ǥ��롣
�ʲ��Τ���ư���ܤ����������Ƥ�����
�ޡ�������ɥ��������פǥޡ�����Ԥ������Ȥʤ륪�֥������Ȥ�Root�Ȥ�֡�LISP�����ϤǤ�Root�Ȥʤ륪�֥������Ȥ��ͤ�«������Ƥ��륷��ܥ롢�������Х��ѿ����������줿Cell���������ݼ�ŪGC���оݤȤʤ�ޥ��󥹥��å��ȥ쥸�����ˤ���Cell�Ǥ��롣GC�ǤϤޤ������Root���������������Ǥ������ƤΥ��֥������Ȥ˥ޡ�����Ĥ��Ƥ����������μ��ϥޡ����ΤĤ��Ƥ��ʤ����֥������Ȥβ����Ԥ��������ơ�����Ǥ������֥������Ȥ������˱����ƥҡ��פγ�ĥ��Ԥ���
static void scheme_gc(void)
{
int collect_cells;
gc_mark_stack();
gc_mark_symbol_table();
/* ... */
collect_cells = gc_sweep();
/* ... */
if (collect_cells < 600) {
add_heap();
}
current_search_page = page_list;
}
���֥������ȤΥޡ�����Ԥ�gc_mark_object�Ǥ�Root�Ȥʤ륪�֥������Ȥ���˺Ƶ�Ū�˥ꥹ�Ȥ򤿤ɤꥪ�֥������Ȥ˥ޡ������Ƥ����������Ǥ������֥������Ȥ�Cell�Τ��ȤǤ��롣����䤹�Ǥ˥ޡ������Ĥ��Ƥ��륪�֥������ȤϤ���ʾ��������ʤ��褦�ˤϤ����Ƥ���(Figure 43. (1))���ޤ���Cell����η��ˤ��碌�Ƽ��Υ��֥������Ȥؤ���������ˡ���Ѥ��Ƥ���(Figure 43. (2))������˼����������륪�֥������Ȥ��ҤȤĤˤʤä�����gotoʬ�������Ƶ��κ�Ŭ����Ԥ��������å��ξ�����ޤ��Ƥ���(Figure 43. (3))��
�����֥������Ȥβ����Ԥ�gc_sweep�Ǥϳƥҡ��ץڡ������������������ޡ����ΤĤ��Ƥ��ʤ�Cell��Freelist���ɲä���(Figure 44. (1))���ޡ����ΤĤ��Ƥ���Cell�ϥޡ����򳰤��ơ�����β���������Ƥ���(Figure 44. (2))��
static void gc_mark_object(SCM obj)
{
loop:
if (obj == NULL) return;
/* (1) */
if (SCM_CONSTANT_P(obj)) return ; /* scm constant is not marking */
if (FREE_CELL_P(obj)) return ; /* free cell is not marking */
if (GC_MARK_P(obj)) return ; /* already marked. */
GC_MARK(obj);
/* (2) */
if (CONS_P(obj)) {
gc_mark_object(CAR(obj));
obj = CDR(obj);
goto loop; /* (3) */
} else if (INTEGER_P(obj)) {
return ;
} else if (SYMBOL_P(obj)) {
gc_mark_object(SYMBOL_VCELL(obj));
} else if (STRING_P(obj)) {
return ;
} else if (PRIMITIVE_P(obj)) {
return ;
} else if (CLOSURE_P(obj)) {
gc_mark_object(CLOSURE_ARGS(obj));
gc_mark_object(CLOSURE_BODY(obj));
obj = CLOSURE_ENV(obj);
goto loop; /* (3) */
} else if (MACRO_P(obj)) {
obj = MACRO_CLOSURE(obj);
goto loop; /* (3) */
}
}
static int gc_sweep(void) {
SCM page = page_list;
int collect = 0;
gc_sweep_symbol_table_free_cell_remove();
while(page != NULL) {
SCM cell = page;
SCM last_cell = page + ALLOCATE_HEAP_PAGE_OBJECT_SIZE - 1;
while (AS_UINT(cell) <= AS_UINT(last_cell)) {
if (FREE_CELL_P(cell)) { /* through */
} else if (GC_MARK_P(cell)) {
if (! GC_FOREVER_MARK_P(cell)) { GC_UNMARK(cell); } /* (2) */
} else { /* unmarked */ /* (1) */
cell_finalize(cell);
int cell_index = 0;
if (PAGES_FREE_CELL_LIST(page) != NULL) {
cell_index = AS_UINT(FREE_CELL_INDEX(PAGES_FREE_CELL_LIST(page)));
}
cell_index++;
FREE_CELL_CONSTRUCT(cell, AS_SCM(cell_index), PAGES_FREE_CELL_LIST(page));
PAGES_FREE_CELL_LIST(page) = cell;
free_cell_total_size++;
collect++;
}
cell++;
}
page = NEXT_PAGE(page);
}
return collect;
}
�ݼ�Ū��GC�Ȥϥ����å����ɥ쥹����Ȥʤɤ����ҡ��פ˳��ݤ���GC�δ������ˤ��륪�֥������Ȥ򤵤��Ƥ�����ˡ����Υ��֥������Ȥ�������Ǥ���ȹͤ�GC��Ԥ���ˡ�Ǥ��롣���Τ�GC�Ȥϰۤʤꡢ������Υ��֥������Ȥ餷����Τϲ����Ԥ�ʤ������ݼ�Ū�ȸƤФ�롣
C����ʤɤǥ����å�����Υ��ɥ쥹������ˡ�LISP��Ԥ��ץ���������Ƭ�ǥ��������ѿ���������롣���Υ��������ѿ��Υ��ɥ쥹�򥹥��å�����Υ��ɥ쥹�Ȥ��롣
#define SCHEME_STACK_INITIALIZE \
SCM __dummy_scheme_stack_start_object; \
stack_initialize(&__dummy_scheme_stack_start_object)
int main(int argc, char **argv) {
{
SCHEME_STACK_INITIALIZE;
scheme_initialize();
read_eval_print_loop();
scheme_finalize();
exit(EXIT_SUCCESS);
}
}
���˥����å�����ü�Υ��ɥ쥹�γ��ݤ��뤿��ˡ������å���GC��Ԥ������ɤ�ľ�����ѿ�����κǸ�˥����å�����ü�Υ��ɥ쥹�γ��ݤ��뤿��Υ��������ѿ���������롣���Υ��������ѿ��Υ��ɥ쥹�򥹥��å�����ü�Υ��ɥ쥹�Ȥ��롣
�����å����ɥ쥹�Ϥ���Ǽ����Ǥ����ΤǼ��˥쥸���������Ƥ���¸��Ԥ�(Figure 47. (1))���쥸���������Ƥ���¸����ˤ�C�����ɸ��饤�֥���setjmp�����Ѥ��롣jmp_buf�򥹥��å�����ü�Υ��ɥ쥹�γ��ݤ��뤿��Υ��������ѿ�������������롣���ݤ���jmp_buf���Ф���setjmp�ؿ���¹Ԥ����쥸��������Ȥ�jmp_buf����¸����(Figure 47. (2))��
�Ǹ�ˤ����ξ��󤫤�ޥ��󥹥��å����ϰϤ��ᡢ�����ΰ���ͤ�GC���������Ƥ���ҡ��פΥ��ɥ쥹���ä����gc_mark_object��¹Ԥ��롣
static void gc_mark_stack(void) {
jmp_buf save_register_for_gc_mark;
void *start;
void *end;
int i;
void *end_of_stack;
/* (2) register value dump */
setjmp(save_register_for_gc_mark);
/* (1) �����å�����ü��Ͽ */
SCHEME_SET_STACK_END(&end_of_stack);
if (AS_UINT(stack_start) < AS_UINT(stack_end)) {
start = stack_start; end = stack_end;
} else {
start = stack_end; end = stack_start;
}
/* �ݼ�ŪGC��Ԥ� */
for (i = 0; i < sizeof(void *); i++) { gc_mark_memory(start, end, i); }
return ;
}
static void gc_mark_memory(void *start, void *end, int offset) {
SCM *obj;
for (obj = (SCM *) (char *) start + offset; (void *) obj < end; obj++) {
gc_mark_maybe_object(*obj);
}
}
���餤�ޤ路�ؿ��μ¹����¾�Υ��󥿥ץ꥿����Ӥ�Ԥ����ޤ�����������Ϥκ�����GC�κ����η��ط����ݼ���ưפ��ˤĤ���ɾ����Ԥ���
��ǽ��Ӥ򤿤餤�ޤ路�ؿ��μ¹Ի��֤ˤ��Ԥ�������оݤˤ�Ʊ�����󥿥ץ꥿��Scheme�����Ϥ�SigScheme[3]�����Ѥ��롣
��Ӥ����Ѥ��������������ɤ򼨤���
(define tak
(lambda (x y z)
(cond ((< y x)
(tak (tak (- x 1) y z)
(tak (- y 1) z x)
(tak (- z 1) x y)))
(#t y))))
(tak 10 5 0)
(exit 0)
(set! tak
(lambda (x y z)
(cond ((< y x)
(tak (tak (- x 1) y z)
(tak (- y 1) z x)
(tak (- z 1) x y)))
(#t y))))
(tak 10 5 0)
(exit 0)
�¹Է�̤�ʲ��˼�����
% time cat tarai.scm | sscm > /dev/null
cat tarai.scm 0.01s user 0.00s system 71% cpu 0.017 total
sscm > /dev/null 0.69s user 0.07s system 98% cpu 0.774 total
% time cat tarai.lisp | ./thesischeme > /dev/null
cat tarai.lisp 0.00s user 0.00s system 19% cpu 0.020 total
./thesischeme > /dev/null 5.82s user 0.04s system 97% cpu 5.990 total
% time cat tarai.lisp | ./thesischeme > /dev/null
cat tarai.lisp 0.00s user 0.01s system 20% cpu 0.040 total
./thesischeme > /dev/null 4.52s user 0.06s system 95% cpu 4.810 total
% time cat tarai.lisp | ./thesischeme > /dev/null
cat tarai.lisp 0.00s user 0.00s system 35% cpu 0.011 total
./thesischeme > /dev/null 2.14s user 0.02s system 99% cpu 2.173 total
���η�̤�ꡢ���٤˳��ݤ���ҡ��ץ��������ç¤ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Û¤ï¿½Â®ï¿½Ù¤ï¿½ï¿½Ð¤ë¤³ï¿½È¤ï¿½ï¿½ï¤«ï¿½ë¡£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ò¡ï¿½ï¿½×¥ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ç¤ï¿½ï¿½ï¿½ï¿½ï¿½Æ¤ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ï¤ï¿½SigScheme�����2�ܰʾ�������٤����Ȥ��狼�롣
�̾�θ�������Ϥϥ��ꥢ�������������ñ¸»¤ò°®¤Ã¤Æ¤ï¿½ï¿½ï¿½È²ï¿½ï¿½ê¤¹ï¿½ë¡£ï¿½ï¿½ï¿½Î¥ï¿½ï¿½ê¥¢ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Þ¤àµï¿½ï¿½ï¿½Î°ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ð¤ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½×¤Ê¥ï¿½ï¿½ï¿½ï¿½Æ°Åªï¿½Ë²ï¿½ï¿½ï¿½ï¿½ï¿½ë¤«ï¿½ï¿½ï¿½ï¿½ï¿½ì¤«ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ë¤«ï¿½ï¿½Í¤ï¿½ï¿½ë¡£ï¿½ï¿½ï¿½ï¿½È¸ï¿½ï¿½ì¤«ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ë¤Ï¸ï¿½ï¿½ï¿½Ëµï¿½ï¿½ï¿½ï¿½Î°ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ò°·¤ï¿½ï¿½ï¿½Ç½ï¿½ï¿½É¬ï¿½×¤È¤Ê¤ë¡£ï¿½ï¿½ï¿½ï¿½Ï¸ï¿½ï¿½ì¤¬ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ô¥å¡¼ï¿½ï¿½ï¿½Îµï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ù¤ï¿½ï¿½ã¤¯ï¿½Ê¤ë¤¿ï¿½á¡¢ï¿½ï¿½ï¿½ï¿½Ù¤Î¹â¤¤ï¿½×¥ï¿½ï¿½ï¿½ï¿½ï¿½ß¥ó¥°¸ï¿½ï¿½ï¿½Ë¤Ï¤Õ¤ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ê¤ï¿½ï¿½ï¿½Ç½ï¿½Ç¤ï¿½ï¿½ë¡£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ã¤Æ¡ï¿½GC�ΰ�¸�٤ϸ��������٤ȴ�Ϣ����ȹͤ����롣
�����������ΰ���������ϸ�����׵ᤵ�ìµï¿½ï¿½ï¿½Î°ï¿½ï¿½ï¿½Ï¤ï¿½ï¿½Ð¤É¤Î¤è¤¦ï¿½Ê¼ï¿½Ë¡ï¿½ï¿½È¤Ã¤Æ¤ï¿½è¤¤ï¿½Ö¥ï¿½Ã¥ï¿½ï¿½Ü¥Ã¥ï¿½ï¿½ï¿½ï¿½Ë¤Ê¤Ã¤Æ¤ë¡£ï¿½ï¿½ï¿½Î¤ï¿½ï¿½á¥¢ï¿½ë¥´ï¿½ê¥ºï¿½ï¿½Î²ï¿½ï¿½É¤Ê¤É¤ï¿½ï¿½È¼ï¿½ï¿½Ë¹Ô¤ï¿½ï¿½ë¡£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ì¤¬ï¿½×µá¤¹ï¿½ëµï¿½ï¿½ï¿½Î°ï¿½Ë°ï¿½ï¿½ï¿½Îµï¿½Â§(Ʊ�쥵�����ʤ�)�������硢���르�ꥺ��θ�Ψ�����ޤ�롣
�������äƵ����ΰ���������ϸ���ΰ����ǡ����˰�¸���롣���������ΰ�����ˤ�������֤ϥץ�����ޡ����鸫���ͽ������������Τ����뤿�ᡢ���λ��֤�����ǤϤʤ��Ф�Ĥ����ϥץ������¹Ի��Υꥢ�륿�������������롣���Τ������¹Ԥ˴ؤ������󤬤����硢�����ΰ�μ�ˡ�����󤬲ݤ����뤳�Ȥ����롣
��������Ϥ�GC�Ȥΰ�¸�ط����θ����ȡ������Ϥ˿������ǡ�����¤���ɲä�����硢�������롼�Ȥ��ɲä������Τ�GC�˼��ä���ɬ�פ����뤳�Ȥ��狼�롣�롼�Ȥ���������¦�ǥ�󥯥ȥꥹ�ȤʤɤǴ�������Ф�����ѹ��������ꡢ�������ǡ�����¤�ΤȤ��Τ�GC��������Ф褤���Ȥ��狼�롣�ޤ�GC���ѹ�����gc_mark_object�����ҤȤĤǤ���Τǡ�GC��°�θ�������Ϥ��ݼ�Υ����Ȥϸ�������ϤΤߤξ����ݼ�Υ����Ȥȸ¤�ʤ��ᤤ���Ȥ���¬�Ǥ��롣
GC��°��LISP�����Ϥ��������������ˤ�ꡢ�ݼ�ŪGC����Ѥ���¤��������Ϥ�GC�ϴ�����ʬΥ���Ƽ�����Ԥ��뤳�Ȥ��ǧ�Ǥ��������������ޡ�������ɥ���������GC�ʳ���GC�Υ��르�ꥺ����ݼ�Ū�Ǥʤ�GC�ξ���Ʊ�ͤ�ʬΥ���Ƽ�����Ԥ��뤫�μ¾ڤ��Ǥ��ʤ��ä���
GC�Υ��르�ꥺ��ˤ��ץ�����ߥ󥰥�������ˤɤΤ褦�����¤������뤫�򤢤餫�����ǧ�Ǥ���С�������GC��������볫ȯ�ԤˤȤäƸ��Ѥ�꤬���䤹���ʤ롣
����θ���Ǻ������������Ϥϰ�����GC���������Ǥ��ʤ��ä����ᡢ�⤦�ҤȤĤ����Ū��GC�Ǥ��륳�ԡ�GC�μ�����Ԥ����Ȥ䡢GC�μ¹Ի��֤�ʬ�����ƥꥢ�륿����������夵����ꥢ�륿����GC�ʤɤμ�����Ԥ����Ȥ�����θ������Ǥ��롣