ObjectPascal.ebnf

(*
  inspired from 
    https://raw.githubusercontent.com/CHiPs44/pascalscript/refs/heads/main/free-pascal.ebnf
  and
    https://github.com/rochus-keller/FreePascal/blob/master/syntax/FreePascal.ebnf
  who were inspired by the FPC documentation.  
*)

(* toplevel: compile module  *)

module = program_module | library_module | package_module | unit_module ;

(* Program *)

program_module = program_header ";" [ full_uses_clause ] block "." ;

program_header = "program" identifier [ "(" program_parameters ")" ] ;

program_parameters = identifier_list ;

full_uses_clause = "uses" full_uses_item { "," full_uses_item } ";" ;

full_uses_item = identifier [ "in" string_literal ] ;

(* Library *)

library_module = library_header ";" [ uses_clause ] block "." ;

library_header = "library" identifier ;

(* Package *)

package_module = package_header ";" [ contains_clause ] [requires_clause] "end" "." ;

package_header = "package" identifier ;

contains_clause = "contains" full_uses_item { "," full_uses_item } ";" ;

requires_clause = "requires" qualifier_list ";" ;

(* unit *)

unit_module = unit_header interface_section implementation_section
              ( [ initialization_section ] [ finalization_section ]
                | "begin" statement_list ) "end" "." ;
                
unit_header = "unit" qualifier [ hintdirectives ] ";" ;

interface_section = "interface" [ uses_clause ] [interface_parts ] ;

uses_clause = "uses" identifier { "," identifier } ";" ;

interface_parts = interface_part { interface_part } ;

interface_part = constant_declaration_block
                     | type_declaration_block
                 | variable_declaration_block
                 | property_declaration_block
                 | procedure_headers_block ;

implementation_section = "implementation" [ uses_clause ] { declaration_part } ;

initialization_section = "initialization" statement_list ;

finalization_section = "finalization" statement_list ;

exports_clause = "exports" exports_list ";" ;

exports_list = exports_entry { "," exports_entry } ;

exports_entry = identifier [ "index" integer_constant ] [ "name" string_constant ] ;

(* block: procedure/function *)
                 
procedure_headers_block = procedure_header
                        | function_header
                        | operator_header;
                        
procedure_header = generic_procedure_header
                  | regular_procedure_header ;

generic_procedure_header = "generic" "procedure" qualifier generic_template_list formal_parameter_list
                                        ";" [ call_modifiers ";" ] [hintdirectives] ;

regular_procedure_header = "procedure" qualifier [ generic_template_list ] formal_parameter_list
                                        ";" [ call_modifiers ";" ] [hintdirectives] ;
                                        
function_header = generic_function_header
                 | regular_function_header ;

generic_function_header = "generic" "function" qualifier  [ "<" generic_template_list ">" ] formal_parameter_list ":" type
                                   [ call_modifiers ";" ] [hintdirectives] ;
                 
regular_function_header = "function" qualifier  [ "<" generic_template_list ">" ] formal_parameter_list ":" type
                                   [ call_modifiers ";" ] [hintdirectives] ;
                                   
operator_header = "operator" operator_definition  [ result_identifier ] ":" type ;

operator_definition = assignment_operator_definition
                 | arithmetic_operator_definition
                         | comparison_operator_definition
                     | logical_operator_definition
                     | other_operator_definition ;
                     
generic_template_list = constrained_template_list
                      | free_template_list ;

constrained_template_list = constrained_templates { ";" constrained_templates } ;

free_template_list = identifier { "," qualifier } ;

constrained_templates = identifier_list ":" type_constraint { "," type_constraint } ;

identifier_list = identifier { "," identifier } ;

type_constraint = identifier
             | "class"
             | "record" ;

block = { declaration_block } statement_block ;

declaration_block = label_declaration_block 
                     | constant_declaration_block 
                     | resourcestring_declaration_block
                     | class_func_proc_declaration_block
                     | func_proc_declaration_block
                     | type_declaration_block
                     | variable_declaration_block
                     | threadvariable_declaration_block
                     | exports_clause ;

func_proc_declaration_block = procedure_declaration
                  | function_declaration
                  | constructor_declaration
                  | destructor_declaration
                  | operator_declaration ;

