//// C++ Grammar


#sx(include "cxx-support.scm")


// 1.2 Lexical conventions

decimal_literal := "[1-9]+[0-9]*[uUlL]*"
octal_literal := "0[0-7]*[uUlL]*"
hexadecimal_literal := "0[xX][a-fA-F0-9]+[uUlL]*"
character_literal := "L?'(\\\\0[0-7]{0,2}|\\\\x[0-9a-fA-F]+|\\\\.|[^'])+'"
floating_literal1 := "[0-9]+\\.[0-9]+([eE][-+]?[0-9]+)?[flFL]?"
floating_literal2 := "[0-9]+[eE][-+]?[0-9]+[flFL]?"
string_literal1 := "L?\"(\\\\0[0-7]{0,2}|\\\\x[0-9a-fA-F]+|\\\\.|[^\"])*\""
identifier := "[a-zA-Z_]+[a-zA-Z0-9_]*"
unary_operator := "[-+*&!~]"


literal -> x = character_literal : #sx(char-literal (car x))
        |  floating_literal
        |  integer_literal
        |  string_literal
        |  boolean_literal

integer_literal -> hexadecimal_literal  : #sx(integer-literal (substring (car ($)) 2) 16)
		|  octal_literal        : #sx(integer-literal (car ($)) 8)
		|  decimal_literal      : #sx(integer-literal (car ($)) 10)

floating_literal -> floating_literal1   : #sx(floating-literal (car ($)))
		 |  floating_literal2   : #sx(floating-literal (car ($)))

boolean_literal -> "false" | "true"

string_literal -> x = {string_literal1}+ : #sx(string-literal (car x))


// 1.3 Basic concepts

start -> declaration


// 1.4 Expressions

primary_expression -> literal
		   |  "this"
		   |  "::" identifier
		   |  "::" operator_function_id
		   |  "::" qualified_id
		   |  "(" expression ")" : 2
		   |  id_expression

id_expression -> unqualified_id
	      |	 qualified_id

unqualified_id -> identifier
	       |  operator_function_id
	       |  conversion_function_id
	       |  "~" class_name
	       |  template_id

qualified_id -> nested_name_specifier ["template"] unqualified_id

nested_name_specifier -> class_or_namespace_name "::" [nested_name_specifier]
		      |	 class_or_namespace_name "::" "template" nested_name_specifier

class_or_namespace_name -> class_name
			|  namespace_name

postfix_expression -> primary_expression [postfix_expression1]
		    |  simple_type_specifier "(" [expression_list] ")" [postfix_expression1]
		    |  "typename" ["::"] nested_name_specifier identifier "(" [expression_list] ")"
  		       [postfix_expression1]
		    |  "typename" ["::"] nested_name_specifier ["template"] template_id "("
		       [expression_list] ")" [postfix_expression1]
		    |  "dynamic_cast" "<" type_id ">" "(" expression ")" [postfix_expression1]
		    |  "static_cast" "<" type_id ">" "(" expression ")" [postfix_expression1]
		    |  "reinterpret_cast" "<" type_id ">" "(" expression ")" [postfix_expression1]
		    |  "const_cast" "<" type_id ">" "(" expression ")" [postfix_expression1]
		    |  "typeid" "(" expression ")" [postfix_expression1]
		    |  "typeid" "(" type_id ")" [postfix_expression1]

postfix_expression1 -> "[" expression "]" [postfix_expression1]
		   |  "(" [expression_list] ")" [postfix_expression1]
		   |  ("." | "->") ["template"] ["::"] id_expression [postfix_expression1]
		   |  ("." | "->") pseudo_destructor_name [postfix_expression1]
		   |  ("++" | "--") [postfix_expression1]

expression_list -> assignment_expression {"," assignment_expression}

pseudo_destructor_name -> ["::"] [nested_name_specifier] type_name "::" "~" type_name
		       |  ["::"] nested_name_specifier "template" template_id "::" "~" type_name
		       |  ["::"] [nested_name_specifier] "~" type_name

unary_expression -> "++" cast_expression
		 |  "--" cast_expression
		 |  "sizeof" unary_expression
		 |  "sizeof" "(" type_id ")"
		 |  unary_operator cast_expression
		 |  new_expression
		 |  delete_expression
		 |  postfix_expression

new_expression -> ["::"] "new" [new_placement] new_type_id [new_initializer]
	       |  ["::"] "new" [new_placement] "(" type_id ")" [new_initializer]

new_placement -> "(" expression_list ")"

new_type_id -> type_specifier_seq [new_declarator]

new_declarator -> ptr_operator [new_declarator]
	       |  direct_new_declarator

