Comando Index vira duas funções PPO.

[Itamar M. Lins Jr.]

Ola!
Mais uma que não tinha conhecimento, verificando o PPO.

Código: Selecionar todos

PRG.
Index on &cOrdBy TAG ea100 FOR &cQuery temporary additive eval {||oBar:Step(),.T.}

PPO.
ordCondSet( cQuery, {|| &cQuery},,, {||oBar:Step(),.T.},, RecNo(),,,,,, .T.,,,,, .T.,, ) ; ordCreate(, "ea100", cOrdBy, {|| &cOrdBy}, )

Saudações,
Itamar M. Lins Jr.

[JoséQuintas]

Isso é por causa da cláusula FOR, pra ativar o filtro antes de criar o índice.

Código: Selecionar todos

   INDEX on Codigo TO temp

   dbCreateIndex( "temp", "Codigo", {|| Codigo}, iif( .F., .T., NIL ) )

   INDEX on Codigo TO temp FOR .t.

   ordCondSet( ".T.", {|| .T.},,,,, RecNo(),,,,,,,,,,,,, ) ; ordCreate( "temp",, "Codigo", {|| Codigo}, )

[fladimir]

Eu entendi o Comando e depois a mesma coisa via Funções...

Agora o q significa PPO?

[rubens]

Se não me engano Fladimir é o pseudocódigo gerado pelo compilador. Pelo que já vi ele transforma quase ou todos os comandos do seu prg em funções. Uma vez usei o Valkrye ou Valkrie (um dos dois) para decompilar um programa que tinha perdido os fontes... Ele decompilou mas trouxe os prgs todos em formato ppo.

Se voce usar um set filter to e na hora de compilar usando a opção de gerar o ppo ele vai transformar o seu set filter to na função dbsetfilter().
Pelo que me lembro o codigo ppo é mais rápido do que o código "prg" mas alguém com mais conhecimento técnico certamente vai explicar melhor...

Rubens

[JoséQuintas]

O fonte do PRG primeiro passa por um pré-compilador, que faz os ajustes no fonte, pra só depois ser compilado.

Ao compilar usando -p, seja Clipper ou Harbour, é gerado um arquivo .ppo contendo o que realmente vai ser compilado.

Também as declarações no .ch (#include) são convertidas nesse .ppo.

Exemplo:

Código: Selecionar todos

IF LastKey() == K_ESC

No .ppo já vai aparecer

Código: Selecionar todos

IF LastKey() == 27

Aproveitando:
Isso mostra que o fonte é pra nós, devemos trabalhar com o fonte pra nós mesmos entendermos.
E o #include é um dos recursos pra facilitar pra nós, e não para o compilador.

[fladimir]

Verdade.... kkkk eu sabia e tinha esquecido....

é tanta sigla e informação q acabei me atrapalhando...

mas vlw pessoal.

[marcosgambeta]

Apenas para complementar o que já foi mencionado:

. tudo que escrevemos nos arquivos .prg precisa ser processado, de forma que os comandos virem chamadas para funções e as constantes virem valores reais

. somente após este pré-processamento, o arquivo .c será gerado

. o próprio arquivo .c passa também por um pré-processamento, mas desta vez usando as ferramentas do compilador C

. somente então, o código estará pronto para se tornar um arquivo objeto e fazer parte de um executável ou biblioteca

Em C, toda rotina vira função. O conceito de comando, usado no xBase, é apenas para deixar a programação 'amigável' do lado do desenvolvedor.

Se quiserem saber como cada comando é traduzido, podem consultar o arquivo \harbour\include\std.ch. Inclusive, este arquivo é uma ótima fonte de referência com respeito aos comandos que o [x]Harbour usa.

[Jairo Maia]

Acrescentando mais uma coisinha:

Quando escrevemos um sistema o fazemos em linguagem de alto nível, ou seja, que pode ser entendida por humanos. Quando o sistema é compilado ele passa para linguagem de baixo nível, ou seja, apenas máquinas podem interpretá-los.

[marcosgambeta]

Mais um recurso interessante: além do parâmetro "-p", existe também o parâmetro "-p+". Pode ser bastante útil da depuração de uma aplicação.

Acompanhem este exemplo:

Código: Selecionar todos

PROCEDURE Main ()

   CLS

   ? "Teste"

   ? hb_gtversion()

   ? version()

   ? hb_compiler()

   WAIT

RETURN

Depois de compilado com 'hbmk2 test -p -p+", temos estes dois arquivos extras (o primeiro é o test.ppo e o segundo é o test.ppt):

Código: Selecionar todos

PROCEDURE Main ()

   Scroll() ; SetPos( 0, 0 )

   QOut( "Teste" )

   QOut( hb_gtversion() )

   QOut( version() )

   QOut( hb_compiler() )

   __Wait( )

RETURN

Código: Selecionar todos

test.prg(3) >CLS<
#command >Scroll() ; SetPos( 0, 0 )<
test.prg(5) >? "Teste"<
#command >QOut( "Teste" )<
test.prg(7) >? hb_gtversion()<
#command >QOut( hb_gtversion() )<
test.prg(9) >? version()<
#command >QOut( version() )<
test.prg(11) >? hb_compiler()<
#command >QOut( hb_compiler() )<
test.prg(13) >WAIT<
#command >__Wait( )<

Notem que no arquivo .ppt, temos como saber onde o processador de comandos agiu, as regras que seguiu e qual foi o resultado.

E não se esqueçam de que .ppt é uma extensão usada pelo Microsoft PowerPoint. O arquivo gerado pelo Harbour precisa ser aberto por um editor de textos plano (o bloco de notas, por exemplo).

[marcosgambeta]

Quando escrevemos um sistema o fazemos em linguagem de alto nível, ou seja, que pode ser entendida por humanos. Quando o sistema é compilado ele passa para linguagem de baixo nível, ou seja, apenas máquinas podem interpretá-los.

Além destes termos (alto nível e baixo nível), acho que vale a pena lembrar também a classificação das linguagens em gerações.

De acordo com o artigo abaixo, o Clipper é considerado de quarta geração:

https://en.wikipedia.org/wiki/Fourth-ge ... g_language

https://en.wikipedia.org/wiki/Clipper_% ... anguage%29

Então, valeria o mesmo para o Harbour e o xHarbour.

Acredito que parte do sucesso do Clipper foi devido justamente à sua sintaxe (muito fácil de aprender). Tanto é que houve quem criasse seu próprio sistema para controlar seu negócio, no lugar de contratar um desenvolvedor para a tarefa. Na época atual isto seria mais difícil, pois embora a linguagem continue fácil de aprender, entraram em jogo muitos outros fatores.