Up ! Compiler

Options de compilation...
Référencement des modules les plus fréquemment importés...
Référencement des modules natifs...

Up ! Compiler est l'outil multi-plates-formes de production d'exécutables natifs, de bibliothèques natives, de ressources ou de fichiers spécifiques. Up ! Compiler gère :

Pour cela, Up ! Compiler génère : Up ! Compiler comporte un compilateur logique qui s'appuie sur des générateurs dédiés tels Up ! C/C++ Generator ou Up ! 5GL Generator. Chaque générateur offre des cibles de génération telles Windows, Linux, Os 400, etc. En fonction de la licence que vous avez acquise, vous disposez de différents générateurs et de différentes cibles.

Up ! Compiler peut être invoqué soit :

Quel que soit son mode d'invocation, Up ! Compiler possède les mêmes options citées dans la section suivante. La commande est, selon les plates-formes, upscmp, upscmp.exe ou upscmp.com.

Certaines options font référence à des fichiers ou à des chemins d'accès. En ce cas, il est possible d'employer des variables environnement dans l'expression des chemins d'accès. Exemple :

Tmp=${UPS_HOME}/demo/tmp/${UPS_USER}

D'autre part, les séparateurs de répertoire peuvent être indifféremment division / ou division inversée \.

Les options sont lues successivement dans :

Revenir en haut de la page...
AdaptateurClientCom permet de demander de générer l'adaptateur client ActiveX Com d'un module écrit dans un autre langage que Up ! 5GL à partir de son Idl. De ce fait, un module en technologie Up ! Virtual Technical Machine utilisant cet adaptateur pourra utiliser via ActiveX Com les données et les traitements de ce module distribué. Par défaut, le module distribué est considéré comme standard et non comme un module distribué ActiveX Com.

AdaptateurClientCom=Oui

AdaptateurClientCorba permet de demander de générer l'adaptateur client Corba d'un module écrit dans un autre langage que Up ! 5GL à partir de son Idl. De ce fait, un module en technologie Up ! Virtual Technical Machine utilisant cet adaptateur pourra utiliser via Corba les données et les traitements de ce module distribué. Par défaut, le module distribué est considéré comme standard et non comme un module distribué Corba.

AdaptateurClientCorba=Oui

AdaptateurClientJava permet de demander de générer l'adaptateur client Java d'un module écrit en langage Java à partir de son source. De ce fait, un module en technologie Up ! Virtual Technical Machine utilisant cet adaptateur pourra utiliser les données et les traitements de ce module distribué. Par défaut, le module distribué est considéré comme standard et non comme un module distribué Java.

AdaptateurClientJava=Oui

AdaptateurClientUpsNet permet de demander de générer l'adaptateur client Up ! Network du module distribué. De ce fait, un module en technologie Up ! Virtual Technical Machine utilisant cet adaptateur pourra utiliser les données et les traitements de ce module distribué. Par défaut, le module est généré et non son adaptateur client.

AdaptateurClientUpsNet=Oui

AdaptateurDictionnaire permet de demander de générer l'adaptateur permettant de travailler dynamiquement avec le module via son dictionnaire de données et de traitements. De ce fait, un autre module utilisant cet adaptateur pourra utiliser les données et les traitements de ce module sans connaître à priori leurs définitions. Par défaut, le module est généré sans son adaptateur dictionnaire.

AdaptateurDictionnaire=Oui

AdaptateurServeurCom permet de demander de générer l'adaptateur serveur ActiveX Com du module. De ce fait, un autre module écrit dans un autre langage que Up ! 5GL utilisant cet adaptateur pourra utiliser via ActiveX Com les données et les traitements de ce module distribué. Par défaut, le module distribué est généré sans son adaptateur serveur ActiveX Com.

AdaptateurServeurCom=Oui

AdaptateurServeurCorba permet de demander de générer l'adaptateur serveur Corba du module. De ce fait, un autre module écrit dans un autre langage que Up ! 5GL utilisant cet adaptateur pourra utiliser via Corba les données et les traitements de ce module distribué. Par défaut, le module distribué est généré sans son adaptateur serveur Corba.

