Ravi
Welcome
Documentation
Documentation
About Ravi
Documentation
Introduction
Premiers pas avec Ravi
ravitool
Scheme Tutorial
Objets Scheme
Le shell ravi
Starting Ravi
Le module trace
Les ports d'E/S
The C Parser
load, require, modules
Système d'interruptions
Scheme compiler
C++ mode
Generating C++ Modules
La déclaration struct
Le type "C-object"
More information
Installation

[PREV][SUIV]

Le type "C-object"

Remarque (Augustin, 27-8-98): cet ensemble de fonctions est à revoir. Supprimer les synonymes, et les fonctions inutiles.

Il faut distinguer deux types d'information pour un object C: l'objet lui-même porte une information de type, appelé "index", et un champ valeur. Seul l'index est directement accessible en Scheme. Cela fait 2 fonctions de base en Scheme:

( c-object? x) c'est la fonction caractéristique des objets C, à comparer avec pair?, vector? string? etc.

(c-object->index c-obj) donne le champ indexe (un entier).

A partir de l'index, diveres informations sont accessibles concernant le type:

(typec-name-index ix) chaine de caractères qui définit le type en C++. Par exemple, pour une classe c'est le nom de la classe.

(c-index->parent-index ix) Donne l'indexe du typec parent.

(c-name->c-index s) fournit l'indexe d'un type C à partir d'une chaine de caractères.

====================================================================

Classes et méthodes - mode d'emploi

Le chargement d'un module C++ introduit dans Ravi des définitions de classes et de méthodes - que peut-on alors faire avec?

Créer un objet

(new nom_de__classe x1 ... xn) appèle le constructeur associé et retourne un objet-c avec le nouvel objet créé. Le constructeur est appelé via une fonction de l'interface, qui a le nom classe::constructor

Appeler une méthode

L'appel d'une méthode se fait via deux mots-clé de Scheme: send et send-typ


	(send OBJET METHOD ... ARGN)
	(send-typ CLASSE_DE_OBJET OBJET METHOD ... ARGN)

le send demande a OBJET d'exécuter METHOD avec ... ARGN comme arguments send-typ demande a OBJET de type CLASSE_DE_OBJET d'exécuter METHOD avec ... ARGN comme arguments

Bien que le send-typ soit plus lourd à utiliser il permet à Ravi d'optimiser les appels aux méthodes. Connaissant le types de l'objet, l'appel de send-typ se transforme en appel direct de la méthode ce qui accelère le traitement surtout dans les boucles. Inconvénient: c'est plus long à écrire et cela implique de connaître le type exact de l'objet qu'on manipule ... Le send effectue une recherche à chaque appel. Cette recherche est courte mais son coût n'est pas nulle - et ce sera facile à améliorer.

Compilation

La compilation de programmes Scheme comportant des appels de send/send-type demande quelques précautions: il faut que toutes les classes C++ soient connues du compilateur. Pour cela il faut des require lui indiquant quels modules C++ sont utilisés. Voir la page sur le compilateur

L'héritage

L'héritage fonctionne entre les modules si ils sont chargés dans le bon ordre. Les rouages de l'héritage sont plus complexes qu'il ne semble, il y aura peut-être d'autres explications.

=====================================================================

Représentation de la hiérarchie des classes C++ sous Ravi

Une description détaillée des classes et des méthodes chargées sous Ravi est analysée lors du chargement, cf. le fichier .x.scm ; on decidera sans doute bientôt de garder toutes ces infos, en vue par ex. de réaliser un interpréteur C++ (allégé).

Actuellement, seules les infos permettant l'accès aux méthodes sont conservées : il s'agit d'une table qui fournit pour chaque classe la table des méthodes; oui, c'est bien une table de tables, qui est utilisé par send et send-type. Une table séparée sert à la fonction new.

Comment peut on inspecter cette table ?

(affiche-tout) : très genereux (trops peut être) (access-table ix) : Plus fin mais il faut l'index

*send-debug* : Variable = #f pas de trace = () on memorise tous les appels à send et send-typ dans *send-debug* On pourrait utiliser ici le buffer des traces

(found-method cl m) :renvoie #f ou (m . func)

(get-method cl m) :renvoie #f ou func

(replace-method cl m lm) :remplace la fonction attachée à m dans cl par lm => ne pas utiliser sans précaution.

(add-method cl m lm) :ajoute une nouvelle methode masquant toutes les autres methodes de même nom. => ne pas utiliser sans précaution.

=====================================================================

Les fonctions suivantes servent à manipuler les objets C/C++ et surtout à les étudier.

c-index->name : A partir du numéro du typeC on obtient le nom C effectif de ce type (c-index->name idx) -> Str erreur si idx different du type int

c-name->c-index!

c-name->c-index : A partir d'un nom de type C on recupere le numero de ce type. La différence est que la premiere fonction alloue un nouveau type si ce type n'existe pas alors que le second renvoie faux dans ce cas. (c-name->c-index! Str) -> idx (c-name->c-index Str) -> idx erreur si Str different du type string

c-index->parent-index : A partir du numéro d'un type on obtient le numéro du type parent ou faux s'il n' y a pas de parent (c-index->parent-index idx) -> idx erreur si idx different du type int

c-object->index : A partir d'un objet de typeC on recupère le numéro du type de l'objet. (c-object->index oc) -> idx erreur si oc n'est pas un c-object

c-object->name : A partir d'un objet de typeC on recupère le nom C/C++ du type de l'objet. (c-object->name oc) -> Str erreur si oc n'est pas un c-object

c-object? : Predicat indiquant si l'objet est un objet C ou non (c-object? o) -> bool o peut être de n'importe quel type

c-null-object? : Predicat indiquant si l'objet est l'objet C NULL ou non. (c-null-object? o) -> bool o peut être de n'importe quel type

Autres fonctions définies dans sctypec.cc:

cast

cast!

display-c-addraffichage d'une adresse

delete