EUCLIDE : Analyseur syntaxique C/C++

TABLE DES MATIERES

1. ANALYSEUR..........................................................................................................................................3 1.1 ANALYSEUR LEXICAL.........................................................................................................................5 1.2 ANALYSEUR SYNTAXIQUE.................................................................................................................7 1.2.1 ARBRE DE SYNTAXE ABSTRAITE...................................................................................................8 1.2.2 TABLE DES SYMBOLES.................................................................................................................14 1.2.3 DESCRIPTION DES TYPES............................................................................................................19 1.3 MODIFICATIONS................................................................................................................................21 1.3.1 LES TYPES LMENTAIRES..........................................................................................................21 1.3.2 LES SYMBOLES..............................................................................................................................21 1.4 POINTS A TRAITER............................................................................................................................22 1.4.1 CONVERSIONS IMPLICITES..........................................................................................................22 1.4.2 SURCHARGE...................................................................................................................................22 1.4.3 EXPRESSIONS................................................................................................................................22 1.4.4 TABLE DES SYMBOLES.................................................................................................................23 1.4.5 PREDICATS.....................................................................................................................................23 1.4.6 APPELS IMPLICITES AUX CONSTRUCTEURS ET DESTRUCTEURS.........................................23 1.4.7 OPTIMISATION................................................................................................................................23 1.4.8 SINGLETON VARIABLES................................................................................................................23 1.4.9 %AFAC.............................................................................................................................................23 1.5 CORRECTIONS..................................................................................................................................23 1.6 VERIFICATIONS.................................................................................................................................23

Documentation technique de lanalyseur pour les langages C et C++. Cet analyseur doit tablir, partir dun fichier texte crit en C ou en C++, un arbre de syntaxe abstraite et une table des symboles, en effectuant une analyse lexicale, puis une analyse syntaxique. Ce rapport rassemble les informations ncessaires pour pouvoir utiliser le programme, le comprendre et le modifier. Il numre galement les points quil reste traiter et prsente les outils qui ont t dvelopps autour de lanalyseur.

1.

ANALYSEUR

Les entres de lanalyseur sont : un flux correspondant un fichier C ou C++ prcompil le langage : c (langage C) ou cpp (langage C++) TF, la table des noms de fichiers, les cls sont de la forme f(1). TNS, la table des rfrences TS, les cls sont les identificateurs. TS, la table des symboles, les cls sont des entiers : de 0 19 pour les types lmentaires et partir de 20 pour les autres symboles.

Pour effectuer lanalyse, il est donc ncessaire : de faire correspondre le fichier prcompil un flux dinitialiser les trois tables de hash (en utilisant la commande i_new de modpls)

Les sorties sont : LArbre de Syntaxe Abstraite TF TNS TS

Pour effectuer lanalyse, on peut, par exemple, utiliser le prdicat suivant : analyse(++FICHIER_SOURCE, ++LANGAGE, --ASA, --TF, --TNS, --TS) FICHIER_SOURCE LANGAGE ASA TF TNS TS : chemin du fichier prcompil : c (langage C) ou cpp (langage C++) : Arbre de Syntaxe Abstraite : Table des noms de fichiers sources : Table des rfrences TS : Table des symboles

analyse(FICHIER_SOURCE,LANGAGE,ASA,TF,TNS,TS) :i_new(TF,8191), open(FICHIER_SOURCE,read,STREAM), analyse_lexicale(STREAM,LANGAGE,LEXEMES,TF), close(STREAM). display('analyse_lexicale i_new(TNS,8191), i_new(TS,8191), analyse_syntaxique(LANGAGE,ASA,TNS,TS,L,[]), display('analyse_syntaxique OK'), nl. OK'), nl,

Il existe un outil pour accder aux diffrents symboles de la table des symboles et permettant de visionner lArbre de Syntaxe Abstraite dans le module outil. outil:menu(++ASA,++TNS,++TS). Modules utiliss : lexical syntaxique type getset modpls analyse lexicale analyse syntaxique types lmentaires et conversions entres et consultation de la table des symboles outil pour le traitement des tables outil de visualisation des symboles et de lASA outil daccs aux informations sur les symboles

outil

symbole_access

1.1

