FlagShip

Le compilateur de Clipper pour UNIX

FlagShip est un compilateur pour UNIX qui supporte totalement le code écrit en CA-Clipper, il élargit la syntaxe de ce langage et offre les avantages propres du code compilé dans un environnement multitâche, multiutilisateur et avec une haute connectivité comme Unix. FlagShip combine le meilleur de ces deux mondes : le langage Clipper et le système d’exploitation UNIX.

SYSTEMES REQUIS :

• Un quelconque système UNIX
• Un compilateur de C pour le système UNIX

Que fait un expert en Clipper devant le dilemme de migrer ses applications au monde Unix ? Quel rôle peuvent jouer les programmes écrits en Clipper dans le marché Unix ?

Grâce à FlagShip, les programmeurs de Clipper, dBase ou FoxBase/FoxPro ne nécessitent plus désormais d’apprendre un nouveau système de gestion de bases de données, ni d’écarter tout ce qui a été développé jusqu’à présent. FlagShip rend possible la migration immédiate, étant donné que son compilateur est totalement compatible avec CA-Clipper 5.2, CA-Clipper 5.01, Summer ’87 et d’autres langages Xbase. Le même code, les mêmes données, le même aspect et comportement. Seule une chose change : Unix, un système d’exploitation beaucoup plus puissant.

Et pas seulement cela. Beaucoup de préoccupations et de maux de tête propres au DOS disparaissent pour toujours, comme la limitation de mémoire. De plus, s’ouvre tout un monde avec de nouvelles et d’attractives possibilités. Pour le programmeur d’Unix, FlagShip assouplit significativement le développement d’applications de bases de données. Dix lignes de code source produisent des centaines de lignes de code « C » libres d’erreurs.

Qu’est-ce que FlagShip ?

C’est un compilateur natif qui compile complètement le code Clipper dans l’environnement Unix. Il n’y a pas de pseudo code comme dans Clipper, il ne s’agit pas non plus d’un interpréteur, comme d’autres systèmes Xbase. FlagShip est un compilateur natif et, comme tel, optimise autant la rapidité que la taille du code généré. Indépendamment des variables polymorphes de Clipper (sans un type fixe), est vérifié lorsque c’est possible, l’existance de conflits et la concordance de types dans des expressions.

Le compilateur dispose de toute l’information sur les classes, les objets et les méthodes internes. Au moment de la compilation, il vérifie que son utilisation soit correcte, ce qui permet un gain de temps important lors du debbugage.

Compilation

Il est possible de développer directement dans FlagShip ou de migrer une application Clipper existante à Unix. Dans les deux cas, la seule chose demandé sont les fichiers source .prg. Pour copier vos sources DOS vers Unix, tant FlagShip comme Unix vous offrent des utilitaires pour lire des disquettes DOS, transférer par un port série vos fichiers ou utiliser une connexion par le réseau.

La compilation réalise différents processus. Tous ceux-ci peuvent se réaliser de manière automatique ou sélective :

• Le code est prétraité, comme dans Clipper
• Ensuite il est compilé au langage C K&R pour maintenir la compatibilité avec tous les systèmes
• Avec le compilateur C du propre Unix (fait partie de chaque Unix), il est compilé pour obtenir le code objet
• Enfin, il est lié avec la bibliothèque FlagShip pour obtenir un exécutable.

L’exécutable obtenu a le même aspect et comportement que son application équivalente sous DOS. Ne sont pas nécessaires des modules de run-time additionnels, ni le paiement d’autres licences, puisqu’il peut être distribué librement.

Bien qu’il soit possible d’utiliser des overlays, ceux-ci ne sont pas habituels dans des environnements Unix. Le système d’exploitation se charge de gérer la mémoire virtuelle de vos applications. Vous pouvez lier toute l’application dans un unique « grand » exécutable et laisser Unix faire le reste. Le système d’exploitation sait quelles parties de votre programme il doit garder en mémoire et sur le disque.