direct_new_declarator -> "[" expression "]" [direct_new_declarator1]

direct_new_declarator1 -> "[" constant_expression "]" [direct_new_declarator1]

new_initializer -> "(" [expression_list] ")"

delete_expression -> ["::"] "delete" cast_expression
		  |  ["::"] "delete" "[" "]" cast_expression

cast_expression -> "(" type_id ")" cast_expression
		|  unary_expression

pm_expression -> cast_expression [pm_expression1]

pm_expression1 -> ".*" cast_expression [pm_expression1]
	       |  "->*" cast_expression [pm_expression1]

multiplicative_expression -> pm_expression multiplicative_expression1
			  |  pm_expression 

multiplicative_expression1 -> ("*" | "/" | "%") pm_expression [multiplicative_expression1]

additive_expression -> multiplicative_expression additive_expression1
		    |  multiplicative_expression

additive_expression1 -> ("+" | "-") multiplicative_expression [additive_expression1]

shift_expression -> additive_expression shift_expression1
		 |  additive_expression 

shift_expression1 -> ("<<" | ">>") additive_expression [shift_expression1]

relational_expression -> shift_expression relational_expression1
		      |  shift_expression

relational_expression1 -> ("<=" | ">=" | "<" | ">") shift_expression [relational_expression1]

equality_expression -> relational_expression equality_expression1
		    |  relational_expression 

equality_expression1 -> ("==" | "!=") relational_expression [equality_expression1]

and_expression -> equality_expression and_expression1
	       |  equality_expression

and_expression1 -> "&"(~"&&") equality_expression [and_expression1]

exclusive_or_expression -> and_expression exclusive_or_expression1
			|  and_expression 

exclusive_or_expression1 -> "^" and_expression [exclusive_or_expression1]

inclusive_or_expression -> exclusive_or_expression inclusive_or_expression1
			|  exclusive_or_expression 

inclusive_or_expression1 -> "|"(~"||") exclusive_or_expression [inclusive_or_expression1]

logical_and_expression -> inclusive_or_expression logical_and_expression1
		       |  inclusive_or_expression

logical_and_expression1 -> "&&" inclusive_or_expression [logical_and_expression1]

logical_or_expression -> logical_and_expression logical_or_expression1
		      |  logical_and_expression 

logical_or_expression1 -> "||" logical_and_expression [logical_or_expression1]

conditional_expression -> logical_or_expression "?" expression ":" assignment_expression
		       |  logical_or_expression

assignment_expression -> logical_or_expression assignment_operator assignment_expression
		      |	 throw_expression
		      |	 conditional_expression

expression -> assignment_expression expression1
	   |  assignment_expression

expression1 -> "," assignment_expression [expression1]

constant_expression -> conditional_expression

assignment_operator -> "=" | "*=" | "/=" | "%=" | "+=" | "-=" | ">>=" | "<<=" | "&=" | "^=" | "|="


// 1.5 Statements

statement -> statement1
	  |  _ "syntax error in statement"
	  
statement1 -> labeled_statement
	   |  compound_statement
	   |  selection_statement
	   |  iteration_statement
	   |  jump_statement
	   |  try_block
	   |  declaration_statement
	   |  expression_statement

labeled_statement -> identifier ":" statement
		  |  "case" constant_expression ":" statement
		  |  "default" ":" statement

expression_statement -> [expression] ";"

compound_statement -> "{" {statement1} "}"

selection_statement -> "if" "(" condition ")" statement ["else" statement]
		    |  "switch" "(" condition ")" statement

condition -> expression
	  |  {type_specifier} declarator "=" assignment_expression

iteration_statement -> "while" "(" condition ")" statement
		    |  "do" statement "while" "(" expression ")" ";"
		    // c++grammar.txt says expression as last element:
		    |  "for" "(" for_init_statement [condition] ";" [for_next_statement] ")" 
		         statement

for_init_statement -> expression_statement
		   |  simple_declaration

// hack to make "mark" work inside "for" (see GC code in runtime.c)
for_next_statement -> "do" statement "while" "(" expression ")"
		   |  expression

jump_statement -> "break" ";"
	       |  "continue" ";"
	       |  "return" [expression] ";"
	       |  "goto" identifier ";"

declaration_statement -> block_declaration


// 1.6 Declarations

declaration_seq -> {declaration}+

declaration -> block_declaration
	    |  function_definition
	    |  template_declaration
	    |  explicit_instantiation
	    |  explicit_specialization
	    |  linkage_specification
	    |  namespace_definition

block_declaration -> simple_declaration
		  |  namespace_alias_definition
		  |  using_declaration
		  |  using_directive

