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