Utilisation des structures.

          Programmer c’est mettre à la suite et dans le bon ordre les instructions qui traduisent les actions lesquelles permettent à la machine de réaliser un travail.

          Un aspect de fond en découle : la cohérence des actions les unes par rapport aux autres. Cela doit être vrai depuis la première action du programme jusqu’à la dernière. Cette cohérence ne peut être évaluée si le langage ne traduit pas totalement le concept d’objet.

          Reprenons la déclaration de structure définie dans la page LanguaObjet. Les attributs (qualite) et opérateurs (operer) sont banalisés par un nom unique et un numéro d’indice. Cela était vu côté ordinateur. Pour les objets de TF(B), une structure nominative est davantage parlante.

!-----------------------------STRUCTURE–pour-- OBJET-de TF(B)------

          type attribut

          character(12) nom  

          character(6) unite 

          integer*4 mini, faible, bas, moyen, bon, fort, maxi

          end type attribut

          type verbe              !verbe est plus parlant que operer

          character(12) nom 

          character(6) etat     

          character(6) unite 

          integer*4 mini, faible, bas, moyen, bon, fort, maxi

          end type verbe 

          type corps

          character(12) classe, groupe, section, element           

          type(attribut) forme, masse, orientation

          type(verbe) associer, dissocier, fusion, rotation

          end type corps 

