prima-gencls - Online na nuvem

PROGRAMA:

NOME

gencls - compilador de interface de classe para módulos Prima Core

SINOPSE

gencls --h --inc --tml -O -I --depend --sayparent filename.cls

DESCRIÇÃO

Cria cabeçalhos com macros C e estruturas para definições de objetos do módulo Prima Core.

ARGUMENTOS

gencls aceita os seguintes argumentos:

--h Gera arquivo .h (com declarações a serem incluídas em um ou mais arquivos)

--inc
Gera arquivo .inc (com declarações a serem incluídas apenas no arquivo)

-O Ativa o algoritmo de otimização para arquivos .inc. O algoritmo é baseado em uma suposição,
que algumas funções são declaradas de forma idêntica, portanto, a parte do código que lida com
o parâmetro e a conversão do resultado podem ser compartilhados. Com o sinalizador "-O" ativado, um corpo de conversão é
substituído por uma chamada para uma função, cujo nome é composto de todos os parâmetros do método
mais resultado. A função real não é gravada no arquivo .inc, mas no arquivo .tml. Tudo
declarações duplicadas de um conjunto de arquivos .tml podem ser removidas e o lembrete
gravado em um arquivo pelo utilitário tmlink.

--tml
Gera arquivo .tml. Liga "-O" automaticamente.

-Idirnome
Adiciona um diretório a um caminho de pesquisa, onde o utilitário pesquisa por arquivos .cls. Pode ser
especificado várias vezes.

--depender
Imprime dependências para um determinado arquivo.

--digamos
Imprime o pai imediato de uma classe dentro de um determinado arquivo.

SINTAXE

Resumindo, a sintaxe de um arquivo .cls pode ser descrita pelo seguinte esquema:

[zero ou mais declarações de tipo]
[declaração de zero ou uma classe]

Gencls produz arquivos .h, .inc ou .tml, com um nome base do arquivo .cls, se nenhum objeto ou
nome do pacote fornecido, ou com um nome do objeto ou o pacote caso contrário.

Basico escalar dados, tipos
Gencls tem vários tipos de dados escalares integrados, com os quais ele sabe lidar. Lidar'
significa que pode gerar um código que transfere dados desses tipos entre C e perl,
usando a interface da biblioteca XS (veja perlguts).

Os tipos são:

int
boleano
Handle
duplo
SV *
HV *
Caracteres *
string (a declaração C é char [256])

Existem também alguns tipos integrados derivados, que são

longo
baixo
carbonizar
Cor
U8

que são mapeados para int. Os dados não são convertidos em int no processo de transferência, mas
é armazenado em vez de escalar perl usando newSViv () função, que, por sua vez, pode perder bits
ou um sinal.

Derivado dados, tipos
A sintaxe para uma nova definição de tipos de dados é a seguinte:



Um escopo pode ser um de dois pragmas, "global" ou "local". Eles sugerem o uso de novos dados
tipo, se o tipo será usado apenas para um ou mais objetos. O uso de "local" é
se assemelha um pouco ao pragma C estático. Atualmente a única diferença é que uma função
usando um tipo local complexo na lista de parâmetros ou como o resultado não é um assunto para
Otimização "-O".

Escalar tipos
Novos tipos escalares só podem ter um alias para os existentes, principalmente para a codificação C
conveniência. Um tipo escalar pode ser definido de duas maneiras:

Aliasing direto
Sintaxe:

$ id => ;

Exemplo:

global $ Handle => int;

O novo tipo de id não será visível em arquivos C, mas o tipo será substituído
todos os arquivos .cls que incluem esta definição.

Macro C
Sintaxe:

id1 id2

Exemplo:

API_HANDLE UV global

Esse código cria uma definição de macro C em um arquivo de cabeçalho .h em formato

#define id1 id2

Macros C com parâmetros não são permitidos. id1 e id2 não precisam estar presentes
no espaço de nomes .cls e nenhuma substituição durante o processamento do arquivo .cls é feita. Esse
o uso do pragma é muito limitado.

Complexo tipos
Tipos de dados complexos podem ser arrays, structs e hashes. Eles podem ser uma combinação ou um
vetor de tipos de dados escalares (mas não complexos).

Gencls permite várias combinações de tipos de dados complexos que a linguagem C não
reconhecer. Eles serão descritos a seguir.

Tipos de dados complexos não são importados para o código perl. Um programador perl deve estar em conformidade com
o tipo de dados usado ao passar parâmetros para uma função.

