ozmake - En ligne dans le Cloud

PROGRAMME:

Nom

Ozmake - Créer pour Oz

SYNOPSIS

ozmake --Aidez-moi
ozmake [--construire] [CIBLES...]
ozmake --installer [CIBLES...]
ozmake --installer [--package=PKG]
ozmake --désinstaller [--package=PKG]
ozmake --nettoyer
ozmake --très propre
ozmake --créer [--package=FICHIER]
ozmake --publier
ozmake --extrait [--package=PKG]
ozmake --liste [--package=MOGUL]
ozmake --config=(mettre|supprimer|liste) ...
ozmake --mogul=(mettre|supprimer|lister|exporter) ...

DESCRIPTION
ozmake OPTIONS CIBLES

ozmake est un outil permettant de créer des projets basés sur Mozart et de créer et d'installer Mozart
paquets. Il a été inspiré par les outils Unix a prendre une et rpm,mais c'est beaucoup, beaucoup plus simple, c'est
spécialisé dans le développement et le déploiement de logiciels basés sur Mozart, et de manière transparente
prend en charge toutes les plateformes sur lesquelles Mozart a été porté. ozmake doit actuellement être invoqué
à partir d'un shell, mais il finira par acquérir en plus une option conviviale
interface graphique.

OPTIONS

Dans ce qui suit, nous écrivons les méta-variables entre crochets angulaires, par exemple or <URI as
cachette chemin>

Général Options
-v --verbeux
Imprime plus d'informations de traçage que la valeur par défaut. En fournissant cette option,
deux fois, vous obtiendrez parfois encore plus d'informations.

-q --silencieux
supprimer toutes les informations de traçage et de rétroaction

-n --just-print
effectuer un essai à sec, c'est-à-dire imprimer simplement ce qui se passerait sans réellement effectuer
les actions

--locale
ne pas effectuer de récursivité dans les sous-répertoires

--(pas)d'autodépendance
par défaut: oui
déterminer automatiquement les dépendances au moment de la construction et de l'installation (temps d'exécution).
Actuellement, cela n'est pris en charge que pour les sources Oz en examinant l'importation et la demande
sections.

--(non)nécessite
par défaut: oui
récupérer et installer automatiquement les autres paquets requis par le paquet actuel. Ceci
L'option est pertinente aussi bien pour la construction que pour l'installation.

Ce que vous devez retenir ici, c'est que -vn est ton ami. Ajouter -vn à la fin de tout
ozmake invocation, et il vous dira en détail ce que la commande ferait, sans
le faire réellement.

Partages de fichiers et URL
--préfixe=
par défaut: ~/.oz
racine de la zone d'installation privée

--rép=
par défaut: répertoire courant
répertoire par défaut pour les autres options ci-dessous

--builddir=
par défaut:
répertoire dans lequel construire

--srcdir=
par défaut:
répertoire où se trouvent les fichiers sources

--bindir=
par défaut: / bin
répertoire où sont placées les cibles bin

--libroot=
par défaut: / cache
répertoire racine du cache dans lequel les cibles lib sont installées

--libdir=
par défaut: /<URI as cachette chemin>
répertoire dans lequel les cibles lib sont installées

--docroot=
par défaut: /doc
répertoire racine dans lequel les cibles de documentation sont installées

--docdir=
par défaut: /<MOGUL as nom de fichier>
répertoire dans lequel les cibles de documentation sont installées

--extractdir=
par défaut:
répertoire dans lequel extraire un package

--archive=
par défaut: http://www.mozart-oz.org/mogul/pkg
URL de l'archive Mogul à partir de laquelle les packages peuvent être téléchargés

--moguldir=
répertoire dans lequel sont placés les sous-répertoires pour les contributions de l'utilisateur : a
répertoire pour les packages, un pour la documentation, un pour les entrées de la base de données Mogul.

--mogulurl=
url correspondant au répertoire MOGULDIR

Documents officiels
-m --makefile=
par défaut: /makefile.oz
emplacement du makefile