AdaptateurServeurCorba=Oui

AdaptateurServeurJava permet de demander de générer l'adaptateur serveur Java du module. De ce fait, un autre module écrit dans le langage Java utilisant cet adaptateur pourra utiliser les données et les traitements de ce module distribué. Par défaut, le module distribué est généré sans son adaptateur serveur Java.

AdaptateurServeurJava=Oui

AdaptateurServeurUpsNet permet de demander de générer l'adaptateur serveur Up ! Network d'un module distribué. De ce fait, un autre module utilisant cet adaptateur pourra utiliser via Up ! Network les données et les traitements de ce module distribué. Par défaut, le module distribué est généré sans son adaptateur client.

AdaptateurServeurUpsNet=Oui

arhivejava permet de spécifier le fichier d'archivage des classes Java générées. Il n'y a pas de valeur par défaut.

ArchiveJava=monapplication.jar

CheminBibliotheques permet de spécifier le chemin d'accès aux bibliothèques statiques pour le compilateur C. Il n'y a pas de valeur par défaut.

CheminBibliotheques=C:\Program Files\Microsoft Visual Studio\VC98\Lib;C:\Program Files\mico2311\lib;C:\forte_jdk\j2sdk1.4.0\lib

CheminClassesJava permet de spécifier le chemin d'accès aux répertoires où sont rangées les classes Java compilées référencées par le module dont il faut générer le client Java. Il n'y a pas de valeur par défaut.

CheminClassesJava=${UPS_HOME}/demo/genere:${UPS_HOME}/application/lib

CheminIdlsCom permet de spécifier le chemin d'accès aux répertoires où sont rangées les Interfaces Definition Language des modules ActiveX référencés par le module dont il faut générer le client Com. Il n'y a pas de valeur par défaut.

CheminIdlsCom=${UPS_HOME}/upscom:${UPS_HOME}/genere

CheminIdlsCorba permet de spécifier le chemin d'accès aux répertoires où sont rangées les Interfaces Definition Language des modules Corba référencés par le module dont il faut générer le client Corba. Il n'y a pas de valeur par défaut.

CheminIdlsCorba=${UPS_HOME}/upscrb:${UPS_HOME}/genere

CheminInclusions permet de spécifier le chemin d'accès aux fichiers d'en-tête pour le compilateur C. Il n'y a pas de valeur par défaut.

CheminInclusions=C:\Program Files\Microsoft Visual Studio\VC98\Include;C:\Program Files\mico2311\include;C:\forte_jdk\j2sdk1.4.0\include

CheminInterfaces permet de spécifier le chemin de recherche des interfaces des modules. Il n'y a pas de valeur par défaut..

CheminInterfaces=${UPS_HOME}/upsvtm/interfaces;${UPS_HOME}/upsnet/interfaces;\
${UPS_HOME}/upsnls/interfaces;${UPS_HOME}/upscmp/interfaces;${UPS_HOME}/upscom/interfaces;\
${UPS_HOME}/upscrb/interfaces;${UPS_HOME}/upsjav/interfaces;${UPS_HOME}/demo/interfaces

CheminSources permet de spécifier où sont rangées les sources des composants et des modules. Par défaut, il s'agit du répertoire courant.

CheminSources=${UPS_HOME}/demo/source

CheminTlbsCom permet de spécifier le chemin d'accès aux répertoires où sont rangés les fichiers Types Library des ActiveX référencés par le module dont il faut générer le client Com. Il n'y a pas de valeur par défaut.

CheminTlbsCom=${UPS_HOME}/demo/upscom:${UPS_HOME}/upscom/upscom

Compile permet de spécifier un mode de compilation. La valeur par défaut est Oui.

Mode de compilationValeur de l'option
Ne pas compilerNon
Compiler en tenant compte des dépendancesOui
Recompiler sans tenir compte des dépendancesRecompiler

Compile=Recompiler

