ozmake - Online na nuvem

PROGRAMA:

NOME

Ozmake - Faça para Oz

SINOPSE

ozmake --Socorro
ozmake [--construir] [METAS ...]
ozmake --instalar [METAS ...]
ozmake --instalar [--package = PKG]
ozmake --Desinstalar [--package = PKG]
ozmake --limpar
ozmake --muito limpo
ozmake --Criar [--package = FILE]
ozmake --publicar
ozmake --extrair [--package = PKG]
ozmake --Lista [--pacote = MOGUL]
ozmake --config = (colocar | excluir | lista) ...
ozmake --mogul = (colocar | excluir | lista | exportar) ...

DESCRIÇÃO
ozmake OPÇÕES ALVOS

ozmake é uma ferramenta para construir projetos baseados em Mozart e para criar e instalar Mozart
pacotes. Foi inspirado nas ferramentas Unix fazer e rpm, mas é muito, muito mais simples, é
especializada para desenvolvimento e implantação de software baseado em Mozart, e de forma transparente
suporta todas as plataformas nas quais Mozart foi portado. ozmake deve ser invocado atualmente
de um shell, mas eventualmente adquirirá adicionalmente um opcional e amigável
interface gráfica.

OPÇÕES

A seguir, escrevemos metavariáveis ​​entre colchetes angulares, por exemplo or <URI as
esconderijo caminho>

Geral Opções
-v --verboso
imprimir mais informações de rastreamento que o padrão. Ao fornecer esta opção
duas vezes, às vezes você obterá ainda mais informações.

-q --quieto
suprimir todas as informações de rastreamento e feedback

-n --simplesmente imprimir
realizar uma simulação, ou seja, apenas imprimir o que aconteceria sem realmente realizar
as ações

--local
não recursivamente em subdiretórios

- (não) autodepend
default: verdadeiro
determine automaticamente as dependências do tempo de construção e do tempo de instalação (tempo de execução).
Atualmente, isso só é compatível com fontes de Oz, observando a importação e exigir
.

- (não) requer
default: verdadeiro
busca e instala automaticamente outros pacotes que o atual requer. Isto
opção é relevante tanto para a construção quanto para a instalação.

O que você deve lembrar aqui, é que -vn é seu amigo. Adicionar -vn no final de qualquer
ozmake invocação, e ele dirá em detalhes o que o comando faria, sem
realmente fazendo isso.

diretórios e URLs
--prefix =
default: ~ / .oz
raiz da área de instalação privada

--dir =
default: diretório atual
diretório padrão para outras opções abaixo

--builddir =
default:
diretório no qual construir

--srcdir =
default:
diretório onde os arquivos de origem estão localizados

--bindir =
default: / bin
diretório onde os alvos bin são colocados

--libroot =
default: / cache
diretório raiz do cache no qual os alvos lib são instalados

--libdir =
default: /<URI as esconderijo caminho>
diretório no qual os alvos lib são instalados

--docroot =
default: / doc
diretório raiz no qual os destinos de documentos são instalados

--docdir =
default: /<MOGUL as nome do arquivo>
diretório no qual os destinos de documentos são instalados

--extractdir =
default:
diretório para o qual extrair um pacote

--archive =
default: http://www.mozart-oz.org/mogul/pkg
URL do arquivo mogul a partir do qual os pacotes podem ser baixados

--moguldir =
diretório no qual são colocados subdiretórios para as contribuições do usuário: a
diretório para pacotes, um para documentação, um para entradas de banco de dados magnatas.

--mogulurl =
url correspondente ao diretório MOGULDIR

Arquivos
-m --makefile =
default: /makefile.oz
localização do makefile

-p --package =
arquivo ou URL do pacote. ao criar um pacote, deve ser um nome de arquivo local.
ao extrair ou instalar, também pode ser um URL ou um id de magnata; no ultimo
caso, o pacote é baixado automaticamente do arquivo mogul

-V --packageversion =
esta opção é respeitada por --extrair e --instalar .Quando --extrair é dada
uma id MOGUL e baixa o pacote correspondente do arquivo MOGUL, ele irá
procure precisamente a versão fornecida do pacote. --instalar irá simplesmente verificar
que o pacote a ser instalado realmente possui esta VERSÃO.

