The Sawzall Language Specification

Objective

Organization and conventions

To describe the language syntax in detail, Extended Backus-Naur Form (EBNF) is used: Alternatives are separated by vertical bars |. Parentheses ( and ) are used for grouping. Expressions enclosed in square brackets [ and ] are optional. Curly braces { and } denote repetition (0 or more times) of the enclosed expression. Names of EBNF productions referring to terminal symbols start with a lower-case letter; all other production names start with a capital letter. Literal characters and strings are enclosed in single quotes ' and '. A precise definition of EBNF can be found in the Appendix.

Occasionally, the language syntax is presented in a slightly simplified form to facilitate reading. For instance, this is the case for the definition of string literals where a complete formal definition would become very cumbersome to understand, without adding value to the reader. Annotations in small font may be used to explain some of the fine points in those cases.

Programming model

Since processing is independent, data about all the processed log entries is aggregated externally to a Sawzall program proper. To that end, Sawzall supports the declaration of output types and corresponding output variables. Output variables are the connection to specific aggregators (such as accumulators, collectors, filters, etc.) of data. A special construct, the emit statement, is used to send data to such an aggregator. The aggregator receives the data emitted to it, and aggregates it in a manner specific to its type. For example, a sum aggregator, referred to via an output variable of sum output type, will add up all the values it receives. A collection aggregator will simply collect all the data, etc. The Sawzall language doesn't specify a particular implementation for aggregators, but the Szl implementation does provide an implementation.

Processing of a large set of log entries may take a considerable amount of time even if they are processed in parallel. Furthermore, it is not unlikely to occasionally encouter corrupted log entries. It is important to be able to handle these cases gracefully, without abortion of the process. To that end, Sawzall supports the notion of defined and undefined values. Expressions and statements may be silently aborted if undefined values are encountered. It is the hope that most programs will be able to continue execution even in the presence of occasional errors caused by corrupted input data.

Overall program structure

Program = { Declaration | Statement }.

Example

# Program to find the three most commonly used word in a list.

# Input is text lines containing a word and a count, separated with a comma.

  topwords: table top(3) of word: string weight count: int;
  fields: array of bytes = splitcsvline(input);
  w: string = string(fields[0]);
  c: int = int(string(fields[1]), 10);
  if (c != 0) {
    emit topwords <- w weight c;
  }

Declarations and scope rules

Declaration = TypeDecl | StaticVarDecl | VarDecl.

Type declarations

TypeDecl = 'type' type_name '=' Type ';'.
type_name = identifier.

Examples

type my_bool = bool;
type Coordinates = { x: float, y: float };
type CityMap = map [city_name: string] of Coordinates;

Variable declarations

The variable type may be specified explicitly, followed by an optional initialization expression. Alternatively, the explicit type specification may be elided in favor of the initialization expression, in which case the type of the variable is the type of the initialization expression. Thus, either the variable type or the initialization expression (but not both) may be missing. A variable may be declared static by prefixing the declaration with the keyword static.

StaticVarDecl = 'static' VarDecl.
VarDecl = var_name ':' [Type] ['=' Expression | Block] ';'.
var_name = identifier.

Initialization expressions for static variables must not refer to non-static variables; if variable names appear in the expression, the associated variables must be static. In particular, if a (non-intrinsic) function is called in an initialization expression, that function must be stored in a static variable.

A variable declaration with an initialization expression of the form:

variable_name: variable_type = expression;

variable_name: variable_type;
variable_name = variable_type(expression);

variable_name := expression;

If the initialization expression is a function, the variable type must be a function type. Therefore, a function declaration looks like this:

function_name: function_type = function_type {
  # function body
};

function_name := function_type {
  # function body
};

function_name: function_type {
  # function body
};

The evaluation of the initialization expression may result in an undefined value. In that case, the undefined value may be silently assigned to the variable (implementation-specific, see also Undefined values below).

Examples

