.Open The Syntax of C++ **
.Status Work in Progress
.Author RJ Botting
.Source ftp://ftp.csci.csusb.edu/u/faculty/dick/cs320/c++.syntax.mth

. See Also
.See http://www.csci.csusb.edu/dick/samples/c++.glossary.html
.See http://www.csci.csusb.edu/dick/samples/c.syntax.html
.See http://www.csci.csusb.edu/dick/samples/math.syntax.html
.See http://www.csci.csusb.edu/dick/samples/math.comp.ascii.html
.See http://www.csci.csusb.edu/dick/samples/objects.glossary.html

C++ is designed to include most of C as a subset.   The following lines formalize this intention:
C::documentation=`c.syntax`,
C.
.See http://www.csci.csusb.edu/dick/samples/c.syntax.html


The above means that this file does not have to repeat any of the
definition in C when the same name is used for different syntaxes in C and C++  and it is necesary to refer to the C form in this grammar then it is written like this example:
	C.comment
Otherwise the old name can be used as if had been included above.

The C++ version is written without a prefix and defined in this file.  For example C++ uses both the old C comment and a new one:
comment::=C.comment | inline_comment.
inline_comment::="//" #(non(eoln))eoln,

. Declarations 
declaration ::=  O(declaration_specifiers ) O(declarator_list )  | function_declaration | linkage_specification,
 
declaration_specifiers ::= N(declaration_specifier) ,
 
declaration_specifier ::= storage_class_specifier | type_specifier | function_specifier | "friend" | "typedef",
 
storage_class_specifier ::= "auto" | "register" | "static" | "extern",
 
function_specifier ::= "inline" | "virtual",
 
type_specifier ::= simple_type_name | class_specifier | enumeration_specifier | elaborated_type_specifier | "const" | "volatile",
 
simple_type_name ::= class_name | "typedef" name | "char" | "short" | "int" | "long" | "signed" | "unsigned" | "float" | "double" | "void",
 
elaborated_type_specifier ::= class_key identifier | class_key class_name | "enum" enumeration_name,
 
class_key ::= "class" | "struct" | "union",
 
enumeration_specifier ::= C.enumeration_specifier,

	|- C.enumeration_specifier=enumeration_identifier | "enum" identifier "{"enumeration_list"}", 
 
linkage_specification ::= "extern" string "{" O(declaration_list ) "}"  | "extern" string_declaration,
 
declaration_list ::= declaration #(";" declaration),
 
class_specifier ::= class_head "{" O(member_list ) "}",
class_head ::= class_key O(identifier ) O(base_specifier ) | class_key class_name O(base_specification ),
 
member_list ::= #( O(access_specifier  colon ) #member_declaration ),
 
member_declaration ::= O(declaration_specifiers) O(member_declarator_list ) ";" | function_definition O(";") | qualified_name ";",
type_description ::= class | struct | union,
simple_class::="class" identifier "{" private_part "public:" public_part"}",
structure::=struct,
simple_struct::="struct" identifier "{" public_part "private:" private_part "}"
union::="union" O(identifier) "{" public_part "}",
private_part::=#member_declaration,
public_part::=#member_declaration,
 
 
member_declarator_list ::= List( member_declarator),
 
member_declarator ::= declarator O(pure_specifier ) | O(identifier )  colon  constant_expression,
 
pure_specifier ::= "=" "0",
 
base_specification ::=  colon  List(base_specifier),
 
base_specifier ::= class_name | "virtual" O(access_specifier ) class_name | access_specifier O("virtual" ) class_name,
 
access_specifier ::= "private" | "protected" | "public",
 
conversion_function_name ::= "operator" conversion_type_name,

constructor_declarations ::= ...

destructor_declarations ::= ...

constructor_initializer ::=  colon  memory_initializer_list,

memory_initializer_list ::= List( memory_initializer),

memory_initializer ::= class_name "(" O(argument_list ) ")" | identifier "(" O(argument_list ) ")",

. Operators and Variables 
operator_function_name ::= "operator" operator,
 
DC::=double_colon::=scope_resolution_operator::lexeme="::".
variable::=C.variable | class_name DC static_data_member.


. Expressions
multiplicative_expression::=pm_expression #(multiplicative_operator pm_expression.

pm_expression::=cast_expression #(cast_operator cast_expression).

cast_operator ::= ".*"  |  "->*".

unary_expression::= C.unary_expression | allocation_expression | deallocation_expression.


allocation_expression::= O(DC) "new" O(placement) new_type_name O(new_initializer) |  O(DC) "new" O(placement) (type_name) O(new_initializer)
deallocation_expression::= O(DC) "delete" O("[]") cast_expression.

placement::="(" expression_list ")".

new_type_name::= N(type_specifier) new_declarator.
new_declarator::= O(complete_class_name DC )"*" const_or_volatile) new_delarator | O(new-declarator) "[" expression "]".

asm_declaration::= "asm" "{" string_literal "}" ";" .

. Declarators
declarator_list::=List(declarator O(initializer)).

declarator::= dname | ptr_operator declarator | declarator ( "(" argument_declaration_list")" const_or_volatile | "[" O(constant_expression)"]" | "(" declarator ")".

ptr_operator::= ("*" | "&"| complete_class_name DC "*") const_or_volatile.

const_or_volatile::= "const" | O("volatile").

dname::= name| O("~") class_name | typedef_name | qualified_type_name.

type_name::= N(type_specifier) O(abstract_declarator).

abstract_declarator::=ptr_operator O(abstract_declarator)| O(abstract_declarator) ( "(" argument_declaration_list")" const_or_volatile | "[" O(constant_expression)"]" | "(" abstract_declarator ")".

argument_declaration_list::=O(arg_declaration_list) (O("...") | O( "," "...") ).

arg_decalration_list::=List(argument_declaration).

arg_decalarion::= decl_specifiers ( declarator O("=" expression) | O(abstract_declarator)O("=" expression)).

fct_body::=compound_statement.

initializer::= "=" ( assignemnt_expression | "{" initializer_list O(comma) "}") "(" expression_list ")".

initializer_list::= List(assignment_expression) | "{" initializer_list O(comma) "}". 


. Class Declarations
class_specifier::=class_head "{" member_list "}".

member_declaration::= qualified_name ";" | function_definition O(";") | O(decl_specifiers) O(List(member_declarator)).

base_spec::=  colon  List(base_specifier).

conversion_type_name::=N(type_specifier) O(ptr-operator).
type_specifier_list::=N(type_specifier).

ctor::=constructor. 
mem::=member.
ctor_initializer::=constructor_initializer::=colon member_initializer_list.
mem_initializer_list::=member_initializer_list::=List(member_initializer).
mem_initializer::=member_initializer::=(complete_class_name | identifier)  "(" O(List(expression)) ")".

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


. Statements

statement::= C.statement | declaration_statement | try_block.

compound_statement::="{" #statement "}".

block::=compound_statement & `with at least one declaration statemnt`.

declaration_statement::= declaration.

for_init_statement::= expression_statement | declaration_statment.

iteration_statement::="while" "(" expression ")" statment | "do" statement "while" "(" expression ")" ";" | "for" "(" for_init_statment O(expression) ";" O(expression) ) statement.


. Templates
template_declaration::= "template" "<" List(template_argument) ">" declaration.

template_argument::=type_argument | argument_deeclaration.

type_argument::="class" identifier.

template_clase_name::= template_name "<" List(template_arg) ">".

template_arg::=expression| type_name.

.Exception Handling

try_block::= "try" compound_statement #handler.

handler::= "catch" "(" exception_declaration ")" compound_statement.

exception_declaration::= "..." | N(type_specifier) O(declarator | abstarct_declarator).

throw_expression::= "throw" O(assignment_expression).

exception_specification::= "throw" "(" List(type) ")".

...
. Namespaces:
.Source //ftp.std.com/AW/strousetroup2e/iso.ps
A mechanism, called namespaces, was introduced for controlling the scope of
otherwise global names.

The grammar for the namespace constructs is:
namespace_definition::="namespace" identifier "{" O( declaration_list) "}".

namespace_alias_definition::= "namespace" identifier "=" namespace_name ";".

using_declaration::= "using" namespace_name "::" identifier ";".

using_directive::= "using" "namespace" namespace_name ";".

namespace_name::= O("::") #( identifier "::" ) identifier.

An identifier in a namespace_name must have been specified to refer to a 
namespace by being the identifier in a namespace_definition or a 
namespace_alias_definition.

.Close