statement_block = compound_statement ;

(* labels *)

label_declaration_block = "label" label_def [ "," label_def ] ";" ;

(* Constants *)

constant_declaration_block = "const" { constant_declaration [hintdirectives] } ;

constant_declaration = identifier ":" constant_expression ";"
                     | identifier ":" type "=" constant_expression ";" ;

resourcestring_declaration_block = "resourcestring" { string_constant_declaration } ;

string_constant_declaration = identifier "=" string_constant_literal ";" ;

(* Variables *)

variable_declaration_block = "var" { variable_declaration } ;

threadvariable_declaration_block = "threadvar" { variable_declaration } ;

variable_declaration = identifier_list ":" type_ [ "=" expression ] [variable_modifiers] [hintdirectives];

variable_modifiers = "absolute" absolute_target
                    | ";" "export"
                    | "cvar"
                    | "external" [ string_constant ] [ "name" string_constant ] ;

absolute_target = identifier | expression ;


(* types *)

type_declaration_block = "type" { type_declaration } ;

hintdirective = "deprecated" [ string_constant ]
                                | "experimental" 
                                | "platform"
                                | "unimplemented" ;

hintdirectives = hintdirective { ";" hintdirective } ;

typed_constant = factor | procedural_constant ;
            
type_declaration = identifier "=" type [hintdirectives] ";" ;

type = ["type"] simple_type
                | pointer_type 
                | full_procedural_type
                | forward_class_type
                | structured_type 
                | class_reference_type 
                | generic_type 
                | specialized_type
                | "helper" helper_type ;


forward_class_type = "class" ;
                 
class_reference_type = "class" "of" identifier ;

pointer_type = "^" qualifier ;


simple_type = string_type
                        | ordinal_type ;

string_type = "string" "[" constant_expression "]"
            |  "string" "(" positive_integer ")"
            | "ansistring"
            | "widestring"
            | "unicodestring" ;

type_name = identifier ; 

subrange_type = simple_constant_expression ".." simple_constant_expression ;

ordinal_type = enumerated_type 
              | builtin_ordinal
              | subrange_type ;
              
builtin_ordinal = "byte"
                | "shortint"
                | "word"
                | "smallint"
                | "cardinal"
                | "longint"
                | "qword"
                | "int64" ;

enumerated_type = "(" enumerated_item  { "," enumerated_item } ")" ;

enumerated_item = qualifier
                | qualifier "=" expression
                | qualifier ":=" expression ;

structured_type = set_type
                | file_type
                | interface_type
                | "packed" unpacked_type
                | "bitpacked" unpacked_type ;

unpacked_type = array_type
               | record_type
               | object_type
               | class_type ;

set_type = "set" "of" ordinal_type ;

file_type = "file" [ "of" type ]
            | "text" ;

array_type = array [ "[" ordinal_type { "," ordinal_type } "]" ] "of" type ;

qualifier_list = qualifier { "," qualifier } ;

(* record type *)

record_type = "record" { record_component_list } [ variant_part ] [";"] "end" ;

record_component_list = record_visibility_specifier
                       | field_definition [";"]
                       | record_method_definition
                       | property_definition
                       | record_operator_definition ;


field_definition = identifier_list ":" type ;

variant_part = "case" [ identifier ":" ] type of variant_case [ ";" [variant_case] ] ;

variant_case = constant { "," constant } ":" "(" variant_field_list ")" ;

variant_field_list = field_definition { ";" field_definition } ;

record_visibility_specifier = "public"
                            | [ "strict" ] "private" ;
                            
record_method_definition = function_header
                         | procedure_header ; 

record_operator_definition = "class" operator_header;

full_procedural_type = procedural_type [ ";" call_modifiers ];

procedural_type = func_proc_header
                  | func_proc_header "of" "object"
                  | func_proc_header "is" "nested" ;
                  

func_proc_header = "function" formal_parameter_list  [ ":" type ]
                     | "procedure" formal_parameter_list ;