ANALYSEUR LEXICAL

Les entres de lanalyseur lexical sont : un flux correspondant un fichier C ou C++ prcompil le langage : c (langage C) ou cpp (langage C++) TF, la table des noms de fichiers, les cls sont de la forme f(N). N un entier 0.

Pour effectuer lanalyse lexicale, il est donc ncessaire : de faire correspondre le fichier prcompil un flux dinitialiser la table TF (en utilisant la commande i_new de modpls)

Les sorties sont : La liste de lexemes TF, la table des noms de fichiers, les cls sont de la forme f(N). N un entier 0.

analyse_lexicale(++STREAM, ++LANGAGE, --LEXEMES, +TF) STREAM LANGAGE LEXEMES TF : flux correspondant au fichier source pr-compil : c (langage C) ou cpp (langage C++) : Liste des lexemes : Table des noms de fichiers sources

Types des lexemes : identificateur mot cl dcimal entier dcimal flottant octal hexadcimal caractre chane de caractres oprateur ponctuateur

Format des lexemes : identificateur

identificateur(IDENTIFICATEUR,FICHIER,LIGNE) mot_cle

mot_cle(MOT_CLE,FICHIER,LIGNE) dcimal entier -

entier(DECIMAL_ENTIER,TYPE,FICHIER,LIGNE) TYPE=[-unsigned,-long,int] DECIMAL_ENTIER est un entier PROLOG.

dcimal flottant

flottant(PARTIE_ENTIERE,PARTIE_DECIMALE,EXPOSANT,TYPE,FICHIER,LIGNE) TYPE=[-unsigned,-long,double] PARTIE_ENTIERE, PARTIE_DECIMALE et EXPOSANT sont des entiers.

octal

octal(OCTAL,TYPE,FICHIER,LIGNE) TYPE=[-unsigned,-long,int] OCTAL est un entier PROLOG.

hexadcimal

hexadecimal(HEXADECIMAL,TYPE,FICHIER,LIGNE) TYPE=[-unsigned,-long,int] HEXADECIMAL est un entier PROLOG.

caractere

caractere(CARACTERE,TYPE,FICHIER,LIGNE) TYPE=[-unsigned,-long,char] ou [-unsigned,-long,wchar_t]

chaine

chaine(CHAINE,TYPE,FICHIER,LIGNE) TYPE=[-unsigned,-long,string] ou [-unsigned,-long,wstring_t]

Les types string et wstring_t nexistent pas en C ou en C++. Ils servent reprsenter les litraux chanes de caractres. operateur

operateur(OPERATEUR,FICHIER,LIGNE) ponctuateur

ponctuateur(PONCTUATEUR,FICHIER,LIGNE) FICHIER est une rfrence un nom de fichier source. Pour retrouver le nom du fichier source, il faut passer par lintermdiaire de TF : i_get(TF,FICHIER,NOM_FICHIER_SOURCE).

1.2

ANALYSEUR SYNTAXIQUE

Les entres de lanalyseur syntaxique sont : Une liste de lexemes le langage : c (langage C) ou cpp (langage C++) TNS, la table des rfrences TS, les cls sont les identificateurs. TS, la table des symboles, les cls sont des entiers : de 0 19 pour les types lmentaires et partir de 20 pour les autres symboles.

Pour effectuer lanalyse syntaxique, il est donc ncessaire : dinitialiser les tables TNS et TS (en utilisant la commande i_new de modpls)

Les sorties sont : LArbre de Syntaxe Abstraite TNS TS

analyse_syntaxique(++LANGAGE,--ARBRE,-TABLE_SYMBOLES_CLES,-TABLE_DES_SYMBOLES,L,R). LANGAGE ARBRE TABLE_SYMBOLES_CLES TABLE_DES_SYMBOLES L R c (C) ou cpp (C++) Arbre de Syntaxe Abstraite TNS, table des noms avec la liste des cls correspondantes TS, table des symboles Liste des lexemes Liste vide

1.2.1

ARBRE DE SYNTAXE ABSTRAITE