n := 10;
counter: int = 0;
static pi := 3.14159265;
hypot := sqrt(x*x + y*y);
static word := load("/home/szluser/current/word");
a: array of float = { 2.4, PI, float("1.234") };
unique_language_values: table unique (10) of {language: string, value: string};
average := function(list: array of float): float;
min := function(x: int, y: int): int { if (x < y) return x; return y; };
static country_codes: array of string = LoadCountries("countries.txt");

Undefined values

If an undefined value is used within an expression, the value of the expression becomes undefined. In particular, if an undefined value is used as an argument for a function call, the function is not called and the function result is undefined.

If an undefined value is assigned to a variable, the variable becomes undefined. In particular, if an undefined value is stored as array element, tuple field, or map entry, the entire array, tuple, or map becomes undefined. Thus, variables are either entirely defined or entirely undefined. Initially, all variables are undefined until a defined value is assigned to them. Function parameters are defined upon invocation of the function because it can only be called if all arguments are defined.

The intrinsic function def(x: T): bool can be used to test an arbitrary expression x of any type T for defined'ness. def(x) returns true if the value of x is defined; it returns false otherwise. Thus, def() acts like a guard against the propagation of undefined values.

Current implementation

Undefined initialization expressions don't cause a run-time trap so that it is possible to write code such as

x: T = expr;  # potentially undefined
if (def(x))
  # x is defined; it can be used w/o runtime trap
else
  # x is undefined; using it will cause a runtime trap
  # (unless used again in one of the exception cases described here)

Undefined return expressions don't cause a run-time trap so that it is possible to return an undefined value from a user-defined function; usually to indicate that the function failed. For instance, one might write a function f that returns a result of type T, and also use the result mechanism to indicate if the function was successful or not:

f := function(...): T {
  ...
  # return an undefined value to indicate failure of f
  u: T;
  return u;
};

result: T = f(...);
if (def(result))
  # function succeeded; result is defined
else
  # function failed; result is undefined
}

Types

Value semantics

Implementation note

Type specifications

Type =
  type_name | ArrayType | MapType | TupleType |
  OutputType | FunctionType | 'proto' Type.
type_name = identifier.

Basic types

bool        # the boolean values true and false
bytes       # arrays of unsigned bytes
int         # 64-bit signed integer values
float       # 64-bit IEEE floating point values
time        # unsigned integral representations of time, with microsecond resolution
fingerprint # unsigned hash values computed by an implementation-defined hash function
string      # arrays of unicode characters
uint        # 64-bit unsigned integer valuse

Composite types

Component = [component_name ':'] ComponentType.
component_name = identifier.
ComponentType = Type.

Array types

ArrayType = 'array' 'of' Element.
Element = Component.

Examples

array of int
array of names: string
array of array of point: Point

Tuple types

The type of a tuple field, static declaration or type declaration may refer to the name of an enclosing type; that is, type declarations may be recursive. When used in a field or type declaration, the inner type reference must occur within an array type or map type enclosed by the outer type declaration. (That is, there must be a way to omit the value of the field. Otherwise it would be impossible to represent an object of that type.)

Although types may be recursive, objects can neither contain nor refer to enclosing objects or themselves (directly or indirectly). This is because Sawzall is value-based and has no pointers or references.

Types cannot be mutually recursive. Since Sawzall does not have forward references it is not possible to have two types (e.g. tuples) each of which makes use of the other.

Named fields only may also have an integer value called (field) tag associated with it. Tags are used to associate the field with a field in the protocol buffer representation of the tuple (see also Protocol Buffers). No two fields within a tuple can have the same tag, and all tags must be > 0. Tuples with tagged fields are called proto tuples; tuples without tagged fields are called simple tuples. All fields of proto tuples must have tags.

Tagged fields of proto tuples may also specify a constant default value. The default value is used to initialize a field during proto conversion if the corresponding field value is missing in the proto buffer being converted. The special intrinsic inproto(field: T): bool can be used to test whether a proto tuple field was present in the protocol buffer converted into the proto tuple (see also A Manual for the Sawzall Intrinsics).