--database =
default: /BASE DE DADOS
caminho de base do banco de dados de pacotes instalados. O banco de dados é salvo em conserva e
formato textual respectivamente nos arquivos DB.ozf e DB.txt

Suporte
ozmake --Socorro

-h --ajuda
imprima esta mensagem de informação

Construção
ozmake [--construir]
construir todos os alvos

ozmake [--construir] ARQUIVOS...
construir estes alvos

-b --construir
este é o padrão. constrói alvos do pacote

--optlevel = (nenhum | depurar | otimizar)
default: otimizar
selecione o nível de otimização para compilação

-g --debug --optlevel = debug
compilar com depuração

-O --optimize --optlevel = optimize
compilar com otimização total. este é o padrão

- (não) gnu
é o compilador C ++, o compilador GNU. isso é determinado automaticamente e permite um
maior nível de otimização, ou seja, passando -O3 ao invés de apenas -O ao
compilador

- (não) fullbuild
default: falso
também construir os alvos src

--includedir DIR -I DIR
diga ao compilador C ++ para pesquisar adicionalmente no DIR por arquivos de inclusão

- (não) sysincludedirs
default: verdadeiro
diga ao compilador C ++ para pesquisar adicionalmente (ou não, se estiver usando --nosysincludeddirs
) os diretórios de inclusão específicos de Mozart localizados na instalação global
e no diretório privado do usuário ~ / .oz área.

--librarydir DIR -L DIR
diga ao linker C ++ para pesquisar adicionalmente no DIR por bibliotecas

- (não) syslibrarydirs
default: verdadeiro
diga ao linker C ++ para pesquisar adicionalmente (ou não, se estiver usando --nosyslibrarydirs
) os diretórios de biblioteca específicos de Mozart localizados na instalação global
e no diretório privado do usuário ~ / .oz área.

Instale
ozmake --instalar
instalar usando o makefile

ozmake --instalar ARQUIVOS...
instale esses alvos usando o makefile

ozmake --instalar --package = PKG
pacote de instalação PKG

-i --instalar
instalar destinos do pacote e atualizar o banco de dados do pacote

--grade = (none | same | up | down | any | freshen)
default: Nenhum
o que fazer se este pacote já estiver instalado? ozmake irá comparar a versão e
datas, onde a versão é mais significativa. --grade = nenhum sinaliza um erro
--grade = mesmo requer que as versões e datas sejam as mesmas --grade = up requer uma
pacote com versão mais recente ou a mesma versão e data de lançamento mais recente que a
instalado --grade = down requer um pacote com uma versão mais antiga ou a mesma versão e
data de lançamento mais antiga do que a instalada --grade = any sem condições --grade = refrescar
instale se o pacote for mais novo, não faça nada

-U --atualizar
equivalente a --instalar --grade = up

- downgrade
equivalente a --instalar --grade = down

-A - qualquer grau
equivalente a --instalar --grade = any

-F --frescado
equivalente a --instalar --grade = refrescar

- (sem) replacefiles
default: falso
permite que a instalação sobrescreva arquivos de outros pacotes

-R --substituir
equivalente a --instalar --grade = any --replacefiles

- (não) extendpackage
default: falso
se deve substituir ou estender a instalação atual deste pacote, se houver

-X --extender
equivalente a --instalar --grade = any - pacote extenso

- (não) salvob
default: verdadeiro
salvar o banco de dados atualizado após a instalação

--includedocs --excludedocs
default: --includedocs
se deve instalar os destinos de doc

--includelibs --excludelibs
default: --includelibs
se deve instalar os alvos lib

--includebins --excludebins
default: --includebins
se deve instalar os alvos bin

- (não) keepzombies
default: falso
se deseja remover os arquivos que sobraram de uma instalação anterior deste pacote

--exe = (padrão | sim | não | ambos | multi)
default: omissão
a convenção no Windows é que os executáveis ​​têm um .exe, enquanto no Unix eles têm
sem extensão. O --Exe opção permite que você controle as convenções usadas por
ozmake ao instalar executáveis. --exe = default usar a convenção da plataforma
--exe = sim use uma extensão .exe --exe = não não use extensão --exe = ambos instalar tudo
executáveis ​​com extensão .exe e sem --exe = multi instalar functores executáveis
para Unix e Windows. As versões Unix são instaladas sem extensão, e
as versões do Windows são instaladas com a extensão .exe

