Paramètres d'Up ! Compiler

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 utilise Up ! Black Board.

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.

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 paramètres cités dans la section suivante. La commande est, selon les plates-formes, upscmp, upscmp.exe ou upscmp.com.

Certains paramètres 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, le séparateur de répertoire est le caractère division / et les noms de fichiers ou de répertoires peuvent utiliser les partitions montées automatiquement par Up ! System.

Les paramètres sont lus successivement dans :

Les valeurs des paramètres comportant des caractères espace doivent être mises entre caractères guillemet " ou entre caractères apostrophe ' .

Pour connaître le source d'Up ! Compiler, merci de se référer à la fiche Source d'Up ! Compiler.

Paramètres de compilation

Up ! Compiler étant un programme Up ! Application System particulier, les paramètres de lancement de Up ! Virtual Technical Machine et celles d'exécution de Up ! Kernel s'appliquent. En revanche, la configuration de Up ! Object Management System est imposée. Elle correspond au fichier ${UPS_HOME}/ini/upssdk.ini.

AdaptateurClientCom

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

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

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

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

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

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

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

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

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

ArchiveJava

ArchiveJava 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

AutoriserMixage

AutoriserMixage permet d'autoriser le mixage des sources des composants et des ressources en Up ! 5GL au sein d'un même programme. En ce cas, l'assemblage est automatiquement réalisé par Up ! Mixer.

Par défaut, le mixage est autorisé.

AutoriserMixage=Non

CheminBibliotheques

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

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

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

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

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

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

CheminRessources

CheminRessources permet de spécifier où sont rangées les ressources graphiques des composants et des modules. Par défaut, il s'agit du répertoire ${UPS_HOME}/demo/resources/${UPS_LANGUAGE};${UPS_HOME}/demo/upsvtm/${UPS_LANGUAGE}.

CheminRessources=${UPS_HOME}/demo/resources/${UPS_LANGUAGE};${UPS_HOME}/upsvtm/resources/${UPS_LANGUAGE}

CheminSources

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 ${UPS_HOME}/demo/sources/${UPS_USER}.

CheminSources=${UPS_HOME}/demo/sources/${UPS_USER}

CheminTlbsCom

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

Compactage

Compactage permet de spécifier que le code doit être compacté au mieux. Par défaut, le code n'est pas compact.

Compactage=Oui

Un code compact est plus lent à l'exécution parce que le noyau est plus sollicité. Par contre, les fichiers des exécutables sont plus petits.

Compile

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

Mode de compilation.Valeur du paramètre.
Ne pas compiler.Non
Compiler en tenant compte des dépendances.Oui
Recompiler sans tenir compte des dépendances.Recompiler

Compile=Recompiler

Contrainte

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

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

Detail=Oui

Entete

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

Entete=Oui

FactoriserChaine

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

FactoriserCode

FactoriserCode 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

Guid permet de spécifier l'identifiant de l'ActiveX à générer quand le paramètre AdaptateurServeurCom 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

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

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

MiseAuPoint

MiseAuPoint 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.

MiseAuPoint=Oui

Menage

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

Menage=Oui

ModuleImplemente

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

Normes

Normes permet de spécifier le fichier des normes de programmation en Up ! 5GL à vérifier. Par défaut, le fichier est ${UPS_HOME}/ini/${UPS_LANGUAGE}/ups5gl.ini en mode mono-utilisateur et ${UPS_HOME}/ini/${UPS_USER}/ups5gl.ini en mode multi-utilisateur.

Normes=${UPS_HOME}/ini/${UPS_USER}/normes.ini

Persistant

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

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 du paramètre
MacintoshMacOs
Z/OsOs390
Os 400Os400
UnixUnix
WindowsWindows

PlateForme=Unix

Profilage

Profilage permet de spécifier l'inclusion de code de profilage. Par défaut, le code de profilage n'est pas inclus.

Profilage=Oui

RepertoireClasses

RepertoireClasses permet de spécifier où ranger les archives des classes Java générées. Par défaut, le répertoire est ${UPS_HOME}/demo/upsjav/${UPS_LANGUAGE}.

RepertoireClasses=${UPS_HOME}/demo/genere

RepertoireExecutable

RepertoireExecutable permet de spécifier où ranger les exécutables et les bibliothèques dynamiques générés. Par défaut, le répertoire est ${UPS_HOME}/demo/bin.

RepertoireExecutable=${UPS_HOME}/demo/bin

RepertoireGeneres

RepertoireGeneres permet de spécifier où ranger les bibliothèques statiques générées ainsi que les interfaces des modules. Par défaut, le répertoire est ${UPS_HOME}/demo/upscmp.