Contrainte permet d'ajouter au code généré du code vérifiant les contraintes d'intégrités définies par l'instruction Contrainte. Par défaut, les contraintes sont vérifiées.

Contrainte=Oui

Detail permet d'afficher le détail des opérations effectuées par Up ! Compiler.

Detail=Oui

Entete permet d'afficher l'en-tête de compilation précisant la date, le fichier source et les options disponibles.

Entete=Oui

FactoriserCchaine permet de demander d'optimiser les chaînes de caractères statiques en les factorisant dès lors qu'elles apparaissent deux fois dans une même procédure, fonction ou méthode. Le nombre d'objets alloués est plus faible et le code est plus efficace. Par défaut, les chaînes de caractères ne sont pas optimisées.

Seuls les procédures, les méthodes et les fonctions qui ne comportent pas explicitement de directives d'optimisation via FactoriserChaine ou NePasFactoriserChaine sont affectées par ce paramètre.

FactoriserChaine=Oui

optimisercode permet de demander d'optimiser le code généré en factorisant le code redondant suite au calcul des invariants. Le code est ainsi plus compact et plus efficace. Par défaut, le code n'est pas optimisé.

Seuls les procédures, les méthodes et les fonctions qui ne comportent pas explicitement de directives d'optimisation via FactoriserCode ou NePasFactoriserCode sont affectées par ce paramètre.

FactoriserCode=Oui

guid permet de spécifier l'identifiant de l'ActiveX à générer quand l'option adaptateurserveurdcom est active. Par défaut, Up ! Compiler choisit un nouvel idenfiant pour l'ActiveX. Les identifiants des objets et des interfaces sont calculés à partir des identifiant de l'ActiveX.

Guid=fecd18c0-8a05-11d0-8e3c-e1043ebbde2b

Lanceur permet de spécifier le mode de lancement de l'exécutable à générer. Par défaut, il s'agit d'un programme interactif.

Valeur de lanceurSémantique de lanceur
InteractifLe programme comporte une fenêtre permettant à l'utilisateur d'interagir avec le programme.
AutomatiqueLe programme est autonome. Il correspond à un programme classique pouvant être appelé par un autre programme et éventuellement par l'utilisateur. Il n'y a pas de fenêtre de lancement.
Le lancement du programme est automatique. Le programme peut être arrêté par Up ! Program Manager.
ServeurLe programme est autonome. Il correspond à un serveur de traitements ou de données. Il n'y a pas de fenêtre de lancement.
Sur les plates-formes Windows, le programme est un service système. Sur Unix, le programme est un démon.
Le lancement du programme est automatique. Le programme doit être arrêté par Up ! Program Manager.
ConsoleSi le mode lancement retenu est serveur et si la plate-forme est Windows, alors un fichier d'extension reg est généré au même endroit que le programme exécutable. Ce fichier, portant le même non que le programme, contient les entrées de registre permettant de référencer le service dans le système d'exploitation.

Lanceur=Interactif

LangueCible permet de spécifier la langue de génération pour les adaptateurs serveurs. Par défaut, il s'agit de la même que celle de l'exécution.

Valeur de langueSémantique de la langue
ArabicLes adaptateurs seront écrits en arabe.
ChineseLes adaptateurs seront écrits en chinois.
EnglishLes adaptateurs seront écrits en anglais.
FrenchLes adaptateurs seront écrits en français.
GermanLes adaptateurs seront écrits en allemand.
ItalianLes adaptateurs seront écrits en italien.
JapaneseLes adaptateurs seront écrits en japonais.
PortugueseLes adaptateurs seront écrits en portugais.
RussianLes adaptateurs seront écrits en russe.
SpanishLes adaptateurs seront écrits en espagnol.

LangueCible=English

Lanceur=Interactif

Map permet de spécifier l'inclusion de code de mise au point. Par défaut, le code de mise au point n'est pas inclus.

Map=Oui

menage permet de spécifier la suppression des fichiers temporaires. Par défaut, les fichiers sont supprimés.