Desinstalar
ozmake --Desinstalar
pacote de desinstalação descrito por makefile

ozmake --Desinstalar --package = PKG
pacote de desinstalação nomeado por id magnata PKG

-e --desinstalar
desinstale um pacote

peixe de água doce
ozmake --limpar
ozmake --muito limpo
remova arquivos conforme especificado pelos recursos limpos e muito limpos do makefile.
--muito limpo implica --limpar .

Crie
ozmake --Criar [--package =]
crie um pacote e salve-o em FILE. os arquivos necessários para o pacote são
calculado automaticamente a partir do makefile. Se --package = não é fornecido, um
o padrão é calculado usando o id do mogul (e possivelmente o número da versão) encontrado no
arquivo make.

--include (bins | libs | docs) --exclude (bins | libs | docs)
controlar quais tipos de destino estão incluídos no pacote

Publicar
ozmake --publicar
cuida automaticamente de todas as etapas necessárias para criar / atualizar um pacote
contribuído pelo usuário e disponibilizando todos os dados necessários para a MOGUL
bibliotecário. Veja a documentação para -- magnata abaixo.

Extrair
ozmake --extrair --package =
extraia os arquivos do arquivo ou URL PKG.if PKG é um id mogul, então o pacote é
baixado automaticamente do arquivo do magnata

Lista
ozmake --Lista
listar informações para todos os pacotes no banco de dados de pacotes instalados

ozmake --Lista --package =
lista de informações para o pacote instalado identificado pelo magnata id MOGUL

--linewidth = N
default: 70
assumir uma linha com de N caracteres

Configuração
ozmake --config = colocar
registrar as OPÇÕES fornecidas no banco de dados de configuração do ozmake e usá-las como
padrões em invocações subsequentes de ozmake, a menos que explicitamente sobrescrito no
linha de comando. Por exemplo: ozmake --config = colocar --prefix = / usr / local / oz salva
/ usr / local / oz como o valor padrão para a opção --prefixo

ozmake --config = deletar ...
exclui algumas entradas do banco de dados de configuração. Por exemplo: ozmake
--config = deletar prefixo remove o padrão para --prefixo da configuração
banco de dados

ozmake --config = list
lista o conteúdo do banco de dados de configuração do ozmake

o argumento para --config pode ser abreviado para qualquer prefixo não ambíguo

Mogul
Se você decidir contribuir com pacotes para o arquivo MOGUL, ozmake --mogul =
simplifica sua tarefa. Isso torna mais fácil para você manter um banco de dados de seus
contribuições e exportá-las para que o bibliotecário da MOGUL as encontre automaticamente.
Na verdade, a maneira mais simples é usar ozmake --publicar que vai cuidar de tudo
detalhes para você.

ozmake --mogul = colocar
atualizar o banco de dados do usuário das próprias contribuições do magnata com os dados para este
contribuição (no diretório local)

ozmake --mogul = colocar --package =
mesmo que acima, mas usando o pacote PKG fornecido explicitamente

ozmake --mogul = deletar ...
remova as entradas com ids magníficos MOG1 a MOGn do próprio banco de dados do usuário
contribuição

ozmake --mogul = deletar
remover entrada para contribuição atual

ozmake --mogul = list
mostra os dados registrados para todas as entradas no banco de dados do usuário do próprio magnata
contribuições

ozmake --mogul = list ...
mostra os dados registrados para as entradas MOG1 a MOGn no banco de dados do próprio usuário
contribuições magnatas

ozmake --mogul = export
escreva todas as entradas de magnata necessárias para as próprias contribuições de magnata do usuário. Estes são
as entradas que serão lidas pelo bibliotecário da MOGUL para montar automaticamente o
banco de dados MOGUL completo.

Os dados de suas contribuições devem ser disponibilizados ao bibliotecário da MOGUL no
REDE. Você deseja apenas atualizar um diretório local com suas contribuições, mas, para que
o bibliotecário da MOGUL para encontrá-los, esses diretórios também devem estar disponíveis por meio de URLs em
a teia. Aqui estão algumas opções que permitem que você controle esta correspondência, e para
que você deve definir como padrão usando ozmake --config = colocar

--moguldir =

--mogulurl =
MOGULDIR é um diretório que também está disponível na WEB através da url MOGULURL.
MOGULDIR destina-se a ser um diretório raiz no qual subdiretórios para pacotes,
documentação e entradas magnatas serão encontradas.

