|
996
|
1 # Data used to generate ByteCode.pm and documentation
|
|
|
2
|
|
|
3 # This file is part of CLC-INTERCAL
|
|
|
4
|
|
|
5 # Copyright (c) 2007-2008 Claudio Calvelli, all rights reserved.
|
|
|
6
|
|
|
7 # CLC-INTERCAL is copyrighted software. However, permission to use, modify,
|
|
|
8 # and distribute it is granted provided that the conditions set out in the
|
|
|
9 # licence agreement are met. See files README and COPYING in the distribution.
|
|
|
10
|
|
|
11 # PERVERSION "CLC-INTERCAL Generate/ByteCode.Data 1.-94.-2";
|
|
|
12
|
|
|
13 # all defined opcodes
|
|
|
14 @GROUP OPCODES NAME=w TYPE=s NUMBER=d ARGS=s DESCR=s ASSIGNABLE=d CONST=d DOC=m
|
|
|
15 @SOURCE STATEMENTS
|
|
|
16 @SOURCE REGISTERS
|
|
|
17 @SOURCE PREFIXES
|
|
|
18 @SOURCE EXPRESSIONS
|
|
|
19 @SOURCE CONSTANTS
|
|
|
20 @END OPCODES
|
|
|
21
|
|
|
22 # statements - opcodes 0x00..0x3f
|
|
|
23 @GROUP STATEMENTS NAME=w TYPE=s NUMBER=d ARGS=s DESCR=s ASSIGNABLE=d CONST=d DOC=m
|
|
|
24 STS S 0x00 '###C(#)S' 'STArt of STAtement' 0 0
|
|
|
25 Takes a variable number of constants, not less than four. The
|
|
|
26 first constant indicates the byte position in the source code
|
|
|
27 where this statement was compiled from; the second constant
|
|
|
28 indicates the length of the statement in the source code;
|
|
|
29 the third indicates whether the statement may be a comment (it has
|
|
|
30 not been recognised using the currently active grammar) or not;
|
|
|
31 the fourth indicates the number of constants following. The
|
|
|
32 rest of the constants indicate which grammar rules were used to
|
|
|
33 compile this particular statement.
|
|
|
34
|
|
|
35 At runtime, not all grammar rules may be available at all times,
|
|
|
36 depending on the history of I<CRE> and I<DES>. To execute
|
|
|
37 a statement corresponding to a given bit of source code, the
|
|
|
38 runtime will find all relevant I<STS> statements find the best one
|
|
|
39 which could have been compiled given the current state of the
|
|
|
40 grammar, and executes it; if a non-comment statement is available,
|
|
|
41 it will be used, otherwise a comment one will have to do.
|
|
|
42 If execution is to proceed sequentially,
|
|
|
43 the second constant is used to figure out how to repeat this
|
|
|
44 process. Execution starts at byte offset 0 in the source code.
|
|
|
45
|
|
|
46 Grammar rules are numbered at compile time, and may differ from
|
|
|
47 program to program.
|
|
|
48 STO S 0x01 'EA' 'STOre' 0 0
|
|
|
49 Followed by two expressions, assigns the value of the first
|
|
|
50 expression to the second. It is common to have a register as the
|
|
|
51 second expression, but any assignable expression will do.
|
|
|
52 CRE S 0x02 'EVC(<)C(>)' 'CREate' 0 0
|
|
|
53 Followed by two expressions (a grammar and a symbol), a constant
|
|
|
54 (a left count), I<left count> rules, another constant (a right
|
|
|
55 count) and I<right count> chunks of code, executes a CREATE
|
|
|
56 statement. This is not documented here but the compilers provide
|
|
|
57 a large number of examples.
|
|
|
58 DES S 0x03 'EVC(<)' 'DEStroy' 0 0
|
|
|
59 Followed by two expressions (a grammar and a symbol) and a constant
|
|
|
60 (a left count) and I<left count> rules, executes a DESTROY statement.
|
|
|
61 MSP S 0x04 'EC(V)' 'Make SPlat' 0 0
|
|
|
62 Followed by an expression, the splat code, a number, the count, and
|
|
|
63 I<count> more expressions, generates a splat. The first expression
|
|
|
64 is the splat code, the rest are used to generate the splat message.
|
|
|
65 The splat code determines the correct number of arguments, if the
|
|
|
66 wrong number is provided the message may look weird.
|
|
|
67 DSX S 0x05 'ES' 'Double-oh-Seven eXecution' 0 0
|
|
|
68 Followed by an expression (which should
|
|
|
69 have value between 0 and 100), it executes the statement with
|
|
|
70 a probability indicated by the expression, between 0% (never)
|
|
|
71 and 100% (always).
|
|
|
72 NOT S 0x06 'S' 'NOT' 0 0
|
|
|
73 Signals that this statement is initially abstained from. A
|
|
|
74 statement might be abstained from without containing a I<NOT>,
|
|
|
75 or might contain one and not be abstained from, depending on the
|
|
|
76 I<ABL>, I<ABG>, I<REL> and I<REG> executed since the start of
|
|
|
77 the program.
|
|
|
78 NXT S 0x07 'E' 'NeXT' 0 0
|
|
|
79 Followed by an expression, a label, stashes the address of
|
|
|
80 the next statement and continues execution at that label. It is
|
|
|
81 an error if the label is multiply defined or not defined at all.
|
|
|
82 RES S 0x08 'E' 'RESume' 0 0
|
|
|
83 Followed by an expression, pops that many levels from
|
|
|
84 the stash containing the return addresses for I<NXT>, I<NXL>
|
|
|
85 and I<NXG>. All the addresses except one are then discarded, and
|
|
|
86 execution continues at the last address extracted from the stash.
|
|
|
87 FOR S 0x09 'E' 'FORget' 0 0
|
|
|
88 Followed by an expression, pops that many levels from
|
|
|
89 the stash containing the return addresses for I<NXT>, I<NXL>
|
|
|
90 and I<NXG> and throws these addresses in the bit bucket.
|
|
|
91 STA S 0x0a 'C(R)' 'STAsh' 0 0
|
|
|
92 Followed by a constant (the count) and I<count> registers, STASHes
|
|
|
93 these registers.
|
|
|
94 RET S 0x0b 'C(R)' 'RETrieve' 0 0
|
|
|
95 Followed by a constant (the count) and I<count> registers, RETRIEVEs
|
|
|
96 these registers.
|
|
|
97 IGN S 0x0c 'C(R)' 'IGNore' 0 0
|
|
|
98 Followed by a constant (a count) and I<count> registers, ignores the
|
|
|
99 registers.
|
|
|
100 REM S 0x0d 'C(R)' 'REMember' 0 0
|
|
|
101 Followed by a constant (a count) and I<count> registers, remembers
|
|
|
102 the registers.
|
|
|
103 ABL S 0x0e 'E' 'ABstain from Label' 0 0
|
|
|
104 Followed by an expression, representing a label, ABSTAINs FROM the
|
|
|
105 corresponding statement(s).
|
|
|
106 ABG S 0x0f 'C(O)' 'ABstain from Gerund' 0 0
|
|
|
107 Followed by a constant (the count) and I<count> gerunds, ABSTAINs FROM
|
|
|
108 the corresponding statement(s).
|
|
|
109 REL S 0x10 'E' 'REinstate from Label' 0 0
|
|
|
110 Followed by an expression, representing a label,
|
|
|
111 REINSTATEs the corresponding statement(s).
|
|
|
112 REG S 0x11 'C(O)' 'REinstate from Gerund' 0 0
|
|
|
113 Followed by a constant (the count) and I<count> gerunds, REINSTATEs the
|
|
|
114 corresponding statement(s).
|
|
|
115 GUP S 0x12 '' 'Give UP' 0 0
|
|
|
116 Causes program termination. When used in a compiler module, causes
|
|
|
117 module processing to stop, the compiler will then load the next
|
|
|
118 module or, if no more modules are to be loaded, it will start
|
|
|
119 compiling the program.
|
|
|
120 WIN S 0x13 'C(A)' 'Write IN' 0 0
|
|
|
121 Followed by a constant (a count) and I<count> assignable
|
|
|
122 expressions, writes them in.
|
|
|
123 ROU S 0x14 'C(E)' 'Read OUt' 0 0
|
|
|
124 Followed by a constant (a count) and I<count> expressions,
|
|
|
125 reads them out.
|
|
|
126 LAB S 0x15 'ES' 'LABel' 0 0
|
|
|
127 Followed by an expression, indicates this statement's
|
|
|
128 label. If the expression is nonzero, after this statement the ICBM
|
|
|
129 will go looking for corresponding I<CFL> and I<NFL> statements
|
|
|
130 (COME FROMs and NEXT FROMs). It is also used to abstain/reinstate
|
|
|
131 by label.
|
|
|
132 CFL S 0x16 'E' 'Come From Label' 0 0
|
|
|
133 Followed by an expression, executes a COME FROM
|
|
|
134 label. The special register I<%CF> determines, amongst other
|
|
|
135 things, whether it is admissible to have multiple COME FROM
|
|
|
136 (and NEXT FROM) all pointing at the same label. The default is
|
|
|
137 to cause a splat; linking with the object I<thick.io> changes
|
|
|
138 this to allow multiple COME FROMs and NEXT FROMs to create threads.
|
|
|
139 CFG S 0x17 'C(O)' 'Come From Gerund' 0 0
|
|
|
140 Followed by a constant (the count) and I<count> gerunds (opcodes),
|
|
|
141 executes a COME FROM gerund. The special register I<%CF>
|
|
|
142 determines, amongst other things, whether these statements
|
|
|
143 are really executed or not. The default is not, and linking a
|
|
|
144 program with the object I<come-from-gerund.io> will change this
|
|
|
145 register to allow these statements: this object is normally linked
|
|
|
146 automatically when the program source has a suffix I<.gi>. See
|
|
|
147 I<CFL> for other functions of the I<%CF> register.
|
|
|
148 QUA S 0x18 'S' 'QUAntum statement' 0 0
|
|
|
149 Executes the rest of the statement in "quantum
|
|
|
150 bit creation" mode. This means that anything which modifies data
|
|
|
151 will end up creating quantum bits.
|
|
|
152 CWB S 0x19 'SS' 'loop: Condition While Body' 0 0
|
|
|
153 Followed by two statements, executes a loop. This implements
|
|
|
154 the (default) loop where the condition is before the WHILE and the
|
|
|
155 body after. The first statement is the body and the second is
|
|
|
156 the condition, not the other way around as one would expect.
|
|
|
157 BWC S 0x1a 'SS' 'loop: Body While Condition' 0 0
|
|
|
158 Followed by two statements, executes a loop. This implements
|
|
|
159 the (non default) loop where the body is before the WHILE and the
|
|
|
160 condition after. The first statement is the condition and the
|
|
|
161 second is the body, not the other way around as one would expect.
|
|
|
162 ENS S 0x1b 'RR' 'ENSlave' 0 0
|
|
|
163 Followed by two registers, enslaves the first to the second.
|
|
|
164 FRE S 0x1c 'RR' 'FREe' 0 0
|
|
|
165 Followed by two registers, frees the first from the
|
|
|
166 second. It is an error to free a register from another register
|
|
|
167 it was not enslaved to.
|
|
|
168 STU S 0x1d 'EER' 'STUdy' 0 0
|
|
|
169 Followed by an expression (the subject), a label (the
|
|
|
170 lecture) and a register (the class), executes a STUDY statement.
|
|
|
171 ENR S 0x1e 'C(E)R' 'ENRol' 0 0
|
|
|
172 Followed by a count of subjects, I<count> expressions representing
|
|
|
173 the subjects, and a register wishing to study these subjects,
|
|
|
174 looks for a class teaching the subjects and enrols the register there.
|
|
|
175 LEA S 0x1f 'ER' 'LEArns' 0 0
|
|
|
176 Followed by an expression (the subject), and a register (the student)
|
|
|
177 looks for a lecture where that subject is taught in one of the
|
|
|
178 classes the student is enrolled in. The class register is
|
|
|
179 temporarily enslaved to the student and execution continues
|
|
|
180 at the start of the lecture.
|
|
|
181 FIN S 0x20 '' 'FINish lecture' 0 0
|
|
|
182 Execution continues after the I<LEA> which took
|
|
|
183 us to the lecture. Also frees the class register from the student.
|
|
|
184 GRA S 0x21 'R' 'GRAduate' 0 0
|
|
|
185 Followed by a register (a student) it causes the
|
|
|
186 student to graduate, that is to drop all classes.
|
|
|
187 NXL S 0x22 'E' 'Next From Label' 0 0
|
|
|
188 Similar to I<CFL>, but executes a NEXT FROM instead: the difference
|
|
|
189 is that I<NXL> stashes the return address in the same way as I<NXT>
|
|
|
190 does. See I<CFL> and I<NXT>.
|
|
|
191 NXG S 0x23 'C(O)' 'Next From Gerund' 0 0
|
|
|
192 Similar to I<CFG>, but executes a NEXT FROM instead: the difference
|
|
|
193 is that I<NXG> stashes the return address in the same way as I<NXT>
|
|
|
194 does. See I<CFG> and I<NXT>.
|
|
|
195 CON S 0x24 'OO' 'CONvert' 0 0
|
|
|
196 Followed by two opcodes, converts the first into the
|
|
|
197 second. The two opcodes must be compatible, in the sense that
|
|
|
198 they take the same operands.
|
|
|
199 SWA S 0x25 'OO' 'SWAp' 0 0
|
|
|
200 Followed by two opcodes, swaps them. The two opcodes must
|
|
|
201 be compatible, in the sense that they take the same operands.
|
|
|
202 BUG S 0x26 '#' 'compiler BUG' 0 0
|
|
|
203 This opcode is automatically inserted by the compiler where
|
|
|
204 appropriate. Takes one argument, the bug type (#0 - explainable,
|
|
|
205 \#1 - unexplainable).
|
|
|
206 OPT S 0x27 'C([)C(])' 'OPTimise' 0 0
|
|
|
207 Takes a constant (the left count), I<left count> patterns, a second
|
|
|
208 constant (the right count) and I<right count> replacements. Inserts
|
|
|
209 the resulting rule into the optimiser, which can do whatever it
|
|
|
210 likes with it.
|
|
|
211 EBC S 0x28 'ES' 'Event: Body while Condition' 0 0
|
|
|
212 Followed by an expression and a statement, schedules an event. This
|
|
|
213 implements the (non default) event where the body is before the WHILE
|
|
|
214 and the condition after, and therefore produces a runtime error unless
|
|
|
215 its implementation is CONVERTed to or SWAPped with I<ECB>.
|
|
|
216 ECB S 0x29 'ES' 'Event: Condition while Body' 0 0
|
|
|
217 Followed by an expression and a statement, schedules an event. This
|
|
|
218 implements the (default) event where the condition is before the
|
|
|
219 WHILE and the body after.
|
|
|
220 FRZ S 0x2a '' 'FReeZe' 0 0
|
|
|
221 Freezes the current program by removing the source code and replacing
|
|
|
222 the grammar used to compile it with the "secondary" grammar; this
|
|
|
223 means that subsequent I<CRE> and I<DES> will be an error if they
|
|
|
224 cause recompilation. A compiler works by creating a secondary grammar,
|
|
|
225 then freezing itself and then continuing with the user's program,
|
|
|
226 which is compiled using the new grammar just created, rather than
|
|
|
227 the one used to compile the compiler itself.
|
|
|
228 SYS S 0x2b 'EC(S)' 'SYStem call' 0 0
|
|
|
229 Followed by an expression (the system call number), a count, and
|
|
|
230 I<count> statements (the system call implementation), defines a
|
|
|
231 system call.
|
|
|
232 UNS S 0x2c 'EEC(E)' 'UNdocumented Statement' 0 0
|
|
|
233 This opcode is documented in the CLC-INTERCAL reference manual.
|
|
|
234 STE S 0x2d 'C(E)C(E)C(R)' 'STEal' 0 0
|
|
|
235 Followed by a count, I<count> expression, a second count, the
|
|
|
236 corresponding number of expressions, a third count and the
|
|
|
237 corresponding number of registers, defines a STEAL statement;
|
|
|
238 the first two counts should be #0 or #1, representing the presence
|
|
|
239 or absence of ON and FROM, respectively.
|
|
|
240 SMU S 0x2e 'C(E)C(E)C(R)' 'SMUggle' 0 0
|
|
|
241 Takes the same arguments as I<STE>, but defines a SMUGGLE statement.
|
|
|
242 CSE S 0x2f 'EC(ES)' 'CaSE' 0 0
|
|
|
243 Followed by an expression, a count and I<count> pairs of (expression,
|
|
|
244 statement), defines a CASE statement.
|
|
|
245 # opcodes 0x30 .. 0x3c are reserved
|
|
|
246 MKG S 0x3d 'EE' 'MaKe Gerund' 0 0
|
|
|
247 This opcode creates a new internal operation. It is useful to
|
|
|
248 extend the compiler (this is fully documented in the CLC-INTERCAL
|
|
|
249 reference manual).
|
|
|
250 USG S 0x3e 'E' 'USe Gerund' 0 0
|
|
|
251 Uses an opcode created by I<MKG>. It is useful to extend the
|
|
|
252 compiler (this is fully documented in the CLC-INTERCAL reference
|
|
|
253 manual).
|
|
|
254 FLA S 0x3f '' 'set object FLAg' 0 0
|
|
|
255 This opcode should never be executed, and will cause a runtime
|
|
|
256 error; compilers can generate this opcode to set an object flag,
|
|
|
257 but the opcode will be executed at compile time and replaced
|
|
|
258 by a single ABSTAINed FROM I<FLA>.
|
|
|
259 @END STATEMENTS
|
|
|
260
|
|
|
261 # registers - opcodes 0x40..0x4f
|
|
|
262 @GROUP REGISTERS NAME=w TYPE=s NUMBER=d ARGS=s DESCR=s ASSIGNABLE=d CONST=d DOC=m
|
|
|
263 SPO R 0x40 'E' 'SPOt' 1 0
|
|
|
264 Spot register (e.g. I<.4>)
|
|
|
265 TSP R 0x41 'E' 'Two SPot' 1 0
|
|
|
266 Two spot register (e.g. I<:7>)
|
|
|
267 TAI R 0x42 'E' 'TAIl' 1 0
|
|
|
268 Tail register (e.g. I<,2>). This represents the whole array. See
|
|
|
269 I<SUB> for subscripting.
|
|
|
270 HYB R 0x43 'E' 'HYBrid' 1 0
|
|
|
271 Hybrid register (e.g. I<;9>). This represents the whole array. See
|
|
|
272 I<SUB> for subscripting.
|
|
|
273 WHP R 0x44 'E' 'WHirlPool' 1 0
|
|
|
274 Whirlpool (e.g. I<@9>). This represents CLC-INTERCAL's class
|
|
|
275 registers. When used for I/O, it represents the filehandle
|
|
|
276 associated with the class.
|
|
|
277 DOS R 0x45 'E' 'Double-Oh-Seven' 1 0
|
|
|
278 Double-oh-seven: a special internal spot register used by the
|
|
|
279 compilers.
|
|
|
280 SHF R 0x46 'E' 'SHark Fin' 1 0
|
|
|
281 Shark fin: a special internal tail register used by the compilers
|
|
|
282 (e.g. I<^1>, the arguments given to the program on startup)
|
|
|
283 CHO R 0x47 'E' 'Crawling HOrror' 1 0
|
|
|
284 Crawling horror: a special register holding a compiler, grammar
|
|
|
285 or something similar. Currently, these registers cannot be used
|
|
|
286 directly, they are implicitely used by I<CRE> and I<DES>.
|
|
|
287 # opcodes 0x48..0x4e are reserved for future register types
|
|
|
288 TYP R 0x4f 'RE' 'TYPe' 1 0
|
|
|
289 Followed by any register, returns its type.
|
|
|
290 For example, I<TYP> I<SPO> I<136> is equivalent
|
|
|
291 to I<SPO>. It can be useful to find out the type of an
|
|
|
292 indirect register, and is used to translate CLC-INTERCAL's
|
|
|
293 intersection-worm.
|
|
|
294 @END REGISTERS
|
|
|
295
|
|
|
296 # register prefixes - opcodes 0x50..0x5f
|
|
|
297 @GROUP PREFIXES NAME=w TYPE=s NUMBER=d ARGS=s DESCR=s ASSIGNABLE=d CONST=d DOC=m
|
|
|
298 OVR R 0x50 'ER' 'OVerload Register' 1 0
|
|
|
299 Followed by an expression and a register,
|
|
|
300 overloads the register and returns the register itself.
|
|
|
301 ROR R 0x51 'R' 'Remove Overload Register' 1 0
|
|
|
302 Followed by a register name, removes any overloads and returns
|
|
|
303 the register itself. Used by the optimiser. Assignable.
|
|
|
304 OWN R 0x52 'ER' 'OWNer' 1 0
|
|
|
305 Followed by a constant and a register, takes the
|
|
|
306 corresponding owner from the register.
|
|
|
307 SUB R 0x53 'ER' 'SUBscript' 1 0
|
|
|
308 Followed by an expression and a subscriptable register,
|
|
|
309 it accesses the given subscript. For multidimensional arrays,
|
|
|
310 repeat as in I<SUB> I<131> I<SUB> I<132> I<TAI> I<133> for I<:5 SUB
|
|
|
311 \#4 SUB #3>. In addition to hybrid, tail and shark fin registers,
|
|
|
312 whirlpools also accept subscripts, allowing to access the subjects
|
|
|
313 directly.
|
|
|
314 # opcodes 0x53..0x5f are reserved
|
|
|
315 @END PREFIXES
|
|
|
316
|
|
|
317 # expressions - opcodes 0x60..0x7b
|
|
|
318 @GROUP EXPRESSIONS NAME=w TYPE=s NUMBER=d ARGS=s DESCR=s ASSIGNABLE=d CONST=d DOC=m
|
|
|
319 MUL E 0x60 'C(E)' 'MULtiple number' 0 0
|
|
|
320 Followed by an expression (the count) and then a number of
|
|
|
321 expressions, represents a ``multiple number''. This can be used
|
|
|
322 to assign to an array, to dimension it (e.g. translating the
|
|
|
323 statement C<,2 <- #3 BY #5> the value to be assigned would be
|
|
|
324 I<MUL> I<130> I<131> I<133>). Not assignable.
|
|
|
325 STR E 0x61 'C(N)' 'STRing' 0 0
|
|
|
326 Similar to I<MUL>, but used in the special case where all the
|
|
|
327 arguments are constant characters. This may result in internal
|
|
|
328 optimisations and the like. Otherwise it is just a more compact
|
|
|
329 way of using I<MUL> where all arguments are constants and fit
|
|
|
330 in a byte. Not assignable.
|
|
|
331 BUT E 0x62 '#E' 'unary BUT' 1 0
|
|
|
332 Followed by two expressions, computes the unary I<BUT> of the
|
|
|
333 second expression, preferring the value of the first - so this
|
|
|
334 can also be used for unary I<3BUT> etc. The special prevference
|
|
|
335 value 7, which is invalid for unary I<BUT>, is used to indicate
|
|
|
336 unary I<AND>. Assignable if the second argument is assignable.
|
|
|
337 BBT E 0x63 '#EE' 'binary BUT' 1 0
|
|
|
338 Binary version of I<BUT>. Used by the optimiser. Assignable if
|
|
|
339 its arguments are.
|
|
|
340 SWB E 0x64 'E' 'unary Subtract Without Borrow' 1 0
|
|
|
341 Followed by one expression, it computes the unary subtract
|
|
|
342 without borrow. In base 2, corresponds to the unary exclusive
|
|
|
343 or. Assignable if the argument is.
|
|
|
344 BSW E 0x65 'EE' 'binary Subtract Without Borrow' 1 0
|
|
|
345 Binary version of I<SWB>. Used by the optimiser. Assignable if
|
|
|
346 its arguments are.
|
|
|
347 AWC E 0x66 'E' 'unary Add Without Carry' 1 0
|
|
|
348 Followed by one expression, it computes the unary Add without
|
|
|
349 carry; invalid in base 2. Assignable if the argument is.
|
|
|
350 BAW E 0x67 'EE' 'binary Add Without Carry' 1 0
|
|
|
351 Binary version of I<AWC>. Used by the optimiser. Assignable if
|
|
|
352 its arguments are.
|
|
|
353 SEL E 0x68 'EE' 'SELect' 1 0
|
|
|
354 Followed by two expressions, it selects them. Assignable if the
|
|
|
355 arguments are assignable.
|
|
|
356 INT E 0x69 'EE' 'INTerleave' 1 0
|
|
|
357 Followed by two expressions, interleaves them. Assignable if both
|
|
|
358 arguments are assignable.
|
|
|
359 NUM E 0x6a 'R' 'NUMber' 1 0
|
|
|
360 Followed by a register, returns its number. So for example I<NUM>
|
|
|
361 I<SPO> I<#2> would be the same as I<#2>. This is more useful when
|
|
|
362 the register provided is reached using I<OWN>. Assignable.
|
|
|
363 OVM E 0x6b 'EE' 'OVerload Many' 1 0
|
|
|
364 Followed by two expressions, overloads a range of registers. Note
|
|
|
365 that all types of registers are overloaded. The range is determined
|
|
|
366 by uninterleaving the second argument. See also I<OVR>. Assignable.
|
|
|
367 ROM E 0x6c 'E' 'Remove Overload Many' 1 0
|
|
|
368 Followed by an expression, removes overload from a range of
|
|
|
369 of registers. Used by the optimiser. Assignable.
|
|
|
370 SPL E 0x6d '' 'SPLat' 1 0
|
|
|
371 Returns the code of the last splat. This is only useful if the
|
|
|
372 program is quantum or threaded, otherwise it won't be executing
|
|
|
373 after a splat. If there was no splat, generates one. Assignable,
|
|
|
374 but in this case it unconditionally splats for obvious reasons.
|
|
|
375 UDV E 0x6e 'E' 'Unary DiVide' 1 0
|
|
|
376 The "most useless" operation, but surely somebody will find a
|
|
|
377 use for it. This operation can be considered arithmetic or
|
|
|
378 bitwise, depending on the value of special register I<%DM>.
|
|
|
379 RSE E 0x6f 'EE' 'Reverse SElect' 1 0
|
|
|
380 Like I<SEL>, but swaps its operands.
|
|
|
381 RIN E 0x70 'EE' 'Reverse INterleave' 1 0
|
|
|
382 Like I<INT>, but swaps its operands.
|
|
|
383 UNE E 0x71 'EEC(E)' 'UNdocumented Expression' 0 0
|
|
|
384 This opcode is documented in the CLC-INTERCAL reference manual.
|
|
|
385 # opcodes 0x72 .. 0x7d are reserved
|
|
|
386 @END EXPRESSIONS
|
|
|
387
|
|
|
388 # constants - opcodes 0x7e..0x7f
|
|
|
389 @GROUP CONSTANTS NAME=w TYPE=s NUMBER=d ARGS=s DESCR=s ASSIGNABLE=d CONST=d DOC=m
|
|
|
390 HSN # 0x7e 'N' 'Half Spot Number' 1 1
|
|
|
391 Followed by a second byte, represents the value of that byte.
|
|
|
392 OSN # 0x7f 'NN' 'One Spot Number' 1 1
|
|
|
393 Followed by two bytes, represents the 16 bit number which has the
|
|
|
394 first such byte as higher significant half, and the second byte
|
|
|
395 as lower significant half.
|
|
|
396 @END CONSTANTS
|
|
|
397
|
|
|
398 # all special registers
|
|
|
399 @GROUP SPECIAL NAME=w TYPE=s NUMBER=d DEFAULT=s CODE=s DESCR=s DOC=m
|
|
|
400 @SOURCE DOUBLE_OH_SEVEN
|
|
|
401 @SOURCE SHARK_FIN
|
|
|
402 @SOURCE WHIRLPOOL
|
|
|
403 @END SPECIAL
|
|
|
404
|
|
|
405 # special "spot" registers
|
|
|
406 @GROUP DOUBLE_OH_SEVEN NAME=w TYPE=s NUMBER=d DEFAULT=s CODE=s DESCR=s DOC=m
|
|
|
407 WT '%' 1 '0' 'zeroone' 'Write Type'
|
|
|
408 Determines how numeric WRITE IN behaves. The default value of
|
|
|
409 \#0 corresponds to the standard, traditional form; the value
|
|
|
410 \#1 enables wimp mode for input. Any other value is invalid.
|
|
|
411 RT '%' 2 '0' 'roman' 'Read Type'
|
|
|
412 Determines how numeric READ OUT produces its output. Assigning
|
|
|
413 a number to this register causes the corresponding style to be
|
|
|
414 selected; assigning a I<MUL> causes a symbolic lookup to determine
|
|
|
415 the style number. See L<Language::INTERCAL::ReadNumbers>.
|
|
|
416 IO '%' 3 '0' 'iotype' 'I/O type'
|
|
|
417 Determines how non-numeric WRITE IN and READ OUT work. Assigning
|
|
|
418 a number to this register causes the corresponding style to be
|
|
|
419 selected; assigning a I<MUL> causes a symbolic lookup to determine
|
|
|
420 the style number. See L<Language::INTERCAL::ArrayIO>.
|
|
|
421 BA '%' 4 '2' 'base' 'BAse'
|
|
|
422 Holds the base used for all arithmetic. Assigning a value less
|
|
|
423 than 2 or greater than 7 causes an error.
|
|
|
424 CF '%' 5 '0' 'comefrom' 'Come From style'
|
|
|
425 This register can only hold values from #0 to #3. The lowest bit
|
|
|
426 (in base 2) determines what happens when multiple COME FROM or
|
|
|
427 NEXT FROM all point at the same label: if zero, you get a splat,
|
|
|
428 if one you get a multithreaded program. The other bit determines
|
|
|
429 whether COME FROM gerund (and NEXT FROM gerund) will work: zero
|
|
|
430 disables these statements, one enables them. Thus all compilers
|
|
|
431 set %CF to #0, except I<thick.io> which sets it to #1 and
|
|
|
432 I<come-from-gerund.io> which sets it to #2.
|
|
|
433 CR '%' 6 '0' 'charset' 'Charset for Reads'
|
|
|
434 The character set used by alphanumeric READ OUT when %IO is
|
|
|
435 CLC. Assigning a number to this register causes the corresponding
|
|
|
436 style to be selected; assigning a I<MUL> causes a symbolic lookup
|
|
|
437 to determine the style number. See L<Language::INTERCAL::Charset>.
|
|
|
438 CW '%' 7 '0' 'charset' 'Charset for Writes'
|
|
|
439 The character set used by alphanumeric WRITE IN when %IO is
|
|
|
440 CLC. Assigning a number to this register causes the corresponding
|
|
|
441 style to be selected; assigning a I<MUL> causes a symbolic lookup
|
|
|
442 to determine the style number. See L<Language::INTERCAL::Charset>.
|
|
|
443 OS '%' 8 '0' 'spot' 'Operating System'
|
|
|
444 Hidden in the darkest corner of the operating system lurks a
|
|
|
445 "DO NEXT FROM %OS". As long as %OS has the default value of zero,
|
|
|
446 you are safe from this.
|
|
|
447
|
|
|
448 If %OS is assigned some other value, it behaves like a normal
|
|
|
449 (?) NEXT FROM, with one added twist to do with parameter
|
|
|
450 passing. Every time your program assigns a value to a register,
|
|
|
451 %OS is freed from any existing masters and enslaved to the
|
|
|
452 register you've just assigned to. This allows the system call code
|
|
|
453 to refer to I<$%OS> to try to guess what you want. The system call
|
|
|
454 will use up to five arguments, provided by registers I<.-$%OS>,
|
|
|
455 I<:-$%OS>, I<,-$%OS>, I<;-$%OS> and I<@%$OS>, in other words the spot,
|
|
|
456 two spot, tail, hybrid and whirlpool register with the same number as whatever
|
|
|
457 you last assigned to. This is called "call by vague resemblance
|
|
|
458 to the last assignment" and, to our knowledge, no other language
|
|
|
459 has ever used this style of parameter passing.
|
|
|
460
|
|
|
461 To use, you do something like "(666) DO .5 <- #1" which would
|
|
|
462 execute syscall #1, assuming %OS has the value #666. This
|
|
|
463 particular example would store the version number of CLC-INTERCAL
|
|
|
464 in ,5.
|
|
|
465 TM '%' 9 '0' 'zeroone' 'Trace Mode'
|
|
|
466 If %TM is zero, the program is not traced. If it is #1 the program
|
|
|
467 will send bytecode trace information to @TRFH. Assigning any other
|
|
|
468 value to %TM is an error.
|
|
|
469 AR '%' 10 '0' 'spot' 'Array read value'
|
|
|
470 Contains the last byte READ OUT when %IO is C.
|
|
|
471 AW '%' 11 '0' 'spot' 'Array write value'
|
|
|
472 Contains the last byte WRITtEn IN when %IO is C.
|
|
|
473 JS '%' 12 "'END_JUNK'" 'symbol' 'Junk Symbol'
|
|
|
474 When parsing a comment, the compiler needs to be told how to
|
|
|
475 recognise the start of next statement: for example, I<1972.io> and
|
|
|
476 I<ick.io> set this to a grammar symbol meaning "optional (number)
|
|
|
477 followed by DO or PLEASE"; I<sick.io> does something similar, but
|
|
|
478 the complication caused by computed labels (if enabled) makes it
|
|
|
479 alightly more difficult to describe what this symbol does.
|
|
|
480
|
|
|
481 Changing the value of this register at runtime can be a great
|
|
|
482 obfuscation tool.
|
|
|
483 SS '%' 13 "'SPACE'" 'symbol' 'Space symbol'
|
|
|
484 The compiler will automatically ignore anything matched by this
|
|
|
485 symbol. If the Whitespace extension is installed, anything matched
|
|
|
486 by this symbol is passed to the Whitespace compiler. See the
|
|
|
487 documentation which comes with the Whitespace extension. Changing
|
|
|
488 the value of this register at runtime can be a great obfuscation
|
|
|
489 tool.
|
|
|
490 PS '%' 14 "'PROGRAM'" 'symbol' 'Program symbol'
|
|
|
491 Determines where the compiler starts when parsing a program.
|
|
|
492 This should be a grammar symbol corresponding to a single
|
|
|
493 statement, the symbol is automaticaly used repeatedly to
|
|
|
494 parse the whole program. Changing the value of this register
|
|
|
495 at runtime can be a great obfuscation tool. See also I<%IS>.
|
|
|
496 FS '%' 15 "'CALC_FULL'" 'symbol' '"full" symbol'
|
|
|
497 Used by the Intercal calculator (intercalc) to determine how to
|
|
|
498 parse lines when operating in "full" mode.
|
|
|
499 ES '%' 16 "'CALC_EXPR'" 'symbol' '"expr" symbol'
|
|
|
500 Used by the Intercal calculator (intercalc) to determine how to
|
|
|
501 parse lines when operating in "expr" mode.
|
|
|
502 IS '%' 17 '0' 'symbol' 'Intersection symbol'
|
|
|
503 Determines what separates statements in the program; this is
|
|
|
504 not currently used in any compiler and can be left at the
|
|
|
505 default, zero. If set to any other value, the corresponding
|
|
|
506 grammar symbol is used to compile the bit of source between
|
|
|
507 consecutive statements; if this generates code, it will be
|
|
|
508 executed with the preceding statement. Changing the value of
|
|
|
509 this register at runtime can be a great obfuscation tool.
|
|
|
510 See also I<%PS>.
|
|
|
511 DM '%' 18 '0' 'zeroone' 'unary Division mode'
|
|
|
512 This register can only have value #0 or #1, and determines
|
|
|
513 the style of unary division employed. The default value #0
|
|
|
514 corresponds to the "arithmetic" style of division, while
|
|
|
515 value #1 corresponds to the "bitwise" style. See the
|
|
|
516 I<UDV> opcode.
|
|
|
517 SP '%' 19 '1000' 'splat' 'SPlat'
|
|
|
518 This register contains the code of the last splat, just like
|
|
|
519 the '*' expression. Assigning to it, however, does not cause
|
|
|
520 a splat, but will trigger any events depending on splats.
|
|
|
521 This register is intended for internal use by the compiler;
|
|
|
522 programs should use I<SPL> instead.
|
|
|
523 TH '%' 20 '0' 'zeroone' 'THeft'
|
|
|
524 This register determines whether a program has been compiled
|
|
|
525 with INTERNET support. If the register is #0, the program
|
|
|
526 cannot be a victim of theft, but cannot steal or smuggle
|
|
|
527 anything; if the register is #1, the program has full network
|
|
|
528 support.
|
|
|
529 RM '%' 21 '0' 'zeroone' 'Reinstate Mode'
|
|
|
530 This register can only have value #0 or #1, and determines
|
|
|
531 whether a REINSTATE of an IGNOREd register behaves in the
|
|
|
532 traditional way (#0) or in the way documented by the CLC-INTERCAL
|
|
|
533 documentation (#1).
|
|
|
534 @END DOUBLE_OH_SEVEN
|
|
|
535
|
|
|
536 # special "tail" registers
|
|
|
537 @GROUP SHARK_FIN NAME=w TYPE=s NUMBER=d DEFAULT=s CODE=s DESCR=s DOC=m
|
|
|
538 AV '^' 1 '[]' 'vector' 'Argument Vector'
|
|
|
539 The runtime initialises it with any command-line arguments provided
|
|
|
540 to the program.
|
|
|
541 EV '^' 2 '[]' 'vector' 'Environment Vector'
|
|
|
542 The runtime initialises it with environment variables available
|
|
|
543 when the program starts.
|
|
|
544 @END SHARK_FIN
|
|
|
545
|
|
|
546 # whirlpool registers are not special, but they get some added value
|
|
|
547 @GROUP WHIRLPOOL NAME=w TYPE=s NUMBER=d DEFAULT=s CODE=s DESCR=s DOC=m
|
|
|
548 OR '@' 0 'undef' 'whirlpool' 'Overload Register'
|
|
|
549 This register cannot be used directly. During overload, it is
|
|
|
550 temporarily enslaved to the register being overloaded, so it
|
|
|
551 is possible to refer to this register's owner (I<OWN> I<1> I<WHP> I<0>,
|
|
|
552 corresponding to I<$@0>) within the second argument of I<OVR> or
|
|
|
553 I<OVM> opcodes.
|
|
|
554 OWFH '@' 1 '$stdwrite' 'whirlpool' 'Object\'s write filehandle'
|
|
|
555 Used by default for all WRITE IN statements. Defaults to the standard
|
|
|
556 write filehandle, which your operating system may call "standard
|
|
|
557 input".
|
|
|
558 ORFH '@' 2 '$stdread' 'whirlpool' 'Object\'s read filehandle'
|
|
|
559 Used by default for all READ OUT statements. Defaults to the standard
|
|
|
560 read filehandle, which your operating system may call "standard
|
|
|
561 output"
|
|
|
562 OSFH '@' 3 '$stdsplat' 'whirlpool' 'Object\'s splat filehandle'
|
|
|
563 Used by default for the text produced by a splat. Defaults to the
|
|
|
564 standard splat filehandle, which your operating system may call
|
|
|
565 "standard error".
|
|
|
566 SNFH '@' 7 '$devnull' 'whirlpool' 'Null filehandle'
|
|
|
567 If you READ OUT to @7 nothing happens. If you WRITE IN from @7
|
|
|
568 you get an empty write (for numeric writes, a value of #0, for
|
|
|
569 non-numeric writes an empty array).
|
|
|
570 TRFH '@' 9 '$stdsplat' 'whirlpool' 'Trace filehandle'
|
|
|
571 Trace output, if enabled by I<%TM>, is sent here. Defaults to the
|
|
|
572 standard splat filehandle, which your operating system may call
|
|
|
573 "standard error"
|
|
|
574 @END WHIRLPOOL
|
|
|
575
|