Larbre de syntaxe abstraite permet de reprsenter toutes les instructions du programme. Description : L'arbre est compos d'une squence d'instructions [instruction_1,instruction_2,...,instruction_n] SOURCE comprend les informations sur la rfrence du fichier source et la ligne. SOURCE = src(REF_FICHIER,LIGNE). les instructions peuvent tre : une dfinition de fonction (function_definition((ident_fonction,cle_fonction,type_retour,reference),BODY,srcs(SO URCE_DEBUT,SOURCE_FIN)),SOURCE_DEBUT). BODY est une squence d'instructions [instruction_1,instruction_2,...,instruction_n,(sp_end,SOURCE_FIN)] type_retour est le type de retour de la fonction sous forme dune liste. reference vaut rf(yes) ou rf(no). remarque : les informations sur les source de dbut et fin de fonction sont redondantes. Il est envisageable de supprimer ces redondances selon lutilisation. Il est galement possible de diffrencier les SOURCE_DEBUT en SOURCE_DEBUT_DEF_FONCTION et SOURCE_DEBUT_CORPS_FONCTION si cela peut avoir une utilit. SOURCE_DEBUT correspond lemplacement du nom de la fonction. SOURCE_FIN correspond lemplacement de la fin du corps de fonction : }. une affectation (affect(AFFECT_OP,(id_ou_asa_gauche,cle_gauche,type_gauche,rf_gauche), (id_ou_asa_droite,cle_droite,type_droite,rf_droite)),SOURCE). (affect(AFFECT_OP,(id_ou_asa_gauche,cle_gauche,type_gauche_rf_gauche), (constante,0,type_constante,rf(no))),SOURCE). AFFECT_OP vaut {=, *=, /=, %=, +=, -=, >>=, <<=, &=, ^= ou |=} SOURCE correspond lemplacement de AFFECT_OP. une opration bin_op(BIN_OP,(id_ou_asa_gauche,cle_gauche,type_gauche,rf_gauche), (id_ou_asa_droite,cle_droite,type_droite,rf_droite),Type). bin_op(BIN_OP,(id_ou_asa_gauche,cle_gauche,type_gauche,rf_gauche), (CONSTANTE,0,type_constante,rf(no)),type).

bin_op(BIN_OP,(CONSTANTE,0,type_constante,rf(no)), (id_ou_asa_droite,cle_droite,type_droite,rf_droite),type). bin_op(BIN_OP,(CONSTANTE,0,type_constante,rf(no)), (ONSTANTE,0,type_constante,rf(no)),type). un_op(UN_OP,(id_ou_asa_droite,cle_droite,type_droite,rf_droite),type). un_op(UN_OP,(CONSTANTE,0,type_constante,rf(no)),type). Avec CONSTANTE = literal(FORMAT,CONST). FORMAT std std hexa oct std std std CONST ENTIER (PARTIE_ENTIERE,PARTIE_DECIMALE,SIGNE,EXPOSANT) ENTIER ENTIER ATOME ATOME ATOME CORRESPONDANCE entier flottant hexadecimal octal boolen caractre chaine

TYPE est de la forme [type(NOM_TYPE,CLE_TYPE)] BIN_OP vaut {+, -, &, ==, !=, ^, |, &&, ||, *, /, %, <, >, <=, >=, << ou >>} UN_OP vaut {&, *, +, -, ! ou ~} Il y a un cas particulier pour les oprateurs ++ et (prefix_incr((ident_droite,cle_droite,type_droite,rf_droite),P_OP,TYPE),SOURCE) (postfix_incr(ident_gauche,cle_gauche,type_gauche,rf_gauche),P_OP,TYPE),SOURCE) P_OP vaut {++ ou } remarque : il ny a pas dinformation sur la source des oprations except les oprations prefix_incr et postfix_incr au quel cas SOURCE correspond lemplacement de P_OP. appel de fonction (function_call((id_fonction,cle_fonction,type_retour_fonction,rf_fonction), [(id_argument,cle_argument,type_argument,rf_argument)_ou_[],...]),SOURCE). (function_call(ss_asa, [(id_argument,cle_argument,type_argument,rf_argument)_ou_[],...]),SOURCE). SOURCE correspond lemplacement du nom de la fonction (lors de lappel). Attention, lappel de fonction ci-dessus comprend le cas de conversion du type nom_de_type(var_a_convertir) : int(c) par exemple Dans ce cas, on retrouvera dans lASA (function_call((id_type_elementaire,cle_type_elementaire,[type(nil,0)],rf(no)), [CONSTANTE_ou_(id_argument,cle_argument,type_argument,rf_argument)_ou_[],...]),SOURCE ).

