Lines Matching +full:very +full:- +full:high
2 .\" Must use -- tbl -- with this one
34 diverse machines as the Sun Workstation, VAX, IBM-PC, and Cray.
55 suggests that bytes be encoded in "little-endian" style [2], or least
63 32 bits) of data. The bytes are numbered 0 through n-1. The bytes
78 \f(CW+--------+--------+...+--------+--------+...+--------+
79 | byte 0 | byte 1 |...|byte n-1| 0 |...| 0 |
80 +--------+--------+...+--------+--------+...+--------+
81 |<-----------n bytes---------->|<------r bytes------>|
82 |<-----------n+r (where (n+r) mod 4 = 0)>----------->|\fP
97 fixed-length sequences of data. "n", "m" and "r" denote integers.
111 An XDR signed integer is a 32-bit datum that encodes an integer in
112 the range [-2147483648,2147483647]. The integer is represented in
120 +-------+-------+-------+-------+
122 +-------+-------+-------+-------+
123 <------------32 bits------------>\fP
130 An XDR unsigned integer is a 32-bit datum that encodes a nonnegative
139 +-------+-------+-------+-------+
141 +-------+-------+-------+-------+
142 <------------32 bits------------>\fP
153 enum { name-identifier = constant, ... } identifier;
184 The standard also defines 64-bit (8-byte) numbers called hyper
196 +-------+-------+-------+-------+-------+-------+-------+-------+
198 +-------+-------+-------+-------+-------+-------+-------+-------+
199 <----------------------------64 bits---------------------------->\fP
202 \&Floating-point
204 .IX XDR "floating-point integer"
206 The standard defines the floating-point data type "float" (32 bits or
208 single-precision floating-point numbers [3]. The following three
209 fields describe the single-precision floating-point number:
222 Therefore, the floating-point number is described by:
224 (-1)**S * 2**(E-Bias) * 1.F
229 \fISingle-Precision Floating-Point\fP
231 \f(CW+-------+-------+-------+-------+
234 +-------+-------+-------+-------+
235 1|<- 8 ->|<-------23 bits------>|
236 <------------32 bits------------>\fP
239 the most and least significant bits of a single-precision floating-
251 \&Double-precision Floating-point
252 .IX XDR "integer, double-precision floating point"
253 .IX XDR "double-precision floating-point integer"
255 The standard defines the encoding for the double-precision floating-
257 the IEEE standard for normalized double-precision floating-point
259 describe the double-precision floating-point number:
272 Therefore, the floating-point number is described by:
274 (-1)**S * 2**(E-Bias) * 1.F
279 \fIDouble-Precision Floating-Point\fP
281 \f(CW+------+------+------+------+------+------+------+------+
284 +------+------+------+------+------+------+------+------+
285 1|<--11-->|<-----------------52 bits------------------->|
286 <-----------------------64 bits------------------------->\fP
289 the most and least significant bits of a double-precision floating-
301 \&Fixed-length Opaque Data
302 .IX XDR "fixed-length opaque data"
305 At times, fixed-length uninterpreted data needs to be passed among
317 \fIFixed-Length Opaque\fP
320 +--------+--------+...+--------+--------+...+--------+
321 | byte 0 | byte 1 |...|byte n-1| 0 |...| 0 |
322 +--------+--------+...+--------+--------+...+--------+
323 |<-----------n bytes---------->|<------r bytes------>|
324 |<-----------n+r (where (n+r) mod 4 = 0)------------>|\fP
327 \&Variable-length Opaque Data
328 .IX XDR "variable-length opaque data"
331 The standard also provides for variable-length (counted) opaque data,
332 defined as a sequence of n (numbered 0 through n-1) arbitrary bytes
339 a multiple of four. Variable-length opaque data is declared in the
352 declaration, it is assumed to be (2**32) - 1, the maximum length.
363 \fIVariable-Length Opaque\fP
366 +-----+-----+-----+-----+-----+-----+...+-----+-----+...+-----+
367 | length n |byte0|byte1|...| n-1 | 0 |...| 0 |
368 +-----+-----+-----+-----+-----+-----+...+-----+-----+...+-----+
369 |<-------4 bytes------->|<------n bytes------>|<---r bytes--->|
370 |<----n+r (where (n+r) mod 4 = 0)---->|\fP
379 The standard defines a string of n (numbered 0 through n-1) ASCII
398 declaration, it is assumed to be (2**32) - 1, the maximum length.
412 +-----+-----+-----+-----+-----+-----+...+-----+-----+...+-----+
413 | length n |byte0|byte1|...| n-1 | 0 |...| 0 |
414 +-----+-----+-----+-----+-----+-----+...+-----+-----+...+-----+
415 |<-------4 bytes------->|<------n bytes------>|<---r bytes--->|
416 |<----n+r (where (n+r) mod 4 = 0)---->|\fP
422 \&Fixed-length Array
423 .IX XDR "fixed-length array"
426 Declarations for fixed-length arrays of homogeneous elements are in
430 type-name identifier[n];
432 Fixed-length arrays of elements numbered 0 through n-1 are encoded by
434 order, 0 through n-1. Each element's size is a multiple of four
436 have different sizes. For example, in a fixed-length array of
441 \fIFixed-Length Array\fP
443 \f(CW+---+---+---+---+---+---+---+---+...+---+---+---+---+
444 | element 0 | element 1 |...| element n-1 |
445 +---+---+---+---+---+---+---+---+...+---+---+---+---+
446 |<--------------------n elements------------------->|\fP
449 \&Variable-length Array
450 .IX XDR "variable-length array"
453 Counted arrays provide the ability to encode variable-length arrays
456 elements, starting with element 0 and progressing through element n-
457 1. The declaration for variable-length arrays follows this form:
460 type-name identifier<m>;
465 type-name identifier<>;
469 assumed to be (2**32) - 1.
475 +--+--+--+--+--+--+--+--+--+--+--+--+...+--+--+--+--+
476 | n | element 0 | element 1 |...|element n-1|
477 +--+--+--+--+--+--+--+--+--+--+--+--+...+--+--+--+--+
478 |<-4 bytes->|<--------------n elements------------->|\fP
490 component-declaration-A;
491 component-declaration-B;
502 \f(CW+-------------+-------------+...
504 +-------------+-------------+...\fP
520 union switch (discriminant-declaration) {
521 case discriminant-value-A:
522 arm-declaration-A;
523 case discriminant-value-B:
524 arm-declaration-B;
526 default: default-declaration;
541 +---+---+---+---+---+---+---+---+
543 +---+---+---+---+---+---+---+---+
544 |<---4 bytes--->|\fP
550 An XDR void is a 0-byte quantity. Voids are useful for describing
566 --><-- 0 bytes\fP
575 const name-identifier = n;
638 \&Optional-data
642 Optional-data is one kind of union that occurs so frequently that we
647 type-name *identifier;
654 type-name element;
659 It is also equivalent to the following variable-length array
664 type-name identifier<1>;
666 Optional-data is not so interesting in itself, but it is very useful
667 for describing recursive data-structures such as linked-lists and
690 or as a variable-length array:
699 type, so the optional-data declaration is preferred over both of
700 them. The optional-data type also has a close correlation to how
701 recursive data structures are represented in high-level languages
710 binary-coded) decimals.
714 machine. Rather, it only describes the most commonly used data-types
715 of high-level languages such as Pascal or C so that applications
721 are support for different block sizes and byte-orders. The XDR
722 discussed here could then be considered the 4-byte big-endian member
731 There are many advantages in using a data-description language such
735 other issues instead of the low-level details of bit-encoding.
737 high-level language such as C or Pascal. This makes the
740 can be passed from machine to machine to perform on-the-fly data
743 \&Why Only one Byte-Order for an XDR Unit?
746 Supporting two byte-orderings requires a higher level protocol for
747 determining in which byte-order the data is encoded. Since XDR is
751 higher level protocol is necessary for determining the byte-order.
753 \&Why does XDR use Big-Endian Byte-Order?
755 Yes, it is unfair, but having only one byte-order means you have to
757 68000 and IBM 370, support the big-endian byte-order.
768 eight-byte aligned Cray. Four is also small enough to keep the
771 \&Why must Variable-Length Data be Padded with Zeros?
772 .IX XDR "variable-length data"
778 \&Why is there No Explicit Data-Typing?
780 Data-typing has a relatively high cost for what small advantages it
784 they expect, so data-typing supplies only redundant information.
785 However, one can still get the benefits of data-typing using XDR. One
799 This specification uses an extended Backus-Naur Form notation for
817 Non-terminal symbols are strings of non-special characters.
831 "a " "very" (", " " very")* [" cold " "and"] " rainy " ("day" | "night")
837 "a very rainy day"
838 "a very, very rainy day"
839 "a very cold and rainy day"
840 "a very, very, very cold and rainy night"
854 optionally preceded by a minus-sign ('-').
861 type-specifier identifier
862 | type-specifier identifier "[" value "]"
863 | type-specifier identifier "<" [ value ] ">"
867 | type-specifier "*" identifier
876 type-specifier:
882 | enum-type-spec
883 | struct-type-spec
884 | union-type-spec
889 enum-type-spec:
890 "enum" enum-body
892 enum-body:
900 struct-type-spec:
901 "struct" struct-body
903 struct-body:
911 union-type-spec:
912 "union" union-body
914 union-body:
921 constant-def:
926 type-def:
928 | "enum" identifier enum-body ";"
929 | "struct" identifier struct-body ";"
930 | "union" identifier union-body ";"
933 type-def
934 | constant-def
1033 12&67 00 00 00&g...& ... and 3 zero-bytes of fill
1041 44&74 29 00 00&t)..& ... and 2 zero-bytes of fill
1052 [3] "IEEE Standard for Binary Floating-Point Arithmetic", ANSI/IEEE
1053 Standard 754-1985, Institute of Electrical and Electronics