Menage=Oui

ModuleImplemente permet de spécifier la liste de modules distribués qui sont implémentés par le programme à générer. Etant donné que plusieurs modules distribués peuvent être implémentés, le paramètre moduleimplemente est suivi d'un index.

ModuleImplemente1=Finances moduleimplemente2=ResHum

Persistant permet de demander à ajouter les méthodes de persistance au module. De ce fait, les programmes l'employant pourront être persistants. Par défaut, le module est généré sans les méthodes de persistance.

Persistant=Oui

PlateForme permet de spécifier la plate-forme cible. Il n'y a pas de plate-forme par défaut et ce paramètre est obligatoire.

Plate-formeValeur de l'option
MacintoshMacOs
Os 390Os390
Os 400Os400
UnixUnix
WindowsWindows

PlateForme=Unix

RepertoireClasses permet de spécifier où ranger les archives des classes Java générées. Par défaut, il s'agit du répertoire courant.

RepertoireClasses=${UPS_HOME}/demo/genere

RepertoireExecutable permet de spécifier où ranger les exécutables et les bibliothèques dynamiques générés. Par défaut, il s'agit du répertoire courant.

RepertoireExecutable=${UPS_HOME}/demo/bin

RepertoireGeneres permet de spécifier où ranger les bibliothèques statiques générées ainsi que les interfaces des modules. Par défaut, il s'agit du répertoire courant.

RepertoireGeneres=${UPS_HOME}/demo/upscmp

RepertoireIdlsCom permet de spécifier le répertoire où doivent être générés les fichiers interfaces ActiveX. Par défaut, le répertoire est le ${UPS_HOME}/upscom.

RepertoireIdlsCom=${UPS_HOME}/demo/upscom

RepertoireIdlsCorba permet de spécifier le répertoire où doivent être générés les fichiers interfaces Corba. Par défaut, le répertoire est ${UPS_HOME}/upscrb.

RepertoireIdlsCorba=${UPS_HOME}/demo/upscrb

RepertoireInterfaces permet de spécifier le répertoire de des interfaces des modules. Par défaut, la liste des répertoires est ${UPS_HOME}/interfaces:..

RepertoireInterfaces=${UPS_HOME}/demo/interfaces

RepertoireObjets permet de spécifier où ranger les objets de génération. Par défaut, il s'agit du répertoire courant.

RepertoireObjets=${UPS_HOME}/demo/objet

Source permet de spécifier le fichier source à compiler. Cette option est obligatoire. Le tableau suivant énumère les types de fichiers sources supportés.

DescriptionExemple d'appel
Source d'un composant ou d'un module multi-composantsSource=essai.upl
Idl d'un ActiveX pour générer le module clientSource=essai.idl
Tlb d'un exécutable d'un ActiveX pour générer le module clientSource=essai.dll
Source=essai.exe
Source=essai.tlb
Idl d'un module Corba pour générer le module clientSource=essai.idl
ObjectId d'un Interface Repository d'un module Corba pour générer le module clientSource=IDL:app/essai:1.0
Source Java pour générer le module clientSource=essai.java

Le paramètre Source peut être utilisé soit unitairement ou soit en séquence pour compiler plusieurs fichiers sources. En ce cas, tous doivent être de la même nature en terme d'adaptateur sélectionné.

Source=caractere.upl

Source1=binaire.upl Source2=caractere.upl Source3=date.upl Source4=entier.upl Source5=enumere.upl Source6=reel.upl

tmp permet de spécifier le répertoire où sont rangés les fichiers temporaires. Par défaut, le répertoire est le répertoire courant.

Tmp=/tmp

Revenir en haut de la page...
Pour pouvoir être générés, un source a besoin d'être analysé au préalable. Cette phase est réalisée par Up ! Grammar, l'analyseur d'Up ! 5GL qui est inclus Up ! Compiler. Celui-ci permet de référencer les modules les plus fréquemment utilisés. Cela évite alors d'avoir à les inclure systématiquement dans le code des sources.

