Canterbury Pascal

Le compilateur Canterbury Pascal est un compilateur Pascal assez particulier, puisqu'il produit du code pour une machine virtuelle Java (bytecode) ou une traduction du programme en Java. A l'origine, il coûtait 99 $ pour la version complète qui génère soit du bytecode compilé, soit du Java et 49 $ pour la version qui génère du bytecode seulement. Ce prix est modique pour un outil de qualité professionnelle. Le site de l'éditeur ayant disparu, le compilateur est téléchargeable gratuitement chez Developpez.com :

• Canterbury Pascal pour Java
• Canterbury Pascal pour JVM

La société MHCCorp.com est impliquée dans la réalisation de compilateurs depuis 1996 et nous avons des raisons de penser que le compilateur Pascal (ils fournissent aussi un Modula 2 et un Oberon 2) date de 1998, car c'est dans l'entête du fichier "runtime" du compilateur dont voici quelques extraits :

UNIT SYSTEM;

INTERFACE

{ the interface itself is part of the compiler... }

IMPLEMENTATION

USES
  java_lang_RuntimeException,
  java_io_InputStreamReader,
  java_io_OutputStreamWriter;


CONST
  IsLongReal      = SizeOf( REAL ) = SizeOf( DOUBLE );

TYPE
  OPENINDEX       = 0..HIGH(LONGINT)-1;
  BYTEARRAY       = ARRAY [OPENINDEX] OF BYTE;
  PBYTEARRAY      = ^BYTEARRAY;
 
VAR
  InOutRes        : INTEGER;
  args             : POINTER;
  
PROCEDURE OrBytes( Dest,Source1,Source2:POINTER; Size:LONGWORD );
    VAR
    i,j       : LONGINT;
    val       : PBYTEARRAY;
    val1      : PBYTEARRAY;
    val2      : PBYTEARRAY;
BEGIN

    val := Dest;
    val1 := Source1;
    val2 := Source2;
     i := 0;
     j := Size;
        WHILE i < j DO BEGIN
            val^[i] := val1^[i] OR val2^[i];
            INC( i );
        END;
END;

A partir de cet exemple, je vais présenter quelques caractéristiques du compilateur.

Le langage est bien du Pascal "standard" et non pas un dialecte plus ou moins proche. La lisibilité du langage, son typage, les déclarations des variables sont bien respectés.
Les types ressemblent beaucoup à ceux auxquels nous sommes habitués (SHORTINT, SMALLINT, LONGINT, INTEGER, BOOLEAN (TRUE et FALSE), STRING, CHAR, ARRAY, etc).
Un RECORD se déclare de la même manière qu'en Borland ou Free Pascal :

RECORD
  name, firstname : ARRAY [0..31] OF CHAR;
  age : INTEGER;
  salary : REAL
END;

Mais attention : la doc précise qu'il est impossible d'utiliser des variables de type VARIANT (qui existent en Canterbury) à l'intérieur d'un RECORD pour accéder à la même donnée avec différents types. Donc, pas de transtypages sauvages en Canterbury dans un RECORD, mais il y a cependant un opérateur de transtypage : TYPECAST, qui est utilisé comme une fonction.

On remarquera un type POINTER, qui pourrait étonner sachant que Java ne possède pas de pointeurs. En fait, il s'agit des "références Java" appliquées au Pascal, ce qui a pour conséquence de ne permettre l'usage de ces pointeurs que pour les types structurés (RECORD, ARRAY, SET, FILE, CLASS ou CLASS REFERENCE) et pas pour les autres types de base (INTEGER, BOOLEAN, ENUMERATION, etc) puisque les références Java ne concernent que les types structurés.

Il convient donc de passer un peu de temps à lire la doc (en anglais seulement), qui est bien faite mais qui souffre parfois d'une concision toute britannique quand on est habitué aux docs de Borland : très peu d'exemples. Il vaut mieux comprendre le Backus-Naur parfois (la grammaire complète du langage est fournie) ou alors expérimenter un peu (j'avoue que j'ai plutôt expérimenté dans les cas douteux). La plupart du temps, néanmoins, la doc suffit. Elle insiste bien sur les incompatibilités avec Borland ou le Pascal ISO.

Le modèle objet est très proche de celui de Java (normal) et pas très éloigné non plus de celui de Borland ou Free Pascal. Les différents attributs pour une classe sont : PUBLIC, PROTECTED et PRIVATE. Pour des raisons de compatibilité avec Borland Object Pascal, il est également possible d'utiliser PUBLISHED et AUTOMATED, qui seront traités comme l'attribut PUBLIC en Canterbury Pascal. L'attribut par défaut est PUBLIC.
Le mot clé est CLASS, c'est un type conformément aux recommandations de Wirth; il y a des CONSTRUCTOR et DESTRUCTOR; la surcharge est permise (attribut OVERRIDE); les méthodes peuvent être statiques ou virtuelles, etc.