Tagged fields of proto tuples may also specify a corresponding underlying protocol buffer field type. This is the field type the tuple field is converted into when the tuple is converted from a Sawzall tuple back into the protocol buffer representation. If no protocol buffer field type is specified, a default field type is assumed (see table below).

For historical reasons, a proto tuple type may start with the keyword parsedmessage to indicate that the tuple is a proto tuple. The keyword is treated as a comment.

TupleType = SimpleTupleType | ProtoTupleType.

SimpleTupleType = '{' [SimpleMemberList] '}'.
SimpleMemberList = SimpleMember {',' SimpleMember} [','].
SimpleMember = TypeDecl | StaticVarDecl | SimpleFieldDecl.
SimpleFieldDecl = Component.

ProtoTupleType = ['parsedmessage'] '{' [ProtoMemberList] '}'.
ProtoMemberList = ProtoMember {',' ProtoMember} [','].
ProtoMember = TypeDecl | StaticVarDecl | ProtoFieldDecl.
ProtoFieldDecl = Component ['=' ProtoFieldDefault] '@' proto_field_tag [':' proto_field_type].
ProtoFieldDefault = Expression.
proto_field_tag = integer.
proto_field_type = identifier.

Protocol buffer type	Sawzall type	Comments
bool	bool	default conversion
boolean	bool
string	bytes	default conversion
fixed32	int	may overflow
fixed64	fingerprint	default conversion
fixed64	int	default conversion
fixed64	time	default conversion
int32	int	may overflow
int64	int
uint64	uint	default conversion
float	float	may overflow
double	float	default conversion

For each protocol buffer field type there is a corresponding Sawzall field type; for each Sawzall field type there may be more than one protocol buffer field type. Some Sawzall fields may lose information (overflow may occur) if they are converted into a protocol buffer field of a narrower type (note that all basic Sawzall types - except bytes and string - are 64 bits wide). The default conversions are used if no protocol buffer field type is specified explicitly.

Automatic proto tuple types

Implementation restriction

Examples

{}

{ x: float, y: float, int }

# the Vector tuple type
{ x: float, y: float,
  static Magnitude := function(p: Vector): float {
    return sqrt(p.x*p.x + p.y*p.y);
  }
}

{ ip: int = 0xffffff00 @ 1,
  value: bytes = bytes("britney") @ 2, # proto strings are Sawzall bytes
  timestamp: time @ 5,
  type Server = {
    id: int,
    location: string
  },
  static location1 := "ROB",
  static location2 := "GRI",
  static location3 := "BGI",
}

parsedmessage {
  g: array of TimeProtocol_G @ 1, # 11
  debug: array of bytes @ 4: bytes # 34
}

proto T  # T must be a tuple type

proto {
  x: int,
  y: float
}

proto proto proto {  # proto is idempotent
  x: int,
  t: {
    s: bytes,
    t: bytes
  }
}

parsedmessage {  # this type is equivalent to the previous one
  x: int @ 1,
  t: parsedmessage {
    s: bytes @ 1,
    t: bytes @ 2
  } @ 2
}

Map types

MapType = 'map' '[' Key ']' 'of' Value.
Key = Component.
Value = Component.

Examples

map [int] of bool
map [symbol: string] of int
map [point: {x: float, y: float}] of name: string

Output types

