forked from ycaseau/CLAIRE4
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathreadme.cl
141 lines (126 loc) · 8.46 KB
/
readme.cl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
/***********************************************************************/
/** metaCLAIRE Yves Caseau */
/** readme.cl for meta (CLAIRE in CLAIRE) */
/** Copyright (C) 1998-2013 Yves Caseau. All Rights Reserved. */
/***********************************************************************/
This directory contains the first part of the meta-description of the CLAIRE system
It is composed of 3 modules:
/*************/
/** Core **/
/*************/
This is the claire-part of the microClaire library. It is defined by the following
files:
- method: first set of key methods, for evaluating methods and using slots
- object: second set of key system methods, mostly for instantiation
- function: the functions from the
- type: the reflective definition of the type system
Here are the table of contents for each files + a short descriptopn
// *********************************************************************
// * Cntents of method.cl *
// * Part 1: Lambda & Methods Evaluation *
// * Part 2: Update methods *
// * Part 3: Management of definition(p) *
// * Part 4: Matching Methods *
// *********************************************************************
// *********************************************************************
// * Contents of function.cl *
// * Part 1: Basics of pretty printing *
// * Part 2: Methods for CLAIRE objects *
// * Part 3: System Methods *
// * Part 4: Methods for Native entities *
// *********************************************************************
// *********************************************************************
// * Contents of object.cl *
// * Part 1: Ask, debug & trace *
// * Part 2: Tables *
// * Part 3: Demons & relations for the logic modules *
// * Part 4: Basics of Exceptions *
// *********************************************************************
// *********************************************************************
// * Contents of type.cl *
// * Part 1: Common Set Methods *
// * Part 2: definition of the type operators *
// * Part 3: Interface methods *
// * Part 4: Lattice methods *
// * Part 5: Type methods *
// *********************************************************************
/*****************/
/** Language **/
/*****************/
This module contains the "self-description" of the CLAIRE language, that is:
- the classes for each syntactic construct
- the self-print method : how to print each type of instruction
- self-eval, how to evaluate = the CLAIRE definition of the interpreter
It is defined by the following four files:
- pretty: this file contains the top of the "instruction" class hierarchy.
- call: this file contains functional calls (ex-messages)
- control: this file contains all major control structures
- define: this file contains all definition & instanciation instructions
// *********************************************************************
// * Contents of pretty.cl: *
// * Part 1: unbound_symbol and variables *
// * Part 2: lambdas *
// * Part 3: close methods for lattice_set instantiation *
// * Part 4: Pretty printing *
// *********************************************************************
// *********************************************************************
// * Contents of call.cl *
// * Part 1: the basic object messages *
// * Part 2: Basic structures *
// * Part 3: Specialized structures *
// * Part 4: Functions on instructions *
// *********************************************************************
// *********************************************************************
// * contents of control.cl *
// * Part 1: If, Do, Let *
// * Part 2: set control structures *
// * Part 3: other control structures *
// * Part 4: the constructs *
// *********************************************************************
// **************************************************************************
// * Contents of define.cl: *
// * Part 1: Definition instructions (Defobj, Defclass, Defmethod ...) *
// * Part 2: the instantiation macros *
// * Part 3: the useful stuff *
// * Part 4: the other macros *
// **************************************************************************
/**************/
/** Reader **/
/**************/
This module contains the I/O library for CLAIRE: how to handle ports/files and
to read stuff in them. CLAIRE implements a syntactic reader very similar to the
one of LISP.
It is organized around 4 files:
- read: this file contains the reader object and the top-level read functions
- syntax: this file contains specialized reading methods
- file: this file contains all that is related to files + top-level
- inspect: this file contains the CLAIRE run-time tools: inspect, trace & debug
// **********************************************************************
// * Content of read.cl: *
// * Part 1: The reader object *
// * Part 2: reading blocks *
// * Part 3: reading expressions *
// * Part 4: miscellaneous *
// **********************************************************************
// **********************************************************************
// * Content of syntax.cl *
// * Part 1: read operation expressions (<exp> <op> <exp>) *
// * Part 2: read control structures *
// * Part 3: read functional calls *
// * Part 4: read definitions *
// **********************************************************************
// **********************************************************************
// * Contents of file.cl: *
// * Part 1: Utilities *
// * Part 2: Loading *
// * Part 3: Reading in a file/string & top-level *
// * Part 4: The show & kill methods + macro-methods *
// **********************************************************************
// *********************************************************************
// * Contents of inspect.cl *
// * Part 1: Inspection *
// * Part 2: Trace *
// * Part 3: Debugger *
// * Part 4: Stepper *
// * Part 5: Profiler *
// *********************************************************************