EBNF syntax definition

Warning

The new tooling will be using a Parsing Expression Grammar (PEG) instead. For now, the EBNF syntax definition is still included here for archiving purposes. The up-to-date PEG can be found at grammar.pest.

Notation	Should be read as
"abc"	Literal text "abc"
\n	Continue at the next line
DEF	Terminal DEF
ghi	Expansion of rule ghi
a b	a followed by b
a | b	Either a or b
a ( b | c)	a followed by either a or b
[a]	a or nothing
{a}	Sequence of zero or more times a
{a}+	Sequence of one or more times a
x ::= b c	x is defined as b followed by c
/* note */	Comment or additional constraint

esl-specification ::=
  { type-definition
  | verb-definition
  | relation-definition
  | world-section /* Exactly one */
  | component-definition }+

/* -------------------------------- */
/* Types */

type-definition ::=
  "define" "type" \n
  { new-singular-type \n
  | new-bundle-type \n
  }+

new-singular-type ::= (
  TYPE-NAME [ enumeration-specification | unit-specification | range-specification ]
|
  TYPE-NAME "is" ( "a" | "an" ) TYPE-NAME [
     unit-specification | range-specification
   ]
)

new-bundle-type ::=
  TYPE-NAME "is" "a" "bundle" "of" \n
  { "*" bundle-field-specification }+

bundle-field-specification ::= (
  FIELD-NAME "is" ( "a" | "an" ) TYPE-NAME
)

unit-specification ::=
  "with" ( "unit" | "units" ) UNIT-NAME { "," UNIT-NAME }

enumeration-specification ::=
  "is" "an" "enumeration" "of" VALUE [ unit ] { "," VALUE [ unit ]}

range-specification ::=
  ( interval-specification | constant-specification )

interval-specification ::=
  "of" interval { "or" interval }

interval ::=
  ( open-interval | closed-interval )

open-interval ::=
  ( lower-bound | upper-bound )

closed-interval ::=
  lower-bound "and" upper-bound

lower-bound ::=
  "at" "least" VALUE [ unit ]

upper-bound ::=
  "at" "most" VALUE [ unit ]

constant-specification ::=
  "equal" "to" VALUE [ unit ]

/* -------------------------------- */
/* Verbs and relations */

verb-definition ::=
    "define" "verb" \n
  { VERB PREPOSITION \n }+

relation-definition ::=
  "define" "relation" \n
  { RELATION-DEF-NAME \n
    { ( "requiring" | "returning" | "relating" ) "parameter"  \n
      { "*" ["one" "or" "more"] PARAMETER-NAME "is" ("a" | "an") TYPE-NAME \n }+
    }+ /* At most one requiring, returning and relating. */
  }+

/* -------------------------------- */
/* World and component */

world-section ::=
    "world" \n
  ( "empty" | { variable-section
              | group-section
              | component-section
              | need-section
              | goal-section
              | behavior-section
              | design-section
              | comment-section }+ )

component-definition ::=
    "define" "component" COMPONENT-KIND \n
  ( "empty" | { parameter-section
              | variable-section
              | group-section
              | transform-section
              | component-section
              | need-section
              | goal-section
              | behavior-section
              | design-section
              | comment-section }+ )

component-section ::=
    "component" \n
  { COMPONENT-NAME "is"
  ( "a" | "an" ) COMPONENT-KIND
  (  \n | arguments  )  }+

/* -------------------------------- */
/* Parameter and variable */

parameter-section ::=
    "parameter" \n
  { PARAMETER-NAME { "," PARAMETER-NAME }
    "is" ( "a" | "an" ) TYPE-NAME [ "property" ] \n
  }+

variable-section ::=
    "variable" \n
  { VARIABLE-NAME { "," VARIABLE-NAME }
    "is" ( "a" | "an" ) TYPE-NAME  \n
  }+

group-section ::=
  "variable-group" \n
  { group-definition }+

group-definition ::=
  GROUP-NAME "is" "a" "group" "of" \n
    argument-list

/* -------------------------------- */
/* Argument */

arguments ::=
    "with" "arguments" \n
    argument-list

argument-list ::=
  { "*" argument-name
    { "," argument-name } \n
  }+

argument-references ::=
    argument-name
  { and-connector argument-name } \n

and-connector ::=
    "and"
  | ","
  | "," "and"

argument-name ::=
    PARAMETER-NAME
  | VARIABLE-NAME

