Zum Hauptinhalt springen

4. Wire-Format (Wire Format)

4.1 Primitive (Primitives)​

4.1.1 Präfixierte Ganzzahlen (Prefixed Integers)​

Dieses Dokument verwendet ausgiebig die präfixierte Ganzzahl aus Abschnitt 5.1 von [RFC7541]. Das Format aus [RFC7541] wird unverändert verwendet. Beachten Sie jedoch, dass QPACK einige Präfixgrößen verwendet, die in HPACK nicht tatsächlich verwendet werden.

QPACK-Implementierungen MÜSSEN in der Lage sein, Ganzzahlen bis einschließlich 62 Bit Länge zu dekodieren.

4.1.2 Zeichenfolgenliterale (String Literals)​

Das in Abschnitt 5.2 von [RFC7541] definierte Zeichenfolgenliteral wird auch in diesem gesamten Dokument verwendet. Dieses Zeichenfolgenformat umfasst optionale Huffman-Kodierung.

HPACK definiert, dass Zeichenfolgenliterale an einer Bytegrenze beginnen. Sie beginnen mit einem einzelnen Bit-Flag, das in diesem Dokument als 'H' bezeichnet wird (zeigt an, ob die Zeichenfolge Huffman-kodiert ist), gefolgt von der Länge, die als 7-Bit-Präfix-Ganzzahl kodiert ist, und schließlich der angegebenen Anzahl von Datenbytes. Wenn die Huffman-Kodierung aktiviert ist, wird die Huffman-Tabelle aus Anhang B von [RFC7541] ohne Änderung verwendet, und die Länge gibt die Größe der kodierten Zeichenfolge an.

Dieses Dokument erweitert die Definition von Zeichenfolgenliteralen, indem es ihnen erlaubt, anders als an einer Bytegrenze zu beginnen. Ein "N-Bit-Präfix-Zeichenfolgenliteral" beginnt in der Mitte eines Bytes, wobei die ersten (8-N) Bits einem vorherigen Feld zugeordnet sind. Die Zeichenfolge verwendet ein Bit für das Huffman-Flag, gefolgt von der Länge, die als (N-1)-Bit-Präfix-Ganzzahl kodiert ist. Der Wert der Präfixgröße N kann zwischen 2 und 8 einschließlich liegen. Der Rest des Zeichenfolgenliterals ist unverändert.

Ein Zeichenfolgenliteral ohne notierte Präfixlänge ist ein 8-Bit-Präfix-Zeichenfolgenliteral und folgt den Definitionen in [RFC7541] ohne Änderung.

4.2 Encoder- und Decoder-Streams (Encoder and Decoder Streams)​

QPACK definiert zwei unidirektionale Stream-Typen:

  • Encoder-Stream ist ein unidirektionaler Stream vom Typ 0x02. Er trägt eine ungerahmte Sequenz von Encoder-Anweisungen vom Encoder zum Decoder.

  • Decoder-Stream ist ein unidirektionaler Stream vom Typ 0x03. Er trägt eine ungerahmte Sequenz von Decoder-Anweisungen vom Decoder zum Encoder.

HTTP/3-Endpunkte enthalten einen QPACK-Encoder und -Decoder. Jeder Endpunkt MUSS höchstens einen Encoder-Stream und höchstens einen Decoder-Stream initiieren. Der Empfang einer zweiten Instanz eines der beiden Stream-Typen MUSS als Verbindungsfehler vom Typ H3_STREAM_CREATION_ERROR behandelt werden.

Der Sender DARF NICHT einen dieser Streams schließen, und der Empfänger DARF NICHT verlangen, dass der Sender einen dieser Streams schließt. Das Schließen eines der unidirektionalen Stream-Typen MUSS als Verbindungsfehler vom Typ H3_CLOSED_CRITICAL_STREAM behandelt werden.

Ein Endpunkt KANN die Erstellung eines Encoder-Streams vermeiden, wenn er nicht verwendet wird (z. B. wenn sein Encoder die dynamische Tabelle nicht verwenden möchte oder wenn die vom Peer erlaubte maximale Größe der dynamischen Tabelle null ist).