!-----------------------------------------FIN STRUCTURE-----

          type(corps) objet_x, objet_y, objet_z

          Un programme peut exploiter un formulaire pour créer une structure complète à partir de séquences comme celle reportée ci-dessous.

          Type nom 

          dim(*) variable 

          type(noma) variable 

          end type nom 

          Dans cette séquence il faut redéfinir nom, noma, redéfinir dim par : integer, real, character, etc. Avec une valeur pour l’astérisque : 1, 2, 4, 8, etc. Remplacer variable par une liste de noms séparés par une virgule. Repeter une ligne type() autant de fois que nécessaire.

          La structure complétée est alors exploitable par les instructions d’un programme écrit en langage d’objet.  

          Position pour TF(B).

          Une telle structure, pour couvrir le plus grand nombre possible d’objets, doit s’élaborer à partir d’un programme de définition d’objet. 

          Cela fut prévu dès 1976 au niveau de Symfor. Les structures précédentes s’écriraient :

          Block objet moule

                    Objet : classe, groupe, section, element

                    Attribut : nom, unite, min, faible, bas, moyen, bon, fort, maxi

                    Verbe : nom, etat, unite, min, faible, bas, moyen, bon, fort, maxi

                    (Attribut) : forme, masse, orientation

                    (Verbe) : associer, dissocier, fusion, rotation

          End Block objet moule

          Comme cela s’est vu dans des langages tel PHP, il n’existe aucune dimension ni type de variable pour Symfor. C’est la valeur entrée qui définit tout. Tout est au format caractère : lettres et chiffres. La zone de la variable est précédée d’un descripteur individuel ou de groupe.

          Avec le block se crée une table des niveaux pour former les noms pointés qui interviennent dans les instructions :

          Les mots objet, attribut, verbe ne doivent jamais apparaître dans un nom pointé. Un mot ne doit jamais apparaître en double dans une même cellule. Les noms pointés ont tous la forme :

                    mot_colonne_1.mot_colonne_2.mot_colonne_3

          Pour exemple :

                    objet_x.classe = "biologie"

                    objet_x.groupe = "cellule"

                    objet_x.section = "cytoplasme"

                    objet_x.element = "enveloppe"

                    objet_x.forme.nom = "potentiel"

                    objet_x.forme.unite = “millimètre”

                    objet_x.fusion.nom = "ecrire"  

                    objet_x.fusion.etat = "subir" 

          Avec cela on peut créer la grammaire d’un langage objet selon Symfor. Exposons en quelques aspects.

          Ce langage doit définir les objets :

          Les mots objet, attribut, verbe sont réservés et connus par le traducteur. Ils ont eux même leurs attributs et verbe d’action.

          - on crée l’espace d’un objet qui est défini par le block objet, mais n’existe pas pour l’ordinateur tant que son espace n’est pas crée :

                    objet_x = objet.creation moule

          - on les crée suivant un modèle fourni par une base d’objets.

                    objet_x = objet.importe db\nom_connu_par_la_base

          - L’affectation de valeurs initiales pour tout objet nouveau, ou la modification des valeurs de la copie :

                    objet_x.classe = “biologie”

                    objet_x.groupe = “cellule”

                    objet_x.section = “cytoplasme”

                    objet_x.element = ”enveloppe”

                    objet_x.forme.nom = “ovale”

                    objet_x.forme.unite = “micron”

                    objet_x.forme.mini = 1

                    objet_x.forme.maxi = 15

                    Objet_x.rotation.nom = “faire”

                    Objet_x.rotation.etat = “subir”

                    Objet_x.rotation.unite = “degré”

                    Objet_x.rotation.mini = 1

                    Objet_x.rotation.maxi = 100

          Noter : si on ne définit pas les valeurs intermédiaires entre mini, maxi elles seront calculées par interpolation linéaire.

          Il doit définir les unités opérantes :

          On reprend les enveloppes de Fortran, claire et précises :

                    program nom

                    -

                    end program nom

                    subroutine nom(argum, argum)

                    -

                    end subroutine nom

                    function nom(argum, argum)

                    -

                    end function

                    module nom

                    -

                    end module nom

                    Block nom

                    -

                    end block nom

          Il doit définir le mode d’écriture des contrôles :

          Pour une écriture orientée objet, toute instruction doit être de même forme et ne faire apparaître que les signes =, >, < . Les opérateurs arithmétiques, les opérateurs booléens, les fonctions intégrée au langage, les unités opérantes. Toutes lient des noms pointés.

          Ainsi disparaissent :

                    IF, WHILE, SWITCH, WITH, etc.

                    FOR, DO, etc.

                    GOTO, etc.

          Par exemple écrire :

                    objet_x.forme.mini > 3 objet_y.forme.moyen = 12

                    Si le premier élément est plus grand que 3, alors affecter la valeur 12 au second élément, puis passer à l’instruction suivante.

                    objet_x.forme.bas > 3 Repete(“objet_y.forme.bas = 12")

                    Tant que le premier élément est plus grand que 3, affecter la valeur 12 au second élément et recommencer. Repete est une fonction intégrée au pré-compilateur.

                    objet_x.forme.bas = 3 Attendre(“programme_a”)

                    objet_x.forme.bas = 3 programme_a

                    Si le premier élément est égal à 3, lance l’exécution du programme_a et demande d’Attendre sa fin d’exécution, ou lance l’exécution et passe sans attendre, dans le second cas. Attendre est une fonction intégrée au pré-compilateur.

          Noter : ce mode d’écriture est facile à concevoir en Fortran. Un pré-compilateur est relativement aisé à programmer, mais opérera par strates : combinant l’interprétation et la traduction dynamique de séquences de programme enregistrées jusqu’à nouvelle modification.

          On notera aussi que le verbe est lié à un objet par un séparateur en position post pointé : nom_objet.verbe.qualificateur. Mais le verbe intégré en tant que fonction au pré-compilateur, intervient comme une unité opérante verbe() en écriture Fortran : subroutine, function etc.

          Lisant un tel programme la visualisation de la logique du travail est parlante. Nous sommes au plus près d’un langage naturel formalisé : par les mots utilisés, la réduction de l’usage des séparateurs tels ([{ etc, comme cela se fait dans un langage C, l’élimination des additifs de liaison. On conserve des mots qui ont un sens dans la vie courante et les symboles mathématiques et logiques les plus connus et exploités pour des textes techniques.

          Tout cela est vu dans Symfor. Il reste que l’analyse de cohérence par un logiciel est concevable.

          Mais seule l’expérience du développeur programmeur dans le langage utilisé et son savoir faire dans la technique qu’il informatise, lui permettent d’écrire un programme cohérent. Il connaît d’expérience l’enchaînement acceptable des instructions, traitant des objets définis par une déclaration valide.

          Pour permettre à des langages de faire une analyse de cohérence, il faut une table des enchaînements valables. Et cette table ne peut-être extraite, constituée qu’à partir de programmes éprouvés écrit dans ce type de langage.