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.

Pour un source d'un composant ou d'un module en Up ! 5GL.
Chaque générateur offre des cibles de génération pour créer un exécutable, une bibliothèque statique ou dynamique pour Windows, Linux, Os 400, etc.
Pour un source d'une ressource en Up ! 5GL.
Chaque générateur permet de produire une ressource compilée directement employable à l'exécution.

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 :

En ligne de commande en mode batch.
En ce cas, pour les plates-formes graphiques, aucune fenêtre n'est ouverte.
En ligne de commande en mode fenêtré.
En ce cas, pour les plates-formes graphiques, une fenêtre sommaire est ouverte contenant les messages de compilation.
Encapsulé dans l'atelier de réalisation d'application Up ! Workbench.

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 variables environnement.
Le fichier d'initialisation.
${UPS_HOME}/ini/${UPS_LANGUAGE}/upscmp.ini en mode mono-utilisateur ou ${UPS_HOME}/ini/${UPS_USER}/upscmp.ini en mode multi-utilisateur.
La section est soit :
- UpsCmp.
  Ceci est la section par défaut.
- UpsCmp.${NomDuModule].
  Ceci est la section dédiée au module à compiler.
Le fichier de paramètres.
S'il existe.
La ligne de commande.
Il s'agit soit de :
- La ligne de commande stricto sensu.
- La valeur de la variable environnement QUERY_STRING.
  En ce cas, le programme s'exécute automatiquement et obligatoirement en mode batch en respectant la norme Common Gateway Interface (CGI).
Les paramètres peuvent être préfixés par UpsCmp.

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 lanceur	Sémantique de lanceur
Interactif	Le programme comporte une fenêtre permettant à l'utilisateur d'interagir avec le programme.
Automatique	Le 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.
Serveur	Le 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.
Console	Si 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 langue	Sémantique de la langue
Arabic	Les adaptateurs seront écrits en arabe.
Chinese	Les adaptateurs seront écrits en chinois.
English	Les adaptateurs seront écrits en anglais.
French	Les adaptateurs seront écrits en français.
German	Les adaptateurs seront écrits en allemand.
Italian	Les adaptateurs seront écrits en italien.
Japanese	Les adaptateurs seront écrits en japonais.
Portuguese	Les adaptateurs seront écrits en portugais.
Russian	Les adaptateurs seront écrits en russe.
Spanish	Les 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-forme	Valeur du paramètre
Macintosh	`MacOs`
Z/Os	`Os390`
Os 400	`Os400`
Unix	`Unix`
Windows	`Windows`

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.

Description	Exemple d'appel
Source d'un composant ou d'un module multi-composants	`Source=essai.upl`
Idl d'un ActiveX pour générer le module client	`Source=essai.idl`
Tlb d'un exécutable d'un ActiveX pour générer le module client	`Source=essai.dll Source=essai.exe Source=essai.tlb`
Idl d'un module Corba pour générer le module client	`Source=essai.idl`
ObjectId d'un Interface Repository d'un module Corba pour générer le module client	`Source=IDL:app/essai:1.0`
Source Java pour générer le module client	`Source=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;\

	C:\Program Files\mico2311\lib;C:\forte_jdk\j2sdk1.4.0\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;\

	C:\Program Files\mico2311\include;\
	C:\forte_jdk\j2sdk1.4.0\include

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=${UPS_HOME}/demo/resources/${UPS_LANGUAGE};

	${UPS_HOME}/demo/upsvtm/${UPS_LANGUAGE}

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

CheminTlbsCom=${UPS_HOME}/demo/upscom;

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