Appendix A Revision History

• Improved type nesting rules (SectionType nesting rules).
• Clarified that directionless extern parameters are passed by reference.

• Introduced distinction between local compile-time known and compile-time known values (SectionCompile-time known and local compile-time known values).

• Added header stack expressions (Section Header stack expressions).

• Allow casts from a type to itself (Section Casts).
• Added an invalid header or header union expression {#} (Sections Operations on headers and Operations on header unions).
• Added a concept of numeric values (Section Numeric types).
• Added a section on operations on extern objects (Section Operations on extern objects).
• Added note in sections operations on types for types that support compile-time size determination.
• Clarified that header stacks are arrays of headers or header unions.
• Added distinctness of fields for types that have fields including error, match kind, struct, header, and header union.
• Clarified types bit<W>, int<W>, and varbit<W> encompass the case where the width is a compile-time known expression evaluating to an appropriate integer (Section Unsigned integers (bit-strings), Section Signed Integers, Section Dynamically-sized bit-strings).
• Clarified restrictions for parameters with default values (Section Justification).
• Added optional trailing commas (Section Optional trailing commas).
• Clarified the scope of parser namespaces (Section Parser declarations).
• Specified that algorithm for generating control-plane names for keys is optional (Section Keys).
• Clarified types of expressions that may appear in select (Section Select expressions).
• Added description of semantics of the core.p4 match kinds (Section Keys).
• Explicitly disallow overloading of parsers, controls, and packages (Section Extern objects).
• Clarified implicit casts present in select expressions (Section Select expressions).
• Clarified that slices can be applied to arbitrary-precision integers (Section Operations on arbitrary-precision integers).
• Clarified that direct invocation is not possible for objects that have constructor arguments (Section Direct type invocation).
• Added comparison for tuples as a legal operation (Section Operations on tuple expressions).
• Clarified the behavior of lookahead on header-typed values (Section Lookahead).
• Added static_assert function (Section Static assertions).
• Clarified semantics of ranges where the start is bigger than the end (Section Ranges).
• Allow ranges to be specified by serializable enums (Section Ranges).
• Specified type produced by the *sizeInB* methods (Section Compile-time size determination).
• Added section with operations on match_kind values (Section Operations on match_kind types).
• Renamed infinite-precision integers to arbitrary-precision integers (Section Arbitrary-precision integers).
• compiler-inserted default_action is not const (Section Tables).
• Clarified the restrictions on run time for tables with const entries (Section Entries).
• renamed list expressions to tuple expressions
• Added list type (Section List types).
• Defined entries table property without const, for entries installed when the P4 program is loaded, but the control plane can later change them or add to them (Section Entries).

• Clarified behavior of table with no key property, or if its list of keys is empty (Section Keys).

• Extended minSizeInBits and minSizeInBytes to apply to more expressions (Section Compile-time size determination).

• Added support for maxSizeInBits and maxSizeInBytes (Section Compile-time size determination).
• Added support for empty lists of const entries in tables (Section Entries).
• Added support for switch statements in actions (Section Actions).
• Added support for direct invocation of controls and parsers (Section Parameterization).
• Added parser value_set to list of control-plane visible names (Section Control plane names).
• Added match_kind as a base type (Section The match kind type).
• Removed structure initializers as they are subsumed by structure-valued expressions (Section Operations on structure-valued expressions).
• Specified operations on values typed as type variables (Section Operations on types that are type variables).
• Clarified semantics of compile-time known values (Section Compile-time known and local compile-time known values).
• Clarified semantics of directionless parameters (Section Calling convention: call by copy in/copy out).
• Clarified semantics of arbitrary precision integers (Section Arbitrary-precision integers).
• Clarified semantics of bit slices, shifts, and concatenation (Section Operations on fixed-width bit types (unsigned integers)).
• Clarified semantics of optional parameters (Section Optional parameters).
• Clarified restrictions on extern method and function invocation (Section Restrictions on compile time and run time calls).

• Clarified semantics of implicit casts (Section Implicit casts).

• Added support for accessing tuple fields (Section Operations on tuple expressions).

• Added support for generic structures (Section Type specialization).
• Added support for integers, enums, and errors in switch statements (Section Switch statement).
• Added support for additional enumeration types (Section Enumeration types).
• Added support for abstract methods (Section Abstract methods).
• Added support for conditional statements and empty statements in parsers (Section Parser states).
• Added support for casts from int to bool (Section Casts).
• Added support for 0-width bitstrings and varbits (Section Reading uninitialized values and writing fields of invalid headers).
• Clarified that default_action is NoAction if otherwise unspecified (Section Tables).
• Clarified the types of expressions that may be used as indexes for header stacks (Section Operations on header stacks).
• Clarified representation of Booleans in headers (Section Header types).
• Clarified representation of empty types (Section Reading uninitialized values and writing fields of invalid headers).
• Clarified that action data can be specified by the control plane, default_action table property, or const entries table property (Section Actions).
• Fixed several typos and inconsistencies in grammar (Section P4 grammar).

• Eliminated annotations on const entries in grammar (Section P4 grammar).

• Added structure-value expressions (Section Operations on structure-valued expressions).

• Added support for default values (Section Default values).
• Added support for concatenating signed strings (Section Concatenation).
• Added key-value and list-structured annotations (Section Annotations).
• Added @pure and @noSideEffects annotations (Section Extern function/method annotations).
• Added @noWarn annotation (Section No warnings annotation).
• Generalized typing for masks to allow serializable enums (Section Masks).
• Restricted the right operands of bit shifts involving arbitrary-precision integers to be constant and positive (Section Operations on arbitrary-precision integers).
• Clarified copy-out behavior for return (Section Return statement) and exit (Section Exit statement) statements.
• Clarified semantics of invalid header stacks (Section Reading uninitialized values and writing fields of invalid headers).
• Clarified initialization semantics (Section L-values and Calling convention: call by copy in/copy out), especially for headers and local variables.
• Clarified evaluation order for table keys (Section Match-action unit execution semantics).

• Fixed grammar to clarify parsing of right shift operator (>>), allow empty statements in parser (Section Parser states), and eliminate annotations on const entries (Section Entries).

• Added table.apply().miss (Section Match-action unit invocation).

• Added string type (Section Strings).
• Added implicit casts from enum values (Section Operations on enum types).
• Allow 1-bit signed values
• Define the type of bit slices from signed and unsigned values to be unsigned.
• Constrain default label position for switch statements.
• Allow empty tuples.
• Added @deprecated annotation.
• Relaxed the structure of annotation bodies.
• Removed the @pkginfo annotation, which is now defined by the P4Runtime specification.
• Added int type (Section Arbitrary-precision integers).
• Added error ParserInvalidArgument (Sections Variable-width extraction, Skipping bits).
• Clarified the significance of order of entries in const entries (Section Entries).

• Added methods to calculate header size (Section Operations on headers).

• Top-level functions (Section Function declarations)

  • Functions may be declared at the top-level of a P4 program.
• Optional and named parameters (Section Calling convention: call by copy in/copy out)
  • Parameters may be specified by name, with a default value, or designated as optional.
• enum representations (Section Operations on enum types)
  • enum values to be specified with a concrete representation.
• Parser values sets (Section Parser Value Sets)
  • value_set objects for control-plane programmable select labels.
• Type definitions (Section Introducing new types)
  • New types may be introduced in programs.
• Saturating arithmetic (Section Operations on fixed-width bit types (unsigned integers))
  • Saturating arithmetic is supported on some targets.
• Structured annotations (Section Annotations)
  • Annotations may be specified as lists of key-value pairs
• Globalname (Section Annotations controlling naming)
  • The reserved globalname annotation has been removed.
• Table size property (Section Size)
  • Meaning of optional size property for tables has been defined.
• Invalid headers (Section Operations on headers)
  • Clarified semantics of operations on invalid headers.
• Calling restrictions (Section Restrictions on compile time and run time calls)
  • Added restrictions on kinds of values that may be passed as arguments to calls.
• Bitwise operator precedence (Section P4 grammar)
  • Modified precedence conventions so that bitwise operators & | and ^ have higher precedence than relation operators < > <= >=.
• Computed bitwidths (Section Base types)
  • Added support for specifying widths using expressions in bit and varbit types.