Para quem realmente gosta de dor, ozmake tem, claro, muitas opções para atirar em si mesmo
o pé. Nas opções abaixo representa a versão do nome do arquivo do magnata do pacote
id (basicamente substitua barras por travessão). Você pode controlar onde os pacotes, seus
documentação e entradas de banco de dados magníficas e armazenadas e disponibilizadas usando as opções
abaixo:

--mogulpkgdir =
default: / pkg //

--mogulpkgurl =
default: / pkg //

--moguldocdir =
default: / doc //

--moguldocurl =
default: / doc //

--moguldbdir =
default: / db //

--moguldburl =
default: / db //

Todas as suas contribuições devem ter ids magnatas que são abaixo o id do magnata que você onde
concedido para sua seção do banco de dados magnata. Por conveniência, ozmake tentará
adivinhe o id do magnata raiz da sua seção assim que houver entradas no seu banco de dados de
suas próprias contribuições. No entanto, é muito preferível dizer ozmake sobre isso usando:

--mogulrootid =

e configurá-lo usando ozmake --config = colocar --mogulrootid =

MAKEFILE

O makefile contém um único registro de Oz que descreve o projeto e deve normalmente
ser colocado em um arquivo chamado makefile.oz.Um makefile normalmente se parece com isto:

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

afirmando explicitamente que há um destino de biblioteca, ou seja, o functor Foo.ozf,e essa
deve ser instalado em URI:

x-ozlib: //mylib/Foo.ozf

e implicitamente que deve ser compilado a partir do arquivo de origem Oz Foo.oz.Quando você invoca
ozmake --instalar,a magnata recurso serve para identificar exclusivamente este pacote e os arquivos
contribui no ozmake banco de dados de pacotes instalados.

Existem muitos outros recursos que podem ocorrer no makefile e todos são opcionais. Se
você omite todos os recursos, obtém apenas os padrões e nem precisa de um makefile.
Todos os valores, como arquivos, deve ser fornecido como string virtual; átomos são recomendados, exceto
para recursos sinopse, info_texto e informações_html, onde strings são recomendadas.

makefile (
bin: [ARQUIVOS ...]
lib: [ARQUIVOS ...]
doc: [ARQUIVOS ...]
src: [ARQUIVOS ...]
depende:
o (ARQUIVO: [ARQUIVOS ...]
...
)
as regras :
o (ARQUIVO: FERRAMENTA (ARQUIVO)
...
)
limpo: [GLOB ...]
muito limpo: [GLOB ...]
uri: URI
magnata: MOGUL
autor: [AUTORES ...]
data de lançamento
blurb: TEXT
info_text: TEXT
info_html: TEXT
subdiretórios: [DIRS ...]
requer: [MOGUL ...]
categorias: [CATEGORY ...]
versão: VERSION
fornece: [ARQUIVOS ...]
)

Recursos bin, lib e destinos de lista de documentos a serem instalados em , e
respectivamente. caixa alvos devem ser functores executáveis, ou seja, devem terminar com
extensão .exe. lib alvos são tipicamente functores compilados, ou seja, terminando com extensão
.ozf, mas também podem ser functores nativos, ou seja, terminando com extensão .assimou simplesmente dados
arquivos. doca destinos são arquivos de documentação.

Extensões
ozmake sabe como construir alvos olhando para a extensão do alvo:

Foo.exe

é um functor executável e é criado a partir de Foo.ozf

Foo.ozf

é um functor compilado e é criado a partir de Foo.oz

Foo.o

é um arquivo C ++ compilado e é criado a partir de Foo.cc

Foo.so

é um functor nativo e é criado a partir de Foo.o

Foo.cc

é um arquivo fonte C ++

Foo.hh

é um arquivo de cabeçalho C ++

Note que estes são abstrato alvos. Em particular, Foo.so realmente denota o arquivo
Foo.so- onde identifica a arquitetura e o sistema operacional onde
o pacote é construído; por exemplo: linux-i486. Além disso, quando um alvo bin Foo.exe is
instalado, ele é instalado tanto como /Foo.exe e / Foo para que possa ser
invocado como Foo em plataformas Windows e Unix.

É fundamental que você respeite o uso convencional de extensões descritas aqui:
ozmake não permite variação e não suporta outras extensões.