Ein Endpunkt KANN die Erstellung eines Decoder-Streams vermeiden, wenn der Decoder die maximale Kapazität der dynamischen Tabelle auf null setzt.

Ein Endpunkt MUSS seinem Peer erlauben, einen Encoder-Stream und einen Decoder-Stream zu erstellen, auch wenn die Einstellungen der Verbindung ihre Verwendung verhindern.

4.3 Encoder-Anweisungen (Encoder Instructions)​

Ein Encoder sendet Encoder-Anweisungen auf dem Encoder-Stream, um die Kapazität der dynamischen Tabelle festzulegen und dynamische Tabelleneinträge hinzuzufügen. Anweisungen, die Tabelleneinträge hinzufügen, können vorhandene Einträge verwenden, um die Übertragung redundanter Informationen zu vermeiden. Der Name kann als Verweis auf einen vorhandenen Eintrag in der statischen oder dynamischen Tabelle oder als Zeichenfolgenliteral übertragen werden. Für Einträge, die bereits in der dynamischen Tabelle vorhanden sind, kann auch der vollständige Eintrag per Verweis verwendet werden, wodurch ein doppelter Eintrag erstellt wird.

4.3.1 Dynamische Tabellenkapazität setzen (Set Dynamic Table Capacity)​

Ein Encoder verwendet eine Anweisung, die mit dem '001' 3-Bit-Muster beginnt, um den Decoder über eine Änderung der Kapazität der dynamischen Tabelle zu informieren. Darauf folgt die neue Kapazität der dynamischen Tabelle, dargestellt als Ganzzahl mit einem 5-Bit-Präfix; siehe Abschnitt 4.1.1.

  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 0 | 1 |   Capacity (5+)   |
+---+---+---+-------------------+

                Abbildung 5: Dynamische Tabellenkapazität setzen

Die neue Kapazität MUSS niedriger oder gleich dem in Abschnitt 3.2.3 beschriebenen Limit sein. In HTTP/3 ist dieses Limit der Wert des SETTINGS_QPACK_MAX_TABLE_CAPACITY-Parameters (Abschnitt 5), der vom Decoder empfangen wurde. Der Decoder MUSS einen neuen dynamischen Tabellenkapazitätswert, der dieses Limit überschreitet, als Verbindungsfehler vom Typ QPACK_ENCODER_STREAM_ERROR behandeln.

Das Reduzieren der Kapazität der dynamischen Tabelle kann dazu führen, dass Einträge entfernt werden; siehe Abschnitt 3.2.2. Dies DARF NICHT dazu führen, dass Einträge entfernt werden, die nicht entfernbar sind; siehe Abschnitt 2.1.1. Das Ändern der Kapazität der dynamischen Tabelle wird nicht bestätigt, da es keinen Eintrag einfügt.

4.3.2 Mit Namensverweis einfügen (Insert with Name Reference)​

Ein Encoder fügt der dynamischen Tabelle einen Eintrag hinzu, bei dem der Feldname mit dem Feldnamen eines in der statischen oder dynamischen Tabelle gespeicherten Eintrags übereinstimmt, indem er eine Anweisung verwendet, die mit dem '1' 1-Bit-Muster beginnt. Das zweite ('T') Bit zeigt an, ob der Verweis auf die statische oder dynamische Tabelle erfolgt. Die folgende 6-Bit-Präfix-Ganzzahl (Abschnitt 4.1.1) wird verwendet, um den Tabelleneintrag für den Feldnamen zu lokalisieren. Wenn T=1, stellt die Zahl den statischen Tabellenindex dar; wenn T=0, ist die Zahl der relative Index des Eintrags in der dynamischen Tabelle.

Auf den Feldnamensverweis folgt der Feldwert, dargestellt als Zeichenfolgenliteral; siehe Abschnitt 4.1.2.

     0   1   2   3   4   5   6   7
   +---+---+---+---+---+---+---+---+
   | 1 | T |    Name Index (6+)    |
   +---+---+-----------------------+
   | H |     Value Length (7+)     |
   +---+---------------------------+
   |  Value String (Length bytes)  |
   +-------------------------------+

             Abbildung 6: Feldzeile einfügen -- Indizierter Name