/* -------------------------------- */
/* Need */

need-section ::=
    "need" \n
  { NEED-NAME ":" need-literal \n }+

need-literal ::=
    subject-name { WORD }+

subject-name ::=
    argument-name
  | COMPONENT-NAME
  | GOAL-NAME
  | TRANSFORMATION-NAME
  | DESIGN-NAME
  | BEHAVIOR-NAME

/* -------------------------------- */
/* Goal */

goal-section ::=
    goal-type \n
  { GOAL-NAME ":" goal-literal }+

goal-type ::=
    "goal-requirement"
  | "goal-constraint"

goal-literal ::=
    COMPONENT-NAME
  ( "does"           /* constraint */
  | auxiliary-verb ) /* requirement */
    VERB argument-references PREPOSITION
    COMPONENT-NAME
  ( \n | subclauses )

/* -------------------------------- */
/* Behavior */

behavior-section ::=
  behavior-type \n
  { BEHAVIOR-NAME ":" \n
    behavior-clause
  }+

behavior-type ::=
  "behavior-requirement" | "behavior-constraint"

behavior-clause ::=
  {
    "case" CASE-NAME ":" \n
    ( regular-case-clause
    | fall-back-case-clause
    )
  }+ /* At most one fall-back-case-clause per behavior-clause. */

regular-case-clause ::=
  when-clause
  then-clause

when-clause ::=
  "when" \n
    { "*" CASE-CONDITION-NAME ":" comparison-rule-line \n }+ /* Only 'is' as auxiliary verb. */

then-clause ::=
  "then" \n
    { "*" CASE-RULE-NAME ":" comparison \n }+

fall-back-case-clause ::=
  "when" "no" "other" "case" "applies" \n
  then-clause


/* -------------------------------- */
/* Transform */

transform-section ::=
    transformation-type \n
  { TRANSFORMATION-NAME ":"
    transform-literal \n }+

transformation-type ::=
    "transformation-requirement"
  | "transformation-constraint"

transformation-literal ::=
  ( "does"           /* constraint */
  | auxiliary-verb ) /* requirement */
    VERB argument-references PREPOSITION
    argument-references
  ( \n | subclauses )

/* -------------------------------- */
/* Design-rules */

design-section ::=
    design-rule-type \n
  { DESIGN-RULE-NAME ":"
    design-rule-line }+

design-rule-type ::=
    "design-requirement"
  | "design-constraint"

design-rule-line ::=
  comparison-rule-line
  ( \n | subclauses )

/* -------------------------------- */
/* Subclauses */

subclauses ::=
  "with" "subclauses" \n
  { "*" SUBCLAUSE-NAME ":"
    comparison-rule-line \n
  }+

/* -------------------------------- */
/* Comparison */

comparison-rule-line ::=
  comparison
  { "or" comparison }

comparison ::=
  argument-name
  ( constraint-rule-literal | requirement-rule-literal )

constraint-rule-literal ::=
  "is" compare-op bound

requirement-rule-literal ::=
  auxiliary-verb "be"
  ( compare-op bound | objective )

compare-op ::=
    "smaller" "than"
  | "greater" "than"
  | "not" "equal" "to"
  | "equal" "to"
  | "at" "least"
  | "at" "most"
  | "approximately" /* Only in a requirement-rule-literal */

bound ::=
    argument-name
  | VALUE [ unit ]
  | "t.b.d." [ unit ]

unit ::=
    UNIT-NAME
  | "[" UNIT-NAME "]"

objective ::=
    "maximized"
  | "minimized"

/* -------------------------------- */
/* Relations */

relation-section ::=
  "relation" \n
  { RELATION-NAME ":" RELATION-DEF-NAME \n
    { ( "requiring" | "returning" | "relating" ) "argument"  \n
      { "*" argument-name \n }+
    }+ /* At most one requiring, returning and relating. */
  }+

/* -------------------------------- */
/* Comments */

comment-section ::=
    "comment"
  { target-name "#<" { WORD } \n }+

target-name ::=
    argument-name
  | COMPONENT-NAME
  | NEED-NAME
  | GOAL-NAME
  | TRANSFORMATION-NAME
  | RELATION-NAME

/* -------------------------------- */
/* Requirement verbs */

auxiliary-verb ::=
    "shall"
  | "must"
  | "should"
  | "could"
  | "won't"