convert/Parserv5/tables.py

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