Encore mieux. Si divers utilisateurs utilisent la même application, seule est maintenue en mémoire une copie de l’exécutable. Est dupliqué uniquement l’ensemble des données (variables) pour chaque utilisateur. De plus, le système standard et les bibliothèques C ne se lient pas avec le code, sinon qu’ils se référencent dynamiquement pendant l’exécution de l’application. Avec cela, on économise l’espace sur le disque et on diminue la charge générale du système. L’application n’est pas limitée par la mémoire disponible, sinon qu’elle peut grandir autant que nécessaire.

Le code C généré et les fichiers objet ne peuvent pas être liés sans la bibliothèque FlagShip, vue que celle-ci contient toute la fonctionnalité du langage.

Compatibilité

Le compilateur et le langage de FlagShip supportent :

• Toutes les commandes, fonctions (quelques 900) et directives de pré processeur de Clipper 5.2
• Locales, statiques, publiques, privées et arrays multidimensionnels
• Les classes, objets et méthodes GET, TBrowse et Error, ainsi que l’API du système d’erreurs
• Code Blocks
• Evaluation de macros en exécution, code blocks évalués grâce à des macros et l’Item API
• L’API de terminal général
• L’API de contrôleurs de bases de données remplaçables (RDD)
• L’API du système de fichiers
• L’API « Extend C »

Il existe seulement deux exceptions dues à la différence entre DOS et Unix :

• La commande RUN, puisque les commandes Unix ont un nom et une fonctionnalité différentes
• La manipulation directe du hardware et de l’écran, incluant la manipulation d’écrans gardée dans une variable.

Vous devez tenir en compte ces deux aspects et changer votre code source en conséquence.

Les extensions de FlagShip

Si vous travaillez sous Unix, pourquoi ne pas utiliser sa puissance ? FlagShip incorpore diverses extensions du langage Clipper qui vous permettent de :

• Simplifier la migration d’applications DOS
• Augmenter la rapidité de vos programmes
• Définir des terminaux peu habituels
• Utiliser un spool pour gérer l’impression
• Se lier avec d’autres applications
• Adapter l’application à la langue de votre pays
• Profiter des utilitaires du système Unix

Migration

Par rapport à votre programme DOS, la différence principale entre DOS et Unix réside dans la convention utilisée pour les noms de fichiers. DOS ne distingue pas l’utilisation de majuscules et minuscules dans les noms de fichiers. Probablement, vous non plus ne prenez cela en compte dans vos programmes. Sous Unix cependant, ce fait est important. FlagShip vous offre une solution immédiate à ce problème.

Par le biais d’un ensemble d’options globales, vous pouvez indiquer à l’API du système de fichiers la forme « standard » dans laquelle apparaissent réellement les noms de fichiers dans le répertoire du disque. De cette manière, l’API pourra déterminer pendant l’exécution comment convertir le nom du fichier pour accéder au fichier sollicité. Il est possible d’indiquer si le nom est en majuscules, s’il doit se convertir en minuscules, la façon de traduire l’extension et le chemin de recherche pour une lettre d’unité. L’exemple suivant montre le code qui doit être utilisé :

FS_SET("lowerfiles", .T.)
FS_SET("pathlower",.T.)
FS_SET("translext",".ntx",".idx")

Tout ce que vous avez à faire est d’indiquer quelques appels à des fonctions du module de démarrage. Vous pouvez aussi utiliser une sentence #include.

#ifdef FlagShip
#include "fspreset.fh"
#endif

Rapidité

Le compilateur supporte tous les types de variables et déclarations habituels. Cependant, pour augmenter la rapidité d’exécution de vos programmes, il est possible d’indiquer un type fixe pour chaque variable au moment de sa déclaration. Cette innovation sera incluse dans CA-Visual Objects for Clipper.

Il est très courant dans les programmes que chaque variable est une utilisation spécifique. Pourquoi alors ne pas la déclarer avec un type déterminé ? Avec cela, la rapidité augmente de façon spectaculaire, le compilateur peut réaliser un plus grand nombre de vérifications sur l’utilisation des variables, et la lisibilité du code est meilleure.

