/***
* Arquivo ...... ALGORITM.CH
* Proposito .... Definir comandos para o estudo de algoritmos
* Autor ........ Fernando Paim
* Data ......... 10 de marco de 1996
* Observacao ... Utilizar com o programa Transbin.exe
* #STDOUT => Transbin <arquivo>
* #STDOUT => Fapp (R) Gerenciador de Algoritmos versao 1.0
* #STDOUT => Copyright (C) Fapp Sistemas 1996. Todos os direitos reservados
*****/

#include "STD.CH"
#xcommand ALGORITMO                        => SetPos (0,0)
#xcommand ALGORITMO()                      => SetPos (0,0)
#xcommand FIM ALGORITMO                    => Return
#xcommand FIM_ALGORITMO                    => Return
#xcommand FIMALGORITMO                     => Return
#xtranslate VERDADE                        => .T.
#xtranslate FALSO                          => .F.
#xtranslate E                              => .AND.
#xtranslate OU                             => .OR.
#xtranslate NAO                            => .NOT.

#xcommand DECLARE REAL <x1> [, <x2> ]      => ;
          <x1> := 0.00 [; <x2> := 0.00 ]
#xcommand DECLARE INTEIRO <x1> [, <x2> ]   => ;
          <x1> := Int ( 0 ) [; <x2> := Int ( 0 ) ]
#xcommand DECLARE CARACTER <x1> [, <x2> ]  => ;
          <x1> := Space ( 10 ) [; <x2> := Space ( 10 ) ]
#xcommand DECLARE ALFA <x1> [, <x2> ]      => ;
          <x1> := Space ( 10 ) [; <x2> := Space ( 10 ) ]
#xcommand DECLARE LOGICO <x1> [, <x2> ]    => ;
          <x1> := .F. [; <x2> := .F. ]

#xcommand PROC AFILL                                    => ;
          PROC _AFILL ; #error AFILL
#xcommand DECLARE VETOR REAL <x> ( <y> )                => ;
          <x> := Array ( <y> ) ; AFill ( <x>, 0.00 )
#xcommand DECLARE VETOR INTEIRO <x> ( <y> )             => ;
          <x> := Array ( <y> ) ; AFill ( <x>, 0 )
#xcommand DECLARE VETOR CARACTER <x> ( <y> )            => ;
          <x> := Array ( <y> ) ; AFill ( <x>, Space ( 10 ) )
#xcommand DECLARE VETOR LOGICO <x> ( <y> )              => ;
          <x> := Array ( <y> ) ; AFill ( <x>, .F. )

#xcommand DECLARE MATRIZ REAL <x> ( <y>, <z> )          => ;
          <x> := Array ( <y>, <z> )
#xcommand DECLARE MATRIZ INTEIRO <x> ( <y>, <z> )       => ;
          <x> := Array ( <y>, <z> )
#xcommand DECLARE MATRIZ CARACTER <x> ( <y>, <z> )      => ;
          <x> := Array ( <y>, <z> )
#xcommand DECLARE MATRIZ LOGICO <x> ( <y>, <z> )        => ;
          <x> := Array ( <y>, <z> )

#xcommand DECLARE MATRIZ REAL <x> ( <y>, <w>, <z> )     => ;
          <x> := Array ( <y>, <w>, <z> )
#xcommand DECLARE MATRIZ INTEIRO <x> ( <y>, <w>, <z> )  => ;
          <x> := Array ( <y>, <w>, <z> )
#xcommand DECLARE MATRIZ CARACTER <x> ( <y>, <w>, <z> ) => ;
          <x> := Array ( <y>, <w>, <z> )
#xcommand DECLARE MATRIZ LOGICO <x> ( <y>, <w>, <z> )   => ;
          <x> := Array ( <y>, <w>, <z> )

/* SEM DECLARE */

#xcommand REAL <x1> [, <x2> ]      => ;
          <x1> := 0.00 [; <x2> := 0.00 ]
#xcommand INTEIRO <x1> [, <x2> ]   => ;
          <x1> := Int ( 0 ) [; <x2> := Int ( 0 ) ]
#xcommand CARACTER <x1> [, <x2> ]  => ;
          <x1> := Space ( 10 ) [; <x2> := Space ( 10 ) ]
#xcommand ALFA <x1> [, <x2> ]      => ;
          <x1> := Space ( 10 ) [; <x2> := Space ( 10 ) ]
