Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 5 sur 5
  1. #1
    Invité de passage
    Femme Profil pro Selma
    Etudiante 3éme année Informatique Academique
    Inscrit en
    avril 2012
    Messages
    14
    Détails du profil
    Informations personnelles :
    Nom : Femme Selma
    Localisation : Algérie

    Informations professionnelles :
    Activité : Etudiante 3éme année Informatique Academique

    Informations forums :
    Inscription : avril 2012
    Messages : 14
    Points : 2
    Points
    2

    Par défaut [Bison] Conflits grammaire

    Bonjour, voici le message affiché quand je fais bison.y
    analyse.y: conflits: 53 décalage/réduction, 60 réduction/réduction
    Et voici ma grammaire :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    %nonassoc   key_parenthese_ouvrante 
    %nonassoc   key_parenthese_fermante   
    %nonassoc   key_le
    %nonassoc   key_ne 
    %nonassoc   key_eq
    %nonassoc   key_te
    %nonassoc   key_dg
    %nonassoc   key_an
    
    %left     key_reel  key_entier key_division key_multiplication key_soustraction key_plus  
    
    %start  PROGRAMME
    
    %%
    
    
    PROGRAMME  :fonction_i
               |programme_principal
               ;
       
    fonction_i : corps_fonction fonction_i 
               | corps_fonction 
               ;          
    
    corps_fonction : prototype decl inst key_idf key_affectation valeur key_endr 
    
               ;
    
    prototype  : type key_routine key_idf key_parenthese_ouvrante parametres key_parenthese_fermante
               ;
    
    
    type       : key_integer
               |key_charactere
               |key_real
               |key_logical
               ;
    
    
    
    parametres : key_idf key_virgule parametres
               | key_idf
               ;
    
    
    decl       : type  key_idf key_dimension key_parenthese_ouvrante taille key_parenthese_fermante decl
               |type key_idf key_virgule decla
               |type key_idf key_dimension key_parenthese_ouvrante taille key_parenthese_fermante
               | type key_idf
               ; 
    
    decla      :type key_idf key_virgule decla
               |type key_idf
               ;
    
    taille     : key_entier key_virgule key_entier 
               | key_entier
               ;
    
    inst       : affectation inst  
    
               |entree_sorties inst
               |condition inst
               | boucle inst
               |appel_fonction inst 
               | equivalence   inst
               |affectation 
               | entree_sorties
               |condition
               |boucle
               |appel_fonction
               |equivalence
               ;
    
    affectation : key_idf key_affectation expr
                ;
    
    expr       : key_entier
               |operation
               |key_guillemets key_idf key_guillemets
               | logique
               ; 
     
    operation  : operand operateur operand
               ;
    
    operateur  : key_plus
               | key_multiplication
               | key_soustraction
               |key_division
               ;
    
    operand    : key_idf  key_parenthese_ouvrante key_entier key_virgule key_entier key_parenthese_fermante
               | key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante     
               ;
    
    logique    : key_true 
               | key_false 
               ;
    
    entree_sorties : key_read key_parenthese_ouvrante key_idf key_parenthese_fermante
                   | key_write key_parenthese_ouvrante key_guillemets phrase key_guillemets key_virgule key_idf key_virgule key_guillemets key_point key_guillemets key_parenthese_fermante 
                   ;
    
    phrase     : key_idf  phrase
               | key_idf
               ;
    
    condition  : key_idf key_parenthese_ouvrante explogique key_parenthese_fermante key_then inst condition key_else inst key_endif
               | inst
               ;
    
    boucle     : key_dowhile key_parenthese_ouvrante explogique key_parenthese_fermante inst key_enddo
               ;
    
    appel_fonction : key_call key_idf key_parenthese_ouvrante parametres key_parenthese_fermante
                   ;
    
    explogique  : key_idf key_point operateur_comp key_point key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante key_point operateur_log key_point key_parenthese_ouvrante key_idf key_point operateur_comp key_point opa key_parenthese_fermante
                ;   
    
    operateur_comp : key_gt
                   |key_ge
                   |key_eq
                   |key_ne
                   |key_le
                   |key_lt
                   ;
    opa            : key_true 
                   | key_false
                   ;
    
    operateur_log  : key_or
                   |key_end
                   ;
    
    valeur         :key_entier
                   |key_reel
                   ;
    
    programme_principal : prototype_prog decl inst key_end
                        ;
    
    prototype_prog   : key_program key_idf
                     ;
    
    equivalence     : key_equivalence key_parenthese_ouvrante parametres key_parenthese_fermante key_virgule equivalence
                    | key_equivalence key_parenthese_ouvrante parametres key_parenthese_fermante
                     ;

  2. #2
    Invité de passage
    Femme Profil pro Selma
    Etudiante 3éme année Informatique Academique
    Inscrit en
    avril 2012
    Messages
    14
    Détails du profil
    Informations personnelles :
    Nom : Femme Selma
    Localisation : Algérie

    Informations professionnelles :
    Activité : Etudiante 3éme année Informatique Academique

    Informations forums :
    Inscription : avril 2012
    Messages : 14
    Points : 2
    Points
    2

    Par défaut

    Et voici le fichier analyse.output partie 01
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    394
    395
    396
    397
    398
    399
    400
    401
    402
    403
    404
    405
    406
    407
    408
    409
    410
    411
    412
    413
    414
    415
    416
    417
    418
    419
    420
    421
    422
    423
    424
    425
    426
    427
    428
    429
    430
    431
    432
    433
    434
    435
    436
    437
    438
    439
    440
    441
    442
    443
    444
    445
    446
    447
    448
    449
    450
    451
    452
    453
    454
    455
    456
    457
    458
    459
    460
    461
    462
    463
    464
    465
    466
    467
    468
    469
    470
    471
    472
    473
    474
    475
    476
    477
    478
    479
    480
    481
    482
    483
    484
    485
    486
    487
    488
    489
    490
    491
    492
    493
    494
    495
    496
    497
    498
    499
    500
    501
    502
    503
    504
    505
    506
    507
    508
    509
    510
    511
    512
    513
    514
    515
    516
    517
    518
    519
    520
    521
    522
    523
    524
    525
    526
    527
    528
    529
    530
    531
    532
    533
    534
    535
    536
    537
    538
    539
    540
    541
    542
    543
    544
    545
    546
    547
    548
    549
    550
    551
    552
    553
    554
    555
    556
    557
    558
    559
    560
    561
    562
    563
    564
    565
    566
    567
    568
    569
    570
    571
    572
    573
    574
    575
    576
    577
    578
    579
    580
    581
    582
    583
    584
    585
    586
    587
    588
    589
    590
    591
    592
    593
    594
    595
    596
    597
    598
    599
    600
    601
    602
    603
    604
    605
    606
    607
    608
    609
    610
    611
    612
    613
    614
    615
    616
    617
    618
    619
    620
    621
    622
    623
    624
    625
    626
    627
    628
    629
    630
    631
    632
    633
    634
    635
    636
    637
    638
    639
    640
    641
    642
    643
    644
    645
    646
    647
    648
    649
    650
    651
    652
    653
    654
    655
    656
    657
    658
    659
    660
    661
    662
    663
    664
    665
    666
    667
    668
    669
    670
    671
    672
    673
    674
    675
    676
    677
    678
    679
    680
    681
    682
    683
    684
    685
    686
    687
    688
    689
    690
    691
    692
    693
    694
    695
    696
    697
    698
    699
    700
    701
    702
    703
    704
    705
    706
    707
    708
    709
    710
    711
    712
    713
    714
    715
    716
    717
    718
    719
    720
    721
    722
    723
    724
    725
    726
    727
    728
    729
    730
    731
    732
    733
    734
    735
    736
    737
    738
    739
    740
    741
    742
    743
    744
    745
    746
    747
    748
    749
    750
    751
    752
    753
    754
    755
    756
    757
    758
    759
    760
    761
    762
    763
    764
    765
    766
    767
    768
    769
    770
    771
    772
    773
    774
    775
    776
    777
    778
    779
    780
    781
    782
    783
    784
    785
    786
    787
    788
    789
    790
    791
    792
    793
    794
    795
    796
    797
    798
    799
    800
    801
    802
    803
    804
    805
    806
    807
    808
    809
    810
    811
    812
    813
    814
    815
    816
    817
    818
    819
    820
    821
    822
    823
    824
    825
    826
    827
    828
    829
    830
    831
    832
    833
    834
    835
    836
    837
    838
    839
    Terminaux inutilisés dans la grammaire
    
       key_endrint
       key_if
       key_te
       key_dg
       key_an
       key_caractere
       key_egalite
    
    
    État 27 conflits: 1 décalage/réduction
    État 28 conflits: 6 décalage/réduction
    État 29 conflits: 6 décalage/réduction
    État 30 conflits: 6 décalage/réduction
    État 31 conflits: 6 décalage/réduction
    État 32 conflits: 6 décalage/réduction
    État 33 conflits: 6 décalage/réduction
    État 35 conflits: 1 décalage/réduction
    État 46 conflits: 10 réduction/réduction
    État 47 conflits: 10 réduction/réduction
    État 48 conflits: 10 réduction/réduction
    État 49 conflits: 10 réduction/réduction
    État 50 conflits: 10 réduction/réduction
    État 51 conflits: 10 réduction/réduction
    État 113 conflits: 1 décalage/réduction
    État 132 conflits: 6 décalage/réduction
    État 138 conflits: 7 décalage/réduction
    État 145 conflits: 1 décalage/réduction
    
    
    Grammaire
    
        0 $accept: PROGRAMME $end
    
        1 PROGRAMME: fonction_i
        2          | programme_principal
    
        3 fonction_i: fonction_i corps_fonction
        4           | corps_fonction
    
        5 corps_fonction: prototype decl inst key_idf key_affectation valeur key_endr
    
        6 prototype: type key_routine key_idf key_parenthese_ouvrante parametres key_parenthese_fermante
    
        7 type: key_integer
        8     | key_charactere
        9     | key_real
       10     | key_logical
    
       11 parametres: key_idf key_virgule parametres
       12           | key_idf
    
       13 decl: type key_idf key_dimension key_parenthese_ouvrante taille key_parenthese_fermante decl
       14     | type key_idf key_virgule decla
       15     | type key_idf key_dimension key_parenthese_ouvrante taille key_parenthese_fermante
       16     | type key_idf
    
       17 decla: type key_idf key_virgule decla
       18      | type key_idf
    
       19 taille: key_entier key_virgule key_entier
       20       | key_entier
    
       21 inst: affectation inst
       22     | entree_sorties inst
       23     | condition inst
       24     | boucle inst
       25     | appel_fonction inst
       26     | equivalence inst
       27     | affectation
       28     | entree_sorties
       29     | condition
       30     | boucle
       31     | appel_fonction
       32     | equivalence
    
       33 affectation: key_idf key_affectation expr
    
       34 expr: key_entier
       35     | operation
       36     | key_guillemets key_idf key_guillemets
       37     | logique
    
       38 operation: operand operateur operand
    
       39 operateur: key_plus
       40          | key_multiplication
       41          | key_soustraction
       42          | key_division
    
       43 operand: key_idf key_parenthese_ouvrante key_entier key_virgule key_entier key_parenthese_fermante
       44        | key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante
    
       45 logique: key_true
       46        | key_false
    
       47 entree_sorties: key_read key_parenthese_ouvrante key_idf key_parenthese_fermante
       48               | key_write key_parenthese_ouvrante key_guillemets phrase key_guillemets key_virgule key_idf key_virgule key_guillemets key_point key_guillemets key_parenthese_fermante
    
       49 phrase: key_idf phrase
       50       | key_idf
    
       51 condition: key_idf key_parenthese_ouvrante explogique key_parenthese_fermante key_then inst condition key_else inst key_endif
       52          | inst
    
       53 boucle: key_dowhile key_parenthese_ouvrante explogique key_parenthese_fermante inst key_enddo
    
       54 appel_fonction: key_call key_idf key_parenthese_ouvrante parametres key_parenthese_fermante
    
       55 explogique: key_idf key_point operateur_comp key_point key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante key_point operateur_log key_point key_parenthese_ouvrante key_idf key_point operateur_comp key_point opa key_parenthese_fermante
    
       56 operateur_comp: key_gt
       57               | key_ge
       58               | key_eq
       59               | key_ne
       60               | key_le
       61               | key_lt
    
       62 opa: key_true
       63    | key_false
    
       64 operateur_log: key_or
       65              | key_end
    
       66 valeur: key_entier
       67       | key_reel
    
       68 programme_principal: prototype_prog decl inst key_end
    
       69 prototype_prog: key_program key_idf
    
       70 equivalence: key_equivalence key_parenthese_ouvrante parametres key_parenthese_fermante key_virgule equivalence
       71            | key_equivalence key_parenthese_ouvrante parametres key_parenthese_fermante
    
    
    Terminaux, suivis des règles où ils apparaissent
    
    $end (0) 0
    error (256)
    key_real (258) 9
    key_integer (259) 7
    key_charactere (260) 8
    key_program (261) 69
    key_routine (262) 6
    key_end (263) 65 68
    key_endr (264) 5
    key_endrint (265)
    key_read (266) 47
    key_write (267) 48
    key_if (268)
    key_then (269) 51
    key_else (270) 51
    key_endif (271) 51
    key_dowhile (272) 53
    key_enddo (273) 53
    key_call (274) 54
    key_equivalence (275) 70 71
    key_dimension (276) 13 15
    key_lt (277) 61
    key_le (278) 60
    key_ne (279) 59
    key_eq (280) 58
    key_te (281)
    key_dg (282)
    key_an (283)
    key_or (284) 64
    key_false (285) 46 63
    key_true (286) 45 62
    key_logical (287) 10
    key_virgule (288) 11 14 17 19 43 48 70
    key_idf (289) 5 6 11 12 13 14 15 16 17 18 33 36 43 44 47 48 49 50 51
        54 55 69
    key_reel (290) 67
    key_entier (291) 19 20 34 43 44 55 66
    key_caractere (292)
    key_egalite (293)
    key_affectation (294) 5 33
    key_plus (295) 39
    key_soustraction (296) 41
    key_division (297) 42
    key_multiplication (298) 40
    key_guillemets (299) 36 48
    key_parenthese_fermante (300) 6 13 15 43 44 47 48 51 53 54 55 70 71
    key_parenthese_ouvrante (301) 6 13 15 43 44 47 48 51 53 54 55 70 71
    key_point (302) 48 55
    key_ge (303) 57
    key_gt (304) 56
    
    
    Non-terminaux, suivis des règles où ils apparaissent
    
    $accept (50)
        à gauche: 0
    PROGRAMME (51)
        à gauche: 1 2, à droite: 0
    fonction_i (52)
        à gauche: 3 4, à droite: 1 3
    corps_fonction (53)
        à gauche: 5, à droite: 3 4
    prototype (54)
        à gauche: 6, à droite: 5
    type (55)
        à gauche: 7 8 9 10, à droite: 6 13 14 15 16 17 18
    parametres (56)
        à gauche: 11 12, à droite: 6 11 54 70 71
    decl (57)
        à gauche: 13 14 15 16, à droite: 5 13 68
    decla (58)
        à gauche: 17 18, à droite: 14 17
    taille (59)
        à gauche: 19 20, à droite: 13 15
    inst (60)
        à gauche: 21 22 23 24 25 26 27 28 29 30 31 32, à droite: 5 21
        22 23 24 25 26 51 52 53 68
    affectation (61)
        à gauche: 33, à droite: 21 27
    expr (62)
        à gauche: 34 35 36 37, à droite: 33
    operation (63)
        à gauche: 38, à droite: 35
    operateur (64)
        à gauche: 39 40 41 42, à droite: 38 44 55
    operand (65)
        à gauche: 43 44, à droite: 38
    logique (66)
        à gauche: 45 46, à droite: 37
    entree_sorties (67)
        à gauche: 47 48, à droite: 22 28
    phrase (68)
        à gauche: 49 50, à droite: 48 49
    condition (69)
        à gauche: 51 52, à droite: 23 29 51
    boucle (70)
        à gauche: 53, à droite: 24 30
    appel_fonction (71)
        à gauche: 54, à droite: 25 31
    explogique (72)
        à gauche: 55, à droite: 51 53
    operateur_comp (73)
        à gauche: 56 57 58 59 60 61, à droite: 55
    opa (74)
        à gauche: 62 63, à droite: 55
    operateur_log (75)
        à gauche: 64 65, à droite: 55
    valeur (76)
        à gauche: 66 67, à droite: 5
    programme_principal (77)
        à gauche: 68, à droite: 2
    prototype_prog (78)
        à gauche: 69, à droite: 68
    equivalence (79)
        à gauche: 70 71, à droite: 26 32 70
    
    
    état 0
    
        0 $accept: . PROGRAMME $end
    
        key_real        décalage et aller à l'état 1
        key_integer     décalage et aller à l'état 2
        key_charactere  décalage et aller à l'état 3
        key_program     décalage et aller à l'état 4
        key_logical     décalage et aller à l'état 5
    
        PROGRAMME            aller à l'état 6
        fonction_i           aller à l'état 7
        corps_fonction       aller à l'état 8
        prototype            aller à l'état 9
        type                 aller à l'état 10
        programme_principal  aller à l'état 11
        prototype_prog       aller à l'état 12
    
    
    état 1
    
        9 type: key_real .
    
        $défaut  réduction par utilisation de la règle 9 (type)
    
    
    état 2
    
        7 type: key_integer .
    
        $défaut  réduction par utilisation de la règle 7 (type)
    
    
    état 3
    
        8 type: key_charactere .
    
        $défaut  réduction par utilisation de la règle 8 (type)
    
    
    état 4
    
       69 prototype_prog: key_program . key_idf
    
        key_idf  décalage et aller à l'état 13
    
    
    état 5
    
       10 type: key_logical .
    
        $défaut  réduction par utilisation de la règle 10 (type)
    
    
    état 6
    
        0 $accept: PROGRAMME . $end
    
        $end  décalage et aller à l'état 14
    
    
    état 7
    
        1 PROGRAMME: fonction_i .
        3 fonction_i: fonction_i . corps_fonction
    
        key_real        décalage et aller à l'état 1
        key_integer     décalage et aller à l'état 2
        key_charactere  décalage et aller à l'état 3
        key_logical     décalage et aller à l'état 5
    
        $défaut  réduction par utilisation de la règle 1 (PROGRAMME)
    
        corps_fonction  aller à l'état 15
        prototype       aller à l'état 9
        type            aller à l'état 10
    
    
    état 8
    
        4 fonction_i: corps_fonction .
    
        $défaut  réduction par utilisation de la règle 4 (fonction_i)
    
    
    état 9
    
        5 corps_fonction: prototype . decl inst key_idf key_affectation valeur key_endr
    
        key_real        décalage et aller à l'état 1
        key_integer     décalage et aller à l'état 2
        key_charactere  décalage et aller à l'état 3
        key_logical     décalage et aller à l'état 5
    
        type  aller à l'état 16
        decl  aller à l'état 17
    
    
    état 10
    
        6 prototype: type . key_routine key_idf key_parenthese_ouvrante parametres key_parenthese_fermante
    
        key_routine  décalage et aller à l'état 18
    
    
    état 11
    
        2 PROGRAMME: programme_principal .
    
        $défaut  réduction par utilisation de la règle 2 (PROGRAMME)
    
    
    état 12
    
       68 programme_principal: prototype_prog . decl inst key_end
    
        key_real        décalage et aller à l'état 1
        key_integer     décalage et aller à l'état 2
        key_charactere  décalage et aller à l'état 3
        key_logical     décalage et aller à l'état 5
    
        type  aller à l'état 16
        decl  aller à l'état 19
    
    
    état 13
    
       69 prototype_prog: key_program key_idf .
    
        $défaut  réduction par utilisation de la règle 69 (prototype_prog)
    
    
    état 14
    
        0 $accept: PROGRAMME $end .
    
        $défaut  accepter
    
    
    état 15
    
        3 fonction_i: fonction_i corps_fonction .
    
        $défaut  réduction par utilisation de la règle 3 (fonction_i)
    
    
    état 16
    
       13 decl: type . key_idf key_dimension key_parenthese_ouvrante taille key_parenthese_fermante decl
       14     | type . key_idf key_virgule decla
       15     | type . key_idf key_dimension key_parenthese_ouvrante taille key_parenthese_fermante
       16     | type . key_idf
    
        key_idf  décalage et aller à l'état 20
    
    
    état 17
    
        5 corps_fonction: prototype decl . inst key_idf key_affectation valeur key_endr
    
        key_read         décalage et aller à l'état 21
        key_write        décalage et aller à l'état 22
        key_dowhile      décalage et aller à l'état 23
        key_call         décalage et aller à l'état 24
        key_equivalence  décalage et aller à l'état 25
        key_idf          décalage et aller à l'état 26
    
        inst            aller à l'état 27
        affectation     aller à l'état 28
        entree_sorties  aller à l'état 29
        condition       aller à l'état 30
        boucle          aller à l'état 31
        appel_fonction  aller à l'état 32
        equivalence     aller à l'état 33
    
    
    état 18
    
        6 prototype: type key_routine . key_idf key_parenthese_ouvrante parametres key_parenthese_fermante
    
        key_idf  décalage et aller à l'état 34
    
    
    état 19
    
       68 programme_principal: prototype_prog decl . inst key_end
    
        key_read         décalage et aller à l'état 21
        key_write        décalage et aller à l'état 22
        key_dowhile      décalage et aller à l'état 23
        key_call         décalage et aller à l'état 24
        key_equivalence  décalage et aller à l'état 25
        key_idf          décalage et aller à l'état 26
    
        inst            aller à l'état 35
        affectation     aller à l'état 28
        entree_sorties  aller à l'état 29
        condition       aller à l'état 30
        boucle          aller à l'état 31
        appel_fonction  aller à l'état 32
        equivalence     aller à l'état 33
    
    
    état 20
    
       13 decl: type key_idf . key_dimension key_parenthese_ouvrante taille key_parenthese_fermante decl
       14     | type key_idf . key_virgule decla
       15     | type key_idf . key_dimension key_parenthese_ouvrante taille key_parenthese_fermante
       16     | type key_idf .
    
        key_dimension  décalage et aller à l'état 36
        key_virgule    décalage et aller à l'état 37
    
        $défaut  réduction par utilisation de la règle 16 (decl)
    
    
    état 21
    
       47 entree_sorties: key_read . key_parenthese_ouvrante key_idf key_parenthese_fermante
    
        key_parenthese_ouvrante  décalage et aller à l'état 38
    
    
    état 22
    
       48 entree_sorties: key_write . key_parenthese_ouvrante key_guillemets phrase key_guillemets key_virgule key_idf key_virgule key_guillemets key_point key_guillemets key_parenthese_fermante
    
        key_parenthese_ouvrante  décalage et aller à l'état 39
    
    
    état 23
    
       53 boucle: key_dowhile . key_parenthese_ouvrante explogique key_parenthese_fermante inst key_enddo
    
        key_parenthese_ouvrante  décalage et aller à l'état 40
    
    
    état 24
    
       54 appel_fonction: key_call . key_idf key_parenthese_ouvrante parametres key_parenthese_fermante
    
        key_idf  décalage et aller à l'état 41
    
    
    état 25
    
       70 equivalence: key_equivalence . key_parenthese_ouvrante parametres key_parenthese_fermante key_virgule equivalence
       71            | key_equivalence . key_parenthese_ouvrante parametres key_parenthese_fermante
    
        key_parenthese_ouvrante  décalage et aller à l'état 42
    
    
    état 26
    
       33 affectation: key_idf . key_affectation expr
       51 condition: key_idf . key_parenthese_ouvrante explogique key_parenthese_fermante key_then inst condition key_else inst key_endif
    
        key_affectation          décalage et aller à l'état 43
        key_parenthese_ouvrante  décalage et aller à l'état 44
    
    
    état 27
    
        5 corps_fonction: prototype decl inst . key_idf key_affectation valeur key_endr
       52 condition: inst .
    
        key_idf  décalage et aller à l'état 45
    
        key_idf   [réduction par utilisation de la règle 52 (condition)]
        $défaut  réduction par utilisation de la règle 52 (condition)
    
    
    état 28
    
       21 inst: affectation . inst
       27     | affectation .
    
        key_read         décalage et aller à l'état 21
        key_write        décalage et aller à l'état 22
        key_dowhile      décalage et aller à l'état 23
        key_call         décalage et aller à l'état 24
        key_equivalence  décalage et aller à l'état 25
        key_idf          décalage et aller à l'état 26
    
        key_read         [réduction par utilisation de la règle 27 (inst)]
        key_write        [réduction par utilisation de la règle 27 (inst)]
        key_dowhile      [réduction par utilisation de la règle 27 (inst)]
        key_call         [réduction par utilisation de la règle 27 (inst)]
        key_equivalence  [réduction par utilisation de la règle 27 (inst)]
        key_idf          [réduction par utilisation de la règle 27 (inst)]
        $défaut         réduction par utilisation de la règle 27 (inst)
    
        inst            aller à l'état 46
        affectation     aller à l'état 28
        entree_sorties  aller à l'état 29
        condition       aller à l'état 30
        boucle          aller à l'état 31
        appel_fonction  aller à l'état 32
        equivalence     aller à l'état 33
    
    
    état 29
    
       22 inst: entree_sorties . inst
       28     | entree_sorties .
    
        key_read         décalage et aller à l'état 21
        key_write        décalage et aller à l'état 22
        key_dowhile      décalage et aller à l'état 23
        key_call         décalage et aller à l'état 24
        key_equivalence  décalage et aller à l'état 25
        key_idf          décalage et aller à l'état 26
    
        key_read         [réduction par utilisation de la règle 28 (inst)]
        key_write        [réduction par utilisation de la règle 28 (inst)]
        key_dowhile      [réduction par utilisation de la règle 28 (inst)]
        key_call         [réduction par utilisation de la règle 28 (inst)]
        key_equivalence  [réduction par utilisation de la règle 28 (inst)]
        key_idf          [réduction par utilisation de la règle 28 (inst)]
        $défaut         réduction par utilisation de la règle 28 (inst)
    
        inst            aller à l'état 47
        affectation     aller à l'état 28
        entree_sorties  aller à l'état 29
        condition       aller à l'état 30
        boucle          aller à l'état 31
        appel_fonction  aller à l'état 32
        equivalence     aller à l'état 33
    
    
    état 30
    
       23 inst: condition . inst
       29     | condition .
    
        key_read         décalage et aller à l'état 21
        key_write        décalage et aller à l'état 22
        key_dowhile      décalage et aller à l'état 23
        key_call         décalage et aller à l'état 24
        key_equivalence  décalage et aller à l'état 25
        key_idf          décalage et aller à l'état 26
    
        key_read         [réduction par utilisation de la règle 29 (inst)]
        key_write        [réduction par utilisation de la règle 29 (inst)]
        key_dowhile      [réduction par utilisation de la règle 29 (inst)]
        key_call         [réduction par utilisation de la règle 29 (inst)]
        key_equivalence  [réduction par utilisation de la règle 29 (inst)]
        key_idf          [réduction par utilisation de la règle 29 (inst)]
        $défaut         réduction par utilisation de la règle 29 (inst)
    
        inst            aller à l'état 48
        affectation     aller à l'état 28
        entree_sorties  aller à l'état 29
        condition       aller à l'état 30
        boucle          aller à l'état 31
        appel_fonction  aller à l'état 32
        equivalence     aller à l'état 33
    
    
    état 31
    
       24 inst: boucle . inst
       30     | boucle .
    
        key_read         décalage et aller à l'état 21
        key_write        décalage et aller à l'état 22
        key_dowhile      décalage et aller à l'état 23
        key_call         décalage et aller à l'état 24
        key_equivalence  décalage et aller à l'état 25
        key_idf          décalage et aller à l'état 26
    
        key_read         [réduction par utilisation de la règle 30 (inst)]
        key_write        [réduction par utilisation de la règle 30 (inst)]
        key_dowhile      [réduction par utilisation de la règle 30 (inst)]
        key_call         [réduction par utilisation de la règle 30 (inst)]
        key_equivalence  [réduction par utilisation de la règle 30 (inst)]
        key_idf          [réduction par utilisation de la règle 30 (inst)]
        $défaut         réduction par utilisation de la règle 30 (inst)
    
        inst            aller à l'état 49
        affectation     aller à l'état 28
        entree_sorties  aller à l'état 29
        condition       aller à l'état 30
        boucle          aller à l'état 31
        appel_fonction  aller à l'état 32
        equivalence     aller à l'état 33
    
    
    état 32
    
       25 inst: appel_fonction . inst
       31     | appel_fonction .
    
        key_read         décalage et aller à l'état 21
        key_write        décalage et aller à l'état 22
        key_dowhile      décalage et aller à l'état 23
        key_call         décalage et aller à l'état 24
        key_equivalence  décalage et aller à l'état 25
        key_idf          décalage et aller à l'état 26
    
        key_read         [réduction par utilisation de la règle 31 (inst)]
        key_write        [réduction par utilisation de la règle 31 (inst)]
        key_dowhile      [réduction par utilisation de la règle 31 (inst)]
        key_call         [réduction par utilisation de la règle 31 (inst)]
        key_equivalence  [réduction par utilisation de la règle 31 (inst)]
        key_idf          [réduction par utilisation de la règle 31 (inst)]
        $défaut         réduction par utilisation de la règle 31 (inst)
    
        inst            aller à l'état 50
        affectation     aller à l'état 28
        entree_sorties  aller à l'état 29
        condition       aller à l'état 30
        boucle          aller à l'état 31
        appel_fonction  aller à l'état 32
        equivalence     aller à l'état 33
    
    
    état 33
    
       26 inst: equivalence . inst
       32     | equivalence .
    
        key_read         décalage et aller à l'état 21
        key_write        décalage et aller à l'état 22
        key_dowhile      décalage et aller à l'état 23
        key_call         décalage et aller à l'état 24
        key_equivalence  décalage et aller à l'état 25
        key_idf          décalage et aller à l'état 26
    
        key_read         [réduction par utilisation de la règle 32 (inst)]
        key_write        [réduction par utilisation de la règle 32 (inst)]
        key_dowhile      [réduction par utilisation de la règle 32 (inst)]
        key_call         [réduction par utilisation de la règle 32 (inst)]
        key_equivalence  [réduction par utilisation de la règle 32 (inst)]
        key_idf          [réduction par utilisation de la règle 32 (inst)]
        $défaut         réduction par utilisation de la règle 32 (inst)
    
        inst            aller à l'état 51
        affectation     aller à l'état 28
        entree_sorties  aller à l'état 29
        condition       aller à l'état 30
        boucle          aller à l'état 31
        appel_fonction  aller à l'état 32
        equivalence     aller à l'état 33
    
    
    état 34
    
        6 prototype: type key_routine key_idf . key_parenthese_ouvrante parametres key_parenthese_fermante
    
        key_parenthese_ouvrante  décalage et aller à l'état 52
    
    
    état 35
    
       52 condition: inst .
       68 programme_principal: prototype_prog decl inst . key_end
    
        key_end  décalage et aller à l'état 53
    
        key_end   [réduction par utilisation de la règle 52 (condition)]
        $défaut  réduction par utilisation de la règle 52 (condition)
    
    
    état 36
    
       13 decl: type key_idf key_dimension . key_parenthese_ouvrante taille key_parenthese_fermante decl
       15     | type key_idf key_dimension . key_parenthese_ouvrante taille key_parenthese_fermante
    
        key_parenthese_ouvrante  décalage et aller à l'état 54
    
    
    état 37
    
       14 decl: type key_idf key_virgule . decla
    
        key_real        décalage et aller à l'état 1
        key_integer     décalage et aller à l'état 2
        key_charactere  décalage et aller à l'état 3
        key_logical     décalage et aller à l'état 5
    
        type   aller à l'état 55
        decla  aller à l'état 56
    
    
    état 38
    
       47 entree_sorties: key_read key_parenthese_ouvrante . key_idf key_parenthese_fermante
    
        key_idf  décalage et aller à l'état 57
    
    
    état 39
    
       48 entree_sorties: key_write key_parenthese_ouvrante . key_guillemets phrase key_guillemets key_virgule key_idf key_virgule key_guillemets key_point key_guillemets key_parenthese_fermante
    
        key_guillemets  décalage et aller à l'état 58
    
    
    état 40
    
       53 boucle: key_dowhile key_parenthese_ouvrante . explogique key_parenthese_fermante inst key_enddo
    
        key_idf  décalage et aller à l'état 59
    
        explogique  aller à l'état 60
    
    
    état 41
    
       54 appel_fonction: key_call key_idf . key_parenthese_ouvrante parametres key_parenthese_fermante
    
        key_parenthese_ouvrante  décalage et aller à l'état 61
    
    
    état 42
    
       70 equivalence: key_equivalence key_parenthese_ouvrante . parametres key_parenthese_fermante key_virgule equivalence
       71            | key_equivalence key_parenthese_ouvrante . parametres key_parenthese_fermante
    
        key_idf  décalage et aller à l'état 62
    
        parametres  aller à l'état 63
    
    
    état 43
    
       33 affectation: key_idf key_affectation . expr
    
        key_false                décalage et aller à l'état 64
        key_true                 décalage et aller à l'état 65
        key_idf                  décalage et aller à l'état 66
        key_entier               décalage et aller à l'état 67
        key_guillemets           décalage et aller à l'état 68
        key_parenthese_ouvrante  décalage et aller à l'état 69
    
        expr       aller à l'état 70
        operation  aller à l'état 71
        operand    aller à l'état 72
        logique    aller à l'état 73
    
    
    état 44
    
       51 condition: key_idf key_parenthese_ouvrante . explogique key_parenthese_fermante key_then inst condition key_else inst key_endif
    
        key_idf  décalage et aller à l'état 59
    
        explogique  aller à l'état 74
    
    
    état 45
    
        5 corps_fonction: prototype decl inst key_idf . key_affectation valeur key_endr
    
        key_affectation  décalage et aller à l'état 75
    
    
    état 46
    
       21 inst: affectation inst .
       52 condition: inst .
    
        key_end          réduction par utilisation de la règle 21 (inst)
        key_end          [réduction par utilisation de la règle 52 (condition)]
        key_read         réduction par utilisation de la règle 21 (inst)
        key_read         [réduction par utilisation de la règle 52 (condition)]
        key_write        réduction par utilisation de la règle 21 (inst)
        key_write        [réduction par utilisation de la règle 52 (condition)]
        key_else         réduction par utilisation de la règle 21 (inst)
        key_else         [réduction par utilisation de la règle 52 (condition)]
        key_endif        réduction par utilisation de la règle 21 (inst)
        key_endif        [réduction par utilisation de la règle 52 (condition)]
        key_dowhile      réduction par utilisation de la règle 21 (inst)
        key_dowhile      [réduction par utilisation de la règle 52 (condition)]
        key_enddo        réduction par utilisation de la règle 21 (inst)
        key_enddo        [réduction par utilisation de la règle 52 (condition)]
        key_call         réduction par utilisation de la règle 21 (inst)
        key_call         [réduction par utilisation de la règle 52 (condition)]
        key_equivalence  réduction par utilisation de la règle 21 (inst)
        key_equivalence  [réduction par utilisation de la règle 52 (condition)]
        key_idf          réduction par utilisation de la règle 21 (inst)
        key_idf          [réduction par utilisation de la règle 52 (condition)]
        $défaut         réduction par utilisation de la règle 21 (inst)

  3. #3
    Invité de passage
    Femme Profil pro Selma
    Etudiante 3éme année Informatique Academique
    Inscrit en
    avril 2012
    Messages
    14
    Détails du profil
    Informations personnelles :
    Nom : Femme Selma
    Localisation : Algérie

    Informations professionnelles :
    Activité : Etudiante 3éme année Informatique Academique

    Informations forums :
    Inscription : avril 2012
    Messages : 14
    Points : 2
    Points
    2

    Par défaut

    Et voici la partie 02 du fichier analyse.output
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    394
    395
    396
    397
    398
    399
    400
    401
    402
    403
    404
    405
    406
    407
    408
    409
    410
    411
    412
    413
    414
    415
    416
    417
    418
    419
    420
    421
    422
    423
    424
    425
    426
    427
    428
    429
    430
    431
    432
    433
    434
    435
    436
    437
    438
    439
    440
    441
    442
    443
    444
    445
    446
    447
    448
    449
    450
    451
    452
    453
    454
    455
    456
    457
    458
    459
    460
    461
    462
    463
    464
    465
    466
    467
    468
    469
    470
    471
    472
    473
    474
    475
    476
    477
    478
    479
    480
    481
    482
    483
    484
    485
    486
    487
    488
    489
    490
    491
    492
    493
    494
    495
    496
    497
    498
    499
    500
    501
    502
    503
    504
    505
    506
    507
    508
    509
    510
    511
    512
    513
    514
    515
    516
    517
    518
    519
    520
    521
    522
    523
    524
    525
    526
    527
    528
    529
    530
    531
    532
    533
    534
    535
    536
    537
    538
    539
    540
    541
    542
    543
    544
    545
    546
    547
    548
    549
    550
    551
    552
    553
    554
    555
    556
    557
    558
    559
    560
    561
    562
    563
    564
    565
    566
    567
    568
    569
    570
    571
    572
    573
    574
    575
    576
    577
    578
    579
    580
    581
    582
    583
    584
    585
    586
    587
    588
    589
    590
    591
    592
    593
    594
    595
    596
    597
    598
    599
    600
    601
    602
    603
    604
    605
    606
    607
    608
    609
    610
    611
    612
    613
    614
    615
    616
    617
    618
    619
    620
    621
    622
    623
    624
    625
    626
    627
    628
    629
    630
    631
    632
    633
    634
    635
    636
    637
    638
    639
    640
    641
    642
    643
    644
    645
    646
    647
    648
    649
    650
    651
    652
    653
    654
    655
    656
    657
    658
    659
    660
    661
    662
    663
    664
    665
    666
    667
    668
    669
    670
    671
    672
    673
    674
    675
    676
    677
    678
    679
    680
    681
    682
    683
    684
    685
    686
    687
    688
    689
    690
    691
    692
    693
    694
    695
    696
    697
    698
    699
    700
    701
    702
    703
    704
    705
    706
    707
    708
    709
    710
    711
    712
    713
    714
    715
    716
    717
    718
    719
    720
    721
    722
    723
    724
    725
    726
    727
    728
    729
    730
    731
    732
    733
    734
    735
    736
    737
    738
    739
    740
    741
    742
    743
    744
    745
    746
    747
    748
    749
    750
    751
    752
    753
    754
    755
    756
    757
    758
    759
    760
    761
    762
    763
    764
    765
    766
    767
    768
    769
    770
    771
    772
    773
    774
    775
    776
    777
    778
    779
    780
    781
    782
    783
    784
    785
    786
    787
    788
    789
    790
    791
    792
    793
    794
    795
    796
    797
    798
    799
    800
    801
    802
    803
    804
    805
    806
    807
    808
    809
    810
    811
    812
    813
    814
    815
    816
    817
    818
    819
    820
    821
    822
    823
    824
    825
    826
    827
    828
    829
    830
    831
    832
    833
    834
    835
    836
    837
    838
    839
    840
    841
    842
    843
    844
    845
    846
    847
    848
    849
    850
    851
    852
    853
    854
    855
    856
    857
    858
    859
    860
    861
    862
    863
    864
    865
    866
    867
    868
    869
    870
    871
    872
    873
    874
    875
    876
    877
    878
    879
    880
    881
    882
    883
    884
    885
    886
    887
    888
    889
    890
    891
    892
    893
    894
    895
    896
    897
    898
    899
    900
    901
    902
    903
    904
    905
    906
    907
    908
    909
    910
    911
    912
    913
    914
    915
    916
    917
    918
    919
    920
    921
    922
    923
    924
    925
    926
    927
    928
    929
    930
    931
    932
    933
    934
    935
    936
    937
    938
    939
    940
    941
    942
    943
    944
    945
    946
    947
    948
    949
    950
    951
    952
    953
    954
    955
    956
    957
    958
    959
    960
    961
    962
    963
    964
    965
    966
    967
    968
    969
    970
    971
    972
    973
    974
    975
    976
    977
    978
    979
    980
    981
    982
    983
    984
    985
    986
    987
    988
    989
    990
    991
    992
    993
    994
    995
    996
    997
    998
    999
    1000
    1001
    1002
    1003
    1004
    1005
    1006
    1007
    1008
    1009
    1010
    1011
    1012
    1013
    1014
    1015
    1016
    1017
    1018
    1019
    1020
    1021
    1022
    1023
    1024
    1025
    1026
    1027
    1028
    1029
    1030
    1031
    1032
    1033
    1034
    1035
    1036
    1037
    1038
    1039
    1040
    1041
    1042
    1043
    1044
    1045
    1046
    1047
    1048
    1049
    1050
    1051
    1052
    1053
    1054
    1055
    1056
    1057
    1058
    1059
    1060
    1061
    1062
    1063
    1064
    1065
    1066
    1067
    1068
    1069
    1070
    1071
    1072
    1073
    1074
    1075
    1076
    1077
    1078
    1079
    1080
    1081
    1082
    1083
    1084
    1085
    1086
    1087
    1088
    1089
    1090
    1091
    1092
    1093
    1094
    1095
    1096
    1097
    1098
    1099
    1100
    1101
    1102
    1103
    1104
    1105
    1106
    1107
    1108
    1109
    1110
    1111
    1112
    1113
    1114
    1115
    1116
    1117
    état 47
    
       22 inst: entree_sorties inst .
       52 condition: inst .
    
        key_end          réduction par utilisation de la règle 22 (inst)
        key_end          [réduction par utilisation de la règle 52 (condition)]
        key_read         réduction par utilisation de la règle 22 (inst)
        key_read         [réduction par utilisation de la règle 52 (condition)]
        key_write        réduction par utilisation de la règle 22 (inst)
        key_write        [réduction par utilisation de la règle 52 (condition)]
        key_else         réduction par utilisation de la règle 22 (inst)
        key_else         [réduction par utilisation de la règle 52 (condition)]
        key_endif        réduction par utilisation de la règle 22 (inst)
        key_endif        [réduction par utilisation de la règle 52 (condition)]
        key_dowhile      réduction par utilisation de la règle 22 (inst)
        key_dowhile      [réduction par utilisation de la règle 52 (condition)]
        key_enddo        réduction par utilisation de la règle 22 (inst)
        key_enddo        [réduction par utilisation de la règle 52 (condition)]
        key_call         réduction par utilisation de la règle 22 (inst)
        key_call         [réduction par utilisation de la règle 52 (condition)]
        key_equivalence  réduction par utilisation de la règle 22 (inst)
        key_equivalence  [réduction par utilisation de la règle 52 (condition)]
        key_idf          réduction par utilisation de la règle 22 (inst)
        key_idf          [réduction par utilisation de la règle 52 (condition)]
        $défaut         réduction par utilisation de la règle 22 (inst)
    
    
    état 48
    
       23 inst: condition inst .
       52 condition: inst .
    
        key_end          réduction par utilisation de la règle 23 (inst)
        key_end          [réduction par utilisation de la règle 52 (condition)]
        key_read         réduction par utilisation de la règle 23 (inst)
        key_read         [réduction par utilisation de la règle 52 (condition)]
        key_write        réduction par utilisation de la règle 23 (inst)
        key_write        [réduction par utilisation de la règle 52 (condition)]
        key_else         réduction par utilisation de la règle 23 (inst)
        key_else         [réduction par utilisation de la règle 52 (condition)]
        key_endif        réduction par utilisation de la règle 23 (inst)
        key_endif        [réduction par utilisation de la règle 52 (condition)]
        key_dowhile      réduction par utilisation de la règle 23 (inst)
        key_dowhile      [réduction par utilisation de la règle 52 (condition)]
        key_enddo        réduction par utilisation de la règle 23 (inst)
        key_enddo        [réduction par utilisation de la règle 52 (condition)]
        key_call         réduction par utilisation de la règle 23 (inst)
        key_call         [réduction par utilisation de la règle 52 (condition)]
        key_equivalence  réduction par utilisation de la règle 23 (inst)
        key_equivalence  [réduction par utilisation de la règle 52 (condition)]
        key_idf          réduction par utilisation de la règle 23 (inst)
        key_idf          [réduction par utilisation de la règle 52 (condition)]
        $défaut         réduction par utilisation de la règle 23 (inst)
    
    
    état 49
    
       24 inst: boucle inst .
       52 condition: inst .
    
        key_end          réduction par utilisation de la règle 24 (inst)
        key_end          [réduction par utilisation de la règle 52 (condition)]
        key_read         réduction par utilisation de la règle 24 (inst)
        key_read         [réduction par utilisation de la règle 52 (condition)]
        key_write        réduction par utilisation de la règle 24 (inst)
        key_write        [réduction par utilisation de la règle 52 (condition)]
        key_else         réduction par utilisation de la règle 24 (inst)
        key_else         [réduction par utilisation de la règle 52 (condition)]
        key_endif        réduction par utilisation de la règle 24 (inst)
        key_endif        [réduction par utilisation de la règle 52 (condition)]
        key_dowhile      réduction par utilisation de la règle 24 (inst)
        key_dowhile      [réduction par utilisation de la règle 52 (condition)]
        key_enddo        réduction par utilisation de la règle 24 (inst)
        key_enddo        [réduction par utilisation de la règle 52 (condition)]
        key_call         réduction par utilisation de la règle 24 (inst)
        key_call         [réduction par utilisation de la règle 52 (condition)]
        key_equivalence  réduction par utilisation de la règle 24 (inst)
        key_equivalence  [réduction par utilisation de la règle 52 (condition)]
        key_idf          réduction par utilisation de la règle 24 (inst)
        key_idf          [réduction par utilisation de la règle 52 (condition)]
        $défaut         réduction par utilisation de la règle 24 (inst)
    
    
    état 50
    
       25 inst: appel_fonction inst .
       52 condition: inst .
    
        key_end          réduction par utilisation de la règle 25 (inst)
        key_end          [réduction par utilisation de la règle 52 (condition)]
        key_read         réduction par utilisation de la règle 25 (inst)
        key_read         [réduction par utilisation de la règle 52 (condition)]
        key_write        réduction par utilisation de la règle 25 (inst)
        key_write        [réduction par utilisation de la règle 52 (condition)]
        key_else         réduction par utilisation de la règle 25 (inst)
        key_else         [réduction par utilisation de la règle 52 (condition)]
        key_endif        réduction par utilisation de la règle 25 (inst)
        key_endif        [réduction par utilisation de la règle 52 (condition)]
        key_dowhile      réduction par utilisation de la règle 25 (inst)
        key_dowhile      [réduction par utilisation de la règle 52 (condition)]
        key_enddo        réduction par utilisation de la règle 25 (inst)
        key_enddo        [réduction par utilisation de la règle 52 (condition)]
        key_call         réduction par utilisation de la règle 25 (inst)
        key_call         [réduction par utilisation de la règle 52 (condition)]
        key_equivalence  réduction par utilisation de la règle 25 (inst)
        key_equivalence  [réduction par utilisation de la règle 52 (condition)]
        key_idf          réduction par utilisation de la règle 25 (inst)
        key_idf          [réduction par utilisation de la règle 52 (condition)]
        $défaut         réduction par utilisation de la règle 25 (inst)
    
    
    état 51
    
       26 inst: equivalence inst .
       52 condition: inst .
    
        key_end          réduction par utilisation de la règle 26 (inst)
        key_end          [réduction par utilisation de la règle 52 (condition)]
        key_read         réduction par utilisation de la règle 26 (inst)
        key_read         [réduction par utilisation de la règle 52 (condition)]
        key_write        réduction par utilisation de la règle 26 (inst)
        key_write        [réduction par utilisation de la règle 52 (condition)]
        key_else         réduction par utilisation de la règle 26 (inst)
        key_else         [réduction par utilisation de la règle 52 (condition)]
        key_endif        réduction par utilisation de la règle 26 (inst)
        key_endif        [réduction par utilisation de la règle 52 (condition)]
        key_dowhile      réduction par utilisation de la règle 26 (inst)
        key_dowhile      [réduction par utilisation de la règle 52 (condition)]
        key_enddo        réduction par utilisation de la règle 26 (inst)
        key_enddo        [réduction par utilisation de la règle 52 (condition)]
        key_call         réduction par utilisation de la règle 26 (inst)
        key_call         [réduction par utilisation de la règle 52 (condition)]
        key_equivalence  réduction par utilisation de la règle 26 (inst)
        key_equivalence  [réduction par utilisation de la règle 52 (condition)]
        key_idf          réduction par utilisation de la règle 26 (inst)
        key_idf          [réduction par utilisation de la règle 52 (condition)]
        $défaut         réduction par utilisation de la règle 26 (inst)
    
    
    état 52
    
        6 prototype: type key_routine key_idf key_parenthese_ouvrante . parametres key_parenthese_fermante
    
        key_idf  décalage et aller à l'état 62
    
        parametres  aller à l'état 76
    
    
    état 53
    
       68 programme_principal: prototype_prog decl inst key_end .
    
        $défaut  réduction par utilisation de la règle 68 (programme_principal)
    
    
    état 54
    
       13 decl: type key_idf key_dimension key_parenthese_ouvrante . taille key_parenthese_fermante decl
       15     | type key_idf key_dimension key_parenthese_ouvrante . taille key_parenthese_fermante
    
        key_entier  décalage et aller à l'état 77
    
        taille  aller à l'état 78
    
    
    état 55
    
       17 decla: type . key_idf key_virgule decla
       18      | type . key_idf
    
        key_idf  décalage et aller à l'état 79
    
    
    état 56
    
       14 decl: type key_idf key_virgule decla .
    
        $défaut  réduction par utilisation de la règle 14 (decl)
    
    
    état 57
    
       47 entree_sorties: key_read key_parenthese_ouvrante key_idf . key_parenthese_fermante
    
        key_parenthese_fermante  décalage et aller à l'état 80
    
    
    état 58
    
       48 entree_sorties: key_write key_parenthese_ouvrante key_guillemets . phrase key_guillemets key_virgule key_idf key_virgule key_guillemets key_point key_guillemets key_parenthese_fermante
    
        key_idf  décalage et aller à l'état 81
    
        phrase  aller à l'état 82
    
    
    état 59
    
       55 explogique: key_idf . key_point operateur_comp key_point key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante key_point operateur_log key_point key_parenthese_ouvrante key_idf key_point operateur_comp key_point opa key_parenthese_fermante
    
        key_point  décalage et aller à l'état 83
    
    
    état 60
    
       53 boucle: key_dowhile key_parenthese_ouvrante explogique . key_parenthese_fermante inst key_enddo
    
        key_parenthese_fermante  décalage et aller à l'état 84
    
    
    état 61
    
       54 appel_fonction: key_call key_idf key_parenthese_ouvrante . parametres key_parenthese_fermante
    
        key_idf  décalage et aller à l'état 62
    
        parametres  aller à l'état 85
    
    
    état 62
    
       11 parametres: key_idf . key_virgule parametres
       12           | key_idf .
    
        key_virgule  décalage et aller à l'état 86
    
        $défaut  réduction par utilisation de la règle 12 (parametres)
    
    
    état 63
    
       70 equivalence: key_equivalence key_parenthese_ouvrante parametres . key_parenthese_fermante key_virgule equivalence
       71            | key_equivalence key_parenthese_ouvrante parametres . key_parenthese_fermante
    
        key_parenthese_fermante  décalage et aller à l'état 87
    
    
    état 64
    
       46 logique: key_false .
    
        $défaut  réduction par utilisation de la règle 46 (logique)
    
    
    état 65
    
       45 logique: key_true .
    
        $défaut  réduction par utilisation de la règle 45 (logique)
    
    
    état 66
    
       43 operand: key_idf . key_parenthese_ouvrante key_entier key_virgule key_entier key_parenthese_fermante
    
        key_parenthese_ouvrante  décalage et aller à l'état 88
    
    
    état 67
    
       34 expr: key_entier .
    
        $défaut  réduction par utilisation de la règle 34 (expr)
    
    
    état 68
    
       36 expr: key_guillemets . key_idf key_guillemets
    
        key_idf  décalage et aller à l'état 89
    
    
    état 69
    
       44 operand: key_parenthese_ouvrante . key_idf operateur key_entier key_parenthese_fermante
    
        key_idf  décalage et aller à l'état 90
    
    
    état 70
    
       33 affectation: key_idf key_affectation expr .
    
        $défaut  réduction par utilisation de la règle 33 (affectation)
    
    
    état 71
    
       35 expr: operation .
    
        $défaut  réduction par utilisation de la règle 35 (expr)
    
    
    état 72
    
       38 operation: operand . operateur operand
    
        key_plus            décalage et aller à l'état 91
        key_soustraction    décalage et aller à l'état 92
        key_division        décalage et aller à l'état 93
        key_multiplication  décalage et aller à l'état 94
    
        operateur  aller à l'état 95
    
    
    état 73
    
       37 expr: logique .
    
        $défaut  réduction par utilisation de la règle 37 (expr)
    
    
    état 74
    
       51 condition: key_idf key_parenthese_ouvrante explogique . key_parenthese_fermante key_then inst condition key_else inst key_endif
    
        key_parenthese_fermante  décalage et aller à l'état 96
    
    
    état 75
    
        5 corps_fonction: prototype decl inst key_idf key_affectation . valeur key_endr
    
        key_reel    décalage et aller à l'état 97
        key_entier  décalage et aller à l'état 98
    
        valeur  aller à l'état 99
    
    
    état 76
    
        6 prototype: type key_routine key_idf key_parenthese_ouvrante parametres . key_parenthese_fermante
    
        key_parenthese_fermante  décalage et aller à l'état 100
    
    
    état 77
    
       19 taille: key_entier . key_virgule key_entier
       20       | key_entier .
    
        key_virgule  décalage et aller à l'état 101
    
        $défaut  réduction par utilisation de la règle 20 (taille)
    
    
    état 78
    
       13 decl: type key_idf key_dimension key_parenthese_ouvrante taille . key_parenthese_fermante decl
       15     | type key_idf key_dimension key_parenthese_ouvrante taille . key_parenthese_fermante
    
        key_parenthese_fermante  décalage et aller à l'état 102
    
    
    état 79
    
       17 decla: type key_idf . key_virgule decla
       18      | type key_idf .
    
        key_virgule  décalage et aller à l'état 103
    
        $défaut  réduction par utilisation de la règle 18 (decla)
    
    
    état 80
    
       47 entree_sorties: key_read key_parenthese_ouvrante key_idf key_parenthese_fermante .
    
        $défaut  réduction par utilisation de la règle 47 (entree_sorties)
    
    
    état 81
    
       49 phrase: key_idf . phrase
       50       | key_idf .
    
        key_idf  décalage et aller à l'état 81
    
        $défaut  réduction par utilisation de la règle 50 (phrase)
    
        phrase  aller à l'état 104
    
    
    état 82
    
       48 entree_sorties: key_write key_parenthese_ouvrante key_guillemets phrase . key_guillemets key_virgule key_idf key_virgule key_guillemets key_point key_guillemets key_parenthese_fermante
    
        key_guillemets  décalage et aller à l'état 105
    
    
    état 83
    
       55 explogique: key_idf key_point . operateur_comp key_point key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante key_point operateur_log key_point key_parenthese_ouvrante key_idf key_point operateur_comp key_point opa key_parenthese_fermante
    
        key_lt  décalage et aller à l'état 106
        key_le  décalage et aller à l'état 107
        key_ne  décalage et aller à l'état 108
        key_eq  décalage et aller à l'état 109
        key_ge  décalage et aller à l'état 110
        key_gt  décalage et aller à l'état 111
    
        operateur_comp  aller à l'état 112
    
    
    état 84
    
       53 boucle: key_dowhile key_parenthese_ouvrante explogique key_parenthese_fermante . inst key_enddo
    
        key_read         décalage et aller à l'état 21
        key_write        décalage et aller à l'état 22
        key_dowhile      décalage et aller à l'état 23
        key_call         décalage et aller à l'état 24
        key_equivalence  décalage et aller à l'état 25
        key_idf          décalage et aller à l'état 26
    
        inst            aller à l'état 113
        affectation     aller à l'état 28
        entree_sorties  aller à l'état 29
        condition       aller à l'état 30
        boucle          aller à l'état 31
        appel_fonction  aller à l'état 32
        equivalence     aller à l'état 33
    
    
    état 85
    
       54 appel_fonction: key_call key_idf key_parenthese_ouvrante parametres . key_parenthese_fermante
    
        key_parenthese_fermante  décalage et aller à l'état 114
    
    
    état 86
    
       11 parametres: key_idf key_virgule . parametres
    
        key_idf  décalage et aller à l'état 62
    
        parametres  aller à l'état 115
    
    
    état 87
    
       70 equivalence: key_equivalence key_parenthese_ouvrante parametres key_parenthese_fermante . key_virgule equivalence
       71            | key_equivalence key_parenthese_ouvrante parametres key_parenthese_fermante .
    
        key_virgule  décalage et aller à l'état 116
    
        $défaut  réduction par utilisation de la règle 71 (equivalence)
    
    
    état 88
    
       43 operand: key_idf key_parenthese_ouvrante . key_entier key_virgule key_entier key_parenthese_fermante
    
        key_entier  décalage et aller à l'état 117
    
    
    état 89
    
       36 expr: key_guillemets key_idf . key_guillemets
    
        key_guillemets  décalage et aller à l'état 118
    
    
    état 90
    
       44 operand: key_parenthese_ouvrante key_idf . operateur key_entier key_parenthese_fermante
    
        key_plus            décalage et aller à l'état 91
        key_soustraction    décalage et aller à l'état 92
        key_division        décalage et aller à l'état 93
        key_multiplication  décalage et aller à l'état 94
    
        operateur  aller à l'état 119
    
    
    état 91
    
       39 operateur: key_plus .
    
        $défaut  réduction par utilisation de la règle 39 (operateur)
    
    
    état 92
    
       41 operateur: key_soustraction .
    
        $défaut  réduction par utilisation de la règle 41 (operateur)
    
    
    état 93
    
       42 operateur: key_division .
    
        $défaut  réduction par utilisation de la règle 42 (operateur)
    
    
    état 94
    
       40 operateur: key_multiplication .
    
        $défaut  réduction par utilisation de la règle 40 (operateur)
    
    
    état 95
    
       38 operation: operand operateur . operand
    
        key_idf                  décalage et aller à l'état 66
        key_parenthese_ouvrante  décalage et aller à l'état 69
    
        operand  aller à l'état 120
    
    
    état 96
    
       51 condition: key_idf key_parenthese_ouvrante explogique key_parenthese_fermante . key_then inst condition key_else inst key_endif
    
        key_then  décalage et aller à l'état 121
    
    
    état 97
    
       67 valeur: key_reel .
    
        $défaut  réduction par utilisation de la règle 67 (valeur)
    
    
    état 98
    
       66 valeur: key_entier .
    
        $défaut  réduction par utilisation de la règle 66 (valeur)
    
    
    état 99
    
        5 corps_fonction: prototype decl inst key_idf key_affectation valeur . key_endr
    
        key_endr  décalage et aller à l'état 122
    
    
    état 100
    
        6 prototype: type key_routine key_idf key_parenthese_ouvrante parametres key_parenthese_fermante .
    
        $défaut  réduction par utilisation de la règle 6 (prototype)
    
    
    état 101
    
       19 taille: key_entier key_virgule . key_entier
    
        key_entier  décalage et aller à l'état 123
    
    
    état 102
    
       13 decl: type key_idf key_dimension key_parenthese_ouvrante taille key_parenthese_fermante . decl
       15     | type key_idf key_dimension key_parenthese_ouvrante taille key_parenthese_fermante .
    
        key_real        décalage et aller à l'état 1
        key_integer     décalage et aller à l'état 2
        key_charactere  décalage et aller à l'état 3
        key_logical     décalage et aller à l'état 5
    
        $défaut  réduction par utilisation de la règle 15 (decl)
    
        type  aller à l'état 16
        decl  aller à l'état 124
    
    
    état 103
    
       17 decla: type key_idf key_virgule . decla
    
        key_real        décalage et aller à l'état 1
        key_integer     décalage et aller à l'état 2
        key_charactere  décalage et aller à l'état 3
        key_logical     décalage et aller à l'état 5
    
        type   aller à l'état 55
        decla  aller à l'état 125
    
    
    état 104
    
       49 phrase: key_idf phrase .
    
        $défaut  réduction par utilisation de la règle 49 (phrase)
    
    
    état 105
    
       48 entree_sorties: key_write key_parenthese_ouvrante key_guillemets phrase key_guillemets . key_virgule key_idf key_virgule key_guillemets key_point key_guillemets key_parenthese_fermante
    
        key_virgule  décalage et aller à l'état 126
    
    
    état 106
    
       61 operateur_comp: key_lt .
    
        $défaut  réduction par utilisation de la règle 61 (operateur_comp)
    
    
    état 107
    
       60 operateur_comp: key_le .
    
        $défaut  réduction par utilisation de la règle 60 (operateur_comp)
    
    
    état 108
    
       59 operateur_comp: key_ne .
    
        $défaut  réduction par utilisation de la règle 59 (operateur_comp)
    
    
    état 109
    
       58 operateur_comp: key_eq .
    
        $défaut  réduction par utilisation de la règle 58 (operateur_comp)
    
    
    état 110
    
       57 operateur_comp: key_ge .
    
        $défaut  réduction par utilisation de la règle 57 (operateur_comp)
    
    
    état 111
    
       56 operateur_comp: key_gt .
    
        $défaut  réduction par utilisation de la règle 56 (operateur_comp)
    
    
    état 112
    
       55 explogique: key_idf key_point operateur_comp . key_point key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante key_point operateur_log key_point key_parenthese_ouvrante key_idf key_point operateur_comp key_point opa key_parenthese_fermante
    
        key_point  décalage et aller à l'état 127
    
    
    état 113
    
       52 condition: inst .
       53 boucle: key_dowhile key_parenthese_ouvrante explogique key_parenthese_fermante inst . key_enddo
    
        key_enddo  décalage et aller à l'état 128
    
        key_enddo  [réduction par utilisation de la règle 52 (condition)]
        $défaut   réduction par utilisation de la règle 52 (condition)
    
    
    état 114
    
       54 appel_fonction: key_call key_idf key_parenthese_ouvrante parametres key_parenthese_fermante .
    
        $défaut  réduction par utilisation de la règle 54 (appel_fonction)
    
    
    état 115
    
       11 parametres: key_idf key_virgule parametres .
    
        $défaut  réduction par utilisation de la règle 11 (parametres)
    
    
    état 116
    
       70 equivalence: key_equivalence key_parenthese_ouvrante parametres key_parenthese_fermante key_virgule . equivalence
    
        key_equivalence  décalage et aller à l'état 25
    
        equivalence  aller à l'état 129
    
    
    état 117
    
       43 operand: key_idf key_parenthese_ouvrante key_entier . key_virgule key_entier key_parenthese_fermante
    
        key_virgule  décalage et aller à l'état 130
    
    
    état 118
    
       36 expr: key_guillemets key_idf key_guillemets .
    
        $défaut  réduction par utilisation de la règle 36 (expr)
    
    
    état 119
    
       44 operand: key_parenthese_ouvrante key_idf operateur . key_entier key_parenthese_fermante
    
        key_entier  décalage et aller à l'état 131
    
    
    état 120
    
       38 operation: operand operateur operand .
    
        $défaut  réduction par utilisation de la règle 38 (operation)
    
    
    état 121
    
       51 condition: key_idf key_parenthese_ouvrante explogique key_parenthese_fermante key_then . inst condition key_else inst key_endif
    
        key_read         décalage et aller à l'état 21
        key_write        décalage et aller à l'état 22
        key_dowhile      décalage et aller à l'état 23
        key_call         décalage et aller à l'état 24
        key_equivalence  décalage et aller à l'état 25
        key_idf          décalage et aller à l'état 26
    
        inst            aller à l'état 132
        affectation     aller à l'état 28
        entree_sorties  aller à l'état 29
        condition       aller à l'état 30
        boucle          aller à l'état 31
        appel_fonction  aller à l'état 32
        equivalence     aller à l'état 33
    
    
    état 122
    
        5 corps_fonction: prototype decl inst key_idf key_affectation valeur key_endr .
    
        $défaut  réduction par utilisation de la règle 5 (corps_fonction)
    
    
    état 123
    
       19 taille: key_entier key_virgule key_entier .
    
        $défaut  réduction par utilisation de la règle 19 (taille)
    
    
    état 124
    
       13 decl: type key_idf key_dimension key_parenthese_ouvrante taille key_parenthese_fermante decl .
    
        $défaut  réduction par utilisation de la règle 13 (decl)
    
    
    état 125
    
       17 decla: type key_idf key_virgule decla .
    
        $défaut  réduction par utilisation de la règle 17 (decla)
    
    
    état 126
    
       48 entree_sorties: key_write key_parenthese_ouvrante key_guillemets phrase key_guillemets key_virgule . key_idf key_virgule key_guillemets key_point key_guillemets key_parenthese_fermante
    
        key_idf  décalage et aller à l'état 133
    
    
    état 127
    
       55 explogique: key_idf key_point operateur_comp key_point . key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante key_point operateur_log key_point key_parenthese_ouvrante key_idf key_point operateur_comp key_point opa key_parenthese_fermante
    
        key_parenthese_ouvrante  décalage et aller à l'état 134
    
    
    état 128
    
       53 boucle: key_dowhile key_parenthese_ouvrante explogique key_parenthese_fermante inst key_enddo .
    
        $défaut  réduction par utilisation de la règle 53 (boucle)
    
    
    état 129
    
       70 equivalence: key_equivalence key_parenthese_ouvrante parametres key_parenthese_fermante key_virgule equivalence .
    
        $défaut  réduction par utilisation de la règle 70 (equivalence)
    
    
    état 130
    
       43 operand: key_idf key_parenthese_ouvrante key_entier key_virgule . key_entier key_parenthese_fermante
    
        key_entier  décalage et aller à l'état 135
    
    
    état 131
    
       44 operand: key_parenthese_ouvrante key_idf operateur key_entier . key_parenthese_fermante
    
        key_parenthese_fermante  décalage et aller à l'état 136
    
    
    état 132
    
       51 condition: key_idf key_parenthese_ouvrante explogique key_parenthese_fermante key_then inst . condition key_else inst key_endif
       52          | inst .
    
        key_read         décalage et aller à l'état 21
        key_write        décalage et aller à l'état 22
        key_dowhile      décalage et aller à l'état 23
        key_call         décalage et aller à l'état 24
        key_equivalence  décalage et aller à l'état 25
        key_idf          décalage et aller à l'état 26
    
        key_read         [réduction par utilisation de la règle 52 (condition)]
        key_write        [réduction par utilisation de la règle 52 (condition)]
        key_dowhile      [réduction par utilisation de la règle 52 (condition)]
        key_call         [réduction par utilisation de la règle 52 (condition)]
        key_equivalence  [réduction par utilisation de la règle 52 (condition)]
        key_idf          [réduction par utilisation de la règle 52 (condition)]
    
        inst            aller à l'état 137
        affectation     aller à l'état 28
        entree_sorties  aller à l'état 29
        condition       aller à l'état 138
        boucle          aller à l'état 31
        appel_fonction  aller à l'état 32
        equivalence     aller à l'état 33
    
    
    état 133
    
       48 entree_sorties: key_write key_parenthese_ouvrante key_guillemets phrase key_guillemets key_virgule key_idf . key_virgule key_guillemets key_point key_guillemets key_parenthese_fermante
    
        key_virgule  décalage et aller à l'état 139
    
    
    état 134
    
       55 explogique: key_idf key_point operateur_comp key_point key_parenthese_ouvrante . key_idf operateur key_entier key_parenthese_fermante key_point operateur_log key_point key_parenthese_ouvrante key_idf key_point operateur_comp key_point opa key_parenthese_fermante
    
        key_idf  décalage et aller à l'état 140
    
    
    état 135
    
       43 operand: key_idf key_parenthese_ouvrante key_entier key_virgule key_entier . key_parenthese_fermante
    
        key_parenthese_fermante  décalage et aller à l'état 141
    
    
    état 136
    
       44 operand: key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante .
    
        $défaut  réduction par utilisation de la règle 44 (operand)
    
    
    état 137
    
       52 condition: inst .
    
        $défaut  réduction par utilisation de la règle 52 (condition)
    
    
    état 138
    
       23 inst: condition . inst
       29     | condition .
       51 condition: key_idf key_parenthese_ouvrante explogique key_parenthese_fermante key_then inst condition . key_else inst key_endif
    
        key_read         décalage et aller à l'état 21
        key_write        décalage et aller à l'état 22
        key_else         décalage et aller à l'état 142
        key_dowhile      décalage et aller à l'état 23
        key_call         décalage et aller à l'état 24
        key_equivalence  décalage et aller à l'état 25
        key_idf          décalage et aller à l'état 26
    
        key_read         [réduction par utilisation de la règle 29 (inst)]
        key_write        [réduction par utilisation de la règle 29 (inst)]
        key_else         [réduction par utilisation de la règle 29 (inst)]
        key_dowhile      [réduction par utilisation de la règle 29 (inst)]
        key_call         [réduction par utilisation de la règle 29 (inst)]
        key_equivalence  [réduction par utilisation de la règle 29 (inst)]
        key_idf          [réduction par utilisation de la règle 29 (inst)]
    
        inst            aller à l'état 48
        affectation     aller à l'état 28
        entree_sorties  aller à l'état 29
        condition       aller à l'état 30
        boucle          aller à l'état 31
        appel_fonction  aller à l'état 32
        equivalence     aller à l'état 33
    
    
    état 139
    
       48 entree_sorties: key_write key_parenthese_ouvrante key_guillemets phrase key_guillemets key_virgule key_idf key_virgule . key_guillemets key_point key_guillemets key_parenthese_fermante
    
        key_guillemets  décalage et aller à l'état 143
    
    
    état 140
    
       55 explogique: key_idf key_point operateur_comp key_point key_parenthese_ouvrante key_idf . operateur key_entier key_parenthese_fermante key_point operateur_log key_point key_parenthese_ouvrante key_idf key_point operateur_comp key_point opa key_parenthese_fermante
    
        key_plus            décalage et aller à l'état 91
        key_soustraction    décalage et aller à l'état 92
        key_division        décalage et aller à l'état 93
        key_multiplication  décalage et aller à l'état 94
    
        operateur  aller à l'état 144
    
    
    état 141
    
       43 operand: key_idf key_parenthese_ouvrante key_entier key_virgule key_entier key_parenthese_fermante .
    
        $défaut  réduction par utilisation de la règle 43 (operand)
    
    
    état 142
    
       51 condition: key_idf key_parenthese_ouvrante explogique key_parenthese_fermante key_then inst condition key_else . inst key_endif
    
        key_read         décalage et aller à l'état 21
        key_write        décalage et aller à l'état 22
        key_dowhile      décalage et aller à l'état 23
        key_call         décalage et aller à l'état 24
        key_equivalence  décalage et aller à l'état 25
        key_idf          décalage et aller à l'état 26
    
        inst            aller à l'état 145
        affectation     aller à l'état 28
        entree_sorties  aller à l'état 29
        condition       aller à l'état 30
        boucle          aller à l'état 31
        appel_fonction  aller à l'état 32
        equivalence     aller à l'état 33
    
    
    état 143
    
       48 entree_sorties: key_write key_parenthese_ouvrante key_guillemets phrase key_guillemets key_virgule key_idf key_virgule key_guillemets . key_point key_guillemets key_parenthese_fermante
    
        key_point  décalage et aller à l'état 146
    
    
    état 144
    
       55 explogique: key_idf key_point operateur_comp key_point key_parenthese_ouvrante key_idf operateur . key_entier key_parenthese_fermante key_point operateur_log key_point key_parenthese_ouvrante key_idf key_point operateur_comp key_point opa key_parenthese_fermante
    
        key_entier  décalage et aller à l'état 147
    
    
    état 145
    
       51 condition: key_idf key_parenthese_ouvrante explogique key_parenthese_fermante key_then inst condition key_else inst . key_endif
       52          | inst .
    
        key_endif  décalage et aller à l'état 148
    
        key_endif  [réduction par utilisation de la règle 52 (condition)]
        $défaut   réduction par utilisation de la règle 52 (condition)
    
    
    état 146
    
       48 entree_sorties: key_write key_parenthese_ouvrante key_guillemets phrase key_guillemets key_virgule key_idf key_virgule key_guillemets key_point . key_guillemets key_parenthese_fermante
    
        key_guillemets  décalage et aller à l'état 149
    
    
    état 147
    
       55 explogique: key_idf key_point operateur_comp key_point key_parenthese_ouvrante key_idf operateur key_entier . key_parenthese_fermante key_point operateur_log key_point key_parenthese_ouvrante key_idf key_point operateur_comp key_point opa key_parenthese_fermante
    
        key_parenthese_fermante  décalage et aller à l'état 150
    
    
    état 148
    
       51 condition: key_idf key_parenthese_ouvrante explogique key_parenthese_fermante key_then inst condition key_else inst key_endif .
    
        $défaut  réduction par utilisation de la règle 51 (condition)
    
    
    état 149
    
       48 entree_sorties: key_write key_parenthese_ouvrante key_guillemets phrase key_guillemets key_virgule key_idf key_virgule key_guillemets key_point key_guillemets . key_parenthese_fermante
    
        key_parenthese_fermante  décalage et aller à l'état 151
    
    
    état 150
    
       55 explogique: key_idf key_point operateur_comp key_point key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante . key_point operateur_log key_point key_parenthese_ouvrante key_idf key_point operateur_comp key_point opa key_parenthese_fermante
    
        key_point  décalage et aller à l'état 152
    
    
    état 151
    
       48 entree_sorties: key_write key_parenthese_ouvrante key_guillemets phrase key_guillemets key_virgule key_idf key_virgule key_guillemets key_point key_guillemets key_parenthese_fermante .
    
        $défaut  réduction par utilisation de la règle 48 (entree_sorties)
    
    
    état 152
    
       55 explogique: key_idf key_point operateur_comp key_point key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante key_point . operateur_log key_point key_parenthese_ouvrante key_idf key_point operateur_comp key_point opa key_parenthese_fermante
    
        key_end  décalage et aller à l'état 153
        key_or   décalage et aller à l'état 154
    
        operateur_log  aller à l'état 155
    
    
    état 153
    
       65 operateur_log: key_end .
    
        $défaut  réduction par utilisation de la règle 65 (operateur_log)
    
    
    état 154
    
       64 operateur_log: key_or .
    
        $défaut  réduction par utilisation de la règle 64 (operateur_log)
    
    
    état 155
    
       55 explogique: key_idf key_point operateur_comp key_point key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante key_point operateur_log . key_point key_parenthese_ouvrante key_idf key_point operateur_comp key_point opa key_parenthese_fermante
    
        key_point  décalage et aller à l'état 156
    
    
    état 156
    
       55 explogique: key_idf key_point operateur_comp key_point key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante key_point operateur_log key_point . key_parenthese_ouvrante key_idf key_point operateur_comp key_point opa key_parenthese_fermante
    
        key_parenthese_ouvrante  décalage et aller à l'état 157
    
    
    état 157
    
       55 explogique: key_idf key_point operateur_comp key_point key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante key_point operateur_log key_point key_parenthese_ouvrante . key_idf key_point operateur_comp key_point opa key_parenthese_fermante
    
        key_idf  décalage et aller à l'état 158
    
    
    état 158
    
       55 explogique: key_idf key_point operateur_comp key_point key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante key_point operateur_log key_point key_parenthese_ouvrante key_idf . key_point operateur_comp key_point opa key_parenthese_fermante
    
        key_point  décalage et aller à l'état 159
    
    
    état 159
    
       55 explogique: key_idf key_point operateur_comp key_point key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante key_point operateur_log key_point key_parenthese_ouvrante key_idf key_point . operateur_comp key_point opa key_parenthese_fermante
    
        key_lt  décalage et aller à l'état 106
        key_le  décalage et aller à l'état 107
        key_ne  décalage et aller à l'état 108
        key_eq  décalage et aller à l'état 109
        key_ge  décalage et aller à l'état 110
        key_gt  décalage et aller à l'état 111
    
        operateur_comp  aller à l'état 160
    
    
    état 160
    
       55 explogique: key_idf key_point operateur_comp key_point key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante key_point operateur_log key_point key_parenthese_ouvrante key_idf key_point operateur_comp . key_point opa key_parenthese_fermante
    
        key_point  décalage et aller à l'état 161
    
    
    état 161
    
       55 explogique: key_idf key_point operateur_comp key_point key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante key_point operateur_log key_point key_parenthese_ouvrante key_idf key_point operateur_comp key_point . opa key_parenthese_fermante
    
        key_false  décalage et aller à l'état 162
        key_true   décalage et aller à l'état 163
    
        opa  aller à l'état 164
    
    
    état 162
    
       63 opa: key_false .
    
        $défaut  réduction par utilisation de la règle 63 (opa)
    
    
    état 163
    
       62 opa: key_true .
    
        $défaut  réduction par utilisation de la règle 62 (opa)
    
    
    état 164
    
       55 explogique: key_idf key_point operateur_comp key_point key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante key_point operateur_log key_point key_parenthese_ouvrante key_idf key_point operateur_comp key_point opa . key_parenthese_fermante
    
        key_parenthese_fermante  décalage et aller à l'état 165
    
    
    état 165
    
       55 explogique: key_idf key_point operateur_comp key_point key_parenthese_ouvrante key_idf operateur key_entier key_parenthese_fermante key_point operateur_log key_point key_parenthese_ouvrante key_idf key_point operateur_comp key_point opa key_parenthese_fermante .
    
        $défaut  réduction par utilisation de la règle 55 (explogique)

  4. #4
    Invité régulier
    Homme Profil pro
    Inscrit en
    décembre 2012
    Messages
    9
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Algérie

    Informations forums :
    Inscription : décembre 2012
    Messages : 9
    Points : 6
    Points
    6

    Par défaut

    Tu as des conflits dans la table de définitions des symboles, revois ton cour ensuite ta grammaire

  5. #5
    Invité de passage
    Femme Profil pro Selma
    Etudiante 3éme année Informatique Academique
    Inscrit en
    avril 2012
    Messages
    14
    Détails du profil
    Informations personnelles :
    Nom : Femme Selma
    Localisation : Algérie

    Informations professionnelles :
    Activité : Etudiante 3éme année Informatique Academique

    Informations forums :
    Inscription : avril 2012
    Messages : 14
    Points : 2
    Points
    2

    Par défaut

    Non, le problème était plutôt dans la grammaire, car elle était loin d’être déterministe !

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •