You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
For field formats described in this specification, we use a limited subset of [Extended Backus-Naur Form][ebnf], similar to that used by the [XML specification][xmlebnf].
31
+
Grammars present in the OCI specification are regular and can be converted to a single regular expressions.
32
+
However, regular expressions are avoided to limit abiguity between regular expression syntax.
33
+
By defining a subset of EBNF used here, the possibility of variation, misunderstanding or ambiguities from linking to a larger specification can be avoided.
34
+
35
+
Grammars are made up of rules in the following form:
36
+
37
+
```
38
+
symbol ::= expression
39
+
```
40
+
41
+
We can say we have the production identified by symbol if the input is matched by the expression.
42
+
Whitespace is completely ignored in rule definitions.
43
+
44
+
## Expressions
45
+
46
+
The simplest expression is the literal, surrounded by quotes:
47
+
48
+
```
49
+
literal ::= "matchthis"
50
+
```
51
+
52
+
The above expression defines a symbol, "literal", that matches the exact input of "matchthis".
53
+
Character classes are delineated by brackets (`[]`), describing either a set, range or multiple range of characters:
54
+
55
+
```
56
+
set := [abc]
57
+
range := [A-Z]
58
+
```
59
+
60
+
The above symbol "set" would match one character of either "a", "b" or "c".
61
+
The symbol "range" would match any character, "A" to "Z", inclusive.
62
+
Currently, only matching for 7-bit ascii literals and character classes is defined, as that is all that is required by this specification.
63
+
Multiple character ranges and explicit characters can be specified in a single character classes, as follows:
64
+
65
+
```
66
+
multipleranges := [a-zA-Z=-]
67
+
```
68
+
69
+
The above matches the characters in the range `A` to `Z`, `a` to `z` and the individual characters `-` and `=`.
70
+
71
+
Expressions can be made up of one or more expressions, such that one must be followed by the other.
72
+
This is known as an implicit concatenation operator.
73
+
For example, to satisfy the following rule, both `A` and `B` must be matched to satisfy the rule:
74
+
75
+
```
76
+
symbol ::= A B
77
+
```
78
+
79
+
Each expression must be matched once and only once, `A` followed by `B`.
80
+
To support the description of repetition and optional match criteria, the postfix operators `*` and `+` are defined.
81
+
`*` indicates that the preceeding expression can be matched zero or more times.
82
+
`+` indicates that the preceeding expression must be matched one or more times.
83
+
These appear in the following form:
84
+
85
+
```
86
+
zeroormore ::= expression*
87
+
oneormore ::= expression+
88
+
```
89
+
90
+
Parentheses are used to group expressions into a larger expression:
91
+
92
+
```
93
+
group ::= (A B)
94
+
```
95
+
96
+
Like simpler expressions above, operators can be applied to groups, as well.
97
+
To allow for alternates, we also define the infix operator `|`.
98
+
99
+
```
100
+
oneof ::= A | B
101
+
```
102
+
103
+
The above indicates that the expression should match one of the expressions, `A` or `B`.
104
+
105
+
## Precedence
106
+
107
+
The operator precedence is in the following order:
108
+
109
+
- Terminals (literals and character classes)
110
+
- Grouping `()`
111
+
- Unary operators `+*`
112
+
- Concatenation
113
+
- Alternates `|`
114
+
115
+
The precedence can be better described using grouping to show equivalents.
116
+
Concatenation has higher precedence than alernates, such `A B | C D` is equivalent to `(A B) | (C D)`.
117
+
Unary operators have higher precedence than alternates and concatenation, such that `A+ | B+` is equivalent to `(A+) | (B+)`.
118
+
119
+
## Examples
120
+
121
+
The following combines the previous definitions to match a simple, relative path name, describing the individual components:
122
+
123
+
```
124
+
path ::= component ("/" component)*
125
+
component ::= [a-z]+
126
+
```
127
+
128
+
The production "component" is one or more lowercase letters.
129
+
A "path" is then at least one component, possibly followed by zero or more slash-component pairs.
130
+
The above can be converted into the following regular expression:
Copy file name to clipboardExpand all lines: descriptor.md
+6-6Lines changed: 6 additions & 6 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -66,14 +66,14 @@ If the _digest_ can be communicated in a secure manner, one can verify content f
66
66
The value of the `digest` property is a string consisting of an _algorithm_ portion and an _encoded_ portion.
67
67
The _algorithm_ specifies the cryptographic hash function and encoding used for the digest; the _encoded_ portion contains the encoded result of the hash function.
68
68
69
-
A digest string MUST match the following grammar:
69
+
A digest string MUST match the following [grammar](considerations.md#ebnf):
0 commit comments