; Copyright (C) 2019-2022 Aleo Systems Inc.
; This file is part of the Leo library.

; The Leo library is free software: you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by
; the Free Software Foundation, either version 3 of the License, or
; (at your option) any later version.

; The Leo library is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; GNU General Public License for more details.

; You should have received a copy of the GNU General Public License
; along with the Leo library. If not, see <https://www.gnu.org/licenses/>.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Lexical Grammar
; ---------------

ascii = %x0-7F

safe-nonascii = %x80-2029 / %x202F-2065 / %x2070-D7FF / %xE000-10FFFF
                ; excludes bidi embeddings/overrides/isolates
                ; and excludes high/low surrogates

character = ascii / safe-nonascii

horizontal-tab = %x9   ; <HT>

line-feed = %xA   ; <LF>

carriage-return = %xD   ; <CR>

space = %x20   ; <SP>

double-quote = %x22   ; "

single-quote = %x27   ; '

line-terminator = line-feed / carriage-return / carriage-return line-feed

whitespace = space / horizontal-tab / line-terminator

not-line-feed-or-carriage-return =
    %x0-9 / %xB-C / %xE-7F / safe-nonascii
    ; anything but <LF> or <CR>

not-star-or-line-feed-or-carriage-return =
    %x0-9 / %xB-C / %xE-29 / %x2B-7F / safe-nonascii
    ; anything but * or <LF> or <CR>

not-star-or-slash-or-line-feed-or-carriage-return =
    %x0-9 / %xB-C / %xE-29 / %x2B-2E / %x30-7F / safe-nonascii
    ; anything but * or / or <LF> or <CR>

not-double-quote-or-backslash-or-line-feed-or-carriage-return =
    %x0-9 / %xB-C / %xE-21 / %x23-5B / %x5D-7F / safe-nonascii
    ; anything but " or \ or <LF> or <CR>

comment = block-comment / end-of-line-comment

block-comment = "/*" rest-of-block-comment

rest-of-block-comment =
      "*" rest-of-block-comment-after-star
    / not-star-or-line-feed-or-carriage-return rest-of-block-comment
    / line-terminator rest-of-block-comment

rest-of-block-comment-after-star =
      "/"
    / "*" rest-of-block-comment-after-star
    / not-star-or-slash-or-line-feed-or-carriage-return rest-of-block-comment
    / line-terminator rest-of-block-comment

end-of-line-comment = "//" *not-line-feed-or-carriage-return

keyword = %s"address"
        / %s"bool"
        / %s"circuit"
        / %s"console"
        / %s"const"
        / %s"constant"
        / %s"else"
        / %s"field"
        / %s"for"
        / %s"function"
        / %s"group"
        / %s"i8"
        / %s"i16"
        / %s"i32"
        / %s"i64"
        / %s"i128"
        / %s"if"
        / %s"in"
        / %s"let"
        / %s"public"
        / %s"record"
        / %s"return"
        / %s"scalar"
        / %s"string"
        / %s"u8"
        / %s"u16"
        / %s"u32"
        / %s"u64"
        / %s"u128"

uppercase-letter = %x41-5A   ; A-Z

lowercase-letter = %x61-7A   ; a-z

letter = uppercase-letter / lowercase-letter

decimal-digit = %x30-39   ; 0-9

octal-digit = %x30-37   ; 0-7

hexadecimal-digit = decimal-digit / "a" / "b" / "c" / "d" / "e" / "f"

identifier = letter *( letter / decimal-digit / "_" )
             ; but not a keyword or a boolean literal or aleo1...

numeral = 1*decimal-digit

unsigned-literal = numeral ( %s"u8" / %s"u16" / %s"u32" / %s"u64" / %s"u128" )

signed-literal = numeral ( %s"i8" / %s"i16" / %s"i32" / %s"i64" / %s"i128" )

field-literal = numeral %s"field"

product-group-literal = numeral %s"group"

scalar-literal = numeral %s"scalar"

boolean-literal = %s"true" / %s"false"

address-literal = %s"aleo1" 58( lowercase-letter / decimal-digit )

single-quote-escape = "\" single-quote   ; \'