Et cela avec d’un simple :

LOCAL nom_var AS type
STATIC nom_var AS type
GLOBAL nom_var AS type
GLOBAL_EXT nom_var AS type

Vous pouvez indiquer n’importe lequel des types simples communs au langage C. Les variables ainsi déclarées s’utilisent de la même façon que le reste des variables du programme.

Support de terminal

Unix permet la connexion de terminaux via des lignes séries ou par l’intermédiaire d’un réseau. FlagShip supporte les marques de terminal les plus courantes à travers des fichiers de description qu’inclus le programme. Mais vous pouvez aussi définir votre terminal spécifique et changer les préférences sur les touches de fonction et les couleurs.

Pour cela, FlagShip utilise une interface indépendante du terminal, de manière à ce que l’utilisateur puisse fournir des définitions de terminal comme fichiers source.

Impression grâce au spool

Sous DOS, vous dirigez normalement l’impression vers un port d’imprimante. Sous Unix, où plusieurs utilisateurs ont recours aux ressources de la machine en même temps, une telle façon de procéder donnerait lieu à des impressions mélangées.

FlagShip permet l’utilisation directe de dispositifs (équivalent aux ports du DOS), bien que l’utilisation du spooler soit recommandée. Pour cela, sont incluses des fonctions qui facilitent la gestion de noms de fichiers exclusifs et du spooler de Unix.

Lien avec d’autres applications

Que peut-on faire avec le code C existant et d’autres applications ?

Les API Open C et Inline C de FlagShip facilitent l’accès aux fonctions C. Pas seulement cela, sinon que grâce à Inline C vous pouvez ajouter le code critique pour le rendement de votre application directement dans vos fichiers .prg. Est également inclus l’accès à ESQL et la possibilité d’interchanger des données entre le C et les variables de votre programme de façon simple et naturelle.

&& types de variables standard de Clipper
STATIC pi := 3.14 && aussi des variables typées
LOCAL mivar AS double
...
mivar = pi /6.0
#Cinline
/* accès à la bibliothèque standard de C */
mivar = sin(mivar);
#endCinline
? mivar // imprime 0.50

Pour passer des données à des applications externes, il est possible de définir des « pipes » pour la redirection de toutes les sorties (comme SET PRINTER TO) à d’autres applications Unix.

SET DEVICE PIPE TO autre_terminal
SET ALTERNATE PIPE TO filtre_appl

Les applications avec lesquelles vous mettez en relation votre programme s’exécuteront simultanément.

Internationalisation

Que se passe-t-il si la langue que doivent supporter vos applications est le français, l’espagnol ou l’italien ?

FlagShip inclus des fichiers sources avec des tables pour :

• la conception de claviers
• le mappage de caractères, d’écrans
• l’ordre de classification des indices
• la comparaison de chaînes
• les messages des fonctions de FlagShip

Le mappage de clavier et d’écran est disponible pour les langues européennes les plus courantes. L’ordre de classification de l’indice est gardé dans les fichiers d’indice de FlagShip pendant la création.

La sélection d’un langage est question d’un simple appel à une fonction dans votre application. De même, vous pouvez créer des applications qui supportent plusieurs langues. Si vous désirez incorporer une nouvelle langue, il suffit d’éditer un fichier de table.

FS_SET("loadlang", 1, "MaTableFr")
FS_SET("loadlang", 2, "MaTableEsp")
FS_SET("setlang", 1)

Comme vous pouvez le constater, le procédé est très simple.

Accès à Unix

Vous pouvez accéder facilement à toutes les fonctions de la bibliothèque Unix par l’intermédiaire de la commande CALL. Voici un exemple :

CALL chdir WITH "/mon/nouveau/rep"

Le code C inclus dans vos programmes .prg ne suppose aucun problème pour FlagShip.

