mirror of
https://github.com/ProvableHQ/leo.git
synced 2024-12-19 08:02:14 +03:00
469 lines
13 KiB
Plaintext
469 lines
13 KiB
Plaintext
; 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" "{" 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
|