double-quote-escape = "\" double-quote   ; \"

backslash-escape = "\\"

line-feed-escape = %s"\n"

carriage-return-escape = %s"\r"

horizontal-tab-escape = %s"\t"

null-character-escape = "\0"

simple-character-escape = single-quote-escape
                        / double-quote-escape
                        / backslash-escape
                        / line-feed-escape
                        / carriage-return-escape
                        / horizontal-tab-escape
                        / null-character-escape

ascii-character-escape = %s"\x" octal-digit hexadecimal-digit

unicode-character-escape = %s"\u{" 1*6hexadecimal-digit "}"

string-literal = double-quote *string-literal-element double-quote

string-literal-element =
      not-double-quote-or-backslash-or-line-feed-or-carriage-return
    / simple-character-escape
    / ascii-character-escape
    / unicode-character-escape

integer-literal = unsigned-literal
                / signed-literal

numeric-literal = integer-literal
                / field-literal
                / product-group-literal
                / scalar-literal

atomic-literal = numeric-literal
               / boolean-literal
               / address-literal
               / string-literal

symbol = "!" / "&&" / "||"
       / "==" / "!="
       / "<" / "<=" / ">" / ">="
       / "&" / "|" / "^"
       / "<<" / ">>"
       / "+" / "-" / "*" / "/" / "**"
       / "="
       / "(" / ")"
       / "[" / "]"
       / "{" / "}"
       / "," / "." / ".." / ";" / ":" / "::" / "?"
       / "->" / "_"
       / %s")group"

token = keyword
      / identifier
      / atomic-literal
      / numeral
      / symbol

lexeme = token / comment / whitespace

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Syntactic Grammar
; -----------------

unsigned-type = %s"u8" / %s"u16" / %s"u32" / %s"u64" / %s"u128"

signed-type = %s"i8" / %s"i16" / %s"i32" / %s"i64" / %s"i128"

integer-type = unsigned-type / signed-type

field-type = %s"field"

group-type = %s"group"

scalar-type = %s"scalar"

arithmetic-type = integer-type / field-type / group-type / scalar-type

boolean-type = %s"bool"

address-type = %s"address"

string-type = %s"string"

primitive-type =  boolean-type / arithmetic-type / address-type / string-type

named-type = primitive-type / identifier

tuple-type = "(" [ type 1*( "," type ) [ "," ] ] ")"

type = named-type / tuple-type

group-coordinate = ( [ "-" ] numeral ) / "+" / "-" / "_"

affine-group-literal = "(" group-coordinate "," group-coordinate %s")group"

literal = atomic-literal / affine-group-literal

group-literal = product-group-literal / affine-group-literal

primary-expression = literal
                   / variable-or-free-constant
                   / associated-constant
                   / "(" expression ")"
                   / free-function-call
                   / static-function-call
                   / tuple-expression
                   / circuit-expression

variable-or-free-constant = identifier

associated-constant = named-type "::" identifier

free-function-call = identifier function-arguments

static-function-call = named-type "::" identifier function-arguments

function-arguments = "(" [ expression *( "," expression ) [ "," ] ] ")"

tuple-expression = "(" [ expression 1*( "," expression ) [ "," ] ] ")"

circuit-expression = identifier "{" circuit-component-initializer
                                    *( "," circuit-component-initializer )
                                    [ "," ] "}"

circuit-component-initializer = identifier
                              / identifier ":" expression

postfix-expression = primary-expression
                   / tuple-component-expression
                   / circuit-component-expression
                   / operator-call

tuple-component-expression = postfix-expression "." numeral

circuit-component-expression = postfix-expression "." identifier

operator-call = unary-operator-call / binary-operator-call

unary-operator-call = postfix-expression "." identifier "(" ")"

binary-operator-call =
    postfix-expression "." identifier "(" expression [ "," ] ")"

unary-expression = postfix-expression
                 / "!" unary-expression
                 / "-" unary-expression

exponential-expression = unary-expression
                       / unary-expression "**" exponential-expression

multiplicative-expression = exponential-expression
                          / multiplicative-expression "*" exponential-expression
                          / multiplicative-expression "/" exponential-expression

