CALL*
 Executa um processo compilado ou assemblado
------------------------------------------------------------------------------

 Sintaxe

     CALL <idProcesso> [WITH <lista expr>]

 Argumentos

     <idProcesso> é o nome do processo externo a ser invocado com CALL.

     <lista expr> é uma lista opcional de até sete expressoes de
     qualquer tipo para serem passadas ao processo externo.

 Descriçao

     CALL executa um processo compilado ou assemblado em separado.  Cada
     processo chamado com CALL deve ser definido como FAR e encerrar com um
     retorno FAR.  Todas as referências a dados consistem em ponteiros de
     quatro bytes na forma de SEGMENT:OFFSET, e estao no topo da pilha
     (stack) na ordem em que foram passados (veja os exemplos abaixo).
     Todos os tipos de dados sao passados por referência.  Os registradores
     DX:BX e ES:BX apontam para o primeiro parâmetro.

     O processo deve preservar os registradores  BP, SS, SI, DI, ES, e DS
     bem como apagar o flag de direçao (direction flag).

     CALL é um comando de compatilidade e portanto nao recomendado. Ele está
     superado pelo Extend System. Consulte a seçao sobre o Extend System no
     livro Programando e Utilitários para maiores informaçoes a este
     respeito.

 Notas

       Strings de caracteres: Um string de caracteres é passado
        por referência e terminado com null (um byte 00h no final).

       Valores numéricos: Cada argumento numérico é passado como
        um número flutuante de oito bytes, consistindo em uma característica
        de 53 bits e um expoente de 11 bits elevado a 1023.  Para passar um
        argumento numérico como inteiro, use WORD() para converter o valor
        do formato interno do Clipper para inteiro.  Se o valor numérico
        passado é maior que <F128P9M%20>æ<F255P255D%0>32.767, ele nao pode
        ser passado como inteiro e o uso de WORD() é inapropriado.  Note
        também que um argumento numérico passado com WORD() será passado por
        valor.

       Valores data: Cada argumento data é passado como ponteiro
        FAR para um long (quatro bytes) contendo um numérico representando
        uma data Juliana.

       Valores lógicos: Cada argumento lógico é passado como um
        ponteiro FAR para um inteiro binário de dois bytes contendo zero
        para falso (.F.) e um para verdadeiro (.T.)

       Compilando e linkando: Programas invocados com CALL devem
        seguir as seguintes regras:

        .  Rotinas devem estar no formato arquivo objeto relocável
           INTEL 8086 com a extensao .OBJ.

        .  Rotinas devem obedecer às convençoes de chamada e passagem
           de parâmetros da linguagem C.

       Rotinas devem estar disponíveis para o linker em tempo de
        linkagem junto com a biblioteca do compilador fonte.  Você deve
        prover suporte de execuçao para qualquer outra linguagem diferente
        de Assembly.  Veja no manual do seu compilador maiores informaçoes a
        este respeito.

       Microsoft C:  O Microsoft C, nas versoes iguais ou
        superiores a 5.0, coloca um sublinha (underline) em nomes de funçao
        quando compiladas. Para invocá-las você deve CALL _<funçao>.

       dBASE III PLUS: Para converter um módulo carregável do
        dBASE III PLUS em um módulo compatível com  Clipper adicione as
        seguintes declaraçoes ao seu arquivo .ASM:

        PUBLIC <proc>

        e

        mov ds,dx

        --------------------------------------------------------------------
        . Aviso

        O tamanho de qualquer dado deve ser mantido já que o layout da área
        de dados contém muitos itens consecutivos em memória.  Se o tamanho
        de um destes itens for modificado, dados podem ser sobre-escritos.
        --------------------------------------------------------------------

 Arquivos:  Biblioteca CLIPPER.LIB.
 To download this example - click here.

See Also: WORD()*