Ce référencement s'effectue dans le fichier ${UPS_HOME}/ini/upsgrm.ini en mode mono-poste ou dans le fichier ${UPS_HOME}/ini/${UPS_USER}/upsgrm.ini en mode multi-poste. La section est Ups5gl. Elle est complétée respectivement par les sections UpsCom, UpsCrb et UpsJav lorsqu'un adaptateur Com, Corba ou Java est utilisé. Il suffit d'énumérer les modules à charger automatiquement dans l'ordre où ils auraient été déclarés dans le fichier source Up ! 5GL.

Les premières inclusions automatiques doivent être obligatoirement UpsKrn.upi, UpsSys.upi, UpsNet.upi et UpsNls.upi. Cet ordre doit être respecté.

ImporterDefinitions permet de spécifier si les définitions du module à charger doivent être importées. Le numéro qui suit le nom de l'option désigne l'ordre de chargement. Par défaut, la valeur est N. Cette option a le même rôle que l'instruction ImporterDefinitions.

ImporterDefintions1=Oui

Module permet de spécifier le module à charger. Le numéro qui suit le nom de l'option désigne l'ordre de chargement.

Module1=UpsKrn.upi

Voici un exemple montrant l'importation automatique de Up ! Object Request Broker puis de Up ! Mathematical en plus de l'importation obligatoire de Up ! Kernel, Up ! System et de Up ! Natural Langage Support :

; -------------------------------------------------------------------
; Fichier : upsgrm.ini
; Objet : Initialisation d'Up ! Grammar.
;
; Module : Up ! Appplication System.
; Auteur-Date : DUVAL Jean-Pierre - Novembre 2003.
; -------------------------------------------------------------------
; Observations
;
;
; -------------------------------------------------------------------


[Ups5GL]
Module1=UpsKrn.upi
ImporterDefinitions1=Oui
Module2=UpsSys.upi
ImporterDefinitions2=Oui
Module3=UpsNet.upi
ImporterDefinitions3=Oui
Module4=UpsNls.upi
ImporterDefinitions4=Oui
Module5=UpsSec.upi
ImporterDefinitions5=Oui

[UpsCom]
Module1=oaidl.upi
ImporterDefinitions1=Oui
Module2=objidl.upi
ImporterDefinitions2=Oui

[UpsCrb]
Module1=corba.upi
ImporterDefinitions1=Oui
Module2=oad.upi
ImporterDefinitions2=Oui

Revenir en haut de la page...
Pour pouvoir générer les adaptateurs des modules natifs, il est nécessaire de les déclarer comme tels. Cela évite alors d'avoir à écrire nativement le code des adaptateurs.

Ce référencement s'effectue dans le fichier ${UPS_HOME}/ini/upsvtm.ini. Il suffit d'énumérer les modules natifs.

Les premières inclusions automatiques doivent être obligatoirement UpsKrn, UpsSys, UpsNls, UpsOms, UpsOrb et UpsSec. Cet ordre doit être respecté.

AppartienAUpsVm permet de spécifier que le module fait partie d'Up ! Virtual Technical Machine. Le numéro qui suit le nom de l'option désigne l'ordre de chargement. Par défaut, la valeur est N.

AppartienAUpsVm1=Oui

MachineInterface permet de spécifier que le module comporte une interface avec la machine pour un logiciel de base. Le numéro qui suit le nom de l'option désigne l'ordre de chargement. Par défaut, la valeur est N.

MachineInterface1=Oui

Module permet de spécifier le module natif. Le numéro qui suit le nom de l'option désigne l'ordre de chargement.

Module1=UpsKrn

Voici un exemple déclarant les modules natifs d'Up ! Virtual Technical Machine puis le module natif Up ! Mathematical :

; -------------------------------------------------------------------
; Fichier : upsvtm.ini
; Objet : Initialisation d'Up ! Virtual Technical Machine.
;
; Module : Up ! Appplication System.
; Auteur-Date : DUVAL Jean-Pierre - Novembre 2003.
; -------------------------------------------------------------------
; Observations
;
;
; -------------------------------------------------------------------

