convert/Parserv5/tables.py

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