Grâce à la commande RUN vous pouvez accéder aux utilitaires Unix. Et, le plus important, c’est qu’il est possible de lancer en tâche de fond un nombre quelconque de tâches. Celles-ci s’exécutent de façon simultanée avec vos applications, ce qui leur permet de se charger des travaux moins critiques.

RUN mail &user < order.txt &

Multi-utilisateur, multitâche, connexion en réseau

Imaginez-vous utiliser vos applications sur des machines éloignées à des milliers de kilomètres du site où vous vous trouvez ? Ou que 20 opérateurs utilisent à la fois le même programme avec les mêmes données sur une seule machine ?

Avec FlagShip et Unix tout est possible. Et vous n’avez pas besoin de modifier votre code. Le blocage et l’utilisation partagée d’une base de données fonctionnent de la même manière que sous DOS avec un environnement réseau. Avec la différence que maintenant vous pouvez utiliser une seule machine, ou plusieurs machines connectées en réseau, ou un WAN, ou même un modem pour accéder de façon distante.

rsh -l monlogin machinesp.de MonApplication

exécute MonApplication sous « monlogin » sur « machinesp » depuis un quelconque endroit du monde ayant une connexion Internet.

L’accès à des applications via modem n’est pas une nouveauté sous Unix. Et cela ne demande pas une machine pour chaque poste de travail ; il suffit d’un simple terminal.

L’aspect et le comportement de FlagShip

Comment un terminal peut-il montrer les écrans de mon application ? Que se passe-t-il avec les touches de fonction ?

FlagShip utilise toutes les possibilités du terminal pour montrer votre application exactement comme vous l’attendez, en utilisant des couleurs, des graphiques basés sur des caractères, des caractères internationaux et un clavier étendu. Tout cela indépendamment de s’il s’agit ou non d’un terminal X/Windows, si la machine dispose d’une carte graphique ou si vous utilisez une émulation de terminal sous DOS.

Dans le cas de terminaux avec des prestations basiques, FlagShip tente de pallier ses carences pour que l’application fonctionne et puisse reconnaître clairement vos écrans.

Pourquoi FlagShip ? Pourquoi Unix ?

Si ce que nous avons dit jusqu’à présent n’était pas suffisant, voici d’autres bonnes raisons.

FlagShip s’exécute sur Unix et vous ouvre les portes de ce nouvel environnement. Il suffit de migrer les applications à Unix pour commencer à profiter de tous ses avantages. Ni la mémoire, ni la taille de votre application ne sont limités.

Vous disposez d’un système multitâche et multi-utilisateur. Vous n’avez pas besoin d’un réseau, ni d’une machine pour que chaque utilisateur puisse exécuter vos programmes. Il suffit d’utiliser des terminaux. Vous pouvez aussi vous connecter à distance via un réseau ou un modem.

La sécurité est aussi quelque chose d’inhérent. Vos utilisateurs doivent s’enregistrer sur le système avant d’accéder aux applications. Et nous ne parlons pas de la maintenance. Les copies de sécurité sont effectuées très simplement, et il est seulement nécessaire de garder une version de votre programme sur chaque système.

Tout cela en investissant une fraction de ce que vous auriez besoin pour monter un réseau sous DOS. Unix est déjà un standard du marché. De nos jours, il n’y a aucune machine qui ne puisse exécuter Unix. Et avec la garantie que si un utilisateur ou une application causent une erreur, le système ne «plante» pas.

Le paquet de FlagShip

FlagShip n’est pas seulement un compilateur et une bibliothèque. Le programme inclus des utilitaires pour :

• simplifier la tâche de migration du code
• copier le code et les données sur Unix
• debbuger
• définir et essayer vos terminaux

Il comporte aussi des tables pour chaque pays ainsi qu’une documentation en ligne et écrite (quelques 1200 pages).

Comment développer avec FlagShip?

FlagShip n’est pas seulement un outil pour la migration. Le programme dispose d’un langage propre et d’un système complet de développement. Le fait qu’il supporte la définition que fait Clipper du standard Xbase est, évidemment, un énorme avantage, mais cela n’est pas tout dans flagShip.