-p --paquet=
fichier ou URL du package. lors de la création d'un package, il doit s'agir d'un nom de fichier local.
lors de l'extraction ou de l'installation, il peut également s'agir d'une URL ou d'un identifiant Mogul ; dans ce dernier cas
cas, le package est automatiquement téléchargé depuis l'archive mogul

-V --packageversion=
cette option est respectée par --extrait et --installer .Lorsque --extrait est donné
un identifiant MOGUL et télécharge le package correspondant à partir de l'archive MOGUL, il
recherchez précisément la VERSION donnée du package. --installer je vais simplement vérifier
que le paquet à installer possède réellement cette VERSION.

--base de données=
par défaut: /BASE DE DONNÉES
chemin de base de la base de données des paquets installés. La base de données est enregistrée dans les formats pickled et
format textuel respectivement dans les fichiers DB.ozf et DB.txt

Aidez
ozmake --Aidez-moi

-h --aide
imprimer ce message d'information

Se construisent
ozmake [--construire]
construire toutes les cibles

ozmake [--construire] DES DOSSIERS...
construire ces cibles

-b --build
c'est la valeur par défaut. construit les cibles du package

--optlevel=( aucun | débogage | optimiser )
par défaut: optimiser
sélectionner le niveau d'optimisation pour la compilation

-g --debug --optlevel=débogage
compiler avec débogage

-O --optimize --optlevel=optimiser
compiler avec une optimisation complète. c'est la valeur par défaut

--(pas)gnu
est le compilateur C++ le compilateur GNU. cela est déterminé automatiquement et permet un
niveau d'optimisation supérieur, à savoir le passage -O3 plutôt que juste -O à la
compilateur

--(pas)de construction complète
par défaut: non
construisez également les cibles src

--inclusir DIR -I DIR
indiquez au compilateur C++ de rechercher également dans DIR les fichiers à inclure

--(no)sysincludedirs
par défaut: oui
indiquez au compilateur C++ de rechercher en plus (ou non, si vous utilisez --nosysinclusirs
)les répertoires d'inclusion spécifiques à Mozart situés dans l'installation globale
répertoire et dans le privé de l'utilisateur ~/.oz région.

--librarydir RÉP. -L RÉP.
indiquez au linker C++ de rechercher également les bibliothèques dans DIR

--(no)syslibrarydirs
par défaut: oui
indiquez au linker C++ de rechercher en plus (ou non, si vous utilisez --nosyslibrarydirs
)les répertoires de bibliothèque spécifiques à Mozart situés dans l'installation globale
répertoire et dans le privé de l'utilisateur ~/.oz région.

Installer
ozmake --installer
installer en utilisant le makefile

ozmake --installer DES DOSSIERS...
installer ces cibles en utilisant le makefile

ozmake --installer --package=PKG
installer le paquet PKG

-i --install
installer les cibles du package et mettre à jour la base de données du package

--grade=( aucun | même | haut | bas | tout | rafraîchir )
par défaut: aucun
Que faire si ce paquet est déjà installé ? ozmake comparera la version et
dates, où la version est plus significative. --grade=aucun signale une erreur
--grade=même nécessite que les versions et les dates soient identiques --grade=up nécessite un
package avec une version plus récente ou la même version et une date de sortie plus récente que celle-ci
Installé --grade=bas nécessite un package avec une version plus ancienne ou la même version et
date de sortie plus ancienne que celle installée --grade=tout aucune condition --grade=rafraîchir
installer si le paquet est plus récent sinon ne rien faire

-U --mise à niveau
équivalente à --installer --grade=up

--rétrograder
équivalente à --installer --grade=bas

-A --toute qualité
équivalente à --installer --grade=tout

-F --rafraîchir
équivalente à --installer --grade=rafraîchir

--(no)replacefiles
par défaut: non
autoriser l'installation à écraser les fichiers d'autres packages

-R --remplacer
équivalente à --installer --grade=tout --replacefiles

--(no)extendpackage
par défaut: non
s'il faut remplacer ou étendre l'installation actuelle de ce package, le cas échéant

-X --étendre
équivalente à --installer --grade=tout --extendpackage

--(no)sauvegardéb
par défaut: oui
enregistrer la base de données mise à jour après l'installation