Arrays
Sintaxe:

@Eu iria [dimensão];

Exemplo:

global @FillPattern U8 [8];

Exemplo de funções usando matrizes:

Array * func (Array a1, Array * a2);

Código Perl:

@ret = func (@ array1, @ array2);

Observe que as referências de array não são usadas, e o número de itens em todos os array
os parâmetros devem ser exatamente como as dimensões das matrizes.

Observação: a declaração a seguir não será compilada com o compilador C, pois C não pode retornar
matrizes. No entanto, isso não é tratado como um erro por gencls:

Array func ();

Estruturas
Sintaxe:

@Eu iria {
;
...
;
};

Exemplo:

@Struc global {
número interno;
identificação da cadeia;
}

Exemplo de funções usando structs:

Struc * func1 (Struc a1, Struc * a2);
Struc func2 (Struc a1, Struc * a2);

Código Perl:

@ret = func1 (@ struc1, @ struc2);
@ret = func2 (@ struc1, @ struc2);

Observe que as referências de matriz não são usadas, e tanto o número quanto a ordem dos itens em todos
os parâmetros do array devem ser definidos exatamente como dimensões e ordem das estruturas. Struct
nomes de campo não são usados ​​em código perl também.

Hashes
Sintaxe:

%Eu iria {
;
...
;
};

Exemplo:

global% Hash {
número interno;
identificação da cadeia;
}

Exemplo de funções usando hashes:

Hash * func1 (Hash a1, Hash * a2);
Hash func2 (Hash a1, Hash * a2);

Código Perl:

% ret =% {func1 (\% hash1, \% hash2)};
% ret =% {func2 (\% hash1, \% hash2)};

Observe que apenas referências de hash são usadas e retornadas. Quando um hash é passado do perl
código pode ter alguns ou todos os campos não definidos. A estrutura C é preenchida e passada para um
Função C, e os campos que não foram definidos são atribuídos a um correspondente
Valor C_TYPE_UNDEF, onde TYPE é um dos literais NUMERIC, STRING e POINTER.

A conversão reversa não conta com esses valores e sempre retorna todas as chaves hash com um
par correspondente.

Namespace seção
Sintaxe:

{

...

}

Um arquivo .cls pode ter zero ou uma seção de namespace, preenchida com descrições de função.
As funções descritas aqui serão exportadas para o ID fornecido durante o código de inicialização. UMA
o namespace pode ser "objeto" ou "pacote".

A sintaxe do namespace do pacote permite apenas a declaração de funções dentro de um "pacote"
bloquear.

pacote {

...
}

A sintaxe do namespace do objeto inclui variáveis ​​e propriedades, bem como funções (
métodos chamados na sintaxe do objeto). A sintaxe geral do namespace do objeto é

objeto [(ID da classe pai)] {



}

Dentro de um namespace de objeto, a sintaxe de herança pode ser usada:

objeto ( ) {...}

ou uma descrição de objeto de raiz nua (sem ancestral)

objeto {...}

para a declaração da classe de objeto.

Funções
Sintaxe:

[ ] ( ) [=> ];

Exemplos:

int package_func1 (int a, int b = 1) => c_func_2;
Point package_func2 (Struc * x, ...);
método void object_func3 (perfil HV *);

Um prefixo é usado apenas com funções de objeto (métodos). Mais sobre o prefixo em Métodos
seção.

Uma função não pode retornar nada (void), um escalar (int, string, etc) ou um complexo (
tipo de matriz, hash). Ele também pode aceitar parâmetros escalares e complexos, com tipo
conversão que corresponde às regras descritas acima em "Tipos de dados escalares básicos"
seção.

Se uma função possui parâmetros e / ou resultado de um tipo que não pode ser convertido
automaticamente entre C e perl, ele é declarado, mas não exposto ao namespace perl. o
aviso correspondente é emitido. Não é possível usar a sintaxe gencls para declarar um
função com parâmetros personalizados ou dados de resultado. Para tal, o C explícito
declaração de código junto com a chamada "newXS" deve ser feita.

Exemplo: reticências (...) não podem ser convertidas por gencls, porém é um C legal
construção.

Point package_func2 (Struc * x, ...);

A sintaxe da função tem vários acréscimos de conveniência:

Valores de parâmetro padrão
Exemplo:

void func (int a = 15);