[UpsCp1]
UpsCp10=UpsGc1 1.1.0
UpsCp11=UpsGl1 1.1.0

[UpsLg1]

[UpsGc1]
UpsGc10=UpsGcm 1.1.0
UpsGc11=UpsGjv 1.1.0
UpsGc12=UpsGun 1.1.0
;UpsGc13=UpsGcb 1.1.0

[UpsGl1]
UpsGl10=UpsLcm 1.1.0
UpsGl11=UpsLjv 1.1.0
;UpsGl12=UpsLcb 1.1.0

[UpsLg1]

[UpsGrm1]

[UpsNet]
UpsNet0=UpsTcp 1.1.0
UpsNet1=UpsMsn 1.1.0
UpsNet2=UpsNap 1.1.0

[UpsVtm]
Module1=UpsKrn
AppartienAUpsVm1=Oui
MachineInterface1=Non
Module2=UpsSys
AppartienAUpsVm2=Oui
MachineInterface2=Oui
Module3=UpsNls
AppartienAUpsVm3=Oui
MachineInterface3=Non
Module4=UpsNet
AppartienAUpsVm4=Oui
MachineInterface4=Non
Module5=UpsOms
AppartienAUpsVm5=Oui
MachineInterface5=Non
Module6=UpsSec
AppartienAUpsVm6=Oui
MachineInterface6=Non
Module7=UpsOrb
AppartienAUpsVm7=Oui
MachineInterface7=Non
Module8=UpsMat
AppartienAUpsVm8=Non
MachineInterface8=Non

[UpsCom]
Module1=UpsKrn
AppartienAUpsVm1=Oui
MachineInterface1=Non
Module2=UpsCom
AppartienAUpsVm2=Oui
MachineInterface2=Non
Module3=UpsSys
AppartienAUpsVm3=Oui
MachineInterface3=Oui
Module4=UpsNls
AppartienAUpsVm4=Oui
MachineInterface4=Non
Module5=UpsNet
AppartienAUpsVm5=Oui
MachineInterface5=Non
Module6=UpsSec
AppartienAUpsVm6=Oui
MachineInterface6=Non
Module7=UpsOrb
AppartienAUpsVm7=Oui
MachineInterface7=Non
Module8=UpsMat
AppartienAUpsVm8=Non
MachineInterface8=Non

[UpsCrb]
Module1=UpsKrn
AppartienAUpsVm1=Oui
MachineInterface1=Non
Module2=UpsCrb
AppartienAUpsVm2=Oui
MachineInterface2=Non
Module3=UpsSys
AppartienAUpsVm3=Oui
MachineInterface3=Oui
Module4=UpsNls
AppartienAUpsVm4=Oui
MachineInterface4=Non
Module5=UpsNet
AppartienAUpsVm5=Oui
MachineInterface5=Non
Module6=UpsSec
AppartienAUpsVm6=Oui
MachineInterface6=Non
Module7=UpsOrb
AppartienAUpsVm7=Oui
MachineInterface7=Non
Module8=UpsMat
AppartienAUpsVm8=Non
MachineInterface8=Non

[UpsJav]
Module1=UpsKrn
AppartienAUpsVm1=Oui
MachineInterface1=Non
Module2=UpsJav
AppartienAUpsVm2=Oui
MachineInterface2=Non
Module3=UpsSys
AppartienAUpsVm3=Oui
MachineInterface3=Oui
Module4=UpsNls
AppartienAUpsVm4=Oui
MachineInterface4=Non
Module5=UpsNet
AppartienAUpsVm5=Oui
MachineInterface5=Non
Module6=UpsSec
AppartienAUpsVm6=Oui
MachineInterface6=Non
Module7=UpsOrb
AppartienAUpsVm7=Oui
MachineInterface7=Non
Module8=UpsMat
AppartienAUpsVm8=Non
MachineInterface8=Non

Revenir en haut de la page...