--inclusocs --excludedocs
par défaut: --inclusocs
s'il faut installer les cibles de documentation

--includelibs --excludelibs
par défaut: --includelibs
s'il faut installer les cibles lib

--includebins --excludebins
par défaut: --includebins
s'il faut installer les cibles bin

--(ne)gardez pas les zombies
par défaut: non
s'il faut supprimer les fichiers restants d'une installation précédente de ce package

--exe=( par défaut | oui | non | les deux | multi )
par défaut: défaut
la convention sous Windows est que les exécutables ont un .exe, tandis que sous Unix ils ont
pas d'extension. Le --EXE option vous permet de contrôler les conventions utilisées par
ozmake lors de l'installation des exécutables. --exe=par défaut utiliser la convention de la plateforme
--exe=oui utiliser une extension .exe --exe=non n'utilisez aucune extension --exe=les deux installer tout
exécutables avec et sans extension .exe --exe=multi installer des foncteurs exécutables
pour Unix et Windows. Les versions Unix s'installent sans extension, et
les versions Windows sont installées avec l'extension .exe

Désinstaller
ozmake --désinstaller
désinstaller le package décrit par makefile

ozmake --désinstaller --package=PKG
désinstaller le package nommé par l'ID mogul PKG

-e --uninstall
désinstaller un paquet

Clean
ozmake --nettoyer
ozmake --très propre
supprimer les fichiers comme spécifié par les fonctionnalités clean et veryclean du makefile.
--très propre implique --nettoyer .

Créer
ozmake --créer [--package=]
créez un package et enregistrez-le dans FICHIER. Les fichiers nécessaires au package sont
calculé automatiquement à partir du makefile. Si --paquet= n'est pas fourni, un
la valeur par défaut est calculée à l'aide de l'identifiant Mogul (et éventuellement du numéro de version) trouvé dans le
makefile.

--include(bins|libs|docs) --exclude(bins|libs|docs)
contrôler les types de cibles inclus dans le package

Publier
ozmake --publier
prend automatiquement en charge toutes les étapes nécessaires à la création/mise à jour d'un package
contribué par l'utilisateur et mettant toutes les données nécessaires à la disposition du MOGUL
bibliothécaire. Voir la documentation pour --magnat ci-dessous.

Extraction
ozmake --extrait --paquet=
extraire les fichiers du fichier ou de l'URL PKG. Si PKG est un identifiant Mogul, alors le package est
téléchargé automatiquement depuis les archives Mogul

Liste
ozmake --liste
répertorier les informations de tous les packages dans la base de données des packages installés

ozmake --liste --paquet=
liste des informations pour le package installé identifié par l'ID mogul MOGUL

--linewidth=N
par défaut: 70
supposer une ligne avec de N caractères

Config
ozmake --config=mettre
enregistrez les OPTIONS données dans la base de données de configuration d'ozmake et utilisez-les comme
valeurs par défaut dans les invocations ultérieures d'ozmake, sauf si elles sont explicitement remplacées sur le
ligne de commande. Par exemple : ozmake --config=mettre --prefix=/usr/local/oz *
/usr/local/oz comme valeur par défaut pour l'option --préfixe

ozmake --config=supprimer ...
Supprime certaines entrées de la base de données de configuration. Par exemple : ozmake
--config=supprimer préfixe supprime la valeur par défaut pour --préfixe à partir de la configuration
base de données

ozmake --config=list
répertorie le contenu de la base de données de configuration d'ozmake

l'argument de --config peut être abrégé en n'importe quel préfixe non ambigu

nabab
Si vous choisissez de contribuer aux archives MOGUL, ozmake --mogul=
simplifie votre tâche. Il vous permet de maintenir facilement une base de données de vos
contributions et de les exporter afin que le bibliothécaire MOGUL puisse les retrouver automatiquement.
En fait, le moyen le plus simple est d'utiliser ozmake --publier qui s'occupera de tout
détails pour vous.

ozmake --mogul=mettre
mettre à jour la base de données de l'utilisateur des propres contributions de Mogul avec les données pour cela
contribution (dans le répertoire local)

ozmake --mogul=mettre --paquet=
même que ci-dessus, mais en utilisant le package PKG explicitement donné