4.3.3 Mit Literalname einfügen (Insert with Literal Name)​

Ein Encoder fügt der dynamischen Tabelle einen Eintrag hinzu, bei dem sowohl der Feldname als auch der Feldwert als Zeichenfolgenliterale dargestellt werden, indem er eine Anweisung verwendet, die mit dem '01' 2-Bit-Muster beginnt.

Darauf folgt der Name, dargestellt als 6-Bit-Präfix-Zeichenfolgenliteral, und der Wert, dargestellt als 8-Bit-Präfix-Zeichenfolgenliteral; siehe Abschnitt 4.1.2.

     0   1   2   3   4   5   6   7
   +---+---+---+---+---+---+---+---+
   | 0 | 1 | H | Name Length (5+)  |
   +---+---+---+-------------------+
   |  Name String (Length bytes)   |
   +---+---------------------------+
   | H |     Value Length (7+)     |
   +---+---------------------------+
   |  Value String (Length bytes)  |
   +-------------------------------+

               Abbildung 7: Feldzeile einfügen -- Neuer Name

4.3.4 Duplizieren (Duplicate)​

Ein Encoder dupliziert einen vorhandenen Eintrag in der dynamischen Tabelle unter Verwendung einer Anweisung, die mit dem '000' 3-Bit-Muster beginnt. Darauf folgt der relative Index des vorhandenen Eintrags, dargestellt als Ganzzahl mit einem 5-Bit-Präfix; siehe Abschnitt 4.1.1.

     0   1   2   3   4   5   6   7
   +---+---+---+---+---+---+---+---+
   | 0 | 0 | 0 |    Index (5+)     |
   +---+---+---+-------------------+

                         Abbildung 8: Duplizieren

Der vorhandene Eintrag wird in die dynamische Tabelle wieder eingefügt, ohne den Namen oder den Wert erneut zu senden. Dies ist nützlich, um das Hinzufügen eines Verweises auf einen älteren Eintrag zu vermeiden, was das Einfügen neuer Einträge blockieren könnte.

4.4 Decoder-Anweisungen (Decoder Instructions)​

Ein Decoder sendet Decoder-Anweisungen auf dem Decoder-Stream, um den Encoder über die Verarbeitung von Feldabschnitten und Tabellenaktualisierungen zu informieren, um die Konsistenz der dynamischen Tabelle sicherzustellen.

4.4.1 Abschnittsbestätigung (Section Acknowledgment)​

Nach der Verarbeitung eines kodierten Feldabschnitts, dessen deklarierter erforderlicher Einfügungszähler nicht null ist, sendet der Decoder eine Abschnittsbestätigungsanweisung. Die Anweisung beginnt mit dem '1' 1-Bit-Muster, gefolgt von der zugehörigen Stream-ID des Feldabschnitts, kodiert als 7-Bit-Präfix-Ganzzahl; siehe Abschnitt 4.1.1.

Diese Anweisung wird wie in den Abschnitten 2.1.4 und 2.2.2 beschrieben verwendet.

  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 1 |      Stream ID (7+)       |
+---+---------------------------+

                   Abbildung 9: Abschnittsbestätigung

Wenn ein Encoder eine Abschnittsbestätigungsanweisung erhält, die auf einen Stream verweist, auf dem jeder kodierte Feldabschnitt mit einem nicht-null erforderlichen Einfügungszähler bereits bestätigt wurde, MUSS dies als Verbindungsfehler vom Typ QPACK_DECODER_STREAM_ERROR behandelt werden.

Die Abschnittsbestätigungsanweisung kann den bekannten Empfangszähler erhöhen; siehe Abschnitt 2.1.4.

4.4.2 Stream-Abbruch (Stream Cancellation)​