#xcommand LOGICO <x1> [, <x2> ]    => ;
          <x1> := .F. [; <x2> := .F. ]

#xcommand VETOR REAL <x> ( <y> )                => ;
          <x> := Array ( <y> ) ; AFill ( <x>, 0.00 )
#xcommand VETOR INTEIRO <x> ( <y> )             => ;
          <x> := Array ( <y> ) ; AFill ( <x>, 0 )
#xcommand VETOR CARACTER <x> ( <y> )            => ;
          <x> := Array ( <y> ) ; AFill ( <x>, Space ( 10 ) )
#xcommand VETOR LOGICO <x> ( <y> )              => ;
          <x> := Array ( <y> ) ; AFill ( <x>, .F. )

#xcommand MATRIZ REAL <x> ( <y>, <z> )          => ;
          <x> := Array ( <y>, <z> )
#xcommand MATRIZ INTEIRO <x> ( <y>, <z> )       => ;
          <x> := Array ( <y>, <z> )
#xcommand MATRIZ CARACTER <x> ( <y>, <z> )      => ;
          <x> := Array ( <y>, <z> )
#xcommand MATRIZ LOGICO <x> ( <y>, <z> )        => ;
          <x> := Array ( <y>, <z> )

#xcommand MATRIZ REAL <x> ( <y>, <w>, <z> )     => ;
          <x> := Array ( <y>, <w>, <z> )
#xcommand MATRIZ INTEIRO <x> ( <y>, <w>, <z> )  => ;
          <x> := Array ( <y>, <w>, <z> )
#xcommand MATRIZ CARACTER <x> ( <y>, <w>, <z> ) => ;
          <x> := Array ( <y>, <w>, <z> )
#xcommand MATRIZ LOGICO <x> ( <y>, <w>, <z> )   => ;
          <x> := Array ( <y>, <w>, <z> )

// update ...

#xtranslate MOLDURA ( <x1>, <y1>, <x2>, <y2> )  => ;
            @ <x1>, <y1> to <x2>, <y2>
#xcommand LIMPA_TELA ()                     => Scroll (); SetPos (0,0)
#xcommand LIMPATELA ()                      => Scroll (); SetPos (0,0)
#xcommand POSICIONE ( <L>, <C> )            => DevPos ( <L>, <C> )
#xcommand POSICAO ( <L>, <C> )              => DevPos ( <L>, <C> )
#xcommand AGUARDE ( <x> )                   => Inkey ( <x> )
#xcommand PAUSA ( )                         => Inkey ( 0 )
#xcommand ENQUANTO <exp>                    => Do While ( <exp> )
#xcommand FIM_ENQUANTO                      => End
#xcommand FIMENQUANTO                       => End
#xcommand REPITA                            => Do While .T.
#xcommand ATE_QUE <exp>                     => if ( <exp> ); Exit; End; End
#xcommand ATEQUE <exp>                      => if ( <exp> ); Exit; End; End
#xcommand PARA                              => For
#xcommand PARA <v> [ ATE <x> ] [ PASSO <s>] => For <v> [ TO <x> ] [ Step <s>]
#xcommand FIM_PARA                          => Next
#xcommand FIMPARA                           => Next
#xcommand INTERROMPA                        => Exit
#xcommand CONTINUE                          => Loop
#xcommand SE <exp>                          => if ( <exp> )
#xcommand SENAO                             => else
#xcommand FIM_SE                            => End
#xcommand FIMSE                             => End
#xcommand SELECIONE                         => Do Case
#xcommand CASO <exp>                        => Case <exp>
#xcommand CASO CONTRARIO                    => Otherwise
#xcommand FIM_SELECAO                       => Endcase
#xcommand FIMSELECAO                        => Endcase
#xcommand ESCREVA ( <list,...> )            => QOut ( <list> )
#xcommand ESCREVA ( <list>, <L>, <C> )      => SetPos ( <L>, <C> );
                                               QOut ( <list> )
#xcommand MOSTRE ( <list,...> )             => QQOut ( <list> )
#xcommand MOSTRE ( <list>, <L>, <C> )       => SetPos ( <L>, <C> );
                                               QQOut ( <list> )
#xcommand LEIACAR ( <idvar> )               => ;
          <idvar> := StrTran( FReadStr(0, 256), Chr(13)+Chr(10) )