ozmake --mogul=supprimer ...
supprimer les entrées avec les identifiants Mogul MOG1 à MOGn de la base de données de l'utilisateur
contribution

ozmake --mogul=supprimer
supprimer l'entrée pour la contribution actuelle

ozmake --mogul=list
afficher les données enregistrées pour toutes les entrées dans la base de données de l'utilisateur de son propre magnat
contributions

ozmake --mogul=list ...
afficher les données enregistrées pour les entrées MOG1 à MOGn dans la base de données de l'utilisateur
contributions des magnats

ozmake --mogul=export
écrire toutes les entrées Mogul nécessaires pour les contributions Mogul de l'utilisateur. Celles-ci sont
les entrées qui seront lues par le bibliothécaire MOGUL pour assembler automatiquement les
base de données MOGUL complète.

Les données de vos contributions doivent être mises à la disposition du bibliothécaire MOGUL sur le
WEB. Vous souhaitez simplement mettre à jour un répertoire local avec vos contributions, mais pour
le bibliothécaire MOGUL pour les trouver, ces répertoires doivent également être disponibles via des URL sur
le WEB. Voici quelques options qui vous permettent de contrôler cette correspondance, et pour
que vous devez définir par défaut en utilisant ozmake --config=mettre

--moguldir=

--mogulurl=
MOGULDIR est un répertoire qui est également disponible sur le WEB via l'url MOGULURL.
MOGULDIR est conçu comme un répertoire racine dans lequel se trouvent des sous-répertoires pour les packages,
On y trouvera de la documentation et des entrées Mogul.

Pour ceux qui aiment vraiment la douleur, ozmake a bien sûr de nombreuses options pour se tirer une balle dans la tête
le pied. Dans les options ci-dessous représente la version du nom de fichier du mogul du package
id (remplacez les barres obliques par des tirets). Vous pouvez contrôler l'emplacement des paquets, leur
la documentation et les entrées de la base de données Mogul sont stockées et mises à disposition à l'aide des options
ci-dessous :

--mogulpkgdir=
par défaut: /paquet//

--mogulpkgurl=
par défaut: /paquet//

--moguldocdir=
par défaut: /doc//

--moguldocurl=
par défaut: /doc//

--moguldbdir=
par défaut: /db//

--moguldburl=
par défaut: /db//

Vos contributions doivent toutes avoir des identifiants de magnat qui sont ci-dessous l'identifiant du magnat que vous étiez
accordé pour votre section de la base de données Mogul. Pour plus de commodité, ozmake tentera de
devinez l'identifiant racine du magnat de votre section dès qu'il y a des entrées dans votre base de données de
vos propres contributions. Cependant, il est préférable de dire ozmake à ce sujet en utilisant :

--mogulrootid=

et de le régler en utilisant ozmake --config=mettre --mogulrootid=

FAIREFILE

Le makefile contient un seul enregistrement Oz qui décrit le projet et devrait normalement
être placé dans un fichier appelé makefile.oz.Un makefile ressemble généralement à ceci :

fichier makefile(
lib : ['Foo.ozf']
uri : 'x-ozlib://mylib'
mogul : 'mogul:/denys/lib-foo')

indiquant explicitement qu'il existe une cible de bibliothèque, à savoir le foncteur Foo.ozf,et cela
il doit être installé à l'URI :

x-ozlib://mylib/Foo.ozf

et implicitement qu'il doit être compilé à partir du fichier source Oz Foo.oz.Lorsque vous invoquez
ozmake --installer,la magnat La fonctionnalité permet d'identifier de manière unique ce package et les fichiers
il contribue à la ozmake base de données des packages installés.

Il existe de nombreuses autres fonctionnalités qui peuvent apparaître dans le makefile et elles sont toutes facultatives. Si
vous omettez toutes les fonctionnalités, vous obtenez uniquement les valeurs par défaut et vous n'avez même pas besoin d'un makefile.
Toutes les valeurs, telles que fichiers,doit être donné sous forme de chaîne virtuelle ; les atomes sont recommandés sauf
pour les fonctionnalités texte de présentation, info_text et info_html,où les chaînes sont recommandées.

