Abstract:
A technique of logically processing bit maps and character maps describing the attributes and values of computer variable ranges and a variable being tested to determine if a match exists between the variable and one or more ranges. Bit maps define the attributes of each character position of variables and ranges; character maps define which character positions are constrained to a fixed character for each of the ranges. This quick and efficient method of logical processing of maps replaces the known method of examining each character position of a variable individually.

Description:
TECHNICAL FIELD  
         [0001]    The invention relates to data processing and particularly to the field of categorizing the contents of computer variables into one or more variable spaces.  
         BACKGROUND OF THE INVENTION  
         [0002]    It is common in the data processing industry to validate computer addresses, the value of variables, and such, before using the values to perform computer operations. There are many reasons to categorize variables, ranging from validity checking to usage counting. In the case of validity checking, such validation before use can avoid unnecessary interference with the orderly operation of data processing systems and computers.  
           [0003]    It is known to perform simple range checks on the contents of variables in which all character positions of a variable have the same attributes, such as base 10 digits, (e.g. 100- 999), or hexadecimal (e.g. 0000- FFFF). When variables can take on disjoint values, it is also known to perform simple range checks on each possible disjoint range. U.S. Pat. No. 4,692,897 and Laid Open Japanese application JP 2000020351A2 are examples of such prior art techniques.  
           [0004]    However, such techniques can become burdensome and consume a disproportionate share of computer resources when there are many possible ranges. The problem becomes more complicated when the different character positions of a variable can have different attributes. For example, a system may use many variable ranges in which each position within a variable is characterized by different attributes (decimal referred to as numeric herein, alphanumeric, alphabetic, hexadecimal, fixed, etc.) In a real system, there can be hundreds or thousands of variable ranges to check. In some cases, all ranges must be checked to determine which ranges match the variable. In other cases, they must be checked at least until a match is found. There can be many reasons these checks are needed; updating of use-counts is a typical reason.  
           [0005]    A system can define many variable ranges. Each variable range is defined by a start variable, an end variable, and the attribute of each character position in the variable. For example, a three character variable range can start with A 10  and end with D 8 F. The first character is an alphabetic range, the second character is a numeric range, and the third character is a hexadecimal range. Shorthand notation of this range would be A 10 -D 8 F (Alpha,Numeric,Hex) where the characteristics of each position are defined within the parentheses. Character position  1  (A and D) is an Alphabetic range, character position  2  ( 1  and  8 ) is a numeric range, and character position  3  ( 0  and F) is a hexadecimal range.  
           [0006]    The variable ranges may overlap or intersect each other.  
           [0007]    For example, consider the following variable ranges:  
           [0008]    C 13  to C 26  (Fixed,Num,Num)  
           [0009]    C 15  to C 2 C (Fixed,Num,Hex)  
           [0010]    C 17  to C 2 M (Fixed,Num,Alphanum)  
           [0011]    It is important to realize how variables increment. It is clear that C 13 -C 26  includes the variable C 18 . It is less obvious that C 15 -C 2 C includes the variable C 1 D or that C 17 -C 2 M includes the variable C 1 X.  
           [0012]    As known in the prior art, it is relatively easy to determine if a variable value is within the start and end boundaries of a range. If there are many disjoint ranges in which all character positions of each range have the same attributes, it is relatively easy to check each range, but this quickly becomes too costly in terms of performance. When the character positions have different attributes, each character position can be checked individually, but that is extremely costly in terms of performance. The processing overhead increases as the length of the variable increases and the number of different character attributes increases. A method is needed to quickly determine if a variable value matches a range definition without checking each character individually.  
         SUMMARY OF THE INVENTION  
         [0013]    The invention provides a technique of logically processing bit maps and character maps that describe the attributes and values of the variable ranges and a variable being tested to determine if a match exists between the variable and one or more ranges. Bit maps define the attributes of each character position of variables and ranges; character maps define which character positions are constrained to a fixed character for each of the ranges. This quick and efficient method of logical processing of maps replaces the known method of examining each character position of a variable individually.  
           [0014]    In the preferred embodiment, each character position of a variable is associated with an attribute that defines a type of value for that character position. When a variable arrives, a bit map is created for the variable and that bit map is compared with range bit maps, wherein each range bit map contains logical representations of the attributes associated with the types of values each character position of a variable can legitimately acquire. The variable is further compared with a character map for each range, wherein each character map describes whether each character position of the variable is constrained to a fixed character. If both of these comparison operations succeed for a given range, then the variable is considered to match that specific range.  
       
    
    
     BRIEF DESCRIPTION OF THE DRAWING  
       [0015]    [0015]FIG. 1 contains a flowchart of the steps of the invention. 
     
    
     DETAILED DESCRIPTION  
       [0016]    For the preferred embodiment, it is assumed that each character position in the variable must fall within one or more of the following types:  
         [0017]    Numeric (0-9)  
         [0018]    Hexadecimal (0-9,A-F)  
         [0019]    Alphabetic (A-Z)  
         [0020]    Alphanumeric (0-9,A-Z)  
         [0021]    All (0-9,A-Z,!,@,#,$,%)  
         [0022]    It is also assumed that the order of characters is:  
         [0023]    blank,0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,!,@,#,$,%  
         [0024]    The character types and ordering are arbitrary and can be varied as desired in any embodiment.  
         [0025]    Consider the example of range values given above:  
         [0026]    Range 1. Cl 3 to C26 (Fixed,Num,Num)  
         [0027]    Range 2. C15 to C2C (Fixed,Num,Hex)  
         [0028]    Range 3. C17 to C2M (Fixed,Num,Alphanum)  
         [0029]    It is assumed that alphabetic letters, like numbers, increment to their highest value before the next position to the left increments. Below is the complete list of values contained within the three ranges defined above.  
         [0030]    For Range 1  
         [0031]    C13-C19  
         [0032]    C20-C26  
         [0033]    For Range 2  
         [0034]    C15-C19  
         [0035]    C1A-C1F  
         [0036]    C20-C29  
         [0037]    C2A-C2C  
         [0038]    For Range 3  
         [0039]    C17-C19  
         [0040]    C1A-C1Z  
         [0041]    C20-C29  
         [0042]    C2A-C2M  
         [0043]    Depending on the exact variable, the variable may fit within one or several of the variable ranges defined above. For example, variable C18 fits within all three ranges; variable C1D fits within ranges (2) and (3); variable C1X fits within range (3) only.  
         [0044]    As mentioned previously, known solutions include checking each character position individually to see if the character is within the character range of that position. Not only is that a long process as the number of characters grows, but the computer code used for each check involves several machine instructions for each position to compare high and low values against the current value. As the number of character positions grow, as the number of ranges to be checked grows, and as the number of variables checked grows, the entire procedure becomes more and more processor intensive.  
         [0045]    A particular variable may appear to fit within a range, but in fact does not because one of its characters does not match a character type defining the range. For example, the variable CC6A fits only the second range of ranges.  
         [0046]    1st range: CC00-CC99 (Fixed,Fixed,Numeric,Numeric)  
         [0047]    2 nd  range: CC20-CC7A (Fixed,Fixed,Numeric,Hexadecimal)  
         [0048]    3 rd  range: BG50-DG7C (Alpha,Fixed,Numeric,Hexadecimal).  
         [0049]    The range CC00 . . . CC99 (Fixed, Fixed, Numeric, Numeric) has 100 variables: CC00- CC09, CC10-CC19, . . . , CC80-CC89, CC90-CC99.  
         [0050]    The range CC20 . . CC7A (Fixed, Fixed, Numeric, Hexadecimal) has 91 variables:  
         [0051]    CC20-CC29, CC2A-CC2F, CC30-CC39, CC3A-CC3F, . . .  
         [0052]    CC60-CC69, CC6A-CC6F, CC70-CC79, CC7A-CC7A.  
         [0053]    The range BG50 . . DG7C (Alpha, Fixed, Numeric, Hexadecimal) has 365 variables BF50-BF9F, CF00-CF9F, DF00-DF7C.  
         [0054]    In this example using the value CC 6 A, the first range is not matched because the right-most character “A” is not numeric. The last range is not matched because the second character “G” is not a fixed “C”.  
         [0055]    In the preferred embodiment, each character above is converted to a number starting with 0 for blank and increasing up to 42 for %. This allows for quick determinations of range calculations according to the algorithm below. However, it is not necessary to use this convention; any notational scheme will work in principle.  
         [0056]    Range matches are determined quickly and conveniently using the following steps.  
         [0057]    Step 1. Create character groupings based on the smallest intersections of character attributes. For example,  
                                       TABLE 1                                   Attribute/Group   Group 1   Group 2   Group 3   Group 4                           Numeric   0-9                       Hexadecimal   0-9   A-F           Alphabetic       A-F   G-Z           Alphanumeric   0-9   A-F   G-Z           All   0-9   A-F   G-Z   !-%                      
 
         [0058]    In this example, a character can be in one of four groups. Group  1  (0-9), Group  2  (A-F), Group  3  (G-Z), or Group  4  (!-%)  
         [0059]    For example, the letter C is part of group  2 .  
         [0060]    For each character position of a variable range, create a bit map (preferably from left to right) that is True for each of the groups above that represents an attribute of that position. Then concatenate these character bit maps into a range bit map. If a character position does not change (i.e., Fixed), label it Fixed and assign all groups to that character position.  
                                                           Range 1: CC00 . . . CC99 (Fixed, Fixed, Numeric, Numeric)                1 st  character = Fixed   All groups   BitMap = 1111           2 nd  character = Fixed   All groups   BitMap = 1111           3 rd  character = Numeric   Group1   BitMap = 1000           4 th  character = Numeric   Group1   BitMap = 1000            Range 1 BitMap = 1111 1111 1000 1000                  
 
         [0061]    For Range 1, since the first position of the variable has a Fixed attribute, all character groups are assigned to that character position, so that the bit map for this position is 1111. Likewise for character position  2 . Character position  3  has a numeric attribute. Reference to Table  1  shows that the numeric attribute matches only Group  1 . Therefore, the bit map for this character position is 1000. Likewise for character position  4 .  
                                                                                   Range 2: CC20 . . . CC7A (Fixed, Fixed, Numeric, Hexadecimal)                1 st  Character = Fixed   All groups   BitMap = 1111           2 nd  Character = Fixed   All groups   BitMap = 1111           3 rd  character = Numeric   Grp1   BitMap = 1000           4 th  character = Hex   Grp1, Grp2   BitMap = 1100            Range 2 BitMap = 1111 1111 1000 1100       Range 3: BG50 . . . DG7C (Alpha, Fixed, Numeric, Hexadecimal)                1 st  character = Alpha   Grp2, Grp3   BitMap = 0110           2 nd  character = Fixed   Special case   BitMap = 1111           3 rd  character = Numeric   Grp1   BitMap = 1000           4 th  character = Hex   Grp1, Grp2   BitMap = 1100            Range 3 bitmap = 0110 1111 1000 1100                  
 
         [0062]    Step 3. Create a Character Map for each character position based on whether or not the position is Fixed. If a position is Fixed to a character, use the character itself for that position in the character map. If the position is not fixed, set that position of the character map to represent all characters (FF).  
                                                       Range 1: CC00 . . . CC99   CharacterMap =   C   C   FF   FF       Range 2: CC20 . . . CC7A   CharacterMap =   C   C   FF   FF       Range 3: BG50 . . . DG7C   CharacterMap =   FF   G   FF   FF                  
 
         [0063]    Step 4. Create a bit map for each character position of the exact variable CC6A.  
         [0064]    CC6A BitMap=0100 0100 1000 0100  
         [0065]    Step 5. Logically AND the bit map of the exact variable CC6A (0100 0100 1000 0100) with the bit map of a variable range. Logically AND the exact variable (CC6A) with the character map of a variable range. If the result of the bit map comparison match the original exact variable bit map and the result of the comparison of the exact variable to the character map is equal to the exact variable, then the exact variable fits within that variable range.  
         [0066]    In this specific example, the first range is not a match because the resulting bit map of the logical AND does not match the original CC6A bit map in the last character position.  
                                                                           CC00 . . . CC99   BitMap   1111   1111   1000   1000   CharMap   C   C   FF   FF       CC6A   BitMap   0100   0100   1000   0100   CharMap   C   C   6   A       Result       0100   0110   1000   0000   CharMap   C   C   6   A                  
 
         [0067]    The second range is a match because the resulting bit map and character map both match the original CC6A bit map and character map, respectively.  
                                                                           CC20 . . . CC7A   BitMap   1111   1111   1000   1100   CharMap   C   C   FF   FF       CC6A   BitMap   0100   0100   1000   0100   CharMap   C   C   6   A       Result       0100   0100   1000   0100   CharMap   C   C   6   A                  
 
         [0068]    The third range is not a match because the resulting character map does not match the original CC6A character map in the second character position.  
                                                                           BG50 . . . DG7C   BitMap   0110   1111   1000   1100   CharMap   FF   G   FF   FF       CC6A   BitMap   0100   0100   1000   0100   CharMap   C   C   6   A       Result       0100   0100   1000   0100   CharMap   C   0   6   A                  
 
         [0069]    The benefit of this logical procedure is that each logical AND can be done using only one assembler instruction. The entire bit map/character map procedure can be performed in only a few instructions. Any other method would require many more instructions because each character position would have to be analyzed.  
         [0070]    Immediately below is pseudo code that illustrates the assembler code needed for a range check.  
         [0071]    If (Range_BitMap AND Variable_BitMap=Variable_BitMap) &amp; ←AND the bitmap and compare  
         [0072]    (Range_CharMap AND Variable=Variable) Then ←AND the character map and compare  
                                                                                                                                                                   L   R06,RANGEPTR   &lt;- Get address of range data       MVC   WORKAREA(8),RANGE_BITMAP(R06)   &lt;- Move range bitmap into workarea       NC   WORKAREA(8),VARIABLE_BITMAP   &lt;- AND range bitmap with variable            bitmap            CLC   WORKAREA(8),VARIABLE_BITMAP   &lt;- Compare result with variable            bitmap            BNE   NO_MATCH   &lt;- If not equal, branch to            NO_MATCH            MVC   WORKAREA(8),RANGE_CHARMAP(R06)   &lt;- Move range character map into            workarea            NC   WORKAREA(8),VARIABLE   &lt;- AND range character map with            variable            CLC   WORKAREA(8),VARIABLE   &lt;- Compare result with variable            name            BNE   NO_MATCH   &lt;- If not equal, branch to NO_MATCH                  
 
         [0073]    [0073]FIG. 1 illustrates a preferred embodiment of the steps of the method. The method can be performed by any computer, including mainframes and personal computers. In the preferred embodiment, the method is executed in an IBM mainframe running the z/OS operating System, such as a z S eries 900 or z S eries 800.  
         [0074]    Steps  100  to  106  are executed initially at system load time, or perhaps as part of the system design process if desired. In either case, step  102  creates a set of character groupings that represent the smallest intersections of character attributes for the character set in use to describe variables. This step corresponds to step 1 described above. Next, step  104  creates, for each character position of a range, a bit map (preferably from left to right) that is True for each of the character groups that represents an attribute of that character position. These bit maps are concatenated into a range bit map. If a character position does not change, i.e. it has a Fixed attribute), then the bit map for that position is assigned all groups. This corresponds to step 2 described above.  
         [0075]    Step  106  creates a character map that represents each character position of a range. If the attribute for a given character position is Fixed, then the fixed character is used in the character map for the corresponding position. If the attribute is not fixed, then the corresponding position in the character map is set to all characters (Hex FF). This step corresponds to step 3 in the above description.  
         [0076]    At this point, initialization is complete and the system is ready to process actual exact range variables. Step  108  symbolically represents the arrival of an exact range variable for verification and classification. In step  110 , a bit map is created for each character position of the exact variable in the same fashion as described above for the initialization of range bitmaps. The actual values in each position of the exact variable are used as a character map. Step  112  sets up a loop through all of the possible ranges defined for the system. Step  114  logically ANDs the created bit map of the exact variable with the bit map of the present range in the loop. This step also ANDs the character map for this range with the exact character. At step  116 , if the results of the bit map AND operation and the character map AND operation match both the exact variable bit map and the exact variable, respectively, then the exact variable falls within the range represented by this particular loop. In this event, step  120  processes the exact variable according to a match. The final processing on a range match is system-specific and not relevant to the invention. If either the bit map or the character map AND operations fail, the exact variable does not fit within the present range being tested and step  118  continues to the next range in the loop or terminates at step  122  if completed. In either event, operations continue symbolically at step  108  to fetch and process another exact variable.  
         [0077]    Artisans in the field of this invention will quickly realize that the preferred and disclosed embodiment can have many minor variations that are within the intent and scope of the teaching. It is the intent of the inventor to encompass these variations to the extent possible in accordance with the state of the applicable relevant art in the field of the invention.