Wenn ein Stream zurückgesetzt wird oder das Lesen abgebrochen wird, sendet der Decoder eine Stream-Abbruchanweisung. Die Anweisung beginnt mit dem '01' 2-Bit-Muster, gefolgt von der Stream-ID des betroffenen Streams, kodiert als 6-Bit-Präfix-Ganzzahl.

Diese Anweisung wird wie in Abschnitt 2.2.2 beschrieben verwendet.

  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 1 |     Stream ID (6+)    |
+---+---+-----------------------+

                    Abbildung 10: Stream-Abbruch

4.4.3 Einfügungszähler-Inkrement (Insert Count Increment)​

Die Einfügungszähler-Inkrementanweisung beginnt mit dem '00' 2-Bit-Muster, gefolgt vom Inkrement, kodiert als 6-Bit-Präfix-Ganzzahl. Diese Anweisung erhöht den bekannten Empfangszähler (Abschnitt 2.1.4) um den Wert des Inkrement-Parameters. Der Decoder sollte einen Inkrementwert senden, der den bekannten Empfangszähler auf die Gesamtzahl der bisher verarbeiteten dynamischen Tabelleneinfügungen und -duplikationen erhöht.

  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 0 |     Increment (6+)    |
+---+---+-----------------------+

                  Abbildung 11: Einfügungszähler-Inkrement

Ein Encoder, der ein Inkrement-Feld gleich null erhält oder eines, das den bekannten Empfangszähler über das hinaus erhöht, was der Encoder gesendet hat, MUSS dies als Verbindungsfehler vom Typ QPACK_DECODER_STREAM_ERROR behandeln.

4.5 Feldzeilendarstellungen (Field Line Representations)​

Ein kodierter Feldabschnitt besteht aus einem Präfix und einer möglicherweise leeren Sequenz von in diesem Abschnitt definierten Darstellungen. Jede Darstellung entspricht einer einzelnen Feldzeile. Diese Darstellungen verweisen auf die statische Tabelle oder die dynamische Tabelle in einem bestimmten Zustand, aber sie ändern diesen Zustand nicht.

Ein kodierter Feldabschnitt wird in einem Frame auf einem Stream getragen, der vom umschließenden Protokoll definiert wird.

4.5.1 Kodierter Feldabschnittspräfix (Encoded Field Section Prefix)​

Jedem kodierten Feldabschnitt werden zwei Ganzzahlen vorangestellt. Der erforderliche Einfügungszähler wird als Ganzzahl mit einem 8-Bit-Präfix unter Verwendung der in Abschnitt 4.5.1.1 beschriebenen Kodierung kodiert. Die Basis wird als Vorzeichenbit ('S') und ein Delta-Basiswert mit einem 7-Bit-Präfix kodiert; siehe Abschnitt 4.5.1.2.

  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
|   Required Insert Count (8+)  |
+---+---------------------------+
| S |      Delta Base (7+)      |
+---+---------------------------+
|      Encoded Field Lines    ...
+-------------------------------+

                   Abbildung 12: Kodierter Feldabschnitt

4.5.1.1 Erforderlicher Einfügungszähler (Required Insert Count)​

Der erforderliche Einfügungszähler identifiziert den Zustand der dynamischen Tabelle, der zum Verarbeiten des kodierten Feldabschnitts erforderlich ist. Blockierende Decoder verwenden den erforderlichen Einfügungszähler, um zu bestimmen, wann es sicher ist, den Rest des Feldabschnitts zu verarbeiten.

Der Encoder transformiert den erforderlichen Einfügungszähler wie folgt vor der Kodierung:

if ReqInsertCount == 0:
   EncInsertCount = 0
else:
   EncInsertCount = (ReqInsertCount mod (2 * MaxEntries)) + 1

Hier ist MaxEntries die maximale Anzahl von Einträgen, die die dynamische Tabelle haben kann. Der kleinste Eintrag hat leere Namen- und Wertzeichenfolgen und hat eine Größe von 32. Daher wird MaxEntries wie folgt berechnet:

MaxEntries = floor( MaxTableCapacity / 32 )