fichier makefile(
bin : [ FICHIERS... ]
lib : [ FICHIERS... ]
doc : [ FICHIERS... ]
src : [ FICHIERS... ]
dépend :
o( FICHIER : [ FICHIERS... ]
...
)
règles :
o( FICHIER : OUTIL(FICHIER)
...
)
nettoyer : [ GLOB... ]
trèspropre : [ GLOB... ]
uri : URI
magnat : MOGUL
auteur : [ AUTEURS... ]
publié : DATE
résumé : TEXTE
info_text : TEXTE
info_html : TEXTE
sous-répertoires : [ DIRS... ]
nécessite : [ MOGUL... ]
catégories : [ CATÉGORIE... ]
version : VERSION
fournit : [ FICHIERS... ]
)

Fonctionnalités bin, lib et doc list cibles à installer dans , et
respectivement. coffre les cibles doivent être des foncteurs exécutables, c'est-à-dire qu'elles doivent se terminer par
l'extension de .exe. lib les cibles sont généralement des foncteurs compilés, c'est-à-dire se terminant par une extension
.ozf,mais pourraient également être des foncteurs natifs, c'est-à-dire se terminant par une extension .so,ou simplement des données
fichiers. dock les cibles sont des fichiers de documentation.

Extensions
ozmake sait construire des cibles en regardant l'extension de la cible :

Foo.exe

est un foncteur exécutable et est créé à partir de Foo.ozf

Foo.ozf

est un foncteur compilé et est créé à partir de Foo.oz

Foo.o

est un fichier C++ compilé et est créé à partir de Foo.cc

Foo.so

est un foncteur natif et est créé à partir de Foo.o

Foo.cc

est un fichier source C++

Foo.hh

est un fichier d'en-tête C++

Notez que ce sont résumé cibles. En particulier, Foo.so désigne vraiment le fichier
Foo.so- où identifie l'architecture et le système d'exploitation où
le paquet est construit ; par exemple : Linux-i486.De plus, lorsqu'une cible bin Foo.exe is
installé, il est installé à la fois comme /Foo.exe et /Foo pour qu'il puisse être
invoqué comme Foo sur les plateformes Windows et Unix.

Il est impératif de respecter l'utilisation conventionnelle des extensions décrite ici :
ozmake ne permet aucune variation et ne prend en charge aucune autre extension.

Règles
ozmake possède des règles intégrées pour la création de fichiers. Il peut arriver que vous souhaitiez contourner ces règles.
règle par défaut pour une ou plusieurs cibles. Ceci est réalisé avec la fonctionnalité exclure qui contient un
mappage d'enregistrement cible à règle :

FICHIER_CIBLE : OUTIL(FICHIER_SOURCE)

la règle peut également avoir une liste d'options :

FICHIER_CIBLE : OUTIL (OPTIONS DU FICHIER_SOURCE)

Les outils pris en charge par ozmake sommes-nous ozc (compilateur Oz), onces (Liant Oz), cc (compilateur C++),
ld (Éditeur de liens C++). Les règles par défaut sont :

'Foo.exe' : ozl('Foo.ozf' [exécutable])
'Foo.ozf' : ozc('Foo.oz')
'Foo.o' : cc('Foo.cc')
'Foo.so' : ld('Foo.o')

Les outils prennent en charge les options suivantes :

ozc

exécutable

rendre le résultat exécutable

'définir'(S)

définir une macro S.Identique à -DS sur la ligne de commande

onces

exécutable

rendre le résultat exécutable

cc

inclure(DIR)

Similaire à l'option habituelle du compilateur C++ -IDIR. DIR est une chaîne virtuelle

'définir' (MAC)

Similaire à l'option habituelle du compilateur C++ -DMAC. MAC est une chaîne virtuelle

ld

bibliothèque (DIR)

Similaire à l'option de lien C++ habituelle -lDIR. DIR est une chaîne virtuelle

Vous souhaiterez peut-être spécifier une règle pour créer une bibliothèque pré-liée :

'Utils.ozf' : ozl('Foo.ozf')

ou pour créer un exécutable non pré-lié :