Dans le cas dun appel de fonction modle, id_fonction est remplac par template_id(id_fonction,[param1,param2,]) conversion (dynamic_cast([type(ID_TYPE,CLE_TYPE)], (id_ou_asa_arg,cle_arg,type_arg,rf_arg)),SOURCE). (static_cast([type(ID_TYPE,CLE_TYPE)], (id_ou_asa_arg,cle_arg,type_arg,rf_arg)),SOURCE). (reinterpret_cast([type(ID_TYPE,CLE_TYPE)], (id_ou_asa_arg,cle_arg,type_arg,rf_arg)),SOURCE). (const_cast([type(ID_TYPE,CLE_TYPE)], (id_ou_asa_arg,cle_arg,type_arg,rf_arg)),SOURCE). (cast_expression([type(ID_TYPE,CLE_TYPE)], (id_ou_asa_arg,cle_arg,type_arg,rf_arg)),SOURCE). SOURCE correspond lemplacement du mot cl XXX_cast. (function_call([type(ID_TYPE,CLE_TYPE)], [(id_ou_asa_arg,cle_arg,type_arg,rf_arg)]),SOURCE).SOURCE correspond lemplacement du nom de la fonction (lors de lappel). sauts label (label((id_label,cle_label)),SOURCE). SOURCE correspond lemplacement du mot cl label. goto (goto((id_label,cle_label)),SOURCE). SOURCE correspond lemplacement du mot cl goto. break (break((id_label,cle_label)),SOURCE). SOURCE correspond lemplacement du mot cl break. continue (continue((id_label,cle_label)),SOURCE). SOURCE correspond lemplacement du mot cl continue.

instructions composes try (try(liste_instructions,liste_descripteurs),SOURCE). (try(ctor_initializer,liste_instructions,liste_descripteurs),SOURCE). liste_instructions est une squence d'instructions liste_descripteurs est une squences de catch : SOURCE correspond lemplacement du mot cl try. (catch(...,liste_instructions),SOURCE). (catch(exception_declaration((id_type,cle_type), (id_declarateur,cle_declarateur)),liste_instructions),SOURCE). SOURCE correspond lemplacement du mot cl catch. if_then_else (if_then_else(Decision,Instruction_ou_Liste_instructions, (else(Instruction_ou_Liste_instructions),SOURCE)),SOURCE).

?:

(conditional_expression(Decision,Instruction_ou_Liste_instructions,Instruction_ou_Lis te_instructions),SOURCE). SOURCE correspond lemplacement de ?. while

[(label(CLE,CLE),SCR_continue), (while(Decision,Instruction_ou_Liste_instructions),srcs(SOURCE_DEBUT,SOURCE_FIN)), (label(CLE,CLE),SRC_break)] SOURCE_DEBUT correspond lemplacement du mot cl while. pour la boucle while, 2 labels anonymes sont crs, le premier tant une rfrence pour une utilisation dune instruction continue, le second tant une rfrence pour une utilisation dune instruction break. do

[(do(Decision,Instruction_ou_Liste_instructions),srcs(SOURCE_DEBUT,SOURCE_FIN)), (label(CLE,CLE),SRC_break)]. SOURCE_DEBUT correspond lemplacement du mot cl do. pour la boucle do_while, 2 labels anonymes sont crs, le premier tant une rfrence pour une utilisation dune instruction continue(ce label est la dernire instruction de la liste dinstructions), le second tant une rfrence pour une utilisation dune instruction break. switch

[(switch(Liste_decisions_et_instructions),srcs(SOURCE_DEBUT,SOURCE_FIN)), (label(CLE,CLE),SRC_break)]

SOURCE_DEBUT correspond lemplacement du mot cl switch.pour le switch, 1 label

anonyme est cr, rfrence pour les utilisations dinstructions break. Les decisions sont de la forme