1. collection: a simple collection or concatenation of the data
2. maximum: a precise sample of the N highest-weighted data items.
3. minimum: a precise sample of the N lowest-weighted data items.
4. sample: a statistical sampling of N items.
5. set: a set (unique elements) containing at most N items per index.
6. sum: an arithmetic sum of the data.
7. top: statistical estimators for the`most frequent N' data items.
8. unique: statistical estimators for the total number of unique data items.
9. weightedsample: a statistical sampling of N items, biased towards items with higher weights.
10. recordio: output to a simple record-based binary file.

Output types may be parametrized and indexed. Parameters are used to set up the aggregation variable. Indices are used to create "arrays" of aggregators. Unlike with arrays, indices of various types (not just int) may be specified. Some output types require the specification of a weight type. When emitting to a variable of output type, the weight is used to scale the emitted value for aggregation.

OutputType =
  'table' table_type [Parameter] {Index} 'of' Element [Weight]
  [FileSpec | ProcSpec ] [FormatSpec].
table_type = identifier.
Parameter = '(' Expression ')'.
Index = '[' Component ']'.
Element = Component.
Weight = 'weight' Component.
FileSpec = 'file' '(' ArgumentList ')'.
ProcSpec = 'proc' '(' ArgumentList ')'.
FormatSpec = 'format' '(' ArgumentList ')'.
ArgumentList = ExprList.
ExprList = Expression {',' Expression }.

If a format specifier is present, any value emitted is formatted into a string as expressed via the specifier. The emitted values are always of type string, independently of the element type specified in the output type; except if there is a file or proc specifier present as well, in which case the string is converted into (UTF-8 encoded) bytes before emission.

The file, proc, and format specifier format expressions similar to printf in C: The first argument must be a string possibly containing format characters. The remaining arguments must correspond in number and type to the format characters in the format string. Within the arguments of file or proc specifiers, output type index values may be referred to via the corresponding component name of a particular index. Within the arguments of format specifiers, the element value may be referred to via its component name.

Examples

# Type of intrinsic output variable stdout
table collection of x: string file("/dev/stdout") format("%s\n", x)

# Type used to collect all the values into a single stream
table collection of string;

# Type used to count the number of times each value is seen
table sum[value: string] of count: int;

# Type used to record the top 10 values for each category
table top(10)[category: string] of value: string weight count: int;

# Type used to record the ten most expensive operations
table maximum(10)[category: string] of operatikon: string weight cost: float;

# Type used to count how many unique values there are, using an (internal)
# sampled table of 10000 values to estimate the distribution
table unique(10000) of value: string;

Function types

FunctionType = 'function' '(' [ParameterList] ')' [ResultSpec].
ParameterList = Parameter {',' Parameter}.
Parameter = identifier ':' Type.
ResultSpec = ':' Type.

Examples

function()
function(n: int): int
function(name: string, hint: Coordinates): Coordinates

Equality of types

Statements

Statement =
  Assignment | Block | BreakStatement | ContinueStatement | DoStatement |
  EmitStatement | ExprStatement | ForStatement | IfStatement | ResultStatement |
  ReturnStatement | SwitchStatement | WhenStatement | WhileStatement.

Assignments

Assignment = Factor '=' Expression ';'

Blocks

Block = '{' { Declaration | Statement } '}'.

Break statements

BreakStatement = 'break'.

Continue statements

ContinueStatement = 'continue'.

Do statements

DoStatement = 'do' Statement 'while' '(' BoolExpression ')' ';'.

Example

do
  d++;
while (d*d < x);

Emit statements

EmitStatement = 'emit' OutputDesignator '<-' Expression ['weight' Expression] ';'.
OutputDesignator = var_name {'[' Expression ']'}.

Examples

emit stdout <- "Hello World!";
emit valuecount[values[somej]] <- 1;

Expression statements

ExprStatement = Expression [ '++' | '--' ] ';'.

Examples

i++;
a[i]--;
f(x, y);

For statements

ForStatement =
  'for' '(' [ForDeclExpr] ';' [BoolExpression] ';' [ForDeclExpr] ')' Statement.
ForDeclExpr = Declaration | ExprStatement.

for (expr1; cond; expr2) statement;

{ expr1;
  while (cond) {
    statement;
    expr2;
  }
}

If statements

IfStatement = 'if' '(' BoolExpression ')' Statement ['else' Statement].

Result statements

ResultStatement = 'result' Expression.

e := ?{
  j := function(): int { result 1; };  # compile-time error
};

Return statements

ReturnStatement = 'return' [ Expression ].

x := function(): int {
  n := ?{
    return 2;  # compile-time error
  };
};

Switch statements

SwitchStatement = 'switch' '(' Expression ')' '{' { Case } Default '}'.
Case = 'case' CaseLabelList ':' StatementList.
CaseLabelList = Expression {',' Expression}.
StatementList = Statement { Statement }.
Default = 'default' ':' StatementList.

switch (tag) {
  case a0, a1, ... an:
    as;
  case b0, b1, ... bn:
    bs;
  ...
  case z0, z1, ... zn:
    zs;
  default:
    s;
}

{ $tag: typeof(tag) = tag;
  if ($tag == a0 || $tag == a1 || ... $tag == an)
    as;
  else if ($tag == b0 || $tag == b1 || ... $tag == bn)
    bs;
  ...
  else if ($tag == z0 || $tag == z1 || ... $tag == zn)
    zs;
  else
    s;
}

Implementation restriction

When statements

• all quantifiers that satisfy the condition for all possible values cause the statement to be executed exactly once. The quantifier value is undefined within the statement.
• each quantifiers are bound to all possible values that satisfy the condition and the statement is executed for each of those values with the quantifier bound to that value.
• some quantifiers are bound to any single value that satisfies the condition and the statement is executed exactly once with the quantifier bound to that value.

WhenStatement = 'when' '(' {QuantifierDecl} BoolExpression ')' Statement.
QuantifierDecl = var_name ':' quantifier Type ';'.
quantifier = 'all' | 'each' | 'some'.

break or continue statements are not permitted in a when statement unless the corresponding switch statement or loop is also in the when statement.

Implementation restriction

Example

# Count the relevant values
when (
  somei: some int;
  somej: some int;
  lowercase(valuewords[somei]) == values[somej]
)
  emit valuecount[values[somej]] <- 1;

While statements

WhileStatement = 'while' '(' BoolExpression ')' Statement.

Example

while (d*d < x)
  d++;

Expressions

Expressions

Expression = Conjunction {('||' | 'or') Conjunction}.
Conjunction = Comparison {('&&' | 'and') Comparison}.
Comparison = SimpleExpr [relation SimpleExpr].
relation = '==' | '!=' | '<' | '<=' | '>' | '>='.
SimpleExpr = Term {add_operator Term}.
add_operator = '+' | '-' | '|' | '^'.
Term = Factor {mul_operator Factor}.
mul_operator = '*' | '/' | '%' | '<<' | '>>' | '&'.

Factors

Factor = Operand { Selector | Index | Call | SawCall }.
Selector = '.' field_name.
field_name = identifier.
Index = '[' Expression [':' Expression] ']'.
Call = '(' ArgumentList ')'.
SawCall =
  '(' [IterationCount ','] InputString
  ',' RegexpList [',' 'rest' Factor] ')'.
IterationCount = Expression.
InputString = Expression.
saw_name = identifier.
RegexpList = Regexp {',' Regexp}.
Regexp = ['skip'] ['submatch'] string.

Member selection

Array indexing

Map indexing

Function calls

Conversions

Operands

Operand =
  identifier | literal | Composite | Function | unary_operator Factor |
  '$' | StatementExpr | '(' Expression ')'.
unary_operator = '+' | '-' | '~' | '!' | 'not'.

Composites

• The type of a composite is equal to the type of a tuple T, if the number of composite elements matches the number of tuple fields, and if the types of the composite elements equal the corresponding (by position) field type.
• The type of a composite is equal to the type of an array, string, or bytes A, if all composite elements have the same type and that type equals the element type of array A. Alternatively, the type of an empty composite {} is equal to the type of any array, string, or bytes.
• The type of a composite is equal to the type of a map M, if the composite elements are key, value pairs separated by :'s, and if the all key types equal the type of the map key, and if all value types equal the type of the map value. Alternatively, the type of an empty map {:} is equal to the type of any map.

Composite = '{' [ExprList | PairList | ':'] '}'.
PairList = Pair {',' Pair}.
Pair = Expression ':' Expression.

Examples

{}
{:}
{ 'a', 'b', 127 }
{ 12, "hello", 3.14, {} }
{ "foo" : 3, "bar" : 7 }

Functions

Function = Type Block.

Examples

function() {}
function(radius: float): float { return 2.0 * PI * radius; }
Action { kill_bill(); }

Intrinsic functions

• basic language support (assert(), def(), convert(), format(), len(), new(), etc.)
• mathematical functions (max(), min(), ln(), exp(), rand(), etc.)
• special types support (haskey(), addday(), trunctoday(), now(), etc.)
• regular expressions support (regex(), saw(), sawn(), sawzall(), match(), etc.)

Statement Expressions

StatementExpr = '?' Block .

Examples

# signum
signum := ?{ switch(true) { case x < 0: result -1; case x > 0: result 1; default: result 0; };

# array filtering
a = ?{
  aa: array of int = {};
  when (i: each int; Test(a[i])) aa = aa + {a[i]};
  result aa;
};

Arithmetic operators

symbol	result
+	sum
-	difference
*	product
/	quotient
%	modulo
&	bitwise and
|	bitwise or
^	bitwise xor
~	bitwise negation
<<	shift left
>>	shift right (logical)

	x  =  (x / y) * y  +  (x % y)

	x ^ y = (x & ~y) | (y & ~x)

Comparison operators

symbol  comparison
==	equal
!=	not equal
<	less
<=	less or equal
>	greater
>=	greater or equal

Boolean operators

and	true if and only if both arguments are true; false otherwise (deprecated)
or	false if and only if both arguments are false; true otherwise (deprecated)
not	true if operand is false; false otherwise
&&	like and, but evaluates rhs only if lhs is true
||	like or, but evaluates rhs only if lhs is false
!	same as not

Array operators

symbol	result
+	concatenation

Operator Precedences

Precedence	Category	Operators	Associativity
6 (highest)	unary	+ - ~ ! not	right to left
5	multiplicative	* / % << >> &	left to right
4	additive	+ - | ^	left to right
3	comparison	== != < <= > >=	left to right
2	conjuction	&& and	left to right
1 (lowest)	disjunction	|| or	left to right

Examples for expressions

2003				# an int
i + 1				# an int
0b100 << i			# an int
(x - a) * (x + a)		# a float
{"the", "answer", "is", 42}	# a 4-tuple {string, string, string, int}
{1.2, 2.3, 3.4, 4.5, 5.6}	# a 5-tuple and also an array of float holding 5 elements
a[i % $]			# (i % len(a)).th element of array a
x.f				# field f of tuple x
{1, 2, 3, 4, 5}[i]		# i.th element of constructed array
(0 <= i) and (i < n)		# true if i in [0, n)
min(x, y)			# call of function min with arguments x and y
a[i:j]				# the array (a[i], a[i+1], .. a[j-1])

Lexical structure

Encodings

Comments

Examples

# Copyright 2010
################

Include clauses

Include = 'include' file_name.
file_name = string.

Platform-specific rules

Examples

include "/home/szluser/stuff"
include "lib/qsort.szl"

Proto clauses

Proto = 'proto' file_name.

Platform-specific rules

Example

proto "/home/szluser/logfile.proto"

Terminal symbols

Identifiers

identifier = (letter | '_') {letter | '_' | digit}.
letter = 'A' .. 'Z' | 'a' .. 'z'.
digit = '0' .. '9'.

int float string time bytes bool fingerprint output stdout stderr _undef_cnt
_undef_details true false PI SECOND SEC MINUTE MIN HOUR HR DEBUG def
convert new regex saw sawn sawzall fingerprintof format len haskey inproto
keys lookup max min assert addday addmonth addweek addyear dayofmonth
dayofweek dayofyear hourof minuteof monthof secondof yearof trunctoday
trunctohour trunctominute trunctomonth trunctosecond trunctoyear now highbit
load getenv lowercase uppercase match strfind strrfind strreplace matchposns
matchstrs ln log10 exp pow ___raise_segv rand nrand tobase64 frombase64
splitcsvline splitcsv

literal = integer | unsigned_integer |
          fingerprint | floating_point | char | string | time.

integer = ['-'] (binary_int | octal_int | decimal_int | hexadecimal_int).

binary_int = '0' ('B' | 'b') bin_digit {bin_digit}.
octal_int = '0' oct_digit {oct_digit}.
decimal_int = dec_digit {dec_digit}.
hexadecimal_int = '0' ('X' | 'x') hex_digit {hex_digit}.

bin_digit = '0' .. '1'.
oct_digit = '0' .. '7'.
dec_digit = '0' .. '9'.
hex_digit = '0' .. '9' | 'A' .. 'F' | 'a' .. 'f'.

1		# = 1
011		# = 9
0b1010		# = 10
42		# = 42
0x7f		# = 127

unsigned_integer = (binary_int | octal_int | decimal_int | hexadecimal_int) ('U' | 'u').

1u		# = 1
011u		# = 9
0b1010U		# = 10
42u		# = 42
0x7fU		# = 127
18446744073709551616U	# = largest possible 64-bit value

fingerprint = integer ('P' | 'p').

0p		# the fingerprint with value 0
0x6347P		# the fingerprint with value 25415

floating_point = ['-'] [integer_part]['.' [fraction_part]] [scale_factor].

integer_part = decimal_int.
fraction_part = decimal_int.
scale_factor = ('E' | 'e') ['+'|'-'] exponent.
exponent = decimal_int.

.01		# = 0.01
1e-3		# = 0.001
2.		# = 2.0
3.1415		# = 3.1415
2.18E5		# = 218000.0

char = ''' character '''.
character = ordinary_character | escaped_character.
escaped_character =
  '\' oct_digit [oct_digit [oct_digit]] |
  '\' 'x' hex_digit {hex_digit} |
  '\' 'u' hex_digit hex_digit hex_digit hex_digit |
  '\' 'U' hex_digit hex_digit hex_digit hex_digit hex_digit hex_digit hex_digit hex_digit |
  '\' ('a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' | '\' | '"') |
  '\' ordinary_character.

'\n'		# = 10
'A'		# = 65

string = '"' {character} '"' | '`' {character} '`'.

""		# empty string
"Sawzall\n"	# Sawzall followed by a newline character
`"Hello"`       # "Hello" (including the "'s)

bytes = 'B' string | 'X' hex_string.
hex_string = '"' { hex_digit hex_digit } '"' .

B""         # empty bytes literal
B"hello"    # five bytes
B`"`        # one byte, a double quote
B"\xff"     # one byte, value 255
X"0011AB"   # three bytes: 0x00 0x11 0xAB