'Foo.exe' : ozc('Foo.oz' [exécutable])

Dépendances
ozmake détermine automatiquement si les cibles doivent être reconstruites, par exemple parce qu'elles
sont manquants ou si un fichier source nécessaire à leur création a été modifié. Les règles sont
Utilisé pour déterminer les dépendances entre les fichiers. Parfois, cela est insuffisant, par exemple parce que
vous utilisez un outil onces (dépendances aux importations), ou insérer dans un fichier Oz, ou #include dans un fichier C++
fichier. Dans ce cas, vous pouvez spécifier des dépendances supplémentaires à l'aide de la fonctionnalité dépend lequel est
un mappage d'enregistrement cible une liste de dépendances :

CIBLE : [ FICHIERS... ]

Par exemple :

'Foo.o' : [ 'Foo.hh' 'Baz.hh' ]

or

'Foo.exe' : [ 'Lib1.ozf' 'Lib2.ozf' ]

Nettoyage
Au cours du développement, il est souvent pratique de pouvoir supprimer facilement tous les éléments indésirables et
fichiers compilés pour obtenir à nouveau un répertoire de projet propre. Ceci est pris en charge par ozmake
--nettoyer et ozmake --très propre;ce dernier implique également le premier. Les fichiers à supprimer sont
spécifié par glob modèles où ? correspond à n'importe quel caractère et * correspond à une séquence de 0
ou plusieurs caractères. Tous les fichiers de BUILDDIR correspondant à un tel motif sont supprimés. Il y a
modèles intégrés, mais vous pouvez les remplacer par des fonctionnalités espace extérieur plus propre, et très propre qui
Il doit s'agir de listes de motifs glob. Par exemple, les motifs glob de nettoyage par défaut sont :

nettoyer : [ "*~" "*.ozf" "*.o" "*.so-*" "*.exe" ]

Forfait Articles connexes Comment ça marche
Links

caractéristique Links Indique l'URI où installer les cibles de bibliothèque. Par exemple :

uri : 'x-ozlib://mylib/XML'

déclare que tous lib cibles (par exemple Foo.ozf)seront installés sous cet URI afin qu'ils
peut également être importé à partir de celui-ci, c'est-à-dire :

importer MyFoo dans 'x-ozlib://mylib/XML/Foo.ozf'

magnat

caractéristique magnat est l'identifiant unique de Mogul qui identifie ce package. Il est utilisé pour identifier
le paquet dans la base de données des paquets installés, pour créer/publier le paquet, et pour
installer ses fichiers de documentation.

auteur

caractéristique auteur est une chaîne virtuelle ou une liste de chaînes virtuelles identifiant respectivement l'auteur
ou les auteurs du package. Il est recommandé d'identifier les auteurs par leur identifiant Mogul,
Il est toutefois possible de simplement indiquer leurs noms. Par exemple, la méthode recommandée
est:

auteur : 'mogul:/duchier'

mais ce qui suit est également possible :

auteur : 'Denys Duchier'

libéré

caractéristique libéré est une chaîne virtuelle spécifiant la date et l'heure de publication dans le
format suivant :

publié : "AAAA-MM-JJ-HH:MM:SS"

L'heure est facultative. Une date de sortie appropriée utilisant la date et l'heure actuelles est
inséré automatiquement lors de l'appel ozmake --créer or ozmake --publier..

texte de présentation

caractéristique texte de présentation contient un très court texte décrivant le package. Ce texte doit
être juste une ligne et est destiné à être utilisé comme titre lorsque le package est publié dans
les archives du magnat.

info_text

caractéristique info_text contient une description en texte brut du package. Ceci est destiné à être
utilisé comme résumé sur la page de présentation du package dans les archives Mogul. Il
doit être bref et informatif, mais ne doit pas tenter de documenter le package.

info_html

caractéristique info_html est similaire à info_text mais contient du HTML plutôt que du texte brut.

src

