Table of contents:
CLC-INTERCAL introduces a concept of classes and lectures which can be used to build object-oriented programs.
Conceptually, a class is a place where you go and learn. This might differ from the concept by the same name in other languages, but is perfectly consistent with English usage of the word. To define a class, we need to list which subjects one can learn there. We do this using the related concept of lecture.
A lecture is more specialised than a class, in that you learn just one
subject. Like everything else in INTERCAL, subject are identified by a
number; lectures, on the other hand, are identified by a label. Just for
completeness, we mention here that classes are identified by a whirlpool
(@) register.
To tell the compiler that a lecture happens at (1000) in class @2,
and the subject of the lecture is #5, you say:
DO STUDY #5 AT (1000) IN CLASS @2
There is no need to explicitely define classes. The above line implies the
existence of a class numbered @2, and if several such lines
mention the same class then we know that all these subjects are taught there.
Note that the labels must exist, as the program will need to execute there. However, the labels only need to exist when the LEARNS statement is executed, and they do not need to exist when the STUDY is executed.
Once you have defined a class, you might want to have some students there. Other languages create objects from a class. We don't. The object is there before, and becomes a student by asking:
PLEASE ENROL :1 TO LEARN #5 + #7
This means, look for a class which teaches subjects #5 and
#7, and make a note that :2 now studies there.
:2 can also study elsewhere. This is not a problem. Other
languages make a very big fuss about this and call it "multiple inheritance",
but it's all very simple as you'll see soon.
In fact, let's step back and define two classes:
DO STUDY #5 AT (1000) IN CLASS @2
DO STUDY #7 AT (1100) IN CLASS @2
PLEASE STUDY #8 AT (1200) IN CLASS @2
DO STUDY #5 AT (2000) IN CLASS @5
DO STUDY #7 AT (2100) IN CLASS @5
PLEASE STUDY #9 AT (2200) IN CLASS @5
We first note that now just asking to learn #5 and #7
is not enough, as both classes teach these subjects. If you try that, you get
a CLASS WAR error. Intuitively, both classes are trying to get you as a student.
But this is easy to fix, just ask for #8 or #9, as
appropriate. Let's now enrol three students:
DO ENROL :1 TO LEARN #8
DO ENROL .2 TO LEARN #5 + #9
PLEASE ENROL ,3 TO LEARN #5 + #8
DO ENROL ,3 TO LEARN #7 + #9
As a result, :1 is in class @2, .2 is
in class @5, and ,3 is in both classes. So what
happens when one of them wants to learn something?
DO :1 LEARNS #5
DO .2 LEARNS #5
DO ,3 LEARNS #5
Here the first statement will attend lecture at (1000), because :1
is in class @2, while the second attends the night lecture at
(2000), because .2 is in class @5. What happens
with the third statement? ,3 is in both classes, so you get
a CLASS WAR error.
If you want to start afresh, you can remove any current ENROLment with:
DO ,3 GRADUATES
After this, you can ENROL again, and you know for sure what class you are in.
Having described the classes and students, it's about time to go to the lectures. This is what other languages might call methods, except that other languages don't select classes by example (find a class with methods "open", "close", and "print" - it could be a useful extension to C++, Java, and Perl)
A lecture is identified by a label. When a student asks to study a subject, program execution continues at that label until the statement FINISH LECTURE is executed, at which point execution resumes where it was before. Note that there are separate stacks for lectures and NEXT, so FORGETting any number of levels will not change the return point for a lecture. It also allows very interesting execution paths as there are two independent ways of executing subroutines. For example, you can have a NEXT (or NEXT FROM) which is executed inside a lecture, then FINISH LECTURE. That gets back just after the LEARNS statement, however you are still allowed to RESUME. Just don't ask us where you end up executing.
Within a lecture, the class register (@nnn) is
enslaved to the student. So in lecture (1000) you can use $@2
for the student. The FINISH LECTURE statement automatically frees the
class register from the student. You can change that as well, but you
are likely to run into problems if you do.
Let us conclude our discussion with an example, actually used in the Turing
Machine program which comes with the compiler. Class @1
implements 16 bit increment and decrement (inspired from the lib/plus.i
program in C-INTERCAL's code pit, but modified to avoid using NEXT and
similar horrors, using the much cleaner computed COME FROM). The student
.2 learns #1 (increment) a total of six times,
and #2 (decrement) twice, so the end result is to add 4 to
the register. As for .1, that just gets incremented once
and decremented twice. And in fact the program prints MCCXXXVIII (1238)
followed by M (1000).
PLEASE STUDY #1 AT (1000) IN CLASS @1
PLEASE STUDY #2 AT (2000) IN CLASS @1
PLEASE ENROL .1 TO LEARN #1
PLEASE ENROL .2 TO LEARN #1 + #2
DO .1 <- #1001
DO .2 <- #1234
PLEASE .2 LEARNS #1
DO .2 LEARNS #1
DO .1 LEARNS #1
DO .2 LEARNS #1
DO .2 LEARNS #2
DO .2 LEARNS #1
PLEASE .2 LEARNS #1
DO .1 LEARNS #2
DO .1 LEARNS #2
DO .2 LEARNS #1
DO .2 LEARNS #2
DO READ OUT .2
PLEASE READ OUT .1
DO GIVE UP
(1000) PLEASE STASH .65530 + .65531 + .65532
DO .65530 <- $@1 ~ #65535
DO .65531 <- #1
PLEASE COME FROM (1001)
DO .65532 <- .65530 ~ #1
DO .65532 <- '.65532 ¢ .65532' ~ #3
DO .65532 <- '.65532 ¢ .65532' ~ #15
DO .65532 <- '.65532 ¢ .65532' ~ #255
DO .65532 <- '.65532 ¢ .65532' ~ #65535
(1002) DO .65532 <- #1002 ~ .65532
DO $@1 <- "¥ '.65531 ¢ "$@1 ~ #65535"'" ~ '#0 ¢ #65535'
PLEASE RETRIEVE .65530 + .65531 + .65532
PLEASE FINISH LECTURE
PLEASE COME FROM .65532
DO .65532 <- #0
DO .65530 <- .65530 ~ #65534
(1001) DO .65531 <- '.65531 ¢ #1' ~ '#65535 ¢ #1'
(2000) PLEASE STASH .65530 + .65531 + .65533
DO .65530 <- $@1 ~ #65535
DO .65531 <- #1
PLEASE COME FROM (2001)
DO .65533 <- .65530 ~ #1
DO .65533 <- '.65533 ¢ .65533' ~ #3
DO .65533 <- '.65533 ¢ .65533' ~ #15
DO .65533 <- '.65533 ¢ .65533' ~ #255
DO .65533 <- '.65533 ¢ .65533' ~ #65535
(2002) DO .65533 <- #2002 ~ .65533
DO .65533 <- #0
DO .65530 <- .65530 ~ #65534
(2001) DO .65531 <- '.65531 ¢ #1' ~ '#65535 ¢ #1'
PLEASE COME FROM .65533
DO $@1 <- "¥ '.65531 ¢ "$@1 ~ #65535"'" ~ '#0 ¢ #65535'
PLEASE RETRIEVE .65530 + .65531 + .65533
PLEASE FINISH LECTURE
To compile the program to Perl, save it as example.i, and use:
sick -lObject example.i
This produces "example.io", which is an executable. Alternatively, run it
directly with:
sick -lRun example.i
Note that you can copy-and-paste from your browser into an (8 bit clean) text editor. If you save the file from the browser you'll also need to replace the HTML escapes with the appropriate characters.
We feel no need to comment on the program, as it is self-exlanatory.