MaxTableCapacity ist die maximale Kapazität der dynamischen Tabelle, wie vom Decoder angegeben; siehe Abschnitt 3.2.3.

Diese Kodierung begrenzt die Länge des Präfixes bei langlebigen Verbindungen.

Der Decoder kann den erforderlichen Einfügungszähler mit einem Algorithmus wie dem folgenden rekonstruieren. Wenn der Decoder auf einen EncodedInsertCount-Wert stößt, der nicht von einem konformen Encoder erzeugt worden sein könnte, MUSS er dies als Verbindungsfehler vom Typ QPACK_DECOMPRESSION_FAILED behandeln.

TotalNumberOfInserts ist die Gesamtzahl der Einfügungen in die dynamische Tabelle des Decoders.

FullRange = 2 * MaxEntries
if EncodedInsertCount == 0:
   ReqInsertCount = 0
else:
   if EncodedInsertCount > FullRange:
      Error
   MaxValue = TotalNumberOfInserts + MaxEntries

   # MaxWrapped ist der größtmögliche Wert von
   # ReqInsertCount, der 0 mod 2 * MaxEntries ist
   MaxWrapped = floor(MaxValue / FullRange) * FullRange
   ReqInsertCount = MaxWrapped + EncodedInsertCount - 1

   # Wenn ReqInsertCount MaxValue überschreitet, muss der Wert des Encoders
   # einmal weniger gewickelt haben
   if ReqInsertCount > MaxValue:
      if ReqInsertCount <= FullRange:
         Error
      ReqInsertCount -= FullRange

   # Wert von 0 muss als 0 kodiert werden
   if ReqInsertCount == 0:
      Error

Wenn die dynamische Tabelle beispielsweise 100 Bytes groß ist, wird der erforderliche Einfügungszähler modulo 6 kodiert. Wenn ein Decoder 10 Einfügungen erhalten hat, zeigt ein kodierter Wert von 4 an, dass der erforderliche Einfügungszähler für den Feldabschnitt 9 beträgt.

4.5.1.2 Basis (Base)​

Die Basis wird verwendet, um Verweise in der dynamischen Tabelle aufzulösen, wie in Abschnitt 3.2.5 beschrieben.

Um Platz zu sparen, wird die Basis relativ zum erforderlichen Einfügungszähler unter Verwendung eines 1-Bit-Vorzeichens ('S' in Abbildung 12) und des Delta-Basiswerts kodiert. Ein Vorzeichenbit von 0 zeigt an, dass die Basis größer oder gleich dem Wert des erforderlichen Einfügungszählers ist; der Decoder addiert den Wert der Delta-Basis zum erforderlichen Einfügungszähler, um den Wert der Basis zu bestimmen. Ein Vorzeichenbit von 1 zeigt an, dass die Basis kleiner als der erforderliche Einfügungszähler ist; der Decoder subtrahiert den Wert der Delta-Basis vom erforderlichen Einfügungszähler und subtrahiert auch eins, um den Wert der Basis zu bestimmen. Das heißt:

if Sign == 0:
   Base = ReqInsertCount + DeltaBase
else:
   Base = ReqInsertCount - DeltaBase - 1

Ein Single-Pass-Encoder bestimmt die Basis vor der Kodierung eines Feldabschnitts. Wenn der Encoder während der Kodierung des Feldabschnitts Einträge in die dynamische Tabelle eingefügt hat und auf sie verweist, wird der erforderliche Einfügungszähler größer als die Basis sein, sodass die kodierte Differenz negativ ist und das Vorzeichenbit auf 1 gesetzt ist. Wenn der Feldabschnitt nicht mit Darstellungen kodiert wurde, die auf den neuesten Eintrag in der Tabelle verweisen, und keine neuen Einträge eingefügt wurden, wird die Basis größer als der erforderliche Einfügungszähler sein, sodass die kodierte Differenz positiv ist und das Vorzeichenbit auf 0 gesetzt ist.