call_modifiers = "inline"
                | "register"
                | "cdecl"
                | "cppdecl" 
                | "pascal"
                | "stdcall"
                | "safecall"
                | "hardfloat"
                | "local"
                | "mwpascal"
                | "ms_abi_default"
                | "ms_abi_cdecl"
                | "nostackframe"
                | "saveregisters"
                | "softfloat"
                | "sysv_abi_default"
                | "sysv_abi_cdecl"
                | "vectorcall"
                | "varargs" ;
        
property_definition = identifier [ property_interface ] property_specifiers ;

property_interface = [ property_parameter_list ] ":" qualifier ;

property_parameter_list = "[" parameter_declaration { ";" parameter_declaration } "]" ;

property_specifiers =  [ "index" expression ] [ read_specifier ] [ write_specifier ] [ default_specifier] ;

read_specifier = "read" qualifier ;

write_specifier = "write" qualifier ;

default_specifier = "default" [ constant ] | "nodefault" ;

(* object type *)

object_type = "object" [ "abstract" | "sealed" ] [ heritage ] { object_component } "end" ;

heritage = "(" qualifier ")" ;

object_component = object_visibility_specifier 
                     | constant_declaration_block 
                     | type_declaration_block 
                     | object_field_definition
                     | object_method_definition
                     | property_declaration_block ;

object_visibility_specifier = "private" | "protected" | "public" ;
                                 
object_field_definition = [ [class] var ] identifier_list ":" type ";" [ "static" ";" ] ;

object_method_definition = constructor_header [ method_directives ] 
                    | destructor_header  [ method_directives ] 
                    | method_definition [ method_directives ] ;


method_definition = [class] function_header
                    | [class] procedure_header
                    | [class] operator_header; 

constructor_header = "constructor" identifier formal_parameter_list ;

destructor_header = "destructor" qualifier formal_parameter_list ;

method_directives = [ "virtual" ";" [ ( "abstract"  | "reintroduce" ) ";" ] ] [ call_modifiers ";" ] ;

(* class declaration *)

class_type = "class" [ "abstract" | "sealed" ] [ class_heritage ] { class_component } ["end"] ;
                                        
class_heritage = "(" qualifier { "," qualifier } ")" ;
                        
class_component = class_visibility_specifier 
                    | constant_declaration_block
                    | type_declaration_block
                    | [class] var_declaration_block
                    | class_field_definition ";"
                    | class_method_definition ";" 
                    | class_property_definition  ";" ;
                
class_visibility_specifier = ["strict"] "private"
                               | ["strict"] "protected"
                               | "public"
                               | "published" ;


class_method_definition =  constructor_header 
                        | destructor_header
                        | method_definition [ class_method_directives ";" ] [ call_modifiers ";" ] ;
                                        
class_method_directives = "virtual" [ abstract_or_reintroduce ]
                    | "dynamic" [ abstract_or_reintroduce ]  
                                        | "override" [ ";" "final" ]
                                        | "reintroduce" [ ";" "virtual" ]
                                        | "message" ( integer_constant | string_constant )  
                                        | "static" [ ";" "inline" ] ;
                                        
abstract_or_reintroduce = ";" ( "abstract" [ ";" "overload" ] | "reintroduce" ) ; 

class_field_definition = identifier_list ":" type ";" [ "static" ";" ] ;

class_property_definition = "property" identifier [ property_interface ] class_property_specifiers [hintdirectives] ";" ;

class_property_specifiers = [ "index" expression ]  [ read_specifier ] [ write_specifier | implements_specifier ] [ default_specifier ]
                        [ stored_specifier ] [ "default" ] ;
                                        
implements_specifier = "implements" identifier { "," identifier } ;

stored_specifier = "stored" identifier;

(* Interface type *)

interface_type = interface [ heritage ] [ guid ] { interface_component } "end";

interface_component = function_header [ ";" call_modifiers ] ";"
                        | procedure_header [ ";" call_modifiers ]  ";"
                        | class_property_definition ";" ;
                        
interface_property_specifiers = [ "index" expression ]  [ read_specifier ] [ write_specifier ] [ default_specifier ] [ "default" ] ;

guid = "[" string_constant "]" ;

(* Generic type *)

generic_type = [ "generic" ] identifier "<" generic_template_list ">" "=" generic_type_def ";" ;

generic_type_def = class_type | object_type | interface_type | procedural_type | record_type | array_type ;

specialized_type = [ "specialize" ] identifier "<" qualifier_list ">" ;