(case(constante),SOURCE). (default,SOURCE). for [(label(CLE,CLE),SRC_continue), (for(init,condition,expression,statement),srcs(SOURCE_DEBUT,SOURCE_FIN)), (label(CLE,CLE),SRC_break)] SOURCE_DEBUT correspond lemplacement du mot cl for. pour la boucle for, 2 labels anonymes sont crs, le premier tant une rfrence pour une utilisation dune instruction continue, le second tant une rfrence pour une utilisation dune instruction break. attribut ou mthode dune instance de classe (class,struct ou union) point(OP, (ident_ou_this_ou_asa_gauche,cle_gauche,type_gauche,rf_gauche),ident_droite). OP = {., ->, .* ou ->*} assembleur (asm(code_assembleur),SOURCE). SOURCE correspond lemplacement du mot cl asm. delete_expression (delete(tab,(id,cle,type,rf)),SOURCE). (delete(nil,(id,cle,type,rf)),SOURCE). SOURCE correspond lemplacement du mot cl asm. new_expression (new(new_placement,new_typeid,new_initializer),SOURCE). SOURCE correspond lemplacement du mot cl new. new_placement est de la forme placement(id,cle,type,rf), avec, en particulier placement(nil,0,[type(nil,0)],rf(no)) lorsquil ny en a pas. new_typeid est un type. pas. sizeof sizeof((id,cle,type,rf)) sizeof([type(TYPE,CLE_TYPE)]) tableau tab((ident_tab,cle_tab,type_tab,rf_tab),nb_dim,liste_dim). Attention, lordre des dim dans la liste est inverse. new_initializer est de la forme init(id,cle,type,rf) ou rf(nil) sil ny en a

T[1][2][3] => tab(t,25,3,[(literal(std,3)),0,[type(signed_int,3)],rf(no)), (literal(std,2)),0,[type(signed_int,3)],rf(no)),(literal(std,1)),0, [type(signed_int,3)],rf(no))]. literal un literal peut tre de la forme : literal(std,ENTIER) literal(oct,ENTIER) literal(hexa,ENTIER) literal(std,(PARTIE_ENTIERE,PARTIE_DECIMALE,SIGNE,EXPOSANT)) literal(std,BOOLEEN) literal(std,CARACTERE) literal(std,CHAINE) entier octal hexadecimal flottant booleen caractere chaine

ENTIER, PARTIE_ENTIERE, PARTIE_DECIMALE et EXPOSANT sont des entiers PROLOG. SIGNE, BOOLEEN, CARACTERE et CHAINE sont des atomes PROLOG

1.2.2

TABLE DES SYMBOLES

Deux tables de hash sont utilises : TNS et TS

1.2.2.1 TNS
Cette table stocke les listes des cls par catgorie syntaxique et par nom. Par exemple, la liste des classe_cpp est accessible par la cl classe_cpp et est de la forme [(IDENT1,CLE1), (IDENT2,CLE2)|FIN_LISTE], FIN_LISTE nest pas instancie. De mme, la liste de tous les identificateurs nomms f est accessible par la cl f et est de la forme [(IDENT1,CLE1),(IDENT2,CLE2)|FIN_LISTE], FIN_LISTE nest pas instancie. CLEX sont les cls pour avoir accs aux symboles dans la table TS.

1.2.2.2 TS
La table des symboles TS permet de mmoriser tous les identificateurs rencontrs lors de lanalyse, ainsi que toutes les caractristiques les concernant. Si un symbole est anonyme, son ident est la cl. Si un symbole est un destructeur, son ident est ~(NOM_CLASSE) Si un symbole est un oprateur, son ident est loprateur caracteristiques associees aux types
id( <ident> , classe_cpp, <rgion_dclarative> , <mot_cl> <liste_des_attributs>, <liste_des_methodes>, <liste_paramtres>, <liste_methodes_virtuelles_pures)> , <liste_classes_amies>, <liste_classes_de_base_direct>, <source> ) [N1,N2]. N1 et N2 des entiers (cls) class, struct ou union attributs([(IDENT1,CLE1),(IDENT2,CLE2)]) methodes([(IDENT1,CLE1),(IDENT2,CLE2)]) params([(IDENT1,CLE1),(IDENT2,CLE2)]) abstract([(IDENT1,CLE1),(IDENT2,CLE2)]) A TRAITER base([(IDENT1,CLE1),(IDENT2,CLE2)]) src(FICHIER,LIGNE)