Regras
ozmake possui regras integradas para a construção de arquivos. Ocasionalmente, você pode querer substituir o
regra padrão para um ou mais destinos. Isso é feito com recurso governar que contém um
alvo de mapeamento de registro para regra:

TARGET_FILE: TOOL (SOURCE_FILE)

a regra também pode ter uma lista de opções:

TARGET_FILE: TOOL (SOURCE_FILE OPTIONS)

As ferramentas suportadas por ozmake e guarante que os mesmos estão ozc (Compilador Oz), onça (Ligante de Oz), cc (Compilador C ++),
ld (Vinculador C ++). As regras padrão são:

'Foo.exe': ozl ('Foo.ozf' [executável])
'Foo.ozf': ozc ('Foo.oz')
'Foo.o': cc ('Foo.cc')
'Foo.so': ld ('Foo.o')

As ferramentas suportam as seguintes opções:

ozc

executável

tornar o resultado executável

'definir' (S)

definir macro S.Im mesmo que -DS na linha de comando

onça

executável

tornar o resultado executável

cc

incluir (DIR)

Semelhante à opção usual do compilador C ++ -IDIR. DIR é uma string virtual

'definir' (MAC)

Semelhante à opção usual do compilador C ++ -DMAC. MAC é uma string virtual

ld

biblioteca (DIR)

Semelhante à opção usual do vinculador C ++ -lDIR. DIR é uma string virtual

Você pode querer especificar uma regra para criar uma biblioteca pré-vinculada:

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

ou para criar um executável não pré-conectado:

'Foo.exe': ozc ('Foo.oz' [executável])

Dependências
ozmake determina automaticamente se os alvos precisam ser reconstruídos, por exemplo, porque eles
estão faltando ou se algum arquivo de origem necessário para criá-los foi modificado. As regras são
usado para determinar dependências entre arquivos. Às vezes, isso é insuficiente, por exemplo, porque
você usa ferramenta onça (dependências de importações), ou inserir em um arquivo Oz ou #include em um C ++
Arquivo. Neste caso, você pode especificar dependências adicionais usando o recurso depende que é
um mapeamento de registro visa a lista de dependências:

ALVO: [ARQUIVOS ...]

Por exemplo:

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

or

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

Limpeza
Durante o desenvolvimento, muitas vezes é conveniente ser capaz de remover facilmente todo lixo e
arquivos compilados para obter novamente um diretório de projeto limpo. Isso é apoiado por ozmake
--limpar e ozmake --muito limpo; o último também implica o primeiro. Os arquivos a serem removidos são
especificado por glob padrões onde ? corresponde a qualquer 1 caractere e * corresponde a uma sequência de 0
ou mais personagens. Todos os arquivos em BUILDDIR correspondentes a um desses padrões são removidos. Há
padrões integrados, mas você pode substituí-los por recursos limpar e muito limpo qual
devem ser listas de padrões glob. Por exemplo, os padrões clean glob padrão são:

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

Pacote Relacionado Recursos
Ligações

integrado Ligações indica o URI onde instalar os destinos lib. Por exemplo:

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

afirma que tudo lib alvos (por exemplo Foo.ozf) será instalado sob este URI para que eles
também pode ser importado dele, ou seja:

import MyFoo em 'x-ozlib: //mylib/XML/Foo.ozf'

magnata

integrado magnata é o id do magnata que identifica exclusivamente este pacote. É usado para identificar
o pacote no banco de dados de pacotes instalados, para criar / publicar o pacote, e para
instale seus arquivos de documentação.

autor

integrado autor é uma string virtual ou lista de string virtual resp. identificando o autor
ou autores do pacote. Recomenda-se identificar os autores por sua id de magnata,
no entanto, também é possível simplesmente fornecer seus nomes. Por exemplo, a forma recomendada
é:

autor: 'magnata: / duchier'

mas o seguinte também é possível:

autor: 'Denys Duchier'

liberado

integrado liberado é uma string virtual que especifica a data e hora de lançamento no
seguinte formato:

lançado: "AAAA-MM-DD-HH: MM: SS"

o tempo é opcional. Uma data de lançamento apropriada usando a data e hora atuais é
inserido automaticamente ao invocar ozmake --Criar or ozmake --publicar..

sinopse