Uma função declarada desta forma pode ser chamada com 0 ou 1 parâmetro. Se for
chamado com 0 parâmetros, um valor inteiro de 15 será usado automaticamente. o
a sintaxe permite parâmetros padrão para os tipos int, ponteiro e string e seus escalares
apelido.

Os parâmetros padrão podem ser tantos quanto possível, mas eles devem estar no final do
lista de parâmetros de função. A declaração "func (int a = 1, int b)" está incorreta.

Aliasing
No código C gerado, uma função C deve ser chamada após os parâmetros terem sido
analisado. Gencls espera que uma função em conformidade esteja presente no código C, com nome fixo
e lista de parâmetros. No entanto, se a tarefa de tal função é um invólucro para um idêntico
função publicada com outro nome, aliasing pode ser executado para salvar o código e
Rapidez.

Exemplo:

pacote Pacote {
void func (int x) => interno;
}

Uma função declarada dessa forma não chamará Package_func () Função C, mas
interno() em vez disso. O único pedido é que interno() função deve ter
parâmetro idêntico e declaração de resultado para um função ().

Hash embutido
Uma maneira prática de chamar uma função com um hash como parâmetro do perl foi desenvolvida. Se um
função é declarada com o último parâmetro ou tipo "HV *", então a tradução do parâmetro
de perl para C é executado como se todos os parâmetros passados ​​fossem um hash. Este hash é
passado para uma função C e seu conteúdo retornado para perl como um hash novamente.
O conteúdo hash pode ser modificado dentro da função C.

Esta declaração é muito usada em construtores, cujo código perl é típico

sub-inicialização
{
meu% ret = shift-> SUPER :: init (@_);
...
return% ret;
}

e o código C é geralmente

void Obj_init (perfil HV *) {
init herdado (perfil);
... [modificar o conteúdo do perfil] ...
}

De Depósito
Métodos são funções chamadas no contexto de um objeto. Praticamente todos os métodos precisam
têm acesso a um objeto com o qual estão lidando. Objetos Prima são visíveis em C como
Lidar com o tipo de dados. Tal Handle é na verdade um ponteiro para uma instância de objeto, que por sua vez
contém um ponteiro para a tabela de métodos virtuais do objeto (VMT). Para facilitar um tipo OO
sintaxe, este parâmetro Handle quase nunca é mencionado em todos os métodos de um objeto
descrição em um arquivo cls, embora seja contado implícito, então todo método cls
declaração

método void a (int x)

para uma classe de objeto Object é refletido em C como

void Object_a (Handle self, int x)

declaração de função. Ao contrário das funções de pacote, que gencls é incapaz de publicar se
não é capaz de lidar com os parâmetros incompatíveis e não suportados, há uma maneira de
emitir tal declaração com um método. O principal uso para isso é o nome do método get
reservado no VMT do objeto.

Os métodos são acessíveis no código C pela desreferenciação do nome direto de um "Handle self" como um
estrutura correspondente:

(((PSampleObject) self) -> self) -> sample_method (self, ...);

Um método pode ter um dos seis prefixos que regem a geração de código C:

método
Este é o primeiro e o tipo de método mais básico. Seu nome de prefixo, "método" é
portanto, foi escolhido como o nome mais descritivo. Espera-se que os métodos sejam codificados em
C, o identificador de objeto está implícito e não está incluído em uma descrição .cls.

método void a ()

resulta em

void Object_a (Handle self)

Declaração C. Um método publicado converte automaticamente seus parâmetros e um resultado
entre C e perl.

público
Quando os métodos que possuem parâmetros e / ou resultados que não podem ser automaticamente
convertido entre C e perl precisa ser declarado, ou a declaração da função não
se encaixar na sintaxe C, um prefixo "público" é usado. Os métodos declarados com "public" são
espera-se que se comunique com perl por meio da interface XS (veja perlxs). Isso é também
esperado que um método "público" crie funções REDEFINED e FROMPERL (ver
Prima :: internals para detalhes). Os exemplos são muitos em toda a fonte Prima, e
não ser mostrado aqui. Métodos "públicos" geralmente têm resultado nulo e nenhum parâmetro, mas
isso não importa muito, uma vez que gencls não produz nenhuma conversão para tais métodos.

importar
Para os métodos que não são razoáveis ​​para codificar em C, mas em perl, gencls podem ser
instruído a produzir os wrappers correspondentes usando o prefixo "import". Este tipo de
método pode ser visto como "método" de dentro para fora. A função "import" não precisa de um C
contrapartida, exceto o código gerado automaticamente.

