Règles

générales :

*  * DEBUT DES REGLES : MAIN : est obligatoire

* Conventions informelles :

*                         Les T_ :  TOKENS

*                         Les M_ :  LES MOTS CLES

*                         Les I_ :  LES INSTRUCTIONS

*                         Les L_ : les variables (entiers,strings etc qui seront

*                                  empilées

*       |       exprime le OU

*       | ;     exprime le RIEN , c'est-à-dire aucune obligation de trouver

*               un mot cles, une instructions, une variable

*       | xxxxxx ;     exprime une obligation de trouver et une fin de régle pos

*                     sible

* Les Tokens sont toujours suivi de ":" et exprime la ou les régles à suivre.

* et leur terminaison est le ;

*  Token :          

                  #TOKEN   <nom du token>

Exemple :"#TOKEN        T_DIVISIONS"

Attention le token "MAIN est obligatoire en début des règles

*  Les instructions:

#DEFINE-INST  <identifiant pour la règle>   suivi <mot clé du langage>.

Exemple : "#DEFINE-INST          I_SUP               >           ",

*  Mots Clés :

#DEFINE-MCLE  <identifiant pour la règle>   suivi <mot clé du langage>

Exemple :"#DEFINE-MCLE           M_GETSELECTLISTBOX          GETSELECTLISTBOX"

*  Règles syntaxiques :

Commence par Début par un TOKEN et 2 petits points":" Identifiant de

l'instruction ou mots clé (Max 30 car )  . Chaque règle peut contenir 35

cellules maximum(inst ou mots clé+ code exe) . Employer le | exprimant la

condition OU . Chaque règle doit se termeiner par un point virgule ;

exemple :

" T_INSTRUCTION :    ",

"                 T_DECLARE_PROCFUNC   ",

"               |  M_BEGIN  T_INST_LIST M_ENDBEGIN    ",

"               |  M_RETURN   T_INSTRUCTRETURN { CodeExeReturn }",

"               |  T_AFFECT_ALPHA   ",

"               |  T_AFFECT_NUM    { CodeExeTabSymUpdate }",

"               |  M_DISPLAY  ;    ",

*  Codes exécution : { Identifiant du Code (3o car max) } : nota si vous avez

plusieurs codes exécutions pour une instructions, vous devez mettre chaque

code exécution sur une ligne .

Exemples

DEPILER

Depiler   Alnum:    OPCF_Pile_Depile(P_STRING, (void *)&(char[] ));

Depiler   String :    OPCF_Pile_Depile(P_STRING, (void *)&(char []l) );

Depiler   Long :    OPCF_Pile_Depile(P_INTEGER, (void *)&(long) );

Depiler   Double  :  OPCF_Pile_Depile(P_INTEGER, (void *)&(double) );

Depiler   Float     :   OPCF_Pile_Depile(P_INTEGER, (void *)&(float));

Depiler   Integer   :  OPCF_Pile_Depile(P_INTEGER, (void *)&(int) );

Exemples

 CODES

 EXECUTIONS

 Annonce:

calcul.cpp : calculette ordinaire

if.cpp

move.cpp

sql.cpp

   Offert en cas d'acquisition d'une licence:  SQL.CPP

RESUME :

* créer votre token : EndUserCompil.cpp

* créer vos instructions et ou mots clés :EndUsercompil.cpp

* créer votre règle syntaxique : EndUsercompil.cpp

* créer vos codes éxécutions :  EndUsercompil.cpp + opccodex.h

+ votre source cpp : Créer la fonction qui sera appelée par EXECUTE.CPP

* Ajouter dans EXECUTE.CPP : fonction OPCExecute_user(long OPCcodeExe)

votre code éxécution en y ajoutant la fonction crée ci dessus

MISE EN OEUVRE

Exemple :

1) Exemple  : Votre instruction :

                 Hello "Windows" ou Hello "xxxxxx"

** *************

** TOKENS

** *************

#TOKEN T_HELLO

** ***********

** KEYWORD   

** **********

##DEFINE-MCLE M_HELLO    HELLO

** ********************

* lexicaux

** ********************

#DEFINE-LEX            L_STRING   STRING

** *************

** RULES/REGLE

** *************

MAIN :  T_HELLO ;

T_HELLO : M_HELLO L_STRING { CodeExeHello } ;

** ************

** Code exe :  opccodex .h

** ************

 #define CodeExeHello 200   <........

 EXECUTE.CPP :

 #include "opccodex.h" .............

Class EndUserApp :: Cwnd

{....

long OPCExecute_user(long );

...

long FunctionTOTO(long)

}

extern long

EndUserApp::OPCExecute_user(long (OPCcodeExe)

) /* C'EST LA FONCTION STANDARD DU COMPILATEUR ENDUSER4GL

{

    if((  OPCcodeExe== 200)    )

                 return FunctionTOTO(OPCcodeExe)  ;    

}

*************************************************Fin de Execute.cpp

 *************************************************

     Programme : toto.cpp             

*************************************************

int EndUserApp::FunctionTOTO(long codeexe)

{  .char value[255];

  char name[60];

 if( OPCcodeExe == 200 )   

        {   

                 OPCF_Pile_Depile(P_NAMEVAR, (void *)name );

                OPCF_Pile_Depile(P_STRING, (void *)value );

                printf("%s" ,value);

         }

 ** **********************************************

**      R E SU ME

** *********************************************

STructure Compilateur :

Call/Appel du compilateur/interpreteur :ENDUSER4GL.CPP: EndUSerApp::InitInstance()

{...

        EndUser4glInterpLib(m_hInstance,m_hPrevInstance,pszLine2+1 ,NULL);

//+1 =blank

}

-- > return (long code execution)

 2) Point entrance /Point d'entrée du  (long Code) :  

         long EendsSer4glApp::OPCExecute_user(long OPCcodeExe)

 3) Execution of the function representedby specialist  :  

                                function ...EndUserApp::xxxxxx