Software Engineers Handbook/Language Dictionary/PLI/bit strings

Note: This article requires basic knowledge of PL/I which can be found in Software Engineers Handbook/Language Dictionary/PLI. Bit Strings "as Strings" In PL/I bit strings formally are declared as strings of "1-bit-letters", i.e. all builtin string functions may be used for it, dcl my_chars char (8) varying init ( 'ABCDCD' ); dcl my_bits bit (8) varying init ( '01010'B ); put skip list ( length ( my_chars ) ); /* output is 6, the current length of the varying string */ put skip list ( length ( my_bits ) ); /* output is 5, the current length of the varying string */ put skip list ( index ( my_chars , 'CD' ) ); /* output is 3, the first position of substring 'CD' */ put skip list ( index ( my_bits , '10'B ) ); /* output is 2, the first position of substring '10'B */ Bit Strings as Boolean Values The common use of bit strings is to employ them as bit vectors, especially bit (1) strings represents single boolean values: '1'B is interpreted as True '0'B is interpreted as False Bit (1) strings may be used as boolean expressions in conditional and loop statements. dcl one_bit bit (1); one_bit = ( 1 < 2 ); /* now one_bit has the value '1'B */ one_bit = ( 2 < 1 ); /* now one_bit has the value '0'B */ if one_bit then put skip list ( 'value of one_bit is true' ); else put skip list ( 'value of one_bit is false' ); do while ( one_bit ); ..... end; Bit strings used in an expression expecting a bit (1) value are interpreted as '1'B = True if and only if at least one bit has then value '1'B. dcl many_bits bit (99); if many_bits then put skip list ( 'at least one of the bits has value 1'''B' ); else put skip list ( 'none of the bits has value 1B' ); do while ( many_bits ); /* do while at least one bit is set */ ..... end; Fundamental Boolean Operators Boolean operators may be used for calculating new bit (1) values: The prefix operator ¬ is used as logical NOT. The infix operator & is used as logical AND. The infix operator | is used as logical OR. dcl bit_a bit (1); dcl bit_b bit (1); dcl result bit (1); result = ¬ bit_a; /* result = '1'B if and only if bit_a is '0'B */ result = bit_a & bit_b; /* result = '1'B if and only if both bit_a and bit_b are '1'B */ result = bit_a | bit_b; /* result = '0'B if and only if both bit_a and bit_b are '0'B */ Note: Using compile-time options NOT operator and OR operator may be replaced by other symbols, for being compatible with existing PL/I programs often ^ is used as NOT, ! is used as OR. Note: In Enterprise PL/I for z/OS ¬ may also by used as an infix operator, A ¬ B means A XOR B (exclusive-or). Boolean operators may also be used for bit (n) strings with n > 1, in this case calculation is done in a bit-by-bit way, i.e. 1st bit of ( A & B ) = ( 1st bit of A ) & ( 1st bit of B ) 2nd bit of ( A & B ) = ( 2nd bit of A ) & ( 2nd bit of B ) and so on ... If A and B have different length the shorter of them is padded on the right with '0'B. dcl bit_a bit (3) init ( '101'B ); dcl bit_b bit (4) init ( '1100'B ); put skip list ( ¬ bit_a ); /* '010'B */ put skip list ( ¬ bit_b ); /* '0011'B */ put skip list ( bit_a & bit_b ); /* '1000'B */ put skip list ( bit_a | bit_b ); /* '1110'B */ Builtin Function BOOL All of the 16 possible binary boolean operations can be done with the BOOL function. BOOL ( A , B , pattern_4 ) where A and B are bit strings and pattern_4 is a bit (4) string. Let us as first assume A and B would be bit (1), then the function of pattern_4 is: 1st bit of pattern_4 defines the result of bool if A = '0'B and B = '0'B 2nd bit of pattern_4 defines the result of bool if A = '0'B and B = '1'B 3rd bit of pattern_4 defines the result of bool if A = '1'B and B = '0'B 4th bit of pattern_4 defines the result of bool if A = '1'B and B = '1'B If A or B is bit (n) with n > 1 then calculation is done in a bit-by-bit way, see above. Some possible values of pattern_4: alternative meaning bool ( A , B , '0001'B ) A & B A AND B logical AND bool ( A , B , '0111'B ) A | B A OR B logical OR bool ( A , B , '0110'B ) A ¬= B A XOR B exclusive-OR bool ( A , B , '1110'B ) ¬ ( A & B ) A NAND B NOT AND bool ( A , B , '1000'B ) ¬ ( A | B ) A NOR B NOT OR bool ( A , B , '1001'B ) A = B A IFF B equivalence bool ( A , B , '1101'B ) ¬A | B A -> B implication: if A then B bool ( A , B , '1011'B ) A | ¬B a <- B implication: if B then A Array Operations The builtin function ALL and ANY expects an array as argument. Let us as first assume the argument ARRAY would be an array of bit (1), then ALL returns '1'B = True if and only if all elements of ARRAY are '1'B. ANY''' returns '1'B = True if and only if at least 1 element of ARRAY is '1'B. If argument ARRAY is an array of bit (n) with n > 1 then calculation is done in a bit-by-bit way, see above. dcl array (3) bit (8) init ( '11110000'B , '11001100'B , '10101010'B ); dcl number (42) bin fixed (15); put skip list ( ALL ( array ) ); /* output is '10000000'B */ put skip list ( ANY ( array ) ); /* output is '11111110'B */ if ANY ( number < 0 ) then /* expression "number < 0" returns an array of 42 bit (1) strings */ put skip list ( 'at least 1 number is negative' );