cython.wy

;; --------
;; Settings
;; --------

%{
  (require 'wisent-cython)
%}

%languagemode cy-mode

;; The default start symbol
%start goal
;; Alternate entry points
;;    - Needed by partial re-parse
%start indented_block
;;    - Needed by EXPANDFULL clauses
%start typed_function_parameters
%start arguments
%start indented_block_body

;; -------------------------------
;; Misc. Python specific terminals
;; -------------------------------
;; The value of these tokens are for documentation only, they are not
;; used by the lexer.
%token <charquote>   BACKSLASH 	  "\\"
%token <newline>     NEWLINE      "\n"
%token <indentation> INDENT       "^\\s-+"
%token <indentation> DEDENT       "[:INDENT:]"
%token <indentation> INDENT_BLOCK "(INDENT DEDENT)"

;; -----------------------------
;; Block & Parenthesis terminals
;; -----------------------------
%type  <block>       ;;syntax "\\s(\\|\\s)" matchdatatype block

%token <block>       PAREN_BLOCK "(LPAREN RPAREN)"
%token <block>       BRACE_BLOCK "(LBRACE RBRACE)"
%token <block>       BRACK_BLOCK "(LBRACK RBRACK)"
%token <block>       BACKQUOTE_BLOCK "(BACKQUOTE BACKQUOTE)"

%token <open-paren>  BACKQUOTE   "`"
%token <close-paren> BACKQUOTE   "`"
%token <open-paren>  LPAREN      "("
%token <close-paren> RPAREN      ")"
%token <open-paren>  LBRACE      "{"
%token <close-paren> RBRACE      "}"
%token <open-paren>  LBRACK      "["
%token <close-paren> RBRACK      "]"

;; ------------------
;; Operator terminals
;; ------------------
%type  <punctuation> ;;syntax "\\(\\s.\\|\\s$\\|\\s'\\)+" matchdatatype string

%token <punctuation> LTLTEQ 	"<<="
%token <punctuation> GTGTEQ 	">>="
%token <punctuation> EXPEQ	"**="
%token <punctuation> DIVDIVEQ 	"//="
%token <punctuation> DIVDIV 	"//"
%token <punctuation> LTLT 	"<<"
%token <punctuation> GTGT 	">>"
%token <punctuation> EXPONENT 	"**"
%token <punctuation> EQ 	"=="
%token <punctuation> GE 	">="
%token <punctuation> LE 	"<="
%token <punctuation> PLUSEQ 	"+="
%token <punctuation> MINUSEQ 	"-="
%token <punctuation> MULTEQ 	"*="
%token <punctuation> DIVEQ 	"/="
%token <punctuation> MODEQ 	"%="
%token <punctuation> AMPEQ 	"&="
%token <punctuation> OREQ 	"|="
%token <punctuation> HATEQ 	"^="
%token <punctuation> LTGT 	"<>"
%token <punctuation> NE 	"!="
%token <punctuation> HAT 	"^"
%token <punctuation> LT 	"<"
%token <punctuation> GT 	">"
%token <punctuation> AMP 	"&"
%token <punctuation> MULT 	"*"
%token <punctuation> DIV 	"/"
%token <punctuation> MOD 	"%"
%token <punctuation> PLUS 	"+"
%token <punctuation> MINUS 	"-"
%token <punctuation> PERIOD 	"."
%token <punctuation> TILDE 	"~"
%token <punctuation> BAR 	"|"
%token <punctuation> COLON 	":"
%token <punctuation> SEMICOLON	";"
%token <punctuation> COMMA 	","
%token <punctuation> ASSIGN 	"="
%token <punctuation> ELLIPSIS 	"..."
%token <punctuation> BACKQUOTE	"`" ;; backquote syntax removed in Python3 in favor of repr()
%token <punctuation> AT         "@"
%token <punctuation> ATEQ 	"@="
%token <punctuation> RETURNTYPE "->"

;;--------------------------------------
;; c punctuation

%token <punctuation> QUESTION "?"

;; -----------------
;; Literal terminals
;; -----------------
%token <string>      STRING_LITERAL

%type  <number>      ;;syntax semantic-lex-number-expression
%token <number>      NUMBER_LITERAL

%type  <symbol>      ;;syntax "\\(\\sw\\|\\s_\\)+"
%token <symbol>      NAME ;; of type or name in a parsed code

;;%type <cdefdecl>
;;%token <cdefdecl> CDEF-EXTERN "\\(\\(?:cdef[[:space:]]+extern\\(?:[[:space:]]+from\\)?[[:space:]]+.+\\)\\)$"
;;%token <cdefdecl> CDEF-API    "\\(\\(?:cdef[[:space:]]?\\(?:public\\)?[[:space:]]+api.+\\)\\)$"
;;%token <cdefdecl> CTYPEDEF    "\\(ctypedef[[:space:]]+.+\\)$"

%nonassoc LOW
%nonassoc COMMA SEMICOLON ASSIGN MULT
%nonassoc PAREN_BLOCK NAME
%nonassoc HIGH

;; -----------------
;; Keyword terminals
;; -----------------
%type  <keyword> ;;syntax "\\(\\sw\\|\\s_\\)+" matchdatatype keyword

%keyword AND	     "and"
%keyword API	     "api"
%keyword AS          "as"
%keyword ASSERT	     "assert"
%keyword ASYNC	     "async"
%keyword AWAIT	     "await"
%keyword BREAK	     "break"
%keyword CDEF	     "cdef"
%keyword CIMPORT     "cimport"
%keyword CLASS	     "class"
%keyword CONTINUE    "continue"
%keyword CPDEF	     "cpdef"
%keyword CTYPEDEF    "ctypedef"
%keyword STRUCT      "struct"
%keyword DEF	     "def"
%keyword DEL	     "del"
%keyword ELIF	     "elif"
%keyword ELSE	     "else"
%keyword ENUM	     "enum"
%keyword EXCEPT	     "except"
%keyword EXCEPTQ     "except?"
%keyword EXEC	     "exec"
%keyword EXTERN	     "extern"
%keyword FALSE       "False"
%keyword FINALLY     "finally"
%keyword FOR	     "for"
%keyword FROM	     "from"
%keyword GIL	     "gil"
%keyword GLOBAL	     "global"
%keyword IF	     "if"
%keyword IMPORT	     "import"
%keyword IN	     "in"
%keyword INLINE	     "inline"
%keyword IS	     "is"
%keyword LAMBDA	     "lambda"
%keyword NOGIL	     "nogil"
%keyword NOT	     "not"
%keyword NONE	     "None"
%keyword NONLOCAL    "nonlocal"
%keyword OR	     "or"
%keyword PASS	     "pass"
%keyword PRINT	     "print"
%keyword PROPERTY    "property"
%keyword PUBLIC      "public"
%keyword RAISE	     "raise"
%keyword RETURN	     "return"
%keyword STRUCT	     "struct"
%keyword TRUE	     "True"
%keyword TRY	     "try"
%keyword WHILE	     "while"
%keyword WITH        "with"
%keyword YIELD	     "yield"

;; %keyword STATIC       "static"
;; %keyword THREAD_LOCAL "_Thread_local"
;; %keyword AUTO         "auto"
;; %keyword REGISTER     "register"

;;---------------------------------
;; c keywords

%keyword AUTO          "auto"
%keyword ATOMIC        "_Atomic"
%keyword CONST         "const"
%keyword RESTRICT      "restrict"
%keyword VOLATILE      "volatile"

%%

goal
  : NEWLINE
  | stmt
  ;

stmt
  : simple_stmt
  | compound_stmt
  ;

simple_stmt
  : small_stmt-list semicolon-opt NEWLINE
  ;

small_stmt-list
  : small_stmt
  | small_stmt-list SEMICOLON small_stmt
  ;

semicolon-opt
  : ;;EMPTY
    %prec LOW
  | SEMICOLON
  ;

small_stmt
  : expr_stmt
  | del_stmt
  | PASS
  | flow_stmt
  | import_stmt
  | global_stmt
  | nonlocal_stmt
  | assert_stmt
  | cdef
  | cimport_stmt
  ;

compound_stmt
  : if_stmt
  | while_stmt
  | for_stmt
  | try_stmt
  | with_stmt
  | funcdef
  | classdef
  | decorated
  | async_stmt
  | with_nogil
  | with_gil
  | cdef_class
  | cdef_func
  | cpdef
  | cdef_extern
  | c_struct
 ;;  | cdef_public_api
  | cython_property
  | cdef_enum
  | cdef_block
 ;;| ctypedef
  ;

decorator
  : AT dotted_name arglist NEWLINE
    (progn $2)
  | AT dotted_name NEWLINE
    (progn $2)
  ;

decorators
  : decorator
    (list $1)
  | decorators decorator
    (cons $2 $1)
  ;

decorated
  : decorators decorated-item
    (cython-decorated $1 $2)
  ;

decorated-item
  : classdef
  | funcdef
  | cdef_func
  | cpdef
  | ASYNC funcdef
    (progn $2)
  ;

;; funcdef: 'def' NAME parameters ['->' test] ':' suite
funcdef
  : DEF NAME parameters RETURNTYPE test COLON suite
    (cython-reconstitute-function-tag
     (FUNCTION-TAG $2 $5 (semantic-tag-get-attribute (car $3) :args) :def 'def :hint t) $7)
  | DEF NAME parameters COLON suite
    (cython-reconstitute-function-tag
     (FUNCTION-TAG $2 nil (semantic-tag-get-attribute (car $3) :args) :def 'def) $5)
  ;

;;------------------------------------------------------

parameters
  : PAREN_BLOCK
    (let ((wisent-python-EXPANDING-block t))
      (EXPANDFULL $1 typed_function_parameters))
  ;

;; parameters: '(' [typedargslist] ')'
typed_function_parameters
  : LPAREN RPAREN ()
  | LPAREN ()
  | typedargs-opt
    (TAG "args" 'args :args $1)
  | RPAREN ()
  ;

;;----------------------------------------------------------
;; Typed function parameters, "PEP 0484 -- Type Hints"
;; Requires lexer modification for the "->" token
;;
;; Also C style type parameters added to the "tfpdef" rule
;;----------------------------------------------------------

;; typedargs: (tfpdef ['=' test] (',' tfpdef ['=' test])* [','
;;        ['*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | '**' tfpdef]]
;;       | '*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | '**' tfpdef)

typedargs-opt
  : ;;EMPTY
  | typedargs
  ;

typedargs
  : typedarg
    (list $1)
  | typedargs typedarg
    (cons $2 $1)
  ;

typedarg
  : tfpdef comma_rparen
    (cython-typed-name (VARIABLE-TAG $1 nil nil))
  | tfpdef ASSIGN test comma_rparen
    (cython-typed-name (VARIABLE-TAG $1 nil $3))
  | EXPONENT tfpdef comma_rparen
    (VARIABLE-TAG (concat $1 $2) nil nil)
  | MULT comma_rparen
    (VARIABLE-TAG $1 nil nil)
  | MULT tfpdef comma_rparen
    (VARIABLE-TAG (concat $1 $2) nil nil)
  ;

comma_rparen
  : COMMA | RPAREN
  ;

tfpdef
  : NAME NAME ;; C style typed parameter
    (concat $1 " " $2)
  | NAME COLON test ;; Python style type hint
    (concat $1 $2 $3)
  | NAME
 ;; cython params
  | cdef_memoryview
  ;

assign_test-opt
  : ;;EMPTY
  | ASSIGN test
  ;

;;------------------------------------------------------
;; Variable args list
;;------------------------------------------------------

;; (vfpdef ['=' test] (',' vfpdef ['=' test])* [','
;;       ['*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef]]
;;     |  '*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef)

varargslist
  : vfpdef assign_test-opt comma_vfpdef-eq_test-list-opt comma_mult_vfpdef-or-exp_vfpdef
  | vfpdef assign_test-opt comma_vfpdef-eq_test-list-opt
  | MULT vfpdef-opt comma_vfpdef-eq_test-list-opt comma_exp_vfpdef-opt
  | EXPONENT vfpdef
  ;

comma_mult_vfpdef-or-exp_vfpdef
  : COMMA mult_vfpdef-or-exp_vfpdef
  | COMMA
  ;

mult_vfpdef-or-exp_vfpdef
  : MULT vfpdef-opt comma_vfpdef-eq_test-list-opt comma_exp_vfpdef-opt
  | EXPONENT vfpdef
  ;

comma_vfpdef-eq_test-list-opt
  : ;;EMPTY
    %prec LOW
  | comma_vfpdef-eq_test-list
    %prec LOW
  ;

comma_vfpdef-eq_test-list
  : COMMA vfpdef assign_test-opt
  | comma_vfpdef-eq_test-list COMMA vfpdef assign_test-opt
  ;

comma_exp_vfpdef-opt
  : ;;EMPTY
  | COMMA EXPONENT vfpdef
  ;

vfpdef
  : NAME
  ;

vfpdef-opt
  : ;;EMPTY
  | NAME
  ;

;;---------------------------------------------------------------------------

expr_stmt
  : testlist_star_expr augassign yield_expr_or_testlist
    (if (and $2 (stringp $1) (string-match "^\\(\\sw\\|\\s_\\|\\.\\)+$" $1))
        ;; If this is an assignment statement and left side is a symbol,
        ;; then generate a 'variable token, else return 'code token.
	(VARIABLE-TAG $1 nil nil)
      (CODE-TAG $1 nil))
  | testlist_star_expr expr_stmt_rhs_assign-list
    (if (and $2 (stringp $1) (string-match "^\\(\\sw\\|\\s_\\|\\.\\)+$" $1))
        ;; If this is an assignment statement and left side is a symbol,
        ;; then generate a 'variable token, else return 'code token.
        (VARIABLE-TAG $1 nil nil :assign t)
      (CODE-TAG $1 nil))
  | testlist_star_expr
  ;

expr_stmt_rhs_assign-list
  : expr_stmt_rhs_assign
  | expr_stmt_rhs_assign-list expr_stmt_rhs_assign
  ;

expr_stmt_rhs_assign
  : ASSIGN yield_expr_or_testlist_star_expr
  ;

yield_expr_or_testlist
  : yield_expr
  | testlist
  ;

yield_expr_or_testlist_star_expr
  : yield_expr
  | testlist_star_expr
  ;

comma-opt
  : ;;EMPTY
  | COMMA
  ;

augassign
  : PLUSEQ
  | MINUSEQ
  | MULTEQ
  | ATEQ
  | DIVEQ
  | MODEQ
  | AMPEQ
  | OREQ
  | HATEQ
  | LTLTEQ
  | GTGTEQ
  | EXPEQ
  | DIVDIVEQ
  ;

del_stmt
  : DEL exprlist
  ;

flow_stmt
  : BREAK
  | CONTINUE
  | return_stmt
  | raise_stmt
  | yield_expr
  ;

return_stmt
  : RETURN testlist
  | RETURN
  ;

raise_stmt
  : RAISE test_from_test-opt
  ;

test_from_test-opt
  : ;;EMPTY
  | test from_test-opt
  ;

from_test-opt
  : ;;EMPTY
  | FROM test
  ;

import_stmt
  : import_name
  | import_from
  ;

import_name
  : IMPORT dotted_as_names
    (INCLUDE-TAG $2 nil)
  ;

;; import_as_name: NAME ['as' NAME]
import_as_name
  : NAME
  | NAME AS NAME
  ;

import_as_name-list
  : import_as_name
  | import_as_name-list COMMA import_as_name
  ;

;; import_as_names: import_as_name (',' import_as_name)* [',']
import_as_names
  : import_as_name-list comma-opt
  ;

;; 'from' (('.' | '...')* dotted_name | ('.' | '...')+)
;;        'import' ('*' | '(' import_as_names ')' | import_as_names)
import_from
  : FROM from-what IMPORT MULT
    (INCLUDE-TAG $2 nil)
  | FROM from-what IMPORT PAREN_BLOCK
    (INCLUDE-TAG $2 nil)
  | FROM from-what IMPORT import_as_names
    (INCLUDE-TAG $2 nil)
  ;

from-what
  : dots dotted_name
  | dotted_name
  | dots
  ;

dots
  : PERIOD
  | dots PERIOD
  ;

;; dotted_as_name: dotted_name [AS NAME]
dotted_as_name
  : dotted_name
  | dotted_name AS NAME
  ;

;; dotted_as_names (',' dotted_as_name)*
dotted_as_names
  : dotted_as_name
    (list $1)
  | dotted_as_names COMMA dotted_as_name
    (cons $3 $1)
  ;

global_stmt
  : GLOBAL names
  ;

names
  : NAME
  | names COMMA NAME
  ;

nonlocal_stmt
  : NONLOCAL names
  ;

assert_stmt
  : ASSERT tests
  ;

tests
  : test
  | tests COMMA test
  ;

async_stmt
  : ASYNC async_stmt_variants
  ;

async_stmt_variants
  : funcdef
  | with_stmt
  | for_stmt
  ;

if_stmt
  : IF test COLON suite else_colon_suite
  | IF test COLON suite elif_test_colon_suite else_colon_suite
  ;

elif_test_colon_suite
  : ELIF test COLON suite
  | elif_test_colon_suite ELIF test COLON suite
  ;

else_colon_suite
  : ;;EMPTY
  | ELSE COLON suite
  ;

while_stmt
  : WHILE test COLON suite else_colon_suite
  ;

for_stmt
  : FOR exprlist IN testlist COLON suite else_colon_suite
  ;

expr-or-star
  : expr
  | star_expr
  ;

expr-or-star-list
  : expr-or-star
  | expr-or-star-list COMMA expr-or-star
  ;

exprlist
  : expr-or-star-list comma-opt
  ;

testlist
  : testlist-comma comma-opt
  ;

testlist-comma
  : test
  | testlist-comma COMMA test
  ;

test-or-star_expr
  : test
  | star_expr
  ;

testlist_star_expr-list
  : test-or-star_expr
  | testlist_star_expr-list COMMA test-or-star_expr
  ;

testlist_star_expr
  : testlist_star_expr-list comma-opt
  ;

try_stmt
  : TRY COLON suite try_stmt_block
  ;

try_stmt_block
  : except_clause_colon_suite_list else_colon_suite
  | except_clause_colon_suite_list else_colon_suite FINALLY COLON suite
  | FINALLY COLON suite
  ;

except_clause_colon_suite_list
  : EXCEPT test_as_name COLON suite
  | except_clause_colon_suite_list EXCEPT test_as_name COLON suite
  ;

test_as_name
  : ;;EMPTY
  | test
  | test AS NAME
  ;

with_stmt
  : WITH with_item_list COLON suite
  ;

with_item_list
  : with_item
  | with_item_list COMMA with_item
  ;

with_item
  : test as_expr
  ;

as_expr
  : ;;EMPTY
  | AS expr
  ;

suite
  : simple_stmt
    (list $1)
  | NEWLINE indented_block
    (progn $2)
  ;

indented_block
  : INDENT_BLOCK
    (EXPANDFULL $1 indented_block_body)
  ;

indented_block_body
  : INDENT ()
  | DEDENT ()
  | simple_stmt
  | compound_stmt
  ;

test
  : or_test IF or_test ELSE test
  | or_test 
  | lambdef
  ;

test_nocond
  : or_test
  | lambdef_nocond
  ;

lambdef
  : LAMBDA varargslist COLON test
  | LAMBDA COLON test
  ;

lambdef_nocond
  : LAMBDA varargslist COLON test_nocond
  | LAMBDA COLON test_nocond
  ;

or_test
  : and_test or_and_test_list
  | and_test
  ;

or_and_test_list
  : OR and_test
  | or_and_test_list OR and_test
  ;

and_test
  : not_test and_not_test_list
  | not_test
  ;

and_not_test_list
  : AND not_test
  | and_not_test_list AND not_test
  ;

not_test
  : NOT not_test
  | comparison
  ;

comparison
  : expr comp_op_expr-list
  | expr
  ;

comp_op_expr-list
  : comp_op expr
  | comp_op_expr-list comp_op expr
  ;

comp_op
  : LT
  | GT
  | EQ
  | GE
  | LE
  | LTGT
  | NE
  | IN
  | NOT IN
  | IS
  | IS NOT
  ;

star_expr
  : MULT expr
  ;

expr
  : xor bar_xor-list
  | xor
  ;

bar_xor-list
  : BAR xor
  | bar_xor-list BAR xor
  ;

xor
  : and hat_and-list
  | and
  ;

hat_and-list
  : HAT and
  | hat_and-list HAT and
  ;

and
  : shift amp_shift-list
  | shift
  ;

amp_shift-list
  : AMP shift
  | amp_shift-list AMP shift
  ;

shift
  : arith ltlt_or_gtgt_arith-list
  | arith
  ;

ltlt_or_gtgt
  : LTLT
  | GTGT
  ;

ltlt_or_gtgt_arith-list
  : ltlt_or_gtgt arith
  | ltlt_or_gtgt_arith-list ltlt_or_gtgt arith
  ;

arith
  : term
  | term plus_or_minus_term-list
  ;

plus_or_minus
  : PLUS
  | MINUS
  ;

plus_or_minus_term-list
  : plus_or_minus term
  | plus_or_minus_term-list plus_or_minus term
  ;

term
  : factor mult_at_div_mod_divdiv_factor-list
  | factor
  ;

mult_at_div_mod_divdiv
  : MULT
  | AT
  | DIV
  | MOD
  | DIVDIV
  ;

mult_at_div_mod_divdiv_factor-list
  : mult_at_div_mod_divdiv factor
  | mult_at_div_mod_divdiv_factor-list mult_at_div_mod_divdiv factor
  ;

factor
  : plus_minus_tilde factor
  | power
  ;

plus_minus_tilde
  : PLUS
  | MINUS
  | TILDE
  ;

power
  : atom_expr EXPONENT factor
  | atom_expr
  ;

atom_expr
  : AWAIT atom
    (concat $1 $2)
  | AWAIT atom trailer-list
    (concat $1 $2 $3)
  | atom
  | atom trailer-list
    (concat $1 $2)
  ;

trailer-list
  : trailer
  | trailer-list trailer
    (concat $1 $2)
  ;

trailer
  : PAREN_BLOCK
    ()
  | BRACK_BLOCK
    ()
  | PERIOD NAME
    (concat $1 $2)
  ;

;; dotted_name: NAME ('.' NAME)*
dotted_name
  : NAME
  | dotted_name PERIOD NAME
    (format "%s.%s" $1 $3)
  ;

atom
  : PAREN_BLOCK
    ()
  | BRACK_BLOCK
    ()
  | BRACE_BLOCK
 ;; backquote block for python 2
  | BACKQUOTE_BLOCK
  | NAME
  | NUMBER_LITERAL
  | strings
  | ELLIPSIS
  | NONE
  | TRUE
  | FALSE
  ;

strings
  : STRING_LITERAL
  | strings STRING_LITERAL
    (concat $1 $2)
  ;

;; parent classes rule, trailer rule
arguments
  : LPAREN ()
  | RPAREN ()
  | NAME comp_for-opt comma_rparen
    (VARIABLE-TAG $1 nil nil)
  | NAME ASSIGN test comma_rparen
    (VARIABLE-TAG $1 nil nil)
  | EXPONENT NAME comma_rparen
    (VARIABLE-TAG $2 nil nil)
  | MULT NAME comma_rparen
    (VARIABLE-TAG $2 nil nil)
  ;

classdef
  : CLASS NAME arglist-opt COLON suite
    (TYPE-TAG $2 $1
              $5                ;; Members
              (cons $3 nil)     ;; (SUPERCLASSES . INTERFACES)
              :def 'class)
  ;

arglist
  : PAREN_BLOCK
    (let ((wisent-python-EXPANDING-block t))
      (EXPANDFULL $1 arguments))
  ;

arglist-opt
  : ;;EMPTY
  | arglist
  ;

comp_iter
  : comp_for
  | comp_if
  ;

comp_iter-opt
  : ;;EMPTY
  | comp_iter
  ;

comp_if
  : IF test_nocond comp_iter-opt
  ;

comp_for-opt
  : ;;EMPTY
  | comp_for
  ;

comp_for
  : FOR exprlist IN or_test comp_iter-opt
  ;

yield_expr
  : YIELD yield_arg
  | YIELD
  ;

yield_arg
  : FROM test
  | testlist
  ;

;;------------------------------------------------------

cdef
  : CDEF cdef_vars comma-opt
 ;; Expanded by `cython-expand-tags'
    (TAG "cdef_vars" 'temp :contents (nreverse $2))
  ;

cdef_var
 ;; types here must be in tag's name(first NAME), type and overlay positions
 ;; will be augmented in `cython-expand-tag' in wisent-cython.el
  : NAME NAME
    (VARIABLE-TAG (concat $1 " " $2) nil nil)
  | NAME NAME ASSIGN test
    (VARIABLE-TAG (concat $1 " " $2) nil $4)
  | NAME ASSIGN test
    (VARIABLE-TAG $1 nil $3)
  | NAME
    (VARIABLE-TAG $1 nil nil)
  | cdef_memoryview
  ;

cdef_memoryview
  : NAME BRACK_BLOCK NAME
    (VARIABLE-TAG $3 (concat $1 $2) nil)
    %prec LOW
  | NAME BRACK_BLOCK NAME ASSIGN test
    (VARIABLE-TAG $3 (concat $1 $2) $5)
    %prec LOW
  ;

cdef_vars
  : cdef_var
    (list $1)
  | cdef_vars COMMA cdef_var
    (cons $3 $1)
  ;

cdef_block
  : CDEF COLON NEWLINE INDENT_BLOCK
    ()
  ;

cdef_func
  : CDEF NAME NAME parameters cdef_except_opt COLON suite
    (cython-reconstitute-function-tag
     (FUNCTION-TAG $3 $2 (semantic-tag-get-attribute (car $4) :args) :def 'cdef) $7)
 ;; cdef func can be without return type
  | CDEF NAME parameters cdef_except_opt COLON suite
    (cython-reconstitute-function-tag
     (FUNCTION-TAG $2 nil (semantic-tag-get-attribute (car $3) :args) :def 'cdef)
     ;;(FUNCTION-TAG $2 nil $3 :def 'cdef)
     $6)
  | CDEF INLINE NAME NAME parameters cdef_except_opt COLON suite
    (cython-reconstitute-function-tag
     (FUNCTION-TAG $4 $3 (semantic-tag-get-attribute (car $5) :args) :def 'cdef :inline t) $8)
  ;

cdef_except_opt
  : ;;EMPTY
  | EXCEPT MULT
  | EXCEPT NUMBER_LITERAL
  | EXCEPTQ NUMBER_LITERAL
  | EXCEPT PLUS
  ;

cdef_class
  : CDEF CLASS NAME arglist-opt COLON suite
    (cython-reconstitute-class-tag
     (TYPE-TAG $3 $2
               $6                ;; Members
               (cons $4 nil)     ;; (SUPERCLASSES . INTERFACES)
               :def 'cdef-class))
  ;

cython_property
  : PROPERTY NAME COLON suite
    (cython-reconstitute-function-tag (FUNCTION-TAG $2 nil nil) $4)
  ;

cpdef
  : CPDEF NAME parameters COLON suite
    (cython-reconstitute-function-tag
     (FUNCTION-TAG $2 nil (semantic-tag-get-attribute (car $3) :args) :def 'cpdef) $5)
  | CPDEF NAME NAME parameters COLON suite
    (cython-reconstitute-function-tag
     (FUNCTION-TAG $3 $2 (semantic-tag-get-attribute (car $4) :args) :def 'cpdef) $6)
  ;

cimport_stmt
  : cimport_name
  | cimport_from
  ;

cimport_name
  : CIMPORT dotted_as_names
    (INCLUDE-TAG $2 nil :def 'cimport)
  ;

cimport_from
  : FROM from-what CIMPORT MULT
    (INCLUDE-TAG $2 nil :def 'cimport)
  | FROM from-what CIMPORT PAREN_BLOCK
    (INCLUDE-TAG $2 nil :def 'cimport)
  | FROM from-what CIMPORT import_as_names
    (INCLUDE-TAG $2 nil :def 'cimport)
  ;

cdef_enum
  : CDEF ENUM NAME COLON NEWLINE INDENT_BLOCK
    (VARIABLE-TAG $3 $2 nil)
  ;

with_nogil
  : WITH NOGIL COLON NEWLINE INDENT_BLOCK
    ()
  ;

with_gil
  : WITH GIL COLON NEWLINE INDENT_BLOCK
    ()
  ;

c_struct
  : STRUCT NAME COLON NEWLINE INDENT_BLOCK
    (VARIABLE-TAG $2 (concat $1 " " $2) nil)
  ;

cdef_extern
  : CDEF EXTERN FROM STRING_LITERAL COLON NEWLINE INDENT_BLOCK
    (TAG (substring $4 1 -1) $nterm)
  | CDEF EXTERN FROM MULT COLON NEWLINE INDENT_BLOCK
    (TAG $4 $nterm)
  ;