code.delx.au - gnu-emacs/blob - lisp/cedet/semantic/wisent/python-wy.el

   1 ;;; semantic/wisent/python-wy.el --- Generated parser support file
   2
   3 ;; Copyright (C) 2002, 2003, 2004, 2007, 2010, 2011
   4 ;; Free Software Foundation, Inc.
   5
   6 ;; This file is part of GNU Emacs.
   7
   8 ;; GNU Emacs is free software: you can redistribute it and/or modify
   9 ;; it under the terms of the GNU General Public License as published by
  10 ;; the Free Software Foundation, either version 3 of the License, or
  11 ;; (at your option) any later version.
  12
  13 ;; GNU Emacs is distributed in the hope that it will be useful,
  14 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 ;; GNU General Public License for more details.
  17
  18 ;; You should have received a copy of the GNU General Public License
  19 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 ;;; Commentary:
  22 ;;
  23 ;; This file was generated from the grammar file
  24 ;; semantic/wisent/wisent-python.wy in the CEDET repository.
  25
  26 ;;; Code:
  27
  28 (require 'semantic/lex)
  29 \f
  30 ;;; Prologue
  31 ;;
  32 \f
  33 ;;; Declarations
  34 ;;
  35 (defconst wisent-python-wy--keyword-table
  36   (semantic-lex-make-keyword-table
  37    '(("and" . AND)
  38      ("as" . AS)
  39      ("assert" . ASSERT)
  40      ("break" . BREAK)
  41      ("class" . CLASS)
  42      ("continue" . CONTINUE)
  43      ("def" . DEF)
  44      ("del" . DEL)
  45      ("elif" . ELIF)
  46      ("else" . ELSE)
  47      ("except" . EXCEPT)
  48      ("exec" . EXEC)
  49      ("finally" . FINALLY)
  50      ("for" . FOR)
  51      ("from" . FROM)
  52      ("global" . GLOBAL)
  53      ("if" . IF)
  54      ("import" . IMPORT)
  55      ("in" . IN)
  56      ("is" . IS)
  57      ("lambda" . LAMBDA)
  58      ("not" . NOT)
  59      ("or" . OR)
  60      ("pass" . PASS)
  61      ("print" . PRINT)
  62      ("raise" . RAISE)
  63      ("return" . RETURN)
  64      ("try" . TRY)
  65      ("while" . WHILE)
  66      ("yield" . YIELD))
  67    '(("yield" summary "Create a generator function")
  68      ("while" summary "Start a 'while' loop")
  69      ("try" summary "Start of statements protected by exception handlers")
  70      ("return" summary "Return from a function")
  71      ("raise" summary "Raise an exception")
  72      ("print" summary "Print each argument to standard output")
  73      ("pass" summary "Statement that does nothing")
  74      ("or" summary "Binary logical 'or' operator")
  75      ("not" summary "Unary boolean negation operator")
  76      ("lambda" summary "Create anonymous function")
  77      ("is" summary "Binary operator that tests for object equality")
  78      ("in" summary "Part of 'for' statement ")
  79      ("import" summary "Load specified modules")
  80      ("if" summary "Start 'if' conditional statement")
  81      ("global" summary "Declare one or more symbols as global symbols")
  82      ("from" summary "Modify behavior of 'import' statement")
  83      ("for" summary "Start a 'for' loop")
  84      ("finally" summary "Specify code to be executed after 'try' statements whether or not an exception occurred")
  85      ("exec" summary "Dynamically execute Python code")
  86      ("except" summary "Specify exception handlers along with 'try' keyword")
  87      ("else" summary "Start the 'else' clause following an 'if' statement")
  88      ("elif" summary "Shorthand for 'else if' following an 'if' statement")
  89      ("del" summary "Delete specified objects, i.e., undo what assignment did")
  90      ("def" summary "Define a new function")
  91      ("continue" summary "Skip to the next iteration of enclosing 'for' or 'while' loop")
  92      ("class" summary "Define a new class")
  93      ("break" summary "Terminate 'for' or 'while' loop")
  94      ("assert" summary "Raise AssertionError exception if <expr> is false")
  95      ("as" summary "EXPR as NAME makes value of EXPR available as variable NAME")
  96      ("and" summary "Logical AND binary operator ... ")))
  97   "Table of language keywords.")
  98
  99 (defconst wisent-python-wy--token-table
 100   (semantic-lex-make-type-table
 101    '(("symbol"
 102       (NAME))
 103      ("number"
 104       (NUMBER_LITERAL))
 105      ("string"
 106       (STRING_LITERAL))
 107      ("punctuation"
 108       (BACKQUOTE . "`")
 109       (ASSIGN . "=")
 110       (COMMA . ",")
 111       (SEMICOLON . ";")
 112       (COLON . ":")
 113       (BAR . "|")
 114       (TILDE . "~")
 115       (PERIOD . ".")
 116       (MINUS . "-")
 117       (PLUS . "+")
 118       (MOD . "%")
 119       (DIV . "/")
 120       (MULT . "*")
 121       (AMP . "&")
 122       (GT . ">")
 123       (LT . "<")
 124       (HAT . "^")
 125       (NE . "!=")
 126       (LTGT . "<>")
 127       (HATEQ . "^=")
 128       (OREQ . "|=")
 129       (AMPEQ . "&=")
 130       (MODEQ . "%=")
 131       (DIVEQ . "/=")
 132       (MULTEQ . "*=")
 133       (MINUSEQ . "-=")
 134       (PLUSEQ . "+=")
 135       (LE . "<=")
 136       (GE . ">=")
 137       (EQ . "==")
 138       (EXPONENT . "**")
 139       (GTGT . ">>")
 140       (LTLT . "<<")
 141       (DIVDIV . "//")
 142       (DIVDIVEQ . "//=")
 143       (EXPEQ . "**=")
 144       (GTGTEQ . ">>=")
 145       (LTLTEQ . "<<="))
 146      ("close-paren"
 147       (RBRACK . "]")
 148       (RBRACE . "}")
 149       (RPAREN . ")"))
 150      ("open-paren"
 151       (LBRACK . "[")
 152       (LBRACE . "{")
 153       (LPAREN . "("))
 154      ("block"
 155       (BRACK_BLOCK . "(LBRACK RBRACK)")
 156       (BRACE_BLOCK . "(LBRACE RBRACE)")
 157       (PAREN_BLOCK . "(LPAREN RPAREN)"))
 158      ("indentation"
 159       (INDENT_BLOCK . "(INDENT DEDENT)")
 160       (DEDENT . "[^:INDENT:]")
 161       (INDENT . "^\\s-+"))
 162      ("newline"
 163       (NEWLINE . "\n"))
 164      ("charquote"
 165       (BACKSLASH . "\\")))
 166    '(("keyword" :declared t)
 167      ("symbol" :declared t)
 168      ("number" :declared t)
 169      ("punctuation" :declared t)
 170      ("block" :declared t)))
 171   "Table of lexical tokens.")
 172
 173 (defconst wisent-python-wy--parse-table
 174   (progn
 175     (eval-when-compile
 176       (require 'semantic/wisent/comp))
 177     (wisent-compile-grammar
 178      '((BACKSLASH NEWLINE INDENT DEDENT INDENT_BLOCK PAREN_BLOCK BRACE_BLOCK BRACK_BLOCK LPAREN RPAREN LBRACE RBRACE LBRACK RBRACK LTLTEQ GTGTEQ EXPEQ DIVDIVEQ DIVDIV LTLT GTGT EXPONENT EQ GE LE PLUSEQ MINUSEQ MULTEQ DIVEQ MODEQ AMPEQ OREQ HATEQ LTGT NE HAT LT GT AMP MULT DIV MOD PLUS MINUS PERIOD TILDE BAR COLON SEMICOLON COMMA ASSIGN BACKQUOTE STRING_LITERAL NUMBER_LITERAL NAME AND AS ASSERT BREAK CLASS CONTINUE DEF DEL ELIF ELSE EXCEPT EXEC FINALLY FOR FROM GLOBAL IF IMPORT IN IS LAMBDA NOT OR PASS PRINT RAISE RETURN TRY WHILE YIELD)
 179        nil
 180        (goal
 181         ((NEWLINE))
 182         ((simple_stmt))
 183         ((compound_stmt)))
 184        (simple_stmt
 185         ((small_stmt_list semicolon_opt NEWLINE)))
 186        (small_stmt_list
 187         ((small_stmt))
 188         ((small_stmt_list SEMICOLON small_stmt)))
 189        (small_stmt
 190         ((expr_stmt))
 191         ((print_stmt))
 192         ((del_stmt))
 193         ((pass_stmt))
 194         ((flow_stmt))
 195         ((import_stmt))
 196         ((global_stmt))
 197         ((exec_stmt))
 198         ((assert_stmt)))
 199        (print_stmt
 200         ((PRINT print_stmt_trailer)
 201          (wisent-raw-tag
 202           (semantic-tag-new-code $1 nil))))
 203        (print_stmt_trailer
 204         ((test_list_opt)
 205          nil)
 206         ((GTGT test trailing_test_list_with_opt_comma_opt)
 207          nil))
 208        (trailing_test_list_with_opt_comma_opt
 209         (nil)
 210         ((trailing_test_list comma_opt)
 211          nil))
 212        (trailing_test_list
 213         ((COMMA test)
 214          nil)
 215         ((trailing_test_list COMMA test)
 216          nil))
 217        (expr_stmt
 218         ((testlist expr_stmt_trailer)
 219          (if
 220              (and $2
 221                   (stringp $1)
 222                   (string-match "^\\(\\sw\\|\\s_\\)+$" $1))
 223              (wisent-raw-tag
 224               (semantic-tag-new-variable $1 nil nil))
 225            (wisent-raw-tag
 226             (semantic-tag-new-code $1 nil)))))
 227        (expr_stmt_trailer
 228         ((augassign testlist))
 229         ((eq_testlist_zom)))
 230        (eq_testlist_zom
 231         (nil)
 232         ((eq_testlist_zom ASSIGN testlist)
 233          (identity $3)))
 234        (augassign
 235         ((PLUSEQ))
 236         ((MINUSEQ))
 237         ((MULTEQ))
 238         ((DIVEQ))
 239         ((MODEQ))
 240         ((AMPEQ))
 241         ((OREQ))
 242         ((HATEQ))
 243         ((LTLTEQ))
 244         ((GTGTEQ))
 245         ((EXPEQ))
 246         ((DIVDIVEQ)))
 247        (del_stmt
 248         ((DEL exprlist)
 249          (wisent-raw-tag
 250           (semantic-tag-new-code $1 nil))))
 251        (exprlist
 252         ((expr_list comma_opt)
 253          nil))
 254        (expr_list
 255         ((expr)
 256          nil)
 257         ((expr_list COMMA expr)
 258          nil))
 259        (pass_stmt
 260         ((PASS)
 261          (wisent-raw-tag
 262           (semantic-tag-new-code $1 nil))))
 263        (flow_stmt
 264         ((break_stmt))
 265         ((continue_stmt))
 266         ((return_stmt))
 267         ((raise_stmt))
 268         ((yield_stmt)))
 269        (break_stmt
 270         ((BREAK)
 271          (wisent-raw-tag
 272           (semantic-tag-new-code $1 nil))))
 273        (continue_stmt
 274         ((CONTINUE)
 275          (wisent-raw-tag
 276           (semantic-tag-new-code $1 nil))))
 277        (return_stmt
 278         ((RETURN testlist_opt)
 279          (wisent-raw-tag
 280           (semantic-tag-new-code $1 nil))))
 281        (testlist_opt
 282         (nil)
 283         ((testlist)
 284          nil))
 285        (yield_stmt
 286         ((YIELD)
 287          (wisent-raw-tag
 288           (semantic-tag-new-code $1 nil)))
 289         ((YIELD testlist)
 290          (wisent-raw-tag
 291           (semantic-tag-new-code $1 nil))))
 292        (raise_stmt
 293         ((RAISE zero_one_two_or_three_tests)
 294          (wisent-raw-tag
 295           (semantic-tag-new-code $1 nil))))
 296        (zero_one_two_or_three_tests
 297         (nil)
 298         ((test zero_one_or_two_tests)
 299          nil))
 300        (zero_one_or_two_tests
 301         (nil)
 302         ((COMMA test zero_or_one_comma_test)
 303          nil))
 304        (zero_or_one_comma_test
 305         (nil)
 306         ((COMMA test)
 307          nil))
 308        (import_stmt
 309         ((IMPORT dotted_as_name_list)
 310          (wisent-raw-tag
 311           (semantic-tag-new-include $2 nil)))
 312         ((FROM dotted_name IMPORT star_or_import_as_name_list)
 313          (wisent-raw-tag
 314           (semantic-tag-new-include $2 nil))))
 315        (dotted_as_name_list
 316         ((dotted_as_name))
 317         ((dotted_as_name_list COMMA dotted_as_name)))
 318        (star_or_import_as_name_list
 319         ((MULT)
 320          nil)
 321         ((import_as_name_list)
 322          nil))
 323        (import_as_name_list
 324         ((import_as_name)
 325          nil)
 326         ((import_as_name_list COMMA import_as_name)
 327          nil))
 328        (import_as_name
 329         ((NAME as_name_opt)
 330          nil))
 331        (dotted_as_name
 332         ((dotted_name as_name_opt)))
 333        (as_name_opt
 334         (nil)
 335         ((AS NAME)
 336          (identity $2)))
 337        (dotted_name
 338         ((NAME))
 339         ((dotted_name PERIOD NAME)
 340          (format "%s.%s" $1 $3)))
 341        (global_stmt
 342         ((GLOBAL comma_sep_name_list)
 343          (wisent-raw-tag
 344           (semantic-tag-new-code $1 nil))))
 345        (comma_sep_name_list
 346         ((NAME))
 347         ((comma_sep_name_list COMMA NAME)))
 348        (exec_stmt
 349         ((EXEC expr exec_trailer)
 350          (wisent-raw-tag
 351           (semantic-tag-new-code $1 nil))))
 352        (exec_trailer
 353         (nil)
 354         ((IN test comma_test_opt)
 355          nil))
 356        (comma_test_opt
 357         (nil)
 358         ((COMMA test)
 359          nil))
 360        (assert_stmt
 361         ((ASSERT test comma_test_opt)
 362          (wisent-raw-tag
 363           (semantic-tag-new-code $1 nil))))
 364        (compound_stmt
 365         ((if_stmt))
 366         ((while_stmt))
 367         ((for_stmt))
 368         ((try_stmt))
 369         ((funcdef))
 370         ((class_declaration)))
 371        (if_stmt
 372         ((IF test COLON suite elif_suite_pair_list else_suite_pair_opt)
 373          (wisent-raw-tag
 374           (semantic-tag-new-code $1 nil))))
 375        (elif_suite_pair_list
 376         (nil)
 377         ((elif_suite_pair_list ELIF test COLON suite)
 378          nil))
 379        (else_suite_pair_opt
 380         (nil)
 381         ((ELSE COLON suite)
 382          nil))
 383        (suite
 384         ((simple_stmt)
 385          (list $1))
 386         ((NEWLINE indented_block)
 387          (progn $2)))
 388        (indented_block
 389         ((INDENT_BLOCK)
 390          (semantic-parse-region
 391           (car $region1)
 392           (cdr $region1)
 393           'indented_block_body 1)))
 394        (indented_block_body
 395         ((INDENT)
 396          nil)
 397         ((DEDENT)
 398          nil)
 399         ((simple_stmt))
 400         ((compound_stmt)))
 401        (while_stmt
 402         ((WHILE test COLON suite else_suite_pair_opt)
 403          (wisent-raw-tag
 404           (semantic-tag-new-code $1 nil))))
 405        (for_stmt
 406         ((FOR exprlist IN testlist COLON suite else_suite_pair_opt)
 407          (wisent-raw-tag
 408           (semantic-tag-new-code $1 nil))))
 409        (try_stmt
 410         ((TRY COLON suite except_clause_suite_pair_list else_suite_pair_opt)
 411          (wisent-raw-tag
 412           (semantic-tag-new-code $1 nil)))
 413         ((TRY COLON suite FINALLY COLON suite)
 414          (wisent-raw-tag
 415           (semantic-tag-new-code $1 nil))))
 416        (except_clause_suite_pair_list
 417         ((except_clause COLON suite)
 418          nil)
 419         ((except_clause_suite_pair_list except_clause COLON suite)
 420          nil))
 421        (except_clause
 422         ((EXCEPT zero_one_or_two_test)
 423          nil))
 424        (zero_one_or_two_test
 425         (nil)
 426         ((test zero_or_one_comma_test)
 427          nil))
 428        (funcdef
 429         ((DEF NAME function_parameter_list COLON suite)
 430          (wisent-raw-tag
 431           (semantic-tag-new-function $2 nil $3))))
 432        (function_parameter_list
 433         ((PAREN_BLOCK)
 434          (let
 435              ((wisent-python-EXPANDING-block t))
 436            (semantic-parse-region
 437             (car $region1)
 438             (cdr $region1)
 439             'function_parameters 1))))
 440        (function_parameters
 441         ((LPAREN)
 442          nil)
 443         ((RPAREN)
 444          nil)
 445         ((function_parameter COMMA))
 446         ((function_parameter RPAREN)))
 447        (function_parameter
 448         ((fpdef_opt_test))
 449         ((MULT NAME)
 450          (wisent-raw-tag
 451           (semantic-tag-new-variable $2 nil nil)))
 452         ((EXPONENT NAME)
 453          (wisent-raw-tag
 454           (semantic-tag-new-variable $2 nil nil))))
 455        (class_declaration
 456         ((CLASS NAME paren_class_list_opt COLON suite)
 457          (wisent-raw-tag
 458           (semantic-tag-new-type $2 $1 $5
 459                                  (cons $3 nil)))))
 460        (paren_class_list_opt
 461         (nil)
 462         ((paren_class_list)))
 463        (paren_class_list
 464         ((PAREN_BLOCK)
 465          (let
 466              ((wisent-python-EXPANDING-block t))
 467            (mapcar 'semantic-tag-name
 468                    (semantic-parse-region
 469                     (car $region1)
 470                     (cdr $region1)
 471                     'paren_classes 1)))))
 472        (paren_classes
 473         ((LPAREN)
 474          nil)
 475         ((RPAREN)
 476          nil)
 477         ((paren_class COMMA)
 478          (wisent-raw-tag
 479           (semantic-tag-new-variable $1 nil nil)))
 480         ((paren_class RPAREN)
 481          (wisent-raw-tag
 482           (semantic-tag-new-variable $1 nil nil))))
 483        (paren_class
 484         ((dotted_name)))
 485        (test
 486         ((test_test))
 487         ((lambdef)))
 488        (test_test
 489         ((and_test))
 490         ((test_test OR and_test)
 491          nil))
 492        (and_test
 493         ((not_test))
 494         ((and_test AND not_test)
 495          nil))
 496        (not_test
 497         ((NOT not_test)
 498          nil)
 499         ((comparison)))
 500        (comparison
 501         ((expr))
 502         ((comparison comp_op expr)
 503          nil))
 504        (comp_op
 505         ((LT))
 506         ((GT))
 507         ((EQ))
 508         ((GE))
 509         ((LE))
 510         ((LTGT))
 511         ((NE))
 512         ((IN))
 513         ((NOT IN))
 514         ((IS))
 515         ((IS NOT)))
 516        (expr
 517         ((xor_expr))
 518         ((expr BAR xor_expr)
 519          nil))
 520        (xor_expr
 521         ((and_expr))
 522         ((xor_expr HAT and_expr)
 523          nil))
 524        (and_expr
 525         ((shift_expr))
 526         ((and_expr AMP shift_expr)
 527          nil))
 528        (shift_expr
 529         ((arith_expr))
 530         ((shift_expr shift_expr_operators arith_expr)
 531          nil))
 532        (shift_expr_operators
 533         ((LTLT))
 534         ((GTGT)))
 535        (arith_expr
 536         ((term))
 537         ((arith_expr plus_or_minus term)
 538          nil))
 539        (plus_or_minus
 540         ((PLUS))
 541         ((MINUS)))
 542        (term
 543         ((factor))
 544         ((term term_operator factor)
 545          nil))
 546        (term_operator
 547         ((MULT))
 548         ((DIV))
 549         ((MOD))
 550         ((DIVDIV)))
 551        (factor
 552         ((prefix_operators factor)
 553          nil)
 554         ((power)))
 555        (prefix_operators
 556         ((PLUS))
 557         ((MINUS))
 558         ((TILDE)))
 559        (power
 560         ((atom trailer_zom exponent_zom)
 561          (concat $1
 562                  (if $2
 563                      (concat " " $2 " ")
 564                    "")
 565                  (if $3
 566                      (concat " " $3)
 567                    ""))))
 568        (trailer_zom
 569         (nil)
 570         ((trailer_zom trailer)
 571          nil))
 572        (exponent_zom
 573         (nil)
 574         ((exponent_zom EXPONENT factor)
 575          nil))
 576        (trailer
 577         ((PAREN_BLOCK)
 578          nil)
 579         ((BRACK_BLOCK)
 580          nil)
 581         ((PERIOD NAME)
 582          nil))
 583        (atom
 584         ((PAREN_BLOCK)
 585          nil)
 586         ((BRACK_BLOCK)
 587          nil)
 588         ((BRACE_BLOCK)
 589          nil)
 590         ((BACKQUOTE testlist BACKQUOTE)
 591          nil)
 592         ((NAME))
 593         ((NUMBER_LITERAL))
 594         ((one_or_more_string)))
 595        (test_list_opt
 596         (nil)
 597         ((testlist)
 598          nil))
 599        (testlist
 600         ((comma_sep_test_list comma_opt)))
 601        (comma_sep_test_list
 602         ((test))
 603         ((comma_sep_test_list COMMA test)
 604          (format "%s, %s" $1 $3)))
 605        (one_or_more_string
 606         ((STRING_LITERAL))
 607         ((one_or_more_string STRING_LITERAL)
 608          (concat $1 $2)))
 609        (lambdef
 610         ((LAMBDA varargslist_opt COLON test)
 611          (format "%s %s" $1
 612                  (or $2 ""))))
 613        (varargslist_opt
 614         (nil)
 615         ((varargslist)))
 616        (varargslist
 617         ((fpdef_opt_test_list_comma_zom rest_args)
 618          (nconc $2 $1))
 619         ((fpdef_opt_test_list comma_opt)))
 620        (rest_args
 621         ((MULT NAME multmult_name_opt)
 622          nil)
 623         ((EXPONENT NAME)
 624          nil))
 625        (multmult_name_opt
 626         (nil)
 627         ((COMMA EXPONENT NAME)
 628          (wisent-raw-tag
 629           (semantic-tag-new-variable $3 nil nil))))
 630        (fpdef_opt_test_list_comma_zom
 631         (nil)
 632         ((fpdef_opt_test_list_comma_zom fpdef_opt_test COMMA)
 633          (nconc $2 $1)))
 634        (fpdef_opt_test_list
 635         ((fpdef_opt_test))
 636         ((fpdef_opt_test_list COMMA fpdef_opt_test)
 637          (nconc $3 $1)))
 638        (fpdef_opt_test
 639         ((fpdef eq_test_opt)))
 640        (fpdef
 641         ((NAME)
 642          (wisent-raw-tag
 643           (semantic-tag-new-variable $1 nil nil))))
 644        (fplist
 645         ((fpdef_list comma_opt)))
 646        (fpdef_list
 647         ((fpdef))
 648         ((fpdef_list COMMA fpdef)))
 649        (eq_test_opt
 650         (nil)
 651         ((ASSIGN test)
 652          nil))
 653        (comma_opt
 654         (nil)
 655         ((COMMA)))
 656        (semicolon_opt
 657         (nil)
 658         ((SEMICOLON))))
 659      '(goal function_parameter paren_class indented_block function_parameters paren_classes indented_block_body)))
 660   "Parser table.")
 661
 662 (defun wisent-python-wy--install-parser ()
 663   "Setup the Semantic Parser."
 664   (semantic-install-function-overrides
 665    '((parse-stream . wisent-parse-stream)))
 666   (setq semantic-parser-name "LALR"
 667         semantic--parse-table wisent-python-wy--parse-table
 668         semantic-debug-parser-source "wisent-python.wy"
 669         semantic-flex-keywords-obarray wisent-python-wy--keyword-table
 670         semantic-lex-types-obarray wisent-python-wy--token-table)
 671   ;; Collect unmatched syntax lexical tokens
 672   (semantic-make-local-hook 'wisent-discarding-token-functions)
 673   (add-hook 'wisent-discarding-token-functions
 674             'wisent-collect-unmatched-syntax nil t))
 675
 676 \f
 677 ;;; Analyzers
 678
 679 (define-lex-keyword-type-analyzer wisent-python-wy--<keyword>-keyword-analyzer
 680   "keyword analyzer for <keyword> tokens."
 681   "\\(\\sw\\|\\s_\\)+")
 682
 683 (define-lex-block-type-analyzer wisent-python-wy--<block>-block-analyzer
 684   "block analyzer for <block> tokens."
 685   "\\s(\\|\\s)"
 686   '((("(" LPAREN PAREN_BLOCK)
 687      ("{" LBRACE BRACE_BLOCK)
 688      ("[" LBRACK BRACK_BLOCK))
 689     (")" RPAREN)
 690     ("}" RBRACE)
 691     ("]" RBRACK))
 692   )
 693
 694 (define-lex-regex-type-analyzer wisent-python-wy--<symbol>-regexp-analyzer
 695   "regexp analyzer for <symbol> tokens."
 696   "\\(\\sw\\|\\s_\\)+"
 697   nil
 698   'NAME)
 699
 700 (define-lex-regex-type-analyzer wisent-python-wy--<number>-regexp-analyzer
 701   "regexp analyzer for <number> tokens."
 702   semantic-lex-number-expression
 703   nil
 704   'NUMBER_LITERAL)
 705
 706 (define-lex-string-type-analyzer wisent-python-wy--<punctuation>-string-analyzer
 707   "string analyzer for <punctuation> tokens."
 708   "\\(\\s.\\|\\s$\\|\\s'\\)+"
 709   '((BACKQUOTE . "`")
 710     (ASSIGN . "=")
 711     (COMMA . ",")
 712     (SEMICOLON . ";")
 713     (COLON . ":")
 714     (BAR . "|")
 715     (TILDE . "~")
 716     (PERIOD . ".")
 717     (MINUS . "-")
 718     (PLUS . "+")
 719     (MOD . "%")
 720     (DIV . "/")
 721     (MULT . "*")
 722     (AMP . "&")
 723     (GT . ">")
 724     (LT . "<")
 725     (HAT . "^")
 726     (NE . "!=")
 727     (LTGT . "<>")
 728     (HATEQ . "^=")
 729     (OREQ . "|=")
 730     (AMPEQ . "&=")
 731     (MODEQ . "%=")
 732     (DIVEQ . "/=")
 733     (MULTEQ . "*=")
 734     (MINUSEQ . "-=")
 735     (PLUSEQ . "+=")
 736     (LE . "<=")
 737     (GE . ">=")
 738     (EQ . "==")
 739     (EXPONENT . "**")
 740     (GTGT . ">>")
 741     (LTLT . "<<")
 742     (DIVDIV . "//")
 743     (DIVDIVEQ . "//=")
 744     (EXPEQ . "**=")
 745     (GTGTEQ . ">>=")
 746     (LTLTEQ . "<<="))
 747   'punctuation)
 748
 749 \f
 750 ;;; Epilogue
 751 ;;
 752
 753 (provide 'semantic/wisent/python-wy)
 754
 755 ;;; semantic/wisent/python-wy.el ends here