estático
Se um método deve ser capaz de funcionar com e sem uma instância de objeto, ele precisa
a ser adicionado ao prefixo "estático". métodos "estáticos" são todos semelhantes aos de "método",
exceto que o primeiro parâmetro "Handle self" não é declarado implicitamente. Se um "estático"
método é chamado sem um objeto (mas com uma classe), como

Class :: Object-> static_method ();

seu primeiro parâmetro não é um objeto, mas uma string "Class :: Object". Se um método nunca
lida com um objeto, basta usar sua declaração como

estático a (char * className = "");

mas é se o fizer, um

estático a (SV * classe_ou_objeto = nulo);

declaração é necessária. No último caso, o próprio código C tem que determinar o que exatamente tem
passado, se alguma vez. Observe o parâmetro padrão aqui: um método "estático" geralmente é
legível para chamar como

Class :: Object :: static_method ();

onde nenhum parâmetro é passado para ele. Sem o parâmetro padrão, tal chamada
gera um erro de tempo de execução 'parâmetros insuficientes aprovados'.

estranho
Não conseguimos encontrar um nome melhor para ele. prefixo "estranho" denota um método que combinou
propriedades de "estático" e "público". Em outras palavras, gencls não gera
código de conversão e não espera "Handle self" como um primeiro parâmetro para tal método.
Como um exemplo, Prima :: Image :: load pode ser representado, que pode ser chamado usando um amplo
espectro de semântica de chamada (veja Prima :: image-load para detalhes).

c_only
Como o próprio nome indica, "c_only" é um método que está presente em um VMT, mas não é
acessível a partir do perl. Ele pode ser sobrecarregado apenas de C. Além disso, é permitido
registrar uma função perl com o nome de um método "c_only", e ainda essas entidades
serão totalmente independentes um do outro - a sobrecarga não ocorrerá.

NB: métodos que possuem tipos de dados de resultado e / ou parâmetros que não podem ser convertidos
automaticamente, altere seu prefixo para "c_only". Provavelmente este é o comportamento errado,
e tal condição deve sinalizar um erro.

Propriedades
O kit de ferramentas Prima apresenta uma entidade chamada propriedade, que deve substituir o método
pares cuja função é adquirir e atribuir alguma variável de objeto interno, por exemplo,
um nome de objeto, cor etc. Em vez de ter um par de métodos como Object :: set_color e
Object :: get_color, uma propriedade Object :: color é criada. Uma propriedade é um método com o
considerações especiais, em particular, quando é chamado sem parâmetros, um modo 'get'
está implícito. Ao contrário, se for chamado com um parâmetro, um modo 'set' é acionado.
Observe que nas invocações 'set' e 'get' "Handle self" o primeiro parâmetro implícito é
sempre presente.

As propriedades podem operar com uma quantidade diferente, mas fixa de parâmetros e realizar um 'conjunto'
e 'get' funciona apenas para um. Por padrão, o único parâmetro é o "Handle" implícito
auto":

propriedade char * nome

tem contrapartida C

char * Object_name (Handle self, Bool set, char * name)

Dependendo do modo, "Bool set" é "true" ou "false". No modo 'set', um código C
o resultado é descartado, no modo 'get' o valor do parâmetro é indefinido.

A sintaxe para propriedade multiparâmetro é

pixel longo de propriedade (int x, int y);

e código C

long Object_pixel (Handle self, Bool set, int x, int y, long pixel)

Observe que, no caso de multiparâmetros, os parâmetros declarados após o nome da propriedade são
sempre inicializado, nos modos 'set' e 'get'.

Instância variáveis
Cada objeto é caracterizado por seu estado interno único. A sintaxe Gencls permite um
declaração de variável, para variáveis ​​que são alocadas para cada instância de objeto. Embora
validação de tipo de dados não é realizada para variáveis, e suas declarações apenas obtêm
copiado 'como está', declarações C complexas envolvendo ponteiros de array, estrutura e função são
não reconhecido. Como solução alternativa, são usados ​​ponteiros para entidades digitadas. Exemplo:

objeto SampleObject {
int x;
Lista de listas;
struct {int x} s; # declaração ilegal
}

As variáveis ​​são acessíveis no código C pela desreferenciação direta do nome de um "Handle self" como um
estrutura correspondente:

((PSampleObject) self) -> x;

AUTORES

Dmitry Karasik,[email protegido]>. Anton Berezin,[email protegido]>.

Use prima-gencls online usando serviços onworks.net