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