#xcommand LEIANUM ( <idvar> )               => ;
          <idvar> := Val( StrTran( FReadStr(0, 256), Chr(13)+Chr(10) ) )

#xtranslate MODULO                          => FUNCTION
#xtranslate FUNCAO                          => FUNCTION
#xtranslate PROCEDIMENTO                    => PROCEDURE
#xtranslate FIM_MODULO                      =>
#xtranslate FIMMODULO                       =>
#xtranslate FIM_FUNCAO                      =>
#xtranslate FIMFUNCAO                       =>
#xtranslate FIM_PROCEDIMENTO                =>
#xtranslate FIMPROCEDIMENTO                 =>
#xcommand RETORNE <exp>                     => RETURN <exp>

/*
#xcommand LEIA ( <var> )                    => @ Row(), Col() GET <var>
#xcommand LEIA ( <exp>, <L>, <C>, <var> )   => @ <L>, <C> Say <exp> Get <var>
#xcommand RECEBA ( <var> )                  => @ Row(), Col() GET <var>
#xcommand RECEBA ( <exp>, <L>, <C>, <var> ) => @ <L>, <C> Say <exp> Get <var>
#xcommand PROCESSE LEITURA                  => READ
#xtranslate LEIA ( <x> )                    =>     ;
            if ( val ( <x> := __Accept () ) != 0 ) ;
            ;  <x> := & ( __acceptstr () )         ;
            ; end
#xtranslate LEIA ( <x> )                    => ;
            if ( val ( <x> := StrTran ( FReadStr( 0, 256 ), Chr(13)+Chr(10) ) ) != 0 ) ;
            ;  <x> := val ( <x> ) ;
            ; end
*/

#xtranslate LEIA ( <x> )                    =>          ;
            if val ( <x> := FReadStr ( 0, 256 ) ) != 0  ;
            ;  <x> := val ( <x> )                       ;
            ; end

#xtranslate QUOCIENTE ( <x>, <y> )         => <x> / <y>
#xtranslate RESTO ( <x>, <y> )             => MOD ( <x>, <y> )
#xtranslate TRUNCA ( <x> )                 => INT ( <x> )
#xtranslate ARREDONDA ( <x>, <y> )         => ROUND ( <x>, <y> )
#command    ABS ( <x> )                    => ABS ( <x> )
#xtranslate SINAL ( <x> )                  => INT ( ABS ( <x> ) / <x> )
#xtranslate RAIZ ( <x> )                   => SQRT ( <x> )
#xtranslate POT ( <x>, <y> )               => <x> ** <y>
#command    EXP ( <x> )                    => EXP ( <x> )
#xtranslate LOG10 ( <x> )                  => ( LOG ( <x> ) / LOG ( 10 ) )
#xtranslate LN ( <x> )                     => LOG ( <x> )
#xtranslate MULTIPLO ( <n1>, <n2> )        => IIF(<n2> == 0, .f., ((<n1> % <n2>) == 0))
#xtranslate PAR ( <n1> )                   => Empty ( <n1> % 2 )
#xtranslate IMPAR ( <n1> )                 => !Empty ( <n1> % 2 )
#xtranslate PERCENTUAL ( <n1>, <n2> )      => ( ( <n1> * 100 ) / <n2> )
#xtranslate NUM_CAR ( <n1> )               => AllTrim ( Str ( <n1> ) )
#xtranslate MOVE <exp> to <x>                   => <x> := <exp>
#xtranslate ADD <n1> TO <n2>                    => <n2>+=<n1>
#xtranslate SUBTRACT <n1> FROM <n2>             => <n2>-=<n1>
#xtranslate MULTIPLY <n1> BY <n2>               => <n2>*=<n1>
#xtranslate DIVIDE <n1> BY <n2>                 => <n1>/=<n2>
#xtranslate DIVIDE <n2> INTO <n1>               => <n1>/=<n2>
#xtranslate RAISE <n2> TO THE POWER OF <n1>     => <n2>^=<n1>
#xtranslate ADD <n1> TO <n2> INTO <n3>          => (<n3> := <n2>+<n1>)
#xtranslate SUBTRACT <n1> FROM <n2> INTO <n3>   => (<n3> := <n2>-<n1>)
#xtranslate MULTIPLY <n1> BY <n2> INTO <n3>     => (<n3> := <n2>*<n1>)
#xtranslate DIVIDE <n1> BY <n2> INTO <n3>       => (<n3> := <n1>/<n2>)