Unix dispose d’utilitaires avancés pour maintenir des versions du code source (sccs), créer des fichiers make et gérer le développement.

Pour le debbugage, FlagShip inclus un debbuger en ligne avec toute la fonctionnalité nécessaire pour analyser et corriger votre code source. De plus, Unix incorpore aussi divers debbugers de bas niveau.

FlagShip ne vous lie pas à un environnement de développement particulier. Grâce à la définition automatique de la constante et de la variable publique « FlagShip », vous pouvez utiliser un unique ensemble de sources pour les environnements Unix et DOS. Par exemple, pour CA-Clipper 5.x :

#ifdef FlagShip
RUN ls -l *.*
#else
RUN DIR *.*
#endif

et pour Clipper ’87, dBase ou Fox :

PUBLIC FLAGSHIP, CLIPPER
if FLAGSHIP
? "Application FlagShip"
elseif CLIPPER
? "Application Clipper"
else
? "Application PC"
endif

Le code est portable et compatible avec DOS et Unix.

Exécution de FlagShip

Pour compiler avec FlagShip, vous n’avez pas besoin d’un fichier .clp. Vous n’avez pas non plus à vous préoccuper pour le type d’éditeur de lien qu’il est nécessaire d’utiliser, ni de la façon dans laquelle il faut lier le programme. Par exemple :

FlagShip monappl.prg xyz*.prg -omonappl -Mstart

compile monappl.prg avec tous les fichiers xyz*.prg et ses modules dependants, lie l’application et lui donne le nom monappl. Les commandes équivalentes sous DOS seraient :

CLIPPER monappl
CLIPPER @xyz.clp
RTLINK FI monappl, xyz OUT monappl

Votre application commencera l’exécution à partir du traitement ou de la fonction « start ».

Le futur de FlagShip

FlagShip continue d’être développé. Vous trouverez ci-dessous les innovations prévues pour les versions futures :

• un complet environnement graphique basé sur X/Windows
• des contrôleurs de base de données remplaçables pour la majorité des formats de fichiers connus, y compris des mécanismes de bloquage
• des accès à des systèmes SQL
• des procédures de transactions
• une compatibilité avec CA-Visual Objects

FlagShip va évoluer vers X/Windows. Il supportera des commandes FoxPro pour une plus grande facilité d’utilisation. Il offrira la compatibilité avec CA-Clipper 5.3. Il inclura des objets de CA-Visual Objects et d’autres améliorations. Tout cela pour le convertir dans la solution la plus complète de développement Xbase dans des environnements Unix.

L’utilisation de systèmes d’exploitation hétérogènes et de différents environnements de base de données grâce à la technologie RDD est un des autres objectifs à réaliser. Sont aussi prioritaires l’accès SQL et la possibilité de partager les mêmes données depuis DOS et Unix simultanément.

Le traitement de transactions renforcera encore plus les systèmes de bases de données. Et de plus, il permettra la compatibilité avec dBase IV.

Conclusion

FlagShip constitue la meilleure alternative pour migrer de Clipper à Unix. Pourquoi ?

Vous disposez d’un environnement de travail familier avec une puissance inimaginable jusqu’à présent. Vous n’avez pas besoin d’apprendre de nouveaux langages ni de reprogrammer vos applications. Et vous pouvez les améliorer de progressivement. Si vous connaissez CA-Clipper, dBASE ou Fox, vous connaissez déjà FlagShip.

FlagShip combine la technologie d’un compilateur avancé, CA-Clipper, avec un des systèmes d’exploitation standards du marché, Unix. Se sont deux mondes qui, au fil des ans, ont atteint leur pleine maturité et qui à présent s’unissent pour offrir le meilleur d’eux même.

Prix

Thèmes associés

FlagShip (démo, version personnelle gratuite, outils, ...)

ACCUEIL | PRODUITS | SERVICES | NOUVELLES | A PROPOS D'ABOX