caractéristique src indique quelles cibles doivent être considérées comme sources, c'est-à-dire en particulier non
constructible. Toutes les cibles mentionnées dans src devrait être mentionné dans coffre, lib, dock aussi. le
point de src est de prendre en charge la distribution de packages avec des cibles pré-construites et sans donner
les sources correspondantes. Vous ne devriez pas faire cela avec des foncteurs natifs, car ils sont
dépend de la plate-forme et n'est pas portable, mais cela peut être un moyen pratique de distribuer des pré-
J'ai construit des bibliothèques Oz. Par exemple :

fichier makefile(
lib : [ 'Foo.ozf' ]
source : [ 'Foo.ozf' ]
uri : 'x-ozlib://mylib'
magnat : 'mogul:/monnom/foolib')

est un makefile pour un package qui distribue le pré-compilé Foo.ozf,mais ne fait pas aussi
distribuer sa source Foo.oz.Normalement, lorsque vous construisez un package, il vérifie simplement que le
src Les fichiers sont présents, mais nous ne tenterons pas de les compiler. Si vous disposez des sources, vous pouvez
forcer la construction de la src cibles si nécessaire en utilisant --complètement construit..

sous-répertoires

caractéristique sous-répertoires est une liste de noms de fichiers nus représentant les sous-répertoires du projet.
par défaut, si nécessaire, ozmake effectuera une récursion dans ces sous-répertoires. Il est attendu
que chaque sous-répertoire doit fournir son propre fichier Makefile. L'identifiant Mogul est automatiquement
hérité des sous-répertoires et l'URI est automatiquement étendu en ajoutant le nom de
le sous-répertoire : ainsi les sous-makefiles peuvent être plus simples puisqu'ils n'ont pas besoin d'être concernés
avec des fonctionnalités au niveau du package.

a besoin

caractéristique a besoin est une liste d'URI de modules ou d'identifiants MOGUL de packages. Ceux-ci représentent
externe dépendances du paquet. Elles ne sont pas encore utilisées, mais elles finiront par l'être. ozmake sera
capable de les utiliser pour automatiser l'installation récursive d'autres packages requis par le
celui qui vous intéresse.

catégories

caractéristique catégories est une liste de catégories MOGUL pour aider à catégoriser ce package dans le
Archives MOGUL.

version

caractéristique version est utilisé pour fournir une chaîne de version. Il s'agit d'une chaîne composée de
entiers séparés par des points simples, par exemple "2" or "3.1.7"..

offre aux

caractéristique offre aux est utilisé pour remplacer les informations par défaut sur ce que contient le package
fournit, normalement calculé automatiquement à partir du coffre et lib cibles : cela devrait être un
liste qui contient un sous-ensemble de ces cibles. Le offre aux la fonctionnalité d'un makefile ne
remplacer ou affecter autrement ses sous-makefiles : chaque makefile doit remplacer séparément
s'il le souhaite. Pour indiquer qu'un makefile ne fournit officiellement aucun foncteur ou
application exécutable, vous ajouteriez :

fournit : nul

Vous devez utiliser le offre aux fonctionnalité lorsque votre package contient à la fois des informations publiques officielles
foncteurs ainsi que des foncteurs purement implémentatifs qui ne font pas partie du
interface publique et ne doit pas être mentionné comme à condition de par paquet.

CONTACTS

Les auteurs devraient vraiment être référencés par des identifiants de mogul indiquant les entrées de mogul qui décrivent
eux. Afin de rendre cela plus facile, un makefile.oz peut également contenir un contact fonctionnalité qui
il s'agit soit d'un enregistrement décrivant une personne, soit d'une liste de tels enregistrements.

Vous ne devriez pas avoir un contact dans chaque makefile. Au contraire, le contact caractéristique est
généralement destiné aux makefiles qui n'ont qu'un contact fonctionnalité, c'est-à-dire dont le seul but
consiste à créer des entrées de magnat pour les personnes correspondantes. Voici un exemple de ce type
fichier makefile:

fichier makefile(
communiquer avec:
o(
mogul : 'mogul:/duchier/denys'
nom : 'Denys Duchier'
e-mail : '[email protected]'
www : 'http://www.ps.uni-sb.de/~duchier/'))

Vous pouvez invoquer ozmake --publier sur un tel makefile pour contribuer au mogul correspondant
entrées de base de données

Utilisez ozmake en ligne avec les services onworks.net