convert/Parserv5/tables.py

   1 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   2 # ======================================================================
   3 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
   4 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   5 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   6 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   7 # (AT YOUR OPTION) ANY LATER VERSION.
   8 #
   9 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  10 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  11 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  12 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  13 #
  14 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  15 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  16 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  17 #
  18 #
  19 # ======================================================================
  20
  21 """
  22     Ce fichier définit une table de tags à utiliser avec le package
  23     mxTextTools pour décoder un fichier au format Asterv5.
  24
  25     XXX Ce fichier doit etre corrigé pour incorporer deux modifications
  26     réalisées dans la version V1_1p1 d'EFICAS
  27 """
  28 try :
  29     from TextTools import *
  30 except :
  31     ""
  32
  33 #
  34 __version__="$Name:  $"
  35 __Id__="$Id: tables.py,v 1.2 2003/07/01 10:26:14 salome Exp $"
  36 #
  37
  38 err0='ERR0 , erreur non identifiee : '
  39 err1='ERR1 , arguments commande errones : '
  40 err2='ERR2 , parenthese obligatoire : '
  41 err3='ERR3 , point virgule obligatoire : '
  42 err4='ERR4 , ":" obligatoire avant mot cle : '
  43 err5='ERR5 , mot cle facteur ou arg obligatoire : '
  44 err6='ERR6 , identificateur obligatoire : '
  45 err7='ERR7 , mot cle facteur errone : '
  46 err8='ERR8 , signe = ou ( attendu : '
  47 err9='ERR9 , ( attendue : '
  48 err10='ERR10 , vexpr attendue : '
  49 err11='ERR11 , ) attendue : '
  50
  51 ERRORS=(err0,err1,err2,err3,err4,err5,err6,err7,err8,err9,
  52         err10,err11)
  53
  54 try :
  55     delim=" ();:=,!&*/%\n"
  56
  57     whitespace = \
  58         (None,AllIn,' \t')
  59
  60     opt_whitespace = \
  61         whitespace      + (MatchOk,)
  62
  63     t_opt_whitespace = \
  64         whitespace      + (+1,)
  65
  66     t_opt_whitenl = \
  67       (None,AllIn,' \t\n\r',+1)
  68
  69     t_err = (
  70         (None,AllNotIn,';',+1),
  71         (None,Is,';'),
  72         (None,Skip,-1),
  73     )
  74
  75     commespaces = \
  76         ('comments',Table,(
  77           (None,IsInSet,white_set,+1,+4),
  78           (None,Is,'%',MatchFail),
  79           # <comment>
  80           (None,AllNotIn,'\n\r',+1),
  81           (None,AllIn,'\n\r',+1),
  82           # <blancs>
  83           (None,AllInSet,white_set,+1),
  84           (None,Is,'%',MatchOk,-3),
  85         ))
  86
  87     t_commespaces = (
  88           (None,IsInSet,white_set,+1,+4),
  89           (None,Is,'%',MatchFail),
  90           # <comment>
  91           (None,AllNotIn,'\n\r',+1),
  92           (None,AllIn,'\n\r',+1),
  93           # <blancs>
  94           (None,AllInSet,white_set,+1),
  95           (None,Is,'%',MatchOk,-3),
  96     )
  97
  98     x_commespaces = \
  99         ('comments',Table,(
 100              # <debut>
 101              (None,Is,'%',+3,+1),
 102                 (None,AllNotIn,'\n\r',+1),
 103                 (None,AllIn,'\n\r',+1,-2),
 104              (None,AllInSet,white_set,+1,-3),
 105         ))
 106
 107     t_ident = \
 108         ('ident',Table,(
 109           (None,IsIn,alpha+'_'),
 110           (None,AllIn,alpha+'_'+number,MatchOk),
 111         ))
 112
 113     t_identificateur = (
 114           (None,IsIn,alpha+'_'),
 115           (None,AllIn,alpha+'_'+number,MatchOk),
 116     )
 117
 118     t_identmc = (
 119           (None,IsIn,alpha+'_'),
 120           (None,AllIn,alpha+'_'+number,+1),
 121           (None,Table,t_commespaces,+1),
 122           (None,Is,':',MatchFail),
 123     )
 124
 125     n_ident = \
 126         (None,Table,(
 127           (None,IsIn,alpha+'_'),
 128           (None,AllIn,alpha+'_'+number,MatchOk),
 129         ))
 130
 131     n_string = \
 132         (None,Table,(
 133           (None,Is,"'"),
 134           # <loop>
 135           (None,AllNotIn,"'",+1),
 136           (None,Word,"''",+1,-1),
 137           (None,Is,"'",MatchFail,MatchOk),
 138         ))
 139
 140     t_number = \
 141         ('num',Table,(
 142           (None,IsIn,'-+',+1),
 143           (None,Is,'.',+2),
 144           (None,IsIn,number,MatchFail,+4),
 145           # <entiere>
 146           (None,IsIn,number,MatchFail),
 147           (None,AllIn,number,+1),
 148           (None,Is,'.',+2),
 149           # <decimal>
 150           (None,AllIn,number,+1),
 151           # <exposant>                      # si pas exposant termine number trouve
 152           (None,IsIn,'deDE',MatchOk),
 153           (None,IsIn,'-+',+1),
 154           (None,AllIn,number,MatchFail,MatchOk),
 155         ))
 156
 157     n_number = \
 158         (None,Table,(
 159           (None,IsIn,'-+',+1),
 160           (None,Is,'.',+2),
 161           (None,IsIn,number,MatchFail,+4),
 162           # <entiere>
 163           (None,IsIn,number,MatchFail),
 164           (None,AllIn,number,+1),
 165           (None,Is,'.',+2),
 166           # <decimal>
 167           (None,AllIn,number,+1),
 168           # <exposant>                      # si pas exposant termine number trouve
 169           (None,IsIn,'deDE',MatchOk),
 170           (None,IsIn,'-+',+1),
 171           (None,AllIn,number,MatchFail,MatchOk),
 172         ))
 173
 174     t_complexe = \
 175       ('CPLX',Table,(
 176         ("RI",Word,'RI',+7),
 177         commespaces     + (+1,),
 178         t_number        + (MatchFail,),      # ce n est pas un complexe
 179         commespaces     + (+1,),             # a partir d ici c est un complexe => produire erreurs
 180         (None,Is,',',+1),
 181         commespaces     + (+1,),
 182         t_number        + (MatchFail,MatchOk),
 183         # <mp>
 184         ("MP",Word,'MP',MatchFail),
 185         commespaces     + (+1,),
 186         t_number        + (MatchFail,),      # ce n est pas un complexe
 187         commespaces     + (+1,),             # a partir d ici c est un complexe => produire erreurs
 188         (None,Is,',',+1),
 189         commespaces     + (+1,),
 190         t_number        + (MatchFail,MatchOk),
 191         # <err>
 192         (err7,Table,t_err,MatchFail,MatchOk),
 193       ))
 194
 195     # Table pour identifier le keyword PI
 196
 197     t_PI = \
 198         ('PI',Table,(
 199           (None,Word,'PI',MatchFail),
 200           (None,IsIn,alpha+'_'+number,MatchOk,+1),
 201           (None,Skip,-1),
 202           (None,Jump,To,MatchFail),
 203         ))
 204
 205     t_vexpr = (
 206         ('par',Is,'(',+5,+1),
 207           commespaces     + (+1,),
 208           ('vexpr',Table,ThisTable,+26),
 209           commespaces     + (+1,),
 210           ('par2',Is,')',+25,+15),
 211         t_number        + (+1,+14),
 212         t_complexe      + (+1,+13),
 213         ('sign',IsIn,'+-',+3,+1),
 214           commespaces     + (+1,),
 215           ('vexpr',Table,ThisTable,+19,+10),
 216         t_PI            + (+1,+9),
 217         t_ident         + (MatchFail,),
 218         commespaces     + (+1,),
 219         ('listpar',Is,'(',+6,+1), # on peut avoir une liste de parametres
 220           # <params>
 221           commespaces     + (+1,),
 222           ('param',Table,ThisTable,+13),
 223           commespaces     + (+1,),
 224           (None,Is,',',+1,-3),
 225           ('finlist',Is,')',+11),
 226         # <op>
 227         commespaces     + (+1,),
 228         ('exp',Word,'**',+3,+1),
 229           commespaces     + (+1,),
 230           ('vexpr',Table,ThisTable,+6,MatchOk),
 231         ('op',IsIn,'+-*/',+3,+1),
 232           commespaces     + (+1,),
 233           ('vexpr',Table,ThisTable,+3,MatchOk),
 234         (None,Jump,To,MatchOk),
 235         # <err>
 236         (err0,Table,t_err,MatchFail,MatchOk),
 237         # <err10>
 238         (err10,Table,t_err,MatchFail,MatchOk),
 239         # <err9>
 240         (err9,Table,t_err,MatchFail,MatchOk),
 241     )
 242
 243     t_liste_param = \
 244       ('liste',Table,(
 245         t_ident,
 246         commespaces     + (+1,),
 247         (None,Is,'('),
 248         commespaces     + (+1,),
 249         t_vexpr         + (MatchFail,),
 250         # <suite>
 251         commespaces     + (+1,),
 252         (None,Is,',',+3),
 253         commespaces     + (+1,),
 254         t_vexpr         + (+3,-3),
 255         # <fin>
 256         commespaces     + (+1,),
 257         (None,Is,')',+1,MatchOk),
 258         # <err>
 259         (err7,Table,t_err,MatchFail,MatchOk),
 260       ))
 261
 262     t_eval_expr = \
 263       ('EVAL',Table,(
 264         (None,Word,'EVAL'),
 265         commespaces     + (+1,),
 266         (None,Is,'(',+5),
 267         commespaces     + (+1,),
 268         ('vexpr',Table,t_vexpr,+3),
 269         commespaces     + (+1,),
 270         (None,Is,')',+1,MatchOk),
 271         # <err>
 272         (err7,Table,t_err,MatchFail,MatchOk),
 273       ))
 274
 275     t_entier = \
 276         ('entier',Table,(
 277           (None,IsIn,number),
 278           (None,AllIn,number,+1),
 279           (None,IsIn,delim,MatchFail,+1),
 280           (None,Skip,-1),
 281         ))
 282
 283     t_comment = \
 284       ('comment',Table,(
 285          (None,Is,'%'),
 286          (None,AllNotIn,'\n\r',+1),
 287          (None,AllIn,'\n\r',MatchOk),
 288       ))
 289
 290     t_nullline = \
 291       ('Null',AllIn,' ;\t\n\r')
 292
 293     t_passline = \
 294       ('passline',Table,(
 295         (None,AllNotIn,newline,+1),
 296         (None,IsIn,newline),
 297       ))
 298
 299     t_reste = \
 300       ('reste',Table,(
 301         (None,AllNotIn,';',+1),
 302       ))
 303
 304     t_rest2 = \
 305       ('reste',Table,(
 306         (None,AllNotIn,';',+1),
 307         (None,Is,';'),
 308         (None,AllNotIn,'\n',+1),
 309         (None,Is,'\n',MatchOk,MatchOk),
 310       ))
 311
 312     t_formule = \
 313       ('formule',Table,(
 314         commespaces     + (+1,),
 315         (None,Word,'!FORMULE'),
 316         commespaces     + (+1,),
 317         (None,Is,'(',+32),
 318         commespaces     + (+1,),
 319         ('type',Table,t_identificateur,+29),
 320         commespaces     + (+1,),
 321         (None,Is,':',+27),
 322         commespaces     + (+1,),
 323         (None,Is,'(',+26),
 324         commespaces     + (+1,),
 325         ('id',Table,t_identificateur,+23),
 326         commespaces     + (+1,),
 327         (None,Is,'(',+22),
 328         # <params>
 329         commespaces     + (+1,),
 330         ('typ',Table,t_identmc,+1),
 331         commespaces     + (+1,),
 332         ('id',Table,t_identificateur,+17),
 333         commespaces     + (+1,),
 334         (None,Is,',',+1,-5),
 335         commespaces     + (+1,),
 336         (None,Is,')',-7),
 337         commespaces     + (+1,),
 338         (None,Is,'=',+11),
 339         commespaces     + (+1,),
 340         ('vexpr',Table,t_vexpr,+9),
 341         commespaces     + (+1,),
 342         (None,Is,')',+9),
 343         commespaces     + (+1,),
 344         (None,Is,')',+7),
 345         commespaces     + (+1,),
 346         (None,Is,';',+3),
 347         (None,AllNotIn,'\n',+1),
 348         (None,Is,'\n',MatchOk,MatchOk),
 349         # <err>
 350         (err0,Table,t_err,MatchFail,MatchOk),
 351         # <err9>
 352         (err9,Table,t_err,MatchFail,MatchOk),
 353         # <err11>
 354         (err11,Table,t_err,MatchFail,MatchOk),
 355       ))
 356
 357     t_nom_ope = \
 358         ('nom_ope',Table,(
 359           (None,Word,'EVAL',+1,MatchFail),  # EVAL n est pas un nom d operateur, il est reserve
 360           (None,IsIn,alpha+'_'),
 361           (None,AllIn,alpha+'_'+number,+1),
 362           commespaces     + (+1,),
 363           (None,Is,'(',MatchFail),
 364           (None,Skip,-1),
 365         ))
 366
 367     t_arg = \
 368       ('arg',Table,(
 369         n_string        + (+1,MatchOk),
 370         n_ident,
 371       ))
 372
 373     t_larg = \
 374       ('larg',Table,(
 375         (None,Is,'(',MatchFail),
 376         # <arg>
 377         commespaces     + (+1,),
 378         t_complexe      + (+1,+4),
 379         t_number        + (+1,+3),
 380         t_eval_expr     + (+1,+2),
 381         t_arg           + (MatchFail,+1),
 382         # <suite>
 383         commespaces     + (+1,),
 384         (None,Is,',',+1),
 385         (None,Is,')',-7,MatchOk),
 386       ))
 387
 388     t_mcf = \
 389       ('mcf',Table,(
 390         (None,Is,'(',MatchFail),
 391         ("comments",Table,t_commespaces,+1),
 392         (None,Is,')',+1,MatchOk),
 393         t_ident         + (MatchFail,),
 394         ("comments",Table,t_commespaces,+1),
 395         (None,Is,':',MatchFail),            # a partir d ici on est dans un mot cle facteur (erreurs eventuelles)
 396         # <args>
 397         ("comments",Table,t_commespaces,+1),
 398         t_larg          + (+1,+5),
 399         t_complexe      + (+1,+4),
 400         t_number        + (+1,+3),
 401         t_eval_expr     + (+1,+2),
 402         t_arg           + (+8,),
 403         # <suite>
 404         ("comments",Table,t_commespaces,+1),
 405         (None,Is,',',+1),
 406         ("comments",Table,t_commespaces,+1),
 407         (None,Is,')',+1,MatchOk),
 408         t_ident         + (+3,),
 409         ("comments",Table,t_commespaces,+1),
 410         (None,Is,':',+1,-12),
 411         # <err>
 412         (err7,Table,t_err,MatchFail,MatchOk),
 413       ))
 414
 415     t_comm = \
 416       ('comm',Table,(                        # on attend les arguments entre () sinon erreur
 417         (None,Is,'(',+21),
 418         commespaces     + (+1,),
 419         (None,Is,')',+1,MatchOk),
 420         # <call>
 421         t_ident         + (+18,),
 422         commespaces     + (+1,),
 423         (None,Is,':',+16),
 424         commespaces     + (+1,),
 425         t_mcf           + (+5,),
 426         # <mcfsuite>
 427         commespaces     + (+1,),
 428         (None,Is,',',+1),
 429         commespaces     + (+1,),
 430         t_mcf           + (+7,-3),
 431         # <args>
 432         t_larg          + (+1,+5),
 433         t_complexe      + (+1,+4),
 434         t_number        + (+1,+3),
 435         t_eval_expr     + (+1,+2),
 436         t_arg           + (+5,),
 437         # <suite>
 438         commespaces     + (+1,),
 439         # <sep>
 440         (None,Is,',',+1),
 441         commespaces     + (+1,),
 442         (None,Is,')',-17,MatchOk),
 443         # <err>
 444         (err1,Table,t_err,MatchFail,MatchOk),
 445       ))
 446
 447     t_affe = \
 448       ('affe',Table,(
 449         commespaces     + (+1,),
 450         t_larg          + (+1,+6),
 451         t_complexe      + (+1,+5),
 452         t_number        + (+1,+4),
 453         t_eval_expr     + (+1,+3),
 454         t_arg           + (+1,+2),
 455         (None,Jump,To,+2),
 456         # <suite>
 457         (None,Jump,To,MatchOk),
 458         # <err>
 459         (err0,Table,t_err,MatchFail,MatchOk),
 460       ))
 461
 462     t_reuse = \
 463       ('reuse',Table,(
 464         t_opt_whitespace,
 465         t_ident,
 466         t_opt_whitespace,
 467         (None,Is,'=',+5),
 468         t_opt_whitespace,
 469         t_nom_ope       + (+2,+1),
 470         # <comm>
 471         t_comm          + (MatchFail,MatchOk),
 472         # <affe>
 473         t_affe          + (MatchFail,MatchOk),
 474         # <err>
 475         (err8,Table,t_err,MatchFail,MatchOk),
 476       ))
 477
 478     t_noreuse = \
 479       ('noreuse',Table,(
 480         t_opt_whitespace,
 481         t_ident,
 482         t_opt_whitenl,
 483         (None,Is,'=',+3,+1),     # on a affaire a un operateur ou une affectation
 484           t_opt_whitespace,
 485           t_nom_ope       + (+4,+3),
 486         (None,Is,'(',+5,+1),
 487         (None,Skip,-1),
 488         # <comm>
 489         t_comm          + (+2,MatchOk),
 490         # <affe>
 491         t_affe          + (+1,MatchOk),
 492         # <err>
 493         (err0,Table,t_err,MatchFail,MatchOk),
 494         # <err8>
 495         (err8,Table,t_err,MatchFail,MatchOk),
 496       ))
 497
 498     t_fin = \
 499       ('commande',Table,(
 500         ('noreuse',Table,(
 501           t_opt_whitespace,
 502           ('ident',Word,"FIN"),
 503           t_opt_whitenl,
 504           (None,Is,'(',MatchFail),          # On est vraiment sur d avoir la commande FIN apres avoir identifie (
 505           # On recule d un caractere pour identifier les arguments entre parenthèses
 506           (None,Skip,-1),
 507           t_comm          + (+1,MatchOk),
 508           (err0,Table,t_err,MatchFail,MatchOk),
 509         )),
 510         commespaces     + (+1,),
 511         (None,Is,';',+1,MatchOk),
 512         # <err>
 513         (err0,Table,t_err,MatchFail,MatchOk),
 514       ))
 515
 516     t_commande = \
 517       ('commande',Table,(
 518         t_opt_whitespace,
 519         (None,Is,'&',+2,+1),
 520           t_reuse         + (MatchFail,+2),
 521         t_noreuse       + (MatchFail,),
 522         # <fin>
 523         commespaces     + (+1,),
 524         (None,Is,';',+1,MatchOk),
 525         # <err>
 526         (err0,Table,t_err,MatchFail,MatchOk),
 527       ))
 528
 529     aster_script = (
 530       # <top>
 531       t_nullline      + (+1,+0),
 532       t_comment       + (+1,-1),
 533       t_formule       + (+1,-2),
 534       t_fin           + (+1,+4),
 535       t_commande      + (+1,-4),
 536       t_passline      + (+1,-5),
 537       (None,EOF,Here,-6),
 538       # <AfterFin>
 539       t_nullline      + (+1,+0),
 540       t_passline      + (+1,-1),
 541       (None,EOF,Here,-2),
 542     )
 543
 544 except:
 545     print "Textools non importe"
 546