classe_cpp

id(

structure_c
<ident>, structure_c, <rgion_dclarative> , <mot_cl>, [N1,N2] . N1 et N2 des entiers (cls) struct ou union

<table_des_champs>, <source> )

champs([(IDENT1,CLE1),(IDENT2,CLE2)]) src(FICHIER,LIGNE)

id(

enumr
<ident>, enumere, <rgion_dclarative> , <Liste_des_etiquettes_valeurs>, [N1,N2]. N1 et N2 des entiers (cls) etiquettes([(IDENT1,CLE1,VALEUR1),]) A TRAITER Pour linstant VALEUR nest instancie que si elle est donne explicitement. <source> ) src(FICHIER,LIGNE)

id(

type lmentaire
<ident>, type_elementaire, <volume>, <valeur_minimum>, <valeur_maximum>, <valeur_par_dfaut>, non-instanci non-instanci non-instanci non-instanci

) Les types lmentaires sont entrs dans TS (et TNS) lors de linitialisation (getset :init_types). Certains types peuvent avoir des noms diffrents et correspondre au mme type (short & short int, par exemple). Dans ce cas, le prdicat type:conv_type renvoie le nom du type utilis dans le fichier source et la cl correspondante. type:conv_type([short],[type(short,1)]). type:conv_type([short,int],[type(short_int,1)]).

Type nil short

Alias

Cl 0 1

Short_int Signed_short Signed_short_int Short_signed_int unsigned_short Unsigned_short_int

1 1 1 1 2 2

Short_unsigned_int int Signed Signed_int unsigned Unsigned_int long long_int Signed_long Signed_long_int unsigned long Unsigned_long_int float double long double char Signed_char unsigned char wchar_t bool void string* wstring_t* long long** unsigned long long**

2 3 3 3

4 5 5 5 5 6 6 7 8 9 10 10 11 12 13 14 15 16 17 18

* **

ces types nexistent pas en C ou en C++. Ils servent caractriser les litraux chanes de caractres ces types ne sont pas ANSI.

id(

type dfini
<ident>, type_defini, <rgion_dclarative>, <type> <(reference>, [N1,N2]. N1 et N2 des entiers (cls) liste rf(no) ou rf(yes)

<liste_paramtres>, <template> , <source> )

params([(IDENT1,CLE1),]) template(yes) ou template(no) src(FICHIER,LIGNE)

caractristiques associes aux sous-programmes

id( <ident>, fonction, <rgion_dclarative>, <signature>, <(est_dfinie ?, <type_retour> <rfrence> <operateur> <virtuelle> <static> <friend> <liste_paramtres>, <liste_paramtres_formels)> table_locale_fonction)> [N1,N2]. N1 et N2 des entiers (cls) signature(NB,((IDENT_TYPE1,CLE_TYPE1),NI1),) A TRAITER liste rf(yes) ou rf(no) op(yes) ou op(no) virtual(yes) ou virtual(no) A TRAITER A TRAITER params([(IDENT1,CLE1),]) params_form([]) ou params_form([(IDENT1,CLE1,TYPE1,RF1),]) IDENT et CLE peuvent tre gaux nil et 0 dans le cas de paramtres anonymes. <(nb_variables_globales_utilises, liste_globales_utilises)>, <(nb_variables_globales_dfinies, liste_globales_dfinies)>, <sous-programmes_appels> <source> <arbre> ) non-instanci non-instanci

fonction

sp_app[(ID1,CLE1,TYPE1,RF1),] ou sp_app([]). src(FICHIER,LIGNE) ss_asa(ASA_FONCTION)

id(

methode
<ident>, methode(IDENT_CLASSE,CLE_CLASSE), <rgion_dclarative>, <sous_categorie>, <signature>, <(est_dfinie ?, <type_retour> <rfrence> <operateur> <virtuelle> <static> table_locale_fonction)> [N1,N2]. N1 et N2 des entiers (cls) nil, constructeur ou destructeur signature(NB,((IDENT_TYPE1,CLE_TYPE1),NI1),) A TRAITER liste rf(yes) ou rf(no) op(yes) ou op(no) virtual(yes) ou virtual(no) A TRAITER

<friend> <liste_paramtres>, <liste_paramtres_formels)>

A TRAITER params([(IDENT1,CLE1),]) params_form([]) ou params_form([(IDENT1,CLE1,TYPE1,RF1),]) IDENT et CLE peuvent tre gaux nil et

0 dans le cas de paramtres anonymes. <(nb_variables_globales_utilises, liste_globales_utilises)>, <(nb_variables_globales_dfinies, liste_globales_dfinies)>, <sous-programmes_appels> sp_app([]). <source> <arbre> ) src(FICHIER,LIGNE) ss_asa(ASA_METHODE) non-instanci non-instanci

sp_app[(ID1,CLE1,TYPE1,RF1),] ou

A partir du moment o une fonction (ou une mthode) est dfinie, toutes les informations concernant la dclaration sont remplaces. Caracteristiques associees aux variables
id( <ident>, var_globale, <rgion_dclarative>, <type> <rfrence>, <initialisation>, <source> ) [] liste rf(yes) ou rf(no) init(sous-ASA) ou init([]) src(FICHIER,LIGNE)

variable globale

id(

paramtre formel
<ident>, parametre(IDENT_SS_PROG,CLE_SS_PROG), <rgion_dclarative>, <type> <rfrence>, [N1,N2]. N1 et N2 des entiers (cls) liste rf(yes) ou rf(no) init(sous-ASA) ou init([]) src(FICHIER,LIGNE)

<initialisation>, <source> )