integrado sinopse contém um pequeno texto que descreve o pacote. Este texto deve
ser apenas uma linha e deve ser usado como um título quando o pacote for publicado em
o arquivo magnata.

info_texto

integrado info_texto contém uma descrição em texto simples do pacote. Isso se destina a ser
usado como um resumo na página de apresentação do pacote no arquivo mogul. Isto
deve ser breve e informativo, mas não deve tentar documentar o pacote.

informações_html

integrado informações_html é similar a info_texto mas contém HTML em vez de texto simples.

src

integrado src indica quais alvos devem ser considerados fonte, ou seja, em particular não
edificável. Todos os alvos mencionados em src deve ser mencionado em caixa, libOu doca também. O
ponto de src é apoiar a distribuição de pacotes com destinos pré-construídos e sem dar
as fontes correspondentes. Você não deve fazer isso com functores nativos, pois eles são
dependente da plataforma e não portátil, mas pode ser um meio conveniente de distribuição
bibliotecas de Oz construídas. Por exemplo:

makefile (
lib: ['Foo.ozf']
src: ['Foo.ozf']
uri: 'x-ozlib: // mylib'
magnata: 'magnata: / meunome / tolo')

é um makefile para um pacote que distribui o pré-compilado Foo.ozf, mas também não
distribuir sua fonte Foo.oz.Normalmente, quando você constrói um pacote, ele simplesmente verifica se o
src os arquivos estão presentes, mas não tentará criá-los. Se você tem as fontes, você pode
força construindo o src alvos, se necessário, usando --compilação completa..

subdiretórios

integrado subdiretórios é uma lista de nomes de arquivos vazios que representam subdiretórios do projeto. Por
padrão, quando necessário, ozmake irá percorrer esses subdiretórios. É esperado
que cada subdiretório deve fornecer seu próprio makefile. O id do magnata é automaticamente
herdado para subdiretórios e o uri é automaticamente estendido ao anexar o nome de
o subdiretório: assim, os sub-makefiles podem ser mais simples, pois não precisam se preocupar
com recursos de nível de pacote.

exige

integrado exige é uma lista de URIs de módulo ou ids de MOGUL de pacote. Estes representam o
externo dependências do pacote. Eles ainda não são usados, mas eventualmente ozmake será
capaz de usá-los para automatizar a instalação recursiva de outros pacotes exigidos pelo
aquele em que você está interessado.

Categorias

integrado Categorias é uma lista de categorias MOGUL para ajudar a categorizar este pacote no
Arquivo MOGUL.

versão

integrado versão é usado para fornecer uma string de versão. Esta é uma string que consiste em
inteiros separados por pontos simples, por exemplo "2" or "3.1.7"..

fornece

integrado fornece é usado para substituir as informações padrão sobre o que o pacote
fornece, normalmente calculado automaticamente a partir do caixa e lib alvos: deve ser um
lista que contém um subconjunto desses alvos. O fornece característica de um makefile não
sobrescrever ou de outra forma afetar seus sub-makefiles: cada makefile deve sobrescrever separadamente
se assim o desejar. Para afirmar que um makefile não fornece oficialmente quaisquer functores ou
aplicativo executável, você adicionaria:

fornece: nil

Você deve usar o fornece recurso quando o seu pacote contém ambos oficiais
functores, bem como functores puramente implementacionais que não fazem parte do oficial
interface pública e não deve ser mencionada como fornecido pelo pacote.

CONTACTOS

Os autores devem ser referenciados por ids magnatas, denotando entradas magnatas que descrevem
eles. Para tornar isso mais fácil, um makefile.oz também pode conter um Contacto recurso que
é um registro que descreve uma pessoa ou uma lista de tais registros.

Você não deveria ter um Contacto recurso em cada makefile. Em vez disso, o Contacto característica é
normalmente destinado a makefiles que têm apenas um Contacto característica, ou seja, cujo único propósito
é criar entradas magníficas para as pessoas correspondentes. Aqui está um exemplo de tal
arquivo make:

makefile (
entre em contato com:
o(
magnata: 'magnata: / duchier / denys'
nome: 'Denys Duchier'
o email : '[email protegido]'
www: 'http://www.ps.uni-sb.de/~duchier/'))

Você pode invocar ozmake --publicar em tal makefile para contribuir com o magnata correspondente
entradas de banco de dados

Use ozmake online usando serviços onworks.net