RepertoireGeneres=${UPS_HOME}/demo/upscmp

RepertoireIdlsCom

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 ${UPS_HOME}/demo/upscom/${UPS_LANGUAGE}.

RepertoireIdlsCom=${UPS_HOME}/demo/upscom

RepertoireIdlsCorba

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}/demo/upscrb/${UPS_LANGUAGE}.

RepertoireIdlsCorba=${UPS_HOME}/demo/upscrb

RepertoireInterfaces

RepertoireInterfaces permet de spécifier le répertoire des interfaces des modules générés. Par défaut, le répertoire est ${UPS_HOME}/demo/interfaces/${UPS_LANGUAGE}.

RepertoireInterfaces=${UPS_HOME}/demo/interfaces/${UPS_LANGUAGE}

RepertoireMessages

RepertoireMessages permet de spécifier où ranger les fichiers messages de génération. Par défaut, le répertoire est ${UPS_HOME}/demo/upsnls.

RepertoireMessages=${UPS_HOME}/demo/upsnls

RepertoireObjets

RepertoireObjets permet de spécifier où ranger les objets de génération. Par défaut, le répertoire est ${UPS_HOME}/demo/objet.

RepertoireObjets=${UPS_HOME}/demo/objet

Source

Source permet de spécifier le fichier source à compiler. Ce paramètre 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

Syntaxe

Syntaxe permet de demander de vérifier la syntaxe des fichiers sources sans générer. Par défaut, la génération est enchaînée s'il n'y a pas d'erreur.

Syntaxe=Oui

Tmp

Tmp permet de spécifier le répertoire où sont rangés les fichiers temporaires. Par défaut, le répertoire est ${UPS_HOME}/demo/tmp/${UPS_USER}.

Tmp=/tmp

Exemple de configuration d'Up ! Compiler

; -------------------------------------------------------------------
; Fichier : upscmp.ini
; Objet : Initialisation d'Up ! Compiler.
;
; Module : Up ! Application System.
; Auteur-Date : DUVAL Jean-Pierre - Novembre 2003.
; -------------------------------------------------------------------
; Observations
;
;
; -------------------------------------------------------------------

[UpsCmp]
AdaptateurClientCom=Oui
AdaptateurClientCorba=Oui
AdaptateurClientJava=Oui
AdaptateurClientUpsNet=Oui
AdaptateurDictionnaire=Oui
AdaptateurServeurCom
AdaptateurServeurCorba=Oui
AdaptateurServeurJava=Oui
AdaptateurServeurUpsNet=Oui
ArchiveJava=monapplication.jar
AutoriserMixage=Non
CheminBibliotheques=C:\Program Files\Microsoft Visual Studio\VC98\Lib;\ CheminClassesJava=${UPS_HOME}/demo/genere:${UPS_HOME}/application/lib
CheminIdlsCom=${UPS_HOME}/upscom:${UPS_HOME}/genere
CheminIdlsCorba=${UPS_HOME}/upscrb:${UPS_HOME}/genere
CheminInclusions=C:\Program Files\Microsoft Visual Studio\VC98\Include;\ CheminInterfaces=${UPS_HOME}/upsvtm/interfaces;\ CheminRessources=${UPS_HOME}/demo/resources/${UPS_LANGUAGE}; CheminSources=${UPS_HOME}/demo/sources/${UPS_USER}
CheminTlbsCom=${UPS_HOME}/demo/upscom; Compactage=Oui
Compile=Recompiler
Contrainte=Oui
Detail=Oui
Entete=Oui
FactoriserChaine=Oui
FactoriserCode=Oui
Guid=fecd18c0-8a05-11d0-8e3c-e1043ebbde2b
Lanceur=Interactif
LangueCible=English
MiseAuPoint=Oui
Menage=Oui
ModuleImplemente1=Finances
ModuleImplemente2=ResHum
Normes=${UPS_HOME}/ini/${UPS_USER}/normes.ini
Persistant=Oui
PlateForme=Unix
Profilage=Oui
RepertoireClasses=${UPS_HOME}/demo/genere
RepertoireExecutable=${UPS_HOME}/demo/bin
RepertoireGeneres=${UPS_HOME}/demo/upscmp
RepertoireIdlsCom=${UPS_HOME}/demo/upscom
RepertoireIdlsCorba=${UPS_HOME}/demo/upscrb
RepertoireInterfaces=${UPS_HOME}/demo/interfaces/${UPS_LANGUAGE}
RepertoireMessages=${UPS_HOME}/demo/upsnls
RepertoireObjets=${UPS_HOME}/demo/objet
Source=caractere.upl
Syntaxe=Oui
Tmp=/tmp