The Perl INTERCAL compiler

... Classes and Lectures

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.

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
    PLEASE ,3 LEARNS #9
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 which lecture will be selected? We decided that the first ENROL statement executed win, so in this case the lecture is at (1000). However, the last statement can only go to the lecture at (2200) in class @5, so that's what happens.

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.

Within a lecture, the class register (@nnn) is enslaved to the student. So in lecture (1000) you can use $@2 for the student. You can change the enslavement of the class itself during a lecture, but it will be restored to its previous value when the lecture finishes. This allows clean recursive calls at the price of a just minor inconvenience.

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:
    'oo, ick' -alPerlText example.i
This produces "example.pl", which is an executable. Alternatively, run it directly with:
    'oo, ick' -a 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.


Back