simple_declaration -> x = decl_specifier_seq y = [init_declarator_list] ";"
		   : #sx(simple-declaration-action (@) x y)

decl_specifier_seq -> {decl_specifier}+

decl_specifier -> storage_class_specifier
	       |  type_specifier
	       |  function_specifier
	       |  "friend"
	       |  "typedef"

storage_class_specifier -> "auto" | "register" | "static" | "extern" | "mutable"

function_specifier -> "inline" | "virtual" | "explicit"

typedef_name -> name = identifier #sx(property? name 'cxx-typedef)

type_specifier -> simple_type_specifier
	       |  class_specifier
	       |  enum_specifier
	       |  elaborated_type_specifier
	       |  cv_qualifier

simple_type_specifier -> ["::"] [nested_name_specifier] type_name
		      |	 ["::"] nested_name_specifier ["template"] template_id
		      |  "char" | "wchar_t" | "bool" | "short" | "int" | "long" 
		      |	 "signed" | "unsigned" | "float" | "double" | "void"

type_name -> class_name
	  |  enum_name
	  |  typedef_name

elaborated_type_specifier -> class_key ["::"] [nested_name_specifier] identifier
			  |  class_key ["::"] [nested_name_specifier] ["template"] template_id
			  |  "enum" ["::"] [nested_name_specifier] identifier
			  |  "typename" ["::"] nested_name_specifier identifier 
			     ["<" template_argument_list ">"]
			  |  "typename" ["::"] nested_name_specifier identifier 
			  |  "typename" ["::"] nested_name_specifier ["template"] template_id

enum_name -> name = identifier #sx(property? name 'cxx-enum)

enum_specifier -> "enum" x = [identifier] "{" y = [enumerator_list] "}"
	       : #sx(enum-specifier-action (@) x y)

enumerator_list -> enumerator_definition {"," enumerator_definition}

enumerator_definition -> enumerator
		      |	 enumerator "=" constant_expression

enumerator -> identifier

namespace_name -> original_namespace_name
	       |  namespace_alias

original_namespace_name -> identifier

namespace_definition -> named_namespace_definition
		     |	unnamed_namespace_definition

named_namespace_definition -> original_namespace_definition
			   |  extension_namespace_definition

original_namespace_definition -> "namespace" identifier "{" namespace_body "}"

extension_namespace_definition -> "namespace" original_namespace_name "{" namespace_body "}"

unnamed_namespace_definition -> "namespace" "{" namespace_body "}"

namespace_body -> [declaration_seq]

namespace_alias -> identifier

namespace_alias_definition -> "namespace" identifier "=" qualified_namespace_specifier ";"

qualified_namespace_specifier -> ["::"] [nested_name_specifier] namespace_name

using_declaration -> "using" ["typename"] ["::"] nested_name_specifier unqualified_id ";"
		  |  "using" "::" unqualified_id ";"

using_directive -> "using" "namespace" ["::"] [nested_name_specifier] namespace_name ";"

linkage_specification -> "extern" string_literal "{" [declaration_seq] "}"
		      |	 "extern" string_literal declaration


// 1.7 Declarators

init_declarator_list -> [init_declarator {"," init_declarator}]

init_declarator -> declarator [initializer]

declarator -> ptr_operator declarator
	   |  direct_declarator

direct_declarator -> declarator_id [direct_declarator1]
		     [exception_specification] [direct_declarator1]
		  |  "(" declarator ")" [direct_declarator1]

direct_declarator1 -> "(" parameter_declaration_clause ")" [cv_qualifier_seq]
		     [exception_specification] [direct_declarator1]
		  |  "[" [constant_expression] "]" [direct_declarator1]

ptr_operator -> "*" [cv_qualifier_seq]
	     |	"&"
	     |	["::"] nested_name_specifier "*" [cv_qualifier_seq]

cv_qualifier_seq -> {cv_qualifier}

cv_qualifier -> "const" | "volatile"

declarator_id -> ["::"] id_expression
	      |	 ["::"] [nested_name_specifier] type_name

type_id -> type_specifier_seq [abstract_declarator]

type_specifier_seq -> {type_specifier}+

abstract_declarator -> ptr_operator [abstract_declarator]
		    |  direct_abstract_declarator

direct_abstract_declarator -> ["(" abstract_declarator ")"] [direct_abstract_declarator1]

direct_abstract_declarator1 -> "(" parameter_declaration_clause ")" [cv_qualifier_seq]
			       [exception_specification] [direct_abstract_declarator1]
			   |  "[" [constant_expression] "]" [direct_abstract_declarator1]

parameter_declaration_clause -> parameter_declaration_list "," "..."
			     |  [parameter_declaration_list] ["..."]