Der Wert der Basis DARF NICHT negativ sein. Obwohl das Protokoll mit einer negativen Basis und Post-Base-Indizierung korrekt funktionieren würde, ist dies unnötig und ineffizient. Wenn der Wert des erforderlichen Einfügungszählers kleiner oder gleich dem Wert der Delta-Basis ist, MUSS ein Endpunkt einen Feldblock mit einem Vorzeichenbit von 1 als ungültig behandeln.

Ein Encoder, der Tabellenaktualisierungen vor der Kodierung eines Feldabschnitts produziert, kann die Basis auf den Wert des erforderlichen Einfügungszählers setzen. In diesem Fall werden sowohl das Vorzeichenbit als auch die Delta-Basis auf null gesetzt.

Ein Feldabschnitt, der ohne Verweise auf die dynamische Tabelle kodiert wurde, kann jeden Wert für die Basis verwenden; das Setzen der Delta-Basis auf null ist eine der effizientesten Kodierungen.

Wenn beispielsweise der erforderliche Einfügungszähler 9 beträgt, ein Vorzeichenbit von 1 und eine Delta-Basis von 2, wird die Basis auf 6 gesetzt und ermöglicht Post-Base-Indizierung für drei Einträge. In diesem Beispiel bezieht sich ein relativer Index von 1 auf den fünften Eintrag, der der Tabelle hinzugefügt wurde; ein Post-Base-Index von 1 bezieht sich auf den achten Eintrag.

4.5.2 Indizierte Feldzeile (Indexed Field Line)​

Eine indizierte Feldzeilendarstellung identifiziert einen Eintrag in der statischen Tabelle oder einen Eintrag in der dynamischen Tabelle mit einem absoluten Index, der kleiner als der Wert der Basis ist.

  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 1 | T |      Index (6+)       |
+---+---+-----------------------+

                    Abbildung 13: Indizierte Feldzeile

Diese Darstellung beginnt mit dem '1' 1-Bit-Muster, gefolgt vom 'T'-Bit, das anzeigt, ob der Verweis auf die statische oder dynamische Tabelle erfolgt. Die folgende 6-Bit-Präfix-Ganzzahl (Abschnitt 4.1.1) wird verwendet, um den Tabelleneintrag für die Feldzeile zu lokalisieren. Wenn T=1, stellt die Zahl den statischen Tabellenindex dar; wenn T=0, ist die Zahl der relative Index des Eintrags in der dynamischen Tabelle.

4.5.3 Indizierte Feldzeile mit Post-Base-Index (Indexed Field Line with Post-Base Index)​

Eine indizierte Feldzeilendarstellung mit Post-Base-Index identifiziert einen Eintrag in der dynamischen Tabelle mit einem absoluten Index, der größer oder gleich dem Wert der Basis ist.

  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 1 |  Index (4+)   |
+---+---+---+---+---------------+

          Abbildung 14: Indizierte Feldzeile mit Post-Base-Index

Diese Darstellung beginnt mit dem '0001' 4-Bit-Muster. Darauf folgt der Post-Base-Index (Abschnitt 3.2.6) der passenden Feldzeile, dargestellt als Ganzzahl mit einem 4-Bit-Präfix; siehe Abschnitt 4.1.1.

4.5.4 Literale Feldzeile mit Namensverweis (Literal Field Line with Name Reference)​

Eine literale Feldzeilendarstellung mit Namensverweis kodiert eine Feldzeile, bei der der Feldname mit dem Feldnamen eines Eintrags in der statischen Tabelle oder dem Feldnamen eines Eintrags in der dynamischen Tabelle mit einem absoluten Index kleiner als der Wert der Basis übereinstimmt.

     0   1   2   3   4   5   6   7
   +---+---+---+---+---+---+---+---+
   | 0 | 1 | N | T |Name Index (4+)|
   +---+---+---+---+---------------+
   | H |     Value Length (7+)     |
   +---+---------------------------+
   |  Value String (Length bytes)  |
   +-------------------------------+

          Abbildung 15: Literale Feldzeile mit Namensverweis