additive-expression = multiplicative-expression
                    / additive-expression "+" multiplicative-expression
                    / additive-expression "-" multiplicative-expression

shift-expression = additive-expression
                 / shift-expression "<<" additive-expression
                 / shift-expression ">>" additive-expression

conjunctive-expression = shift-expression
                       / conjunctive-expression "&" shift-expression

disjunctive-expression = conjunctive-expression
                       / disjunctive-expression "|" conjunctive-expression

exclusive-disjunctive-expression =
      disjunctive-expression
    / exclusive-disjunctive-expression "^" disjunctive-expression

ordering-expression =
      exclusive-disjunctive-expression
    / exclusive-disjunctive-expression "<" exclusive-disjunctive-expression
    / exclusive-disjunctive-expression ">" exclusive-disjunctive-expression
    / exclusive-disjunctive-expression "<=" exclusive-disjunctive-expression
    / exclusive-disjunctive-expression ">=" exclusive-disjunctive-expression

equality-expression = ordering-expression
                    / ordering-expression "==" ordering-expression
                    / ordering-expression "!=" ordering-expression

conditional-conjunctive-expression =
      equality-expression
    / conditional-conjunctive-expression "&&" equality-expression

conditional-disjunctive-expression =
      conditional-conjunctive-expression
    / conditional-disjunctive-expression "||" conditional-conjunctive-expression

binary-expression = conditional-disjunctive-expression

conditional-ternary-expression = binary-expression
                               / binary-expression "?" expression ":" expression

expression = conditional-ternary-expression

statement = return-statement
          / variable-declaration
          / constant-declaration
          / conditional-statement
          / loop-statement
          / assignment-statement
          / console-statement
          / block

block = "{" *statement "}"

return-statement = %s"return" expression ";"

variable-declaration = %s"let" identifier ":" type "=" expression ";"

constant-declaration = %s"const" identifier ":" type "=" expression ";"

branch = %s"if" expression block

conditional-statement = branch
                      / branch %s"else" block
                      / branch %s"else" conditional-statement

loop-statement = %s"for" identifier ":" type
                 %s"in" expression ".." [ "=" ] expression
                 block

assignment-operator = "="

assignment-statement = expression assignment-operator expression ";"

console-statement = %s"console" "." console-call ";"

console-call = assert-call
             / print-call

assert-call = %s"assert" "(" expression ")"

print-function = %s"error" / %s"log"

print-arguments = "(" string-literal  *( "," expression ) [ "," ] ")"

print-call = print-function print-arguments

function-declaration = %s"function" identifier
                       "(" [ function-parameters ] ")" "->" type
                       block

function-parameters = function-parameter *( "," function-parameter ) [ "," ]

function-parameter = [ %s"public" / %s"constant" / %s"const" ]
                     identifier ":" type

circuit-declaration = %s"circuit" identifier
                      "{" circuit-component-declaration
                          *( "," circuit-component-declaration )
                          [ "," ] "}"

circuit-component-declaration = identifier ":" type

record-declaration = %s"record" "{" circuit-component-declaration
                                    *( "," circuit-component-declaration )
                                    [ "," ] "}"

declaration = function-declaration
            / circuit-declaration
            / record-declaration

file = *declaration

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Format String Grammar
; ---------------------

not-brace = %x0-7A / %x7C / %x7E-10FFFF  ; anything but { or }

format-string-container = "{}"

format-string-open-brace = "{{"

format-string-close-brace = "}}"

format-string-element = not-brace
                      / format-string-container
                      / format-string-open-brace
                      / format-string-close-brace

format-string = *format-string-element

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Input Grammar
; -------------

input-type = primitive-type

input-expression = expression

input-item = identifier ":" input-type "=" input-expression ";"

input-title = "[" ( %s"public" / %s"private" / %s"constant" / %s"const" ) "]"

input-section = input-title *input-item

input-file = *input-section

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Output Grammar
; --------------

output-expression = expression

output-item = output-expression ";"

output-title = "[" %s"output" "]"

output-section = output-title output-item

output-file = output-section