parameter_declaration_list -> parameter_declaration {"," parameter_declaration}

parameter_declaration -> decl_specifier_seq declarator ["=" assignment_expression]
		      |	 decl_specifier_seq [abstract_declarator] ["=" assignment_expression]

function_definition -> [decl_specifier_seq] declarator [ctor_initializer] function_body
		    |  [decl_specifier_seq] declarator function_try_block

function_body -> compound_statement
	      |  _ "syntax error in function body"

initializer -> "=" initializer_clause
	    |  "(" expression_list ")"

initializer_clause -> assignment_expression
		   |  "{" initializer_list [","] "}"
		   |  "{" "}"

initializer_list -> initializer_clause {"," initializer_clause}


// 1.8 Classes

class_name -> name = identifier #sx(property? name 'cxx-class)
	   |  template_id

class_specifier -> x = class_head "{" y = [member_specification] "}"
		: #sx(class-specifier-action (@) x y)

class_head -> class_key [identifier] [base_clause]
	   |  class_key nested_name_specifier identifier [base_clause]
	   |  class_key [nested_name_specifier] template_id [base_clause]

class_key -> "class" | "struct" | "union"

member_specification -> member_declaration [member_specification]
		     |	access_specifier ":" [member_specification]

member_declaration -> [decl_specifier_seq] [member_declarator_list] ";"
		   |  function_definition [";"]
		   |  ["::"] nested_name_specifier ["template"] unqualified_id ";"
		   |  using_declaration
		   |  template_declaration

member_declarator_list -> member_declarator {"," member_declarator}

member_declarator -> declarator [pure_specifier | constant_initializer] 
		  |  [identifier] ":" constant_expression

pure_specifier -> "=" "0"

constant_initializer -> "=" constant_expression


// 1.9 Derived classes

base_clause -> ":" base_specifier_list

base_specifier_list -> base_specifier {"," base_specifier}

base_specifier -> ["::"] [nested_name_specifier] class_name
	       |  "virtual" [access_specifier] ["::"] [nested_name_specifier] class_name
	       |  access_specifier ["virtual"] ["::"] [nested_name_specifier] class_name

access_specifier -> "private" | "protected" | "public"


// 1.10 Special member functions

conversion_function_id -> "operator" conversion_type_id

conversion_type_id -> type_specifier_seq [conversion_declarator]

conversion_declarator -> ptr_operator [conversion_declarator]

ctor_initializer -> ":" mem_initializer_list

mem_initializer_list -> mem_initializer {"," mem_initializer_list}

mem_initializer -> mem_initializer_id "(" [expression_list] ")"

mem_initializer_id -> ["::"] [nested_name_specifier] class_name
		   |  identifier


// 1.11 Overloading

operator_function_id -> "operator" opr

opr -> "new" ["[" "]"] 
    |  "delete" ["[" "]"]
    |  "+=" | "-=" | "*=" | "/=" | "%=" | "^=" | "&=" | "|="
    |  ">>=" | "<<=" | ">>" | "<<" | "==" | "!=" | "++" | "--"
    |  "->*" | "->" | "&&" | "||" | ">=" | "<="
    |  "+" | "-" | "*" | "/" | "%" | "^" | "&" | "|" | "~"
    |  "!" | "=" | "<" | ">" | "," 
    |  "(" | ")" | "[" | "]"


// 1.12 Templates

template_declaration -> ["export"] "template" "<" template_parameter_list ">" declaration

template_parameter_list -> template_parameter {"," template_parameter}

template_parameter -> type_parameter 
		   |  parameter_declaration

type_parameter -> "class" [identifier] ["=" type_id]
	       |  "typename" [identifier] ["=" type_id]
	       |  "template" "<" template_parameter_list ">" "class" [identifier] ["=" template_name]

template_id -> template_name "<" [template_argument_list] ">"

template_name -> identifier

template_argument_list -> template_argument {"," template_argument}

template_argument -> assignment_expression
		  |  type_id
		  |  template_name

explicit_instantiation -> "template" declaration

explicit_specialization -> "template" "<" ">" declaration


// 1.13 Exception handling

try_block -> "try" compound_statement handler_seq

function_try_block -> "try" [ctor_initializer] function_body handler_seq

handler_seq -> handler [handler_seq]

handler -> "catch" "(" exception_declaration ")" compound_statement

exception_declaration -> type_specifier_seq [declarator | abstract_declarator]
		      |	 "..."

throw_expression -> "throw" [assignment_expression]

exception_specification -> "throw" "(" [type_id_list] "="

type_id_list -> type_id {"," type_id}