time = integer ('T' | 't') | 'T' string.

0t		# 0 microseconds
1000000T	# 1 second
T"Tue Jun  5 10:43:07 America/Los_Angeles 2007"
T"Wed Feb  4 16:26:41 PST 2004"

Sawzall's time zone support is built upon the ICU C++ code. You can use any time zone recognized by that code. "America/Los_Angeles"-style identifiers are encouraged.

Operators and delimiters

+	-	*	/	%	&	|	^
<<	>>	==	!=	<	<=	>	>=
(	)	[	]	{	}	&&	||
~	!	.	,	;	:	=	<-
$	--	++

all	and	array	break	case	continue	default	do	each
else	emit	file	for	format	function	if	include	map
not	of	or	parsedmessage	proc	proto	rest	result	return
skip	some	static	submatch	switch	table	type	weight	when	while

Appendix

EBNF Syntax

Production = production_name '=' Expression '.'.
Expression = Term { '|' Term }.
Term = Factor { Factor }.
Factor = production_name | symbol | Group | Option | Repetition.
Group = '(' Expression ')'.
Option = '[' Expression ']'.
Repetition = '{' Expression '}'.
production_name = identifier.

Acknowledgments

• "The C Programming Language", 2nd edition. Brian W. Kernighan, Dennis M. Ritchie.
• "The Oberon Language Report", revised edition 10/1/1990. Niklaus Wirth.
• "Newsqueak: A Language for Communicating with Mice". Rob Pike.