Diese Darstellung beginnt mit dem '01' 2-Bit-Muster. Das folgende Bit 'N' zeigt an, ob ein Vermittler berechtigt ist, diese Feldzeile bei nachfolgenden Hops zur dynamischen Tabelle hinzuzufügen. Wenn das 'N'-Bit gesetzt ist, MUSS die kodierte Feldzeile immer mit einer literalen Darstellung kodiert werden. Insbesondere wenn ein Peer eine Feldzeile sendet, die er als literale Feldzeile mit gesetztem 'N'-Bit erhalten hat, MUSS er eine literale Darstellung verwenden, um diese Feldzeile weiterzuleiten. Dieses Bit soll Feldwerte schützen, die nicht durch Komprimierung gefährdet werden sollen; siehe Abschnitt 7.1 für weitere Details.

Das vierte ('T') Bit zeigt an, ob der Verweis auf die statische oder dynamische Tabelle erfolgt. Die folgende 4-Bit-Präfix-Ganzzahl (Abschnitt 4.1.1) wird verwendet, um den Tabelleneintrag für den Feldnamen zu lokalisieren. Wenn T=1, stellt die Zahl den statischen Tabellenindex dar; wenn T=0, ist die Zahl der relative Index des Eintrags in der dynamischen Tabelle.

Nur der Feldname wird aus dem dynamischen Tabelleneintrag entnommen; der Feldwert wird als 8-Bit-Präfix-Zeichenfolgenliteral kodiert; siehe Abschnitt 4.1.2.

4.5.5 Literale Feldzeile mit Post-Base-Namensverweis (Literal Field Line with Post-Base Name Reference)​

Eine literale Feldzeilendarstellung mit Post-Base-Namensverweis kodiert eine Feldzeile, bei der der Feldname mit dem Feldnamen eines dynamischen Tabelleintrags mit einem absoluten Index größer oder gleich dem Wert der Basis übereinstimmt.

     0   1   2   3   4   5   6   7
   +---+---+---+---+---+---+---+---+
   | 0 | 0 | 0 | 0 | N |NameIdx(3+)|
   +---+---+---+---+---+-----------+
   | H |     Value Length (7+)     |
   +---+---------------------------+
   |  Value String (Length bytes)  |
   +-------------------------------+

     Abbildung 16: Literale Feldzeile mit Post-Base-Namensverweis

Diese Darstellung beginnt mit dem '0000' 4-Bit-Muster. Das fünfte Bit ist das 'N'-Bit wie in Abschnitt 4.5.4 beschrieben. Darauf folgt ein Post-Base-Index (Abschnitt 3.2.6) des dynamischen Tabelleintrags, kodiert als Ganzzahl mit einem 3-Bit-Präfix; siehe Abschnitt 4.1.1.

Nur der Feldname wird aus dem dynamischen Tabelleneintrag entnommen; der Feldwert wird als 8-Bit-Präfix-Zeichenfolgenliteral kodiert; siehe Abschnitt 4.1.2.

4.5.6 Literale Feldzeile mit Literalname (Literal Field Line with Literal Name)​

Eine literale Feldzeilendarstellung mit Literalname kodiert einen Feldnamen und einen Feldwert als Zeichenfolgenliterale.

     0   1   2   3   4   5   6   7
   +---+---+---+---+---+---+---+---+
   | 0 | 0 | 1 | N | H |NameLen(3+)|
   +---+---+---+---+---+-----------+
   |  Name String (Length bytes)   |
   +---+---------------------------+
   | H |     Value Length (7+)     |
   +---+---------------------------+
   |  Value String (Length bytes)  |
   +-------------------------------+

           Abbildung 17: Literale Feldzeile mit Literalname

Diese Darstellung beginnt mit dem '001' 3-Bit-Muster. Das vierte Bit ist das 'N'-Bit wie in Abschnitt 4.5.4 beschrieben. Der Name folgt, dargestellt als 4-Bit-Präfix-Zeichenfolgenliteral, dann der Wert, dargestellt als 8-Bit-Präfix-Zeichenfolgenliteral; siehe Abschnitt 4.1.2.

Letztes Update am