id(

attribut de classe ou de structure

<ident>,

attribut(IDENT_CLASSE,CLE_CLASSE), <rgion_dclarative>, <type> <rfrence>, <initialisation>, <source> [N1,N2]. N1 et N2 des entiers (cls) liste. rf(yes) ou rf(no) init(SOUS-ASA) ou init([]) src(FICHIER,LIGNE)

id( <ident>, var_locale(IDENT_SS_PROG,CLE_SS_PROG), <rgion_dclarative>, <type> <rfrence>, <initialisation>, <source> [N1,N2]. N1 et N2 des entiers (cls) liste rf(yes) ou rf(no) init(sous-ASA) ou init([]) src(FICHIER,LIGNE)

variable locale

id( <ident>, label, <rgion_dclarative>, <type>, [N1,N2]. N1 et N2 des entiers (cls) label, continue ou break label correspond aux labels classiques, continue, et break, aux labels ajouts pour traiter les instructions break et continue comme des goto <source> src(FICHIER,LIGNE)

label

1.2.3

DESCRIPTION DES TYPES

De manire gnrale, les types sont des listes ayant pour dernier lment le type de rfrence type(ID_TYPE,CLE_TYPE). Les lments prcdents peuvent tre : t_ptr [t_ptr|SUITE] : pointeur sur le type SUITE t_ptr_inv [t_ptr_inv|SUITE] : drfrencement sur le type SUITE t_tab(DIM)

[t_tab(DIM)|SUITE] : tableau une dimension dont les DIM lments sont de type SUITE DIM est de la forme (IDENT,CLE,TYPE,REFERENCE) t_fonction(NB_PARAMS_FORM,PARAMS_FORM) fonction retournant un type IDENT peut-tre un LITERAL (dans ce cas, CLE=0). [t_fonction(NB_PARAMS_FORM,PARAMS_FORM)|SUITE)] : SUITE NB_PARAMS_FORM est un atome. PARAMS_FORM est de la forme params_form(LISTE_DE_TYPES).

1.3
1.3.1

MODIFICATIONS
LES TYPES LMENTAIRES

Pour lajout dun type lmentaire, il faut modifier le prdicat type:init_types afin de lenregistrer dans TNS et TS. le prdicat syntaxique:simple_type_specifier pour lanalyse

le prdicat type:conv_types afin de normaliser la forme retourne par decl_specifier et uniformiser les alias. Si la barre des 20 types_elementaires est dpasse, il faut galement modifier le prdicat syntaxique:analyse_syntaxique. Tous les prdicats correspondants pour les conversions implicites

Pour lajout dalias de type, il faut modifier le prdicat type:conv_types

1.3.2

LES SYMBOLES

Lors de la modification du format des caractristiques des symboles, il est ncessaire de faire attention. En effet, le format des symboles nest pas utilis dans un seul prdicat, mais dans plusieurs ; il faut modifier tous les prdicats qui appelent getset :get/5 et getset_set. De plus, si les informations ajouter ne sont pas disponibles, il faut modifier tous les prdicats de lanalyseur permettant dobtenir et de transfrer ces informations. Ici aussi, il est ncessaire dtre vigilant au nombre et aux places respectives des arguments.

1.4
1.4.1

POINTS A TRAITER
CONVERSIONS IMPLICITES

Les conversions implicites ne sont pas encore traites. Seule une partie des conversion de types pour les oprations binaires a t aborde dans le prdicat type:usual_arithmetic_conversion. Tous les autres types de conversion implicites sont traiter totalement.

1.4.2

SURCHARGE

Pour linstant, lappel une fonction/mthode surcharge fonctionne uniquement sil ny a pas ncessit de convertir implicitement les expressions et ne fonctionne pas pour les types tableaux. Il faut donc introduire un prdicat permettant dvaluer la fonction/mthode qui convient le mieux lappel analys, en tenant compte des conversions implicites possibles. Ce prdicat devra tre ajout dans getset:get, pour les catgories syntaxiques fonction et mthodes. De mme que pour les pointeurs sur type, il faut effectuer un traitement pour les type tableaux (on pourra sinspirer de ce qui a t ralis pour les pointeurs) Le traitement des fonctions/mthodes ayant des arguments par dfaut ou largument na pas t abord. Il est raliser et tre ajout au niveau de getset :get. La surcharge doprateurs na pas t aborde. Il sera necessaire dintroduire dans une nouvelle clause un get adapt juste avant danalyser loprateur comme un oprateur classique. Ce get devra vrifier que le contexte pour lutilisation de loprateur est correct : arguments adapts (en tenant ventuellement compte des conversions implicites). Il faut veiller bien prciser le type de retour de lexpression (avec le nombre dindirections).

1.4.3

EXPRESSIONS

Toutes les expressions nont pas t totalement tudies ; il faudra en particulier vrifier pour chaque expression, que les conversions implicites sont traites, ainsi que le type de retour (on pourra sinspirer des prdicats qui ont t traits).

1.4.4

TABLE DES SYMBOLES

La table des symboles nest pas encore totalement remplie. Il faudra la complter.

1.4.5

PREDICATS

Lutilit de certains prdicat na pas t comprise, il y aura sans doutes des modifications y effectuer.

1.4.6

APPELS IMPLICITES AUX CONSTRUCTEURS ET DESTRUCTEURS

Les appels implicites aux constructeurs et destructeurs dfinis dans le programme (pas ceux par dfaut) nont pas t traits.

1.4.7

OPTIMISATION

Lanalyseur est lent ; il est pensable doptimiser. Il est, sans doutes possible doptimiser le recherche dans TS dans certains cas : souvent on recherche un symbole gnral, alors que lon sait dj quil sagit dun cas plus particulier. Il y a certainement quelque chose faire au niveau des appels syntaxique:block_declaration et syntaxique:function_definition dans le prdicat syntaxique:declaration. En effet, lanalyse faite avant de rencontrer ; ou {BODY} semble presque identique dans les deux cas.

1.4.8

SINGLETON VARIABLES

Tout singleton variables warning de PROLOG reflte un problme : pas encore trait, pas compris, Il faut veiller ne plus en avoir.

1.4.9

%AFAC

Tout commentaire %AFAC est un commentaire provisoire refltant un problme traiter.

1.5

CORRECTIONS

Tout chec lors de lanalyse, si les entres sont correctes (fichier prprocess, langage correct en norme ANSI) nest pas normal.

1.6

VERIFICATIONS

Afin de vrifier que le programme est correct, il est possible dutiliser le prdicat outil:menu, permettant daccder aux diffrents symboles de la table des symboles et de visionner lArbre de Syntaxe Abstraite. outil:menu(++ASA,++TNS,++TS).