A noter les deux mots réservés IS et AS, qui sont des opérateurs sur les classes. IS, par exemple, permet un contrôle dynamique des types objets et retourne un booléen (ex : MonRectangle IS TRectangle retourne TRUE si MonRectangle est une instance de la classe TRectangle).

Voici la déclaration d'une classe "rectangle" que j'ai récupérée dans la documentation :

TYPE
  TRectangle = CLASS( TFigure )
    lenght : INTEGER;
    width : INTEGER;
    CONSTRUCTOR Create();
      OVERRIDE;
    CONSTRUCTOR Init( length, width : INTEGER );
      VIRTUAL;
    DESTRUCTOR;
      VIRTUAL;
  END;

Le gros avantage, vous avez pu le deviner avec le premier exemple, c'est que Canterbury est capable d'importer directement une classe Java par la clause USES (jetez un coup d'oeil à l'exemple 1). La doc dit "A direct Java class import enables the programmer to gain access to a foreign Java class which was not originally created by Canterbury Pascal" c'est-à-dire que le programmeur peut importer et utiliser une classe Java directement (avec USES java_class_une classe;), même si elle a été créée en Java et non en Canterbury Pascal.

La simplicité de cet import permet au programmeur Canterbury Pascal d'avoir accès à l'immense réservoir de bibliothèques Java disponibles sur le Net, le tout en Pascal ! Un projet Java peut ainsi être écrit à la fois en Java pour certains modules et en Pascal pour d'autres, le mélange des deux sera invisible au moment de la compilation. La reprise et la traduction de programmes Borland, Free ou Think Pascal et autres ne se fera certes pas sans un peu de transpiration mais reste possible.

Avec Canterbury Pascal, la reprise d'un vieux programme Turbo d'une dizaine d'années et son interfaçage avec des bibliothèques Java flambant neuves est tout-à-fait possible (c'est sur ce type de - petit - projet que j'ai travaillé : un logiciel éducatif en Turbo Pascal qui devait s'interfacer avec le Net et bénéficier d'un module écrit en Java; ça a fonctionné). Canterbury Pascal peut donc servir de langage de glue.

Je n'ai pas mis la portabilité en avant car Free Pascal étant devenu mon Pascal par "défaut", je pense que je bénéficie d'une portabilité extraordinaire mais pour certains ce pourra être un argument de plus.

Voilà pour le langage.

Je dois dire que je n'ai pas utilisé intensivement Canterbury puisque j'ai testé la version d'essai mais j'ai aussi pu tester quelques exemples et courts programmes et compiler le logiciel éducatif dont j'ai déjà parlé chez un collègue qui a acquis la version complète. Je n'ai pas eu de problème de compilation ou de bug particulier, mais je ne l'ai pas utilisé intensivement, je le répète. L'ensemble me paraît néanmoins bien pensé et fiable.

En ce qui concerne la vitesse de compilation j'ai trouvé ça plus que correct, ce n'est pas du Borland c'est sûr, mais on n'a pas vraiment le temps de vider une cafetière, même à moitié pleine. Maintenant, pour un très gros projet, il faudra faire l'expérience soi-même. La phase de génération du Java à partir du code Pascal est rapide je trouve; après, c'est le compilo java qui fait le boulot. Il y en a des plus ou moins rapides paraît-il, je n'en sais pas plus, je ne suis pas spécialiste.

Les moins :

• Pas assez d'exemples complets : il n'y a pas de petits programmes à compiler pour tester la syntaxe, c'est dommage je trouve parce que ça aide bien.

• Le package ne comporte pas d'EDI (on accède à la doc via un navigateur HTML, c'est un peu moins pratique), pour ma part j'utilise Scite pour des petits et moyens projets et Lazarus pour les plus gros ou pour le GUI. Mon collègue avait PSPAD, un éditeur freeware que je ne connaissais pas, (très complet au demeurant) qui fonctionnait aussi très bien avec Canterbury. Le compilateur est invoqué par la ligne de commande : java mhc.pas <MonProgramme> (il faut que " MonProgramme " ait une extension en ".pas" et on peut rajouter des options de compilation). Donc, un simple fichier de configuration convient.

• Il n'y a pas non plus de GUI builder mais il en existe pour Java, il suffit donc de faire l'interface avec un GUI Builder Java et d'interfacer ensuite avec Canterbury (ce n'est pas moi qui me suis occupé de l'interface mais c'est comme cela que ça a fonctionné pour le logiciel éducatif). C'est évidemment moins pratique que Lazarus ou Delphi.

Je trouve que c'est un produit intéressant et original qui put rendre pas mal de services au programmeur Pascal. Personnellement, j'utilise aussi le langage Python donc je n'ai pas éprouvé le besoin d'acquérir la version complète. C'est pourtant un produit qui m'a bien séduit dans son concept, sa réalisation (et son rappport qualité/prix à l'origine).