(* Helper type*)

helper_type = ( class | record | type ) "helper" [ "(" base_helper ")" ] for qualifier 
                                helper_component_list "end" [hintdirectives] ;

helper_component_list = helper_component { ";" helper_component } ;

helper_component = method_definition
                 | property_definition ;

constructor_declaration = constructor_header ";" subroutine_block ";" ;

destructor_declaration = destructor_header ";" subroutine_block ";" ;

(* Expressions *)

expression = simple_expression [ relop simple_expression ] ;

relop = "<" | "<=" | ">" | ">=" | "=" | "<>" | "in" | "is" ;

simple_expression = term { addop term } ;

simple_constant_expression = simple_expression ;

addop = "+" | "-" | "or" | "xor" | "><" ;

term = factor { multop factor } ;

multop = "*" | "/" | "div" | "mod" | "and" | "shl" | "shr" | "as" | "<<" | ">>" ;

factor = nested_expr_or_structured_const { selector }
           | varref_or_funcall_or_constid_or_cast
           | unsigned_constant
           | "not" factor
           | sign factor
           | set_constructor
           | address_factor
           | inherited_call ;

varref_or_funcall_or_constid_or_cast = qualifier [ actual_parameter_list ] ;
                                
nested_expr_or_structured_const = "(" element { (","|";") [ element ] } ")" ;

element = [ ":" identifier ":" ] expression ;

unsigned_constant = unsigned_number | character_string | "nil" ;

sign = "+" | "-" ;

actual_parameter_list = "(" [ expression { "," expression } ] ")" ;

set_constructor = "[" [ set_group { "," set_group } ] "]" ;

set_group = expression [ ".." expression ] ;

address_factor = "@" ( designator | nested_expr_or_structured_const ) ;

(* Statements *)

statement_list = statement { ";" [statement] } ;

statement = [ label_def ":" ] unlabeled_statement ;

unlabeled_statement = simple_statement
                    | structured_statement
                    | asm_statement ;

simple_statement = inherited_call
                   | assignment_or_call
                   | goto_statement
                   | raise_statement ;

inherited_call = "inherited" [ identifier [ actual_parameter_list ] ] ;

assignment_or_call = ( designator | nested_expr_or_structured_const { selector } ) 
                       [ assignop expression ] ;

assignop = ":=" | "+=" | "-=" | "*=" | "/=" ;

goto_statement = goto label_def ;

structured_statement = compound_statement
                  | conditional_statement
                  | loop_statement
                  | with_statement
                  | try_statement ;

conditional_statement = case_statement
                      | if_statement ;

loop_statement = for_statement
               | repeat_statement
               | while_statement ;

compound_statement = "begin" statement_list "end" ;

case_statement = case expression of case_part { ";" case_part } [ else_part ] "end" ;

case_part = case_range { "," case_range } ":" statement ;

case_range = constant_expression [ ".." constant_expression ] ;

else_part = ";" ( else | "otherwise" ) statement_list ;

if_statement = if expression then statement [ else statement ] ;

for_statement = for_to_statement
               | for_downto_statement
               | for_in_statement ;

for_to_statement = for identifier ":=" expression "to" expression "do" statement ;

for_downto_statement = for identifier ":=" expression "downto" expression "do" statement ;

for_in_statement = for identifier in enumerable "do" statement ;

enumerable = enumerated_type 
                        | designator
                        | set_constructor ;

repeat_statement = "repeat" statement_list "until" expression ;

while_statement = "while" expression "do" statement ;

with_statement = "with" variable_reference { "," variable_reference } "do" statement ;

asm_statement = "asm" asm_statement_list "end" [ register_list ] ;
                                
register_list = "[" string_constant { "," string_constant } "]" ;

raise_statement = "raise" [ expression [ exception_address ] ] ;

exception_address = "at" expression [ "," expression ] ;

try_statement = "try" statement_list ( "except" exceptionhandlers | "finally" statement_list ) "end" ;

exceptionhandlers = [ statement_list | exception_handler { ";" exception_handler } [ else statement_list ] ];

exception_handler = "on" [ identifier ":" ] type_name "do" statement ;

(* Procedure and function declarations *)

procedure_declaration = procedure_header ";" subroutine_block ";" ;

subroutine_block = block
                 | external_directive
                 | asm_block
                 | "forward" ;

function_declaration = function_header ";" subroutine_block ";" ;

formal_parameter_list = [ "(" parameter_declaration { ";" parameter_declaration } ")" ] ;

parameter_declaration = constant_parameter
                      | value_parameter
                      | variable_parameter
                      | out_parameter ;
                      
value_parameter = identifier_list ":" parameter_type [ "=" default_parameter_value ] ;
                                
variable_parameter = var identifier_list [ ":" parameter_type ] ;

out_parameter = out identifier_list [ ":" parameter_type ] ;

constant_parameter = ( "const" | "constref" ) identifier_list [ ":" parameter_type [ "=" default_parameter_value ] ] ;
                                        
parameter_type = [ array of ] ( qualifier | "const" ) ;

external_directive = "external" [ string_constant [ "name" string_constant | "index" integer_constant] ] ;

asm_block = "assembler" ";" asm_statement_list ;

modifiers = ";" modifier { ";" modifier } ;

modifier = 
        "export"
        | "alias" ":" string_constant
        | "interrupt"
        | "noreturn"
        | "iocheck"
        | call_modifier ;
                                                
operator_implementation = operator_header ";" subroutine_block ";" ;

assignment_operator_definition = ( ":=" | "explicit" | "implicit" ) "(" parameter_list ")" ;

arithmetic_operator_definition = ( "+" | "-" | "*" | "/" | "**" | "><" | div | mod | shl | shr ) "(" parameter_list ")" ;

comparison_operator_definition = ( "=" | "<" | "<=" | ">" | ">=" | "<>" | in ) "(" parameter_list ")" ;

logical_operator_definition = ( and | or | xor | not ) "(" parameter_list ")" ;

other_operator_definition = ( "enumerator" | "inc" | "dec" ) "(" parameter_list ")" ;

label_def = decimal_int | identifier ;

identifier =   letter | "_" { letter | dec_digit | "_" } ;

designator = ( identifier | string ) { selector  | subrange } ;

selector = "." identifier | "[" expression  { "," expression } "]" | "^"  | actual_parameter_list ;

qualifier = identifier [ "." identifier ] ;


string_constant = character_string { "+" character_string } ;

integer_constant = signed_integer | unsigned_integer ;

(* scanner/lexer *)

comment = "(*" non_comment_characters "*)"
          | "{" non_comment_characters "}"
          | "//" non_comment_character EOL ;

letter =   "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" 
       |   "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z"
       |   "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" 
       |   "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z"
       ;
       
binary_digit      =   "0" | "1" ;
octal_digit       =   binary_digit | "2"  "3" | "4" |"5" | "6" | "7" ;
decimal_digit     =   octal_digit | "8" | "9" ;
hexadecimal_digit =   decimal_digit | "A" | "B" | "C" | "D" | "E" | "F" | "a" | "b" | "c" | "d" | "e" | "f" ;

binary_digit_sequence  =   binary_digit { ( "_"| binary_digit ) } ;
octal_digit_sequence  =   octal_digit {  ( "_"| octal_digit ) } ;
decimal_digit_sequence  =   decimal_digit {  ( "_"| decimal_digit ) } ;
hexadecimal_digit_sequence  =   hexadecimal_digit {  ( "_"| hexadecimal_digit ) } ;

unsigned_integer    =   decimal_digit_sequence 
                    |   "%" binary_digit_sequence 
                    |   "&" octal_digit_sequence 
                    |   "$" hexadecimal_digit_sequence 
                    ;
                    
signed_integer = sign unsigned_integer ;
                    
unsigned_real       =   dec_digit_sequence  [ "." dec_digit_sequence ] [ scale_factor ] ;

scale_factor        =   "E" | "e" [ sign ] dec_digit_sequence ;

unsigned_number     =   unsigned_real | unsigned_integer ;

signed_number       =   sign unsigned_number ;

quoted_string       =   "'" { string_character } "'" ;

string_character    =   "'" | non_terminal_string_character ;

control_string      =   "#" unsigned_integer ;

character_string = ( quoted_string | control_string ) { quoted_string | control_string } ;