Quésoft microsystèmes
Spécifications du langage Moka.

Préambule

Le langage Moka a été développé par Quésoft microsystèmes dans l'optique de fournir une alternative orientée objet à la programmation C sur calculatrice graphique TI-89 et TI-92 plus.  En effet, bien que le langage C soit convivial et que d'excellents environnements de développement soient disponibles, il reste que la programmation orienté objet n'est toujours pas supportée.  Moka a été conçus dès le début comme un langage orienté objet et vient combler cette lacune.

Historique des langages orienté-objets de Quésoft microsystèmes

C'est le développement d'interfaces graphiques qui engagea Quésoft microsystèmes sur la voie du développement de langages orientés objet.  La première solution disponible fut le Texas Instruments Basic Object Oriented Language (TIBOOL), un "super set" au langage TI Basic qui ne prit une forme définitive qu'après Release 2.  Quésoft distribua par la suite le jeu Hippic Challenge, un jeu disposant d'une interface utilisateur graphique programmée en TIBOOL.  Bien que le résultat estétique des programmes TIBOOL fut satisfaisant, la vitesse d'affichage était quant à elle déficiente.

Quésoft microsystèmes développa alors le New Object Oriented Language (NOOL) pour palier au problème.  NOOL apportait de nombreuses améliorations à TIBOOL.  En premier lieu, comme il utilisait la librairie CLib (et FLib au début) pour les fonctions de dessin graphique, la vitesse d'affichage était maintenant convenable.  En second lieu, NOOL était plus proche du paradigme orienté objet que TIBOOL et son code était plus efficient.  Cependant, comme NOOL demeurait un "super set" du TI Basic, la vitesse d'exécution des programmes demeurait décevante.  Quésoft microsystèmes prit alors une décision historique : l'abandon du TI Basic pour le language C.

C'est alors que le C Object Oriented Language (COOL) apparut.  COOL était un "super set" du C, ce qui faisait de ces programmes des application natives et donc très rapides et efficientes.  Cependant, il apparût que COOL ne serait pas aussi fidèle au paradigme objet que NOOL.  C'est pourquoi avant même la distribution de COOL, Quésoft microsystèmes travailla sur Moka, un premier véritable langage pur orienté objet convivial et qui de surcroît, permet de développer des applications natives.

Qu'est-ce que Moka ?

Moka est un langage orienté objet qui permet de développer des applications natives pour les calculatrices TI-92 / TI-92Plus.  Moka est un langage, une syntaxe et un convertisseur, mais pas un compilateur.  En effet, Moka traduit une syntaxe orientée objet en un langage pouvant être compilé.  Pour le moment, le code compilé est du C.  C'est-à-dire que le code Moka est exporté sous forme de COOL amélioré (Enhanced C Object Oriented Language) puis compilé à l'aide de TIGCC.  La syntaxe Moka est très proche du Java.  En fait, si proche qu'on peut générer la javadoc d'un programme Moka.

Moka vs Java
Moka utilise les mêmes mots clés que Java.  Cependant, Moka dispose de fonctionnalités moins complètes que Java :
- Pas de nettoyeur (Garbage Collector).  La fonction de récupération d'espace est implémentée, de façon très limitée, par l'interface moka.lang.Use_GarbageCollection.
- Pas de multi-thread. Cependant, un mécanisme relié est disponible, voir l'API de la classe moka.event.Interrupt
- Polymorphisme limité.  Traitement statique du polymorphisme :
Dans un langage 100% OO, le polymorphisme est traitée de façon  dynamique lors de l'exécution.  Par exemple, en Java,  si une référence vers un Object est passé en paramètre à une methode existant sous deux formes, l'une pouvant recevoir un Object et l'autre une String, et que cet
Object se révêle être une String, la méthode pouvant recevoir une String sera appelée.
    Object o = new String(); //o est une référence vers un Object, mais cet Object se révèle être une String.
    System.out.print(o);//public void System.out.print(String s) sera appelée.
En Moka, un CAST EXPLICITE est nécessaire si l'on désire que la Méthode acceptant une String soit appelée, car la résolution de la nature précise d'un objet est effectuée de façon statique, lors de la compilation.
    Object o = new String();
    //System.print(o);//public void System.print(Object o); sera appelée.
    System.print((String)o);//public void System.print(String s); sera appelée.
- Il n'y a pas de distinction entre le type "float" et le type "double".
- Les vecteurs ne sont pas implémentés comme étant des objets, leur manipulation est conforme à celle des tableaux du langage C.
- Les chaînes de caractères ne sont pas copiées lors de l'assignation :
En java, l'opération (s1 == s2, ou "s1 est-il le même objet que s2 ?") évaluée après les opérations suivantes retourne false, en Moka, elle retourne true :
    String s1 = "salut"; //Déclare une String s1 et fait pointer la référence sur une nouvelle String valant "salut"
    String s2; //Déclare une String s2
    s2 = s1; //Assigne s1 à s2
NB: Plusieurs methodes acceptant des objets String 'finalizent' l'objet String passé en paramètre.  Il faut donc passer en paramètre une copie de la String si l'on désire l'utiliser dans une autre instruction par la suite.
    String s = "salut";
//Déclare une String s et fait pointer la référence sur une nouvelle String valant "salut"
    System.out.print(s.toString());//La méthode toString de la classe String renvoie une copie de la String
- L'API de Moka ne contient qu'un nombre très limité des classe de l'API Java.  Également, ses classes sont implantées différement et bien que tout à été mis en oeuvre pour les rendre le plus semblable possibles aux classes Java, elle difèrent sensiblement et sont la plupart du temps moins complètes.  Par exemple, la méthode print, implémenté à l'aide du l'objet out de la classe System en Java, est une fonction statique de la classe System en Moka.
    System.out.print("salut");//En Java, affiche la chaîne de caractère "salut" à l'écran
    System.print("salut");//En Moka, affiche la chaîne de caractère "salut" à l'écran
- En Java, l'instruction "import" permet d'utiliser une classe sans avoir à spécifier son package.  En Moka, l'instruction "import" ajoute le code d'une classe au code du programme, permettant au programmeur de l'employer, mais du même coup, augmentant significativement la taille du programme.
- En Moka, toutes les classes présente dans le répertoire du principal sont incluse dans le projet.
- En Java, les classe du package "java.lang" sont accessible directement, même si le programmeur n'a pas importé le package "java.lang".  En Moka, les classe du package "moka.lang" doivent être importé explicitement avant de pouvoir être utilisées.
- En Java, le mot clé "native" ne s'applique qu'à une méthode et signifie qu'elle est implémentée de façon externe, dans un langage compilé.  En Moka, cela signifie que la méthode contient du code qui ne doit pas être converti.  Les blocs natifs (native {}) et les instruction natives (native () ou native.instruction()) sont aussi supportés en Moka.
    public native void outp () {//Méthode native, le contenu ne sera pas interprété.
        printf("salut");
    }
    public void outp () {//Méthode standard, le contenu sera interprété.
        native { //Bloc natif, le contenu ne sera pas interprété.
            printf("salut");
        }
    }
    public void outp () {//Méthode standard, le contenu sera interprété.
            if (true)
                native ( printf("salut") );//Instruction native, ne sera pas interprétée.
    }

Types de Moka

Moka
Équivalent en C
Taille mémoire en C
boolean
BOOL
16 unsigned
char
char
8 signed
float
float
80-bit
double
double
80-bit
byte
byte*
8 signed
short
short int
16 signed
int
long int
32 signed
long
long long int
64 signed

* : byte est défini #define byte char

Les packages
moka.lang : Contient les classes de base du langage, entre-autres System, String et Object.
moka.util : Contient des classes d'utilitaires, comme Vector, String Tokenizer et Timer.
moka.io : Contient les classes encapsulant les opérations d'entrée-sortie, comme File, Socket et Serializable.
moka.event : Contient les classes relié à la programmation evenementielle, comme Event et Interupt.
moka.x : Contient les classes utilisées pour la création d'environnements graphiques, comme GEM (Le Gestionnaire d'Environnement Graphique) et Frame.