|
Open64 (mfef90, whirl2f, and IR tools)
TAG: version-openad; SVN changeset: 916
|
|
Open64 (mfef90, whirl2f, and IR tools)
TAG: version-openad; SVN changeset: 916
|
00001 /* 00002 00003 Copyright (C) 2000, 2001 Silicon Graphics, Inc. All Rights Reserved. 00004 00005 This program is free software; you can redistribute it and/or modify it 00006 under the terms of version 2 of the GNU General Public License as 00007 published by the Free Software Foundation. 00008 00009 This program is distributed in the hope that it would be useful, but 00010 WITHOUT ANY WARRANTY; without even the implied warranty of 00011 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 00012 00013 Further, this software is distributed without any warranty that it is 00014 free of the rightful claim of any third person regarding infringement 00015 or the like. Any license provided herein, whether implied or 00016 otherwise, applies only to this software file. Patent licenses, if 00017 any, provided herein do not apply to combinations of this program with 00018 other software, or any other product whatsoever. 00019 00020 You should have received a copy of the GNU General Public License along 00021 with this program; if not, write the Free Software Foundation, Inc., 59 00022 Temple Place - Suite 330, Boston MA 02111-1307, USA. 00023 00024 Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pky, 00025 Mountain View, CA 94043, or: 00026 00027 http://www.sgi.com 00028 00029 For further information regarding this notice, see: 00030 00031 http://oss.sgi.com/projects/GenInfo/NoticeExplan 00032 00033 */ 00034 00035 00036 00037 static char USMID[] = "\n@(#)5.0_pl/sources/utils.c 5.9 10/14/99 12:53:57\n"; 00038 00039 # include <stdio.h> /* for tempnam */ 00040 # include <stdlib.h> 00041 00042 00043 # include "defines.h" /* Machine dependent ifdefs */ 00044 00045 # include "host.m" /* Host machine dependent macros.*/ 00046 # include "host.h" /* Host machine dependent header.*/ 00047 # include "target.m" /* Target machine dependent macros.*/ 00048 # include "target.h" /* Target machine dependent header.*/ 00049 00050 # ifdef _ARITH_H 00051 # include "arith.h" 00052 # endif 00053 00054 # include "globals.m" 00055 # include "tokens.m" 00056 # include "sytb.m" 00057 # include "debug.m" 00058 # include "globals.h" 00059 # include "tokens.h" 00060 # include "sytb.h" 00061 00062 # if defined(_HOST32) && defined(_TARGET64) 00063 00064 # define OCT_FMT "%llo" 00065 # define HEX_FMT "%llx" 00066 # define DEC_FMT "%lld" 00067 00068 # else 00069 00070 # define OCT_FMT "%o" 00071 # define HEX_FMT "%x" 00072 # define DEC_FMT "%d" 00073 00074 # endif 00075 00076 # define LLOCT_FMT "%llo" 00077 # define LLHEX_FMT "%llx" 00078 # define LLDEC_FMT "%lld" 00079 00080 00081 # define STR_FMT "\"%s\"" 00082 00083 # if defined(_HOST_OS_LINUX) 00084 # define DBL_FMT "%Le" 00085 # elif defined(_HOST_OS_SOLARIS) || (defined(_HOST_OS_IRIX) || defined(_HOST_OS_LINUX)) 00086 # define DBL_FMT "%e" 00087 # else 00088 # define DBL_FMT "%Le" 00089 # endif 00090 00091 # define FLT_FMT "%e" 00092 00093 00094 /******************************************************************************\ 00095 |* *| 00096 |* Description: *| 00097 |* *| 00098 |* Convert a numeric or typeless constant to a string to be used in *| 00099 |* fprintf's. This routine is used to avoid problems with varying *| 00100 |* definitions of "long" and "float" on different architectures. *| 00101 |* Only one long_type word is printed for Typeless constants. If the *| 00102 |* Typeless constant is longer than one word, then the calling routine *| 00103 |* must make multiple calls to convert_to_string with the address *| 00104 |* "the_constant" advancing by a long_type. *| 00105 |* *| 00106 |* Input parameters: *| 00107 |* the_constant : address of the constant to be "converted" *| 00108 |* type_idx : the data type of the constant (index into Type Table) *| 00109 |* *| 00110 |* Output parameters: *| 00111 |* result : the_constant converted to a string (also returned as *| 00112 |* the result of this function) *| 00113 |* *| 00114 |* Returns: *| 00115 |* A character string version of the_constant (in result). *| 00116 |* *| 00117 \******************************************************************************/ 00118 00119 char * convert_to_string (long_type *the_constant, 00120 int type_idx, 00121 char *result) 00122 00123 { 00124 00125 int i; 00126 int inc; 00127 int base; 00128 int stat; 00129 char str1[50]; 00130 char str2[50]; 00131 long_type value[4]; 00132 long_type value2[4]; 00133 char *fmt1; 00134 00135 00136 TRACE (Func_Entry, "convert_to_string", NULL); 00137 00138 switch(TYP_LINEAR(type_idx)) { 00139 00140 # ifdef _ARITH_INPUT_CONV 00141 00142 case Integer_1 : 00143 case Integer_2 : 00144 case Integer_4 : 00145 case Integer_8 : 00146 for (i = 0; i < num_host_wds[TYP_LINEAR(type_idx)]; i++) { 00147 value[i] = the_constant[i]; 00148 } 00149 00150 SHIFT_ARITH_ARG(value, TYP_LINEAR(type_idx)); 00151 base = 10; 00152 stat = AR_convert_int_to_str(result, 00153 (const int *)&base, 00154 (const AR_DATA *)value, 00155 (const AR_TYPE *)&linear_to_arith[TYP_LINEAR(type_idx)]); 00156 break; 00157 00158 case Real_4 : 00159 case Real_8 : 00160 case Real_16 : 00161 for (i = 0; i < num_host_wds[TYP_LINEAR(type_idx)]; i++) { 00162 value[i] = the_constant[i]; 00163 } 00164 00165 SHIFT_ARITH_ARG(value, TYP_LINEAR(type_idx)); 00166 00167 stat = AR_convert_float_to_str(result, 00168 (const AR_DATA *)value, 00169 (const AR_TYPE *)&linear_to_arith[TYP_LINEAR(type_idx)]); 00170 00171 break; 00172 00173 case Complex_4 : 00174 value[0] = *the_constant; 00175 value2[0] = *(the_constant + 1); 00176 00177 SHIFT_ARITH_ARG(value, Real_4); 00178 SHIFT_ARITH_ARG(value2, Real_4); 00179 00180 stat = AR_convert_float_to_str(str1, 00181 (const AR_DATA *)value, 00182 (const AR_TYPE *)&linear_to_arith[Real_4]); 00183 00184 stat = AR_convert_float_to_str(str2, 00185 (const AR_DATA *)value2, 00186 (const AR_TYPE *)&linear_to_arith[Real_4]); 00187 00188 sprintf(result, "(%s,%s)", str1, str2); 00189 break; 00190 00191 case Complex_8 : 00192 # ifdef _TARGET64 00193 inc = 1; 00194 # else 00195 inc = 2; 00196 # endif 00197 stat = AR_convert_float_to_str(str1, 00198 (const AR_DATA *)the_constant, 00199 (const AR_TYPE *)&linear_to_arith[Real_8]); 00200 00201 stat = AR_convert_float_to_str(str2, 00202 (const AR_DATA *)(the_constant + inc), 00203 (const AR_TYPE *)&linear_to_arith[Real_8]); 00204 00205 sprintf(result, "(%s,%s)", str1, str2); 00206 break; 00207 00208 case Complex_16 : 00209 stat = AR_convert_float_to_str(str1, 00210 (const AR_DATA *)the_constant, 00211 (const AR_TYPE *)&linear_to_arith[Real_16]); 00212 00213 stat = AR_convert_float_to_str(str2, 00214 (const AR_DATA *)(the_constant + 2), 00215 (const AR_TYPE *)&linear_to_arith[Real_16]); 00216 00217 sprintf(result, "(%s,%s)", str1, str2); 00218 break; 00219 00220 # else 00221 00222 # ifdef _TARGET32 00223 case Integer_1 : 00224 case Integer_2 : 00225 case Integer_4 : 00226 switch (convert_to_string_fmt) { 00227 00228 case Octal_Fmt: 00229 fmt1 = OCT_FMT; 00230 break; 00231 00232 case Character_Fmt: 00233 case Binary_Fmt: 00234 case Hex_Fmt: 00235 fmt1 = HEX_FMT; 00236 break; 00237 00238 case Dont_Care: 00239 default: 00240 fmt1 = DEC_FMT; 00241 break; 00242 } 00243 00244 sprintf(result, fmt1, *the_constant); 00245 break; 00246 00247 case Integer_8 : 00248 switch (convert_to_string_fmt) { 00249 00250 case Octal_Fmt: 00251 fmt1 = LLOCT_FMT; 00252 break; 00253 00254 case Character_Fmt: 00255 case Binary_Fmt: 00256 case Hex_Fmt: 00257 fmt1 = LLHEX_FMT; 00258 break; 00259 00260 case Dont_Care: 00261 default: 00262 /*FMZH fmt1 = LLDEC_FMT;*/ 00263 /* mostly default should give hex form since the sprintf is given 00264 2-word for integer(8) type constant this should be work well for 00265 little endian machine 00266 */ 00267 fmt1 = LLHEX_FMT; 00268 break; 00269 } 00270 00271 sprintf(result, fmt1, *(long long *)the_constant); 00272 break; 00273 00274 # else 00275 case Integer_1 : 00276 case Integer_2 : 00277 case Integer_4 : 00278 case Integer_8 : 00279 switch (convert_to_string_fmt) { 00280 00281 case Octal_Fmt: 00282 fmt1 = OCT_FMT; 00283 break; 00284 00285 case Character_Fmt: 00286 case Binary_Fmt: 00287 case Hex_Fmt: 00288 fmt1 = HEX_FMT; 00289 break; 00290 00291 case Dont_Care: 00292 default: 00293 fmt1 = DEC_FMT; 00294 break; 00295 } 00296 00297 sprintf(result, fmt1, *the_constant); 00298 break; 00299 # endif 00300 00301 # ifdef _TARGET64 00302 case Real_4 : 00303 case Real_8 : 00304 if (sizeof(float_type) > sizeof(float)) { 00305 #if defined(_HOST32) 00306 sprintf(result, FLT_FMT, *(float_type *)the_constant); 00307 #else 00308 sprintf(result, DBL_FMT, *(float_type *)the_constant); 00309 #endif 00310 } 00311 else { 00312 sprintf(result, FLT_FMT, *(float_type *)the_constant); 00313 } 00314 break; 00315 00316 case Real_16 : 00317 sprintf(result, DBL_FMT, *(ldouble *)the_constant); 00318 break; 00319 00320 case Complex_4 : 00321 case Complex_8 : 00322 inc = (TYP_LINEAR(type_idx) > COMPLEX_DEFAULT_TYPE) ? 2 : 1; 00323 00324 if (sizeof(float_type) > sizeof(float)) { 00325 #if defined(_HOST32) 00326 sprintf(result, "(" FLT_FMT ", " FLT_FMT ")", 00327 *(float_type *)the_constant, 00328 *(float_type *)(the_constant + inc)); 00329 #else 00330 sprintf(result, "(" DBL_FMT ", " DBL_FMT ")", 00331 *(float_type *)the_constant, 00332 *(float_type *)(the_constant + inc)); 00333 #endif 00334 } 00335 else { 00336 sprintf(result, "(" FLT_FMT ", " FLT_FMT ")", 00337 *(float_type *)the_constant, 00338 *(float_type *)(the_constant + inc)); 00339 } 00340 break; 00341 00342 case Complex_16 : 00343 inc = (TYP_LINEAR(type_idx) > COMPLEX_DEFAULT_TYPE) ? 2 : 1; 00344 00345 sprintf(result, "(" DBL_FMT ", " DBL_FMT ")", 00346 *(ldouble *)the_constant, 00347 *(ldouble *)(the_constant + inc)); 00348 break; 00349 00350 # else 00351 case Real_4 : 00352 sprintf(result, FLT_FMT, *(float *)the_constant); 00353 break; 00354 00355 case Real_8 : 00356 # if defined(_HOST_OS_LINUX) 00357 sprintf(result, FLT_FMT, *(double *)the_constant); 00358 break; 00359 # endif 00360 00361 case Real_16 : 00362 if (sizeof(ldouble) > sizeof(float)) { 00363 sprintf(result, DBL_FMT, *(ldouble *)the_constant); 00364 } 00365 else { 00366 sprintf(result, FLT_FMT, *(float_type *)the_constant); 00367 } 00368 break; 00369 00370 case Complex_4 : 00371 inc = (TYP_LINEAR(type_idx) > COMPLEX_DEFAULT_TYPE) ? 2 : 1; 00372 00373 sprintf(result, "(" FLT_FMT ", " FLT_FMT ")", 00374 *(float_type *)the_constant, 00375 *(float_type *)(the_constant + inc)); 00376 break; 00377 00378 case Complex_8 : 00379 case Complex_16 : 00380 inc = (TYP_LINEAR(type_idx) > COMPLEX_DEFAULT_TYPE) ? 2 : 1; 00381 00382 if (sizeof(ldouble) > sizeof(float)) { 00383 sprintf(result, "(" DBL_FMT ", " DBL_FMT ")", 00384 *(ldouble *)the_constant, 00385 *(ldouble *)(the_constant + inc)); 00386 } 00387 break; 00388 # endif 00389 # endif 00390 00391 case Typeless_4: 00392 case Typeless_8: 00393 case Short_Typeless_Const: 00394 case Long_Typeless: 00395 if (convert_to_string_fmt == Hex_Fmt) { 00396 fmt1 = HEX_FMT; 00397 } 00398 else { 00399 fmt1 = OCT_FMT; 00400 } 00401 00402 /* only one word is printed */ 00403 00404 sprintf(result, fmt1, *the_constant); 00405 break; 00406 00407 case Character_1: 00408 *result = (char) *the_constant; 00409 break; 00410 00411 case Logical_1: 00412 case Logical_2: 00413 case Logical_4: 00414 case Logical_8: 00415 if (THIS_IS_TRUE(the_constant, type_idx)) { 00416 sprintf(result, ".T."); 00417 } 00418 else { 00419 sprintf(result, ".F."); 00420 } 00421 break; 00422 00423 default : 00424 PRINTMSG(stmt_start_line, 626, Internal, stmt_start_col, 00425 "valid type", "convert_to_string"); 00426 00427 } 00428 00429 convert_to_string_fmt = Dont_Care; 00430 00431 TRACE (Func_Exit, "convert_to_string", NULL); 00432 00433 return(result); 00434 00435 } /* convert_to_string */ 00436 00437 00438 /******************************************************************************\ 00439 |* *| 00440 |* Description: *| 00441 |* ALL compiler temporary files should be created by this routine so *| 00442 |* their location can be controlled by TMPDIR. *| 00443 |* *| 00444 |* Use UNIX function "tempnam" to produce a unique file name. The first *| 00445 |* argument to tempnam points to a name of a directory in which the file *| 00446 |* is to be created. Since we set this argument to NULL, tempname will *| 00447 |* use the path in P_tmpdir in <stdio.h>. If that directory is not *| 00448 |* available, /tmp will be used. The user can override this sequence by *| 00449 |* using environment variable TMPDIR to specify what directory they want *| 00450 |* the file to be created in. The second argument allows for a file *| 00451 |* name prefix. Although tempnam tries to produce a unique name and *| 00452 |* normally creates the file in a temp directory that should be scrubbed *| 00453 |* reasonably often by the system administrator, we have seen the names *| 00454 |* roll over and clash with existing names. The second argument could *| 00455 |* be used to prefix the file name with the month and day for example *| 00456 |* (the complete month, day, and year are too large since only 5 prefix *| 00457 |* characters are allowed. *| 00458 |* *| 00459 |* Input parameters: *| 00460 |* open_status : the file access method(s) *| 00461 |* file_name : if NULL, ignore this argument; otherwise, return the *| 00462 |* file name in it *| 00463 |* *| 00464 |* Output parameters: *| 00465 |* file_ptr : set to point to the temporary file *| 00466 |* file_name : returns the temporary file name *| 00467 |* *| 00468 |* Returns: *| 00469 |* TRUE if the temporary file could be created and opened; otherwise, *| 00470 |* returns FALSE. *| 00471 |* *| 00472 \******************************************************************************/ 00473 00474 00475 boolean get_temp_file(char *open_status, 00476 FILE **file_ptr, 00477 char *file_name) 00478 { 00479 boolean result; 00480 char tmp_file_name[MAXPATHLEN]; 00481 int fd_temp; 00482 FILE *tmp_file_ptr; 00483 00484 TRACE (Func_Entry, "get_temp_file", NULL); 00485 00486 result = FALSE; 00487 fd_temp = -1; 00488 strcpy(tmp_file_name, "/tmp/Open64_XXXXXX"); 00489 fd_temp = mkstemp(tmp_file_name); 00490 00491 if (fd_temp != -1) { 00492 *file_ptr = fdopen(fd_temp, /*"rw"*/ open_status); 00493 if (*file_ptr != NULL) { 00494 result = TRUE; 00495 } 00496 if (file_name != NULL) { 00497 strcpy(file_name, tmp_file_name); 00498 } 00499 } 00500 00501 00502 /* 00503 tmp_file_name = (char *) tempnam(NULL, NULL); 00504 00505 00506 if (tmp_file_name != NULL) { 00507 00508 if (file_name != NULL) { 00509 strcpy(file_name, tmp_file_name); 00510 } 00511 00512 if ((*file_ptr = fopen(tmp_file_name, open_status)) != NULL) { 00513 result = TRUE; 00514 } 00515 } 00516 */ 00517 00518 TRACE (Func_Exit, "get_temp_file", NULL); 00519 00520 return(result); 00521 00522 } /* get_temp_file */ 00523 00524 /******************************************************************************\ 00525 |* *| 00526 |* Description: *| 00527 |* srch_name_tbl searches a name table for the identifier or label *| 00528 |* specified in name_str. *| 00529 |* *| 00530 |* Input parameters: *| 00531 |* name_str -> The string to search for. *| 00532 |* name_len -> The length of string to search for. *| 00533 |* table -> The name table to search in. This currently could be *| 00534 |* loc_name_tbl, global_name_tbl, hidden_name_tbl or *| 00535 |* cc_name_tbl. *| 00536 |* pool -> The pool that the table uses (str_pool or name_pool) *| 00537 |* first_entry -> The first entry of the name table. *| 00538 |* last_entry -> The last entry of the name table. *| 00539 |* *| 00540 |* Output parameters: *| 00541 |* name_idx -> The name table index where the match occured *| 00542 |* or where entry should be inserted *| 00543 |* *| 00544 |* Returns: *| 00545 |* The test value. non zero means found, zero means not found. *| 00546 |* *| 00547 |* Method: *| 00548 |* The word length of the identifier is calculated (id_len). This is *| 00549 |* used to determine the number of words to compare in the name pool. *| 00550 |* The local name table is a sorted table (alphabetically) of links *| 00551 |* between the name pool and the attribute table. The body of the *| 00552 |* routine is a switch statement based on id_len. *| 00553 |* *| 00554 |* The search samples local name table entries at a stride calculated *| 00555 |* so that the loop is a shortloop (<= vector length). The compare *| 00556 |* is long integer subtraction, a word at a time. When the sign of *| 00557 |* the result goes positive, the search has gone too far, or if the *| 00558 |* result is zero, there has been a match. If there was not a match, *| 00559 |* the search area becomes the entries in the table between the two *| 00560 |* entries sampled where the sign has changed from negative to *| 00561 |* positive. This process continues until the stride between samplings *| 00562 |* is 1. At this point, if no match is found, the entry where the *| 00563 |* sign bit changed is the point where the new identifier should be *| 00564 |* entered. As an optimization, once a segment length for searching *| 00565 |* is 32 or less, the search goes immediately to stride 1 search. *| 00566 |* *| 00567 |* The above describes the basic search method for 1 word identifiers. *| 00568 |* For more than one word, the first word is compared. A mask is *| 00569 |* created which is all ones (-1) if the first words did not match,, *| 00570 |* and zero if they matched. The second words are compared and the *| 00571 |* result anded bitwise with the complement of the mask; thus if *| 00572 |* there was a difference in the first word, any difference in the *| 00573 |* second word is ignored. The mask is recalculated based on the *| 00574 |* result of the compares of the first two words, and the process is *| 00575 |* repeated, until all words are compared. The net result is to *| 00576 |* carry forward a running difference, which carries the sign bit of *| 00577 |* the first word of the compare which was not a match. The general *| 00578 |* computation of masks and differences is as follows: *| 00579 |* *| 00580 |* diff(i) = name_pool_word(i) - identifier_word(i) *| 00581 |* *| 00582 |* rdiff(0) = 0 *| 00583 |* mask(0) = 0 *| 00584 |* ... *| 00585 |* rdiff(i) = rdiff(i-1) | ((~mask(i-1)) & diff(i)) *| 00586 |* mask(i) = -(sign_bit_of(diff(i) | -(diff(i)) | mask(i-1) *| 00587 |* *| 00588 |* The variable tst_val accumulates the running differences, mask *| 00589 |* contains the current mask. Since the values of rdiff(0) and *| 00590 |* mask(0) are both 0, the computation of rdiff(1) and mask(1) have *| 00591 |* have been optimized to remove the following unneeded calculations. *| 00592 |* *| 00593 |* 0 | anything = anything; ~0 = -1; -1 & anything = anything *| 00594 |* *| 00595 \******************************************************************************/ 00596 00597 int srch_name_tbl(char *name_str, 00598 int name_len, 00599 int *name_idx, 00600 name_tbl_type *table, 00601 name_pool_type *pool, 00602 int first_entry, 00603 int last_entry) 00604 00605 { 00606 register int first; /* 1st word index of search segment */ 00607 register long *id ; /* pointer to 1st word of identifier */ 00608 register int id_len; /* word length of identifier */ 00609 register int idx; /* name table index */ 00610 register int last; /* last word index of search segment */ 00611 register long mask; /* mask used in search */ 00612 register int seg_len; /* number of entries in search segment*/ 00613 register int stride; /* search stride between entries */ 00614 register long tst_val; /* result of name comparison */ 00615 00616 # if defined(_HOST64) && !defined(_WHIRL_HOST64_TARGET64) 00617 register long *name_tbl_base; /* name table base address */ 00618 # endif 00619 00620 /*********************************************************************/ 00621 /* Specific macros needed for this routine. These macros reference */ 00622 /* variable declared in this routine. */ 00623 /*********************************************************************/ 00624 00625 /* Warning: for optimization purposes, don't remove parens around DIFF macro */ 00626 00627 # if defined(_HOST64) && !defined(_WHIRL_HOST64_TARGET64) 00628 # define NAME_IDX(IDX) (name_tbl_base[IDX] & MSK_NAME_IDX) 00629 # else 00630 # define NAME_IDX(IDX) (table[IDX].name_idx) 00631 # endif 00632 00633 # if defined(_HOST_LITTLE_ENDIAN) 00634 # define DIFF(I) compare_names(&pool[NAME_IDX(idx)+(I)-1].name_long, \ 00635 HOST_BYTES_PER_WORD-1, \ 00636 &id[(I) - 1], \ 00637 HOST_BYTES_PER_WORD-1 ) 00638 # else 00639 # define DIFF(I) (pool[NAME_IDX(idx) + (I) - 1].name_long - id[(I) - 1]) 00640 # endif 00641 00642 # define MASK(I) -(RIGHT_JUSTIFY_SIGN_BIT(DIFF((I)) | -DIFF((I))))| mask 00643 00644 # define RUNNING_DIFF(I) tst_val | ((~mask) & DIFF(I)) 00645 00646 /***************************/ 00647 /* End macro definitions. */ 00648 /***************************/ 00649 00650 TRACE (Func_Entry, "srch_name_tbl", name_str); 00651 00652 /* initialize first and last word of segment and segment length for search */ 00653 00654 # if defined(_HOST64) && !defined(_WHIRL_HOST64_TARGET64) 00655 name_tbl_base = (long *) table; 00656 # endif 00657 id = (long *) name_str; 00658 first = first_entry; 00659 last = last_entry; 00660 seg_len = last - first + 1; 00661 id_len = WORD_LEN(name_len); 00662 stride = STRIDE_CALC(seg_len); 00663 tst_val = -1; 00664 mask = 0; 00665 00666 switch (id_len) { 00667 case 1: 00668 while (seg_len > 32) { 00669 for (idx = first + stride -1 ; idx <= last; idx += stride) { 00670 tst_val = DIFF(1); 00671 if (tst_val >= 0) { 00672 break; 00673 } 00674 } /* for */ 00675 if (tst_val == 0) { 00676 goto EXIT; 00677 } 00678 else if (tst_val > 0) { 00679 last = idx; 00680 } 00681 first = idx - stride + 1; 00682 seg_len = last - first + 1; 00683 stride = STRIDE_CALC(seg_len); 00684 } /* end while seg_len > 32 */ 00685 00686 for (idx = first; idx <= last; idx += 1) { 00687 /* 00688 fprintf(stderr, "idx = %d, name_idx = %d, %d, value = %ld\n", 00689 idx, table[idx].name_idx, NAME_IDX(idx), 00690 pool[NAME_IDX(idx)].name_long); 00691 */ 00692 tst_val = DIFF(1); 00693 if (tst_val >= 0) { 00694 break; 00695 } 00696 } 00697 break; 00698 00699 case 2: 00700 while (seg_len > 32) { 00701 for (idx = first + stride -1 ; idx <= last; idx += stride) { 00702 tst_val = DIFF(1); 00703 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 00704 tst_val = RUNNING_DIFF(2); 00705 if (tst_val >= 0) { 00706 break; 00707 } 00708 } /* for */ 00709 if (tst_val == 0) { 00710 goto EXIT; 00711 } 00712 else if (tst_val > 0) { 00713 last = idx; 00714 } 00715 first = idx - stride + 1; 00716 seg_len = last - first + 1; 00717 stride = STRIDE_CALC(seg_len); 00718 } /* end while seg_len > 32 */ 00719 00720 for (idx = first; idx <= last; idx += 1) { 00721 tst_val = DIFF(1); 00722 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 00723 tst_val = RUNNING_DIFF(2); 00724 if (tst_val >= 0) { 00725 break; 00726 } 00727 } 00728 break; 00729 00730 case 3: 00731 while (seg_len > 32) { 00732 for (idx = first + stride -1 ; idx <= last; idx += stride) { 00733 tst_val = DIFF(1); 00734 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 00735 tst_val = RUNNING_DIFF(2); 00736 mask = MASK(2); 00737 tst_val = RUNNING_DIFF(3); 00738 if (tst_val >= 0) { 00739 break; 00740 } 00741 } /* for */ 00742 if (tst_val == 0) { 00743 goto EXIT; 00744 } 00745 else if (tst_val > 0) { 00746 last = idx; 00747 } 00748 first = idx - stride + 1; 00749 seg_len = last - first + 1; 00750 stride = STRIDE_CALC(seg_len); 00751 } /* end while seg_len > 32 */ 00752 00753 for (idx = first; idx <= last; idx += 1) { 00754 tst_val = DIFF(1); 00755 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 00756 tst_val = RUNNING_DIFF(2); 00757 mask = MASK(2); 00758 tst_val = RUNNING_DIFF(3); 00759 if (tst_val >= 0) { 00760 break; 00761 } 00762 } 00763 break; 00764 00765 case 4: 00766 while (seg_len > 32) { 00767 for (idx = first + stride -1 ; idx <= last; idx += stride) { 00768 tst_val = DIFF(1); 00769 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 00770 tst_val = RUNNING_DIFF(2); 00771 mask = MASK(2); 00772 tst_val = RUNNING_DIFF(3); 00773 mask = MASK(3); 00774 tst_val = RUNNING_DIFF(4); 00775 if (tst_val >= 0) { 00776 break; 00777 } 00778 } /* for */ 00779 if (tst_val == 0) { 00780 goto EXIT; 00781 } 00782 else if (tst_val > 0) { 00783 last = idx; 00784 } 00785 first = idx - stride + 1; 00786 seg_len = last - first + 1; 00787 stride = STRIDE_CALC(seg_len); 00788 } /* end while seg_len > 32 */ 00789 00790 for (idx = first; idx <= last; idx += 1) { 00791 tst_val = DIFF(1); 00792 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 00793 tst_val = RUNNING_DIFF(2); 00794 mask = MASK(2); 00795 tst_val = RUNNING_DIFF(3); 00796 mask = MASK(3); 00797 tst_val = RUNNING_DIFF(4); 00798 if (tst_val >= 0) { 00799 break; 00800 } 00801 } 00802 break; 00803 00804 case 5: 00805 while (seg_len > 32) { 00806 for (idx = first + stride -1 ; idx <= last; idx += stride) { 00807 tst_val = DIFF(1); 00808 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 00809 tst_val = RUNNING_DIFF(2); 00810 mask = MASK(2); 00811 tst_val = RUNNING_DIFF(3); 00812 mask = MASK(3); 00813 tst_val = RUNNING_DIFF(4); 00814 mask = MASK(4); 00815 tst_val = RUNNING_DIFF(5); 00816 if (tst_val >= 0) { 00817 break; 00818 } 00819 } /* for */ 00820 if (tst_val == 0) { 00821 goto EXIT; 00822 } 00823 else if (tst_val > 0) { 00824 last = idx; 00825 } 00826 first = idx - stride + 1; 00827 seg_len = last - first + 1; 00828 stride = STRIDE_CALC(seg_len); 00829 } /* end while seg_len > 32 */ 00830 00831 for (idx = first; idx <= last; idx += 1) { 00832 tst_val = DIFF(1); 00833 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 00834 tst_val = RUNNING_DIFF(2); 00835 mask = MASK(2); 00836 tst_val = RUNNING_DIFF(3); 00837 mask = MASK(3); 00838 tst_val = RUNNING_DIFF(4); 00839 mask = MASK(4); 00840 tst_val = RUNNING_DIFF(5); 00841 if (tst_val >= 0) { 00842 break; 00843 } 00844 } 00845 break; 00846 00847 case 6: 00848 while (seg_len > 32) { 00849 for (idx = first + stride -1 ; idx <= last; idx += stride) { 00850 tst_val = DIFF(1); 00851 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 00852 tst_val = RUNNING_DIFF(2); 00853 mask = MASK(2); 00854 tst_val = RUNNING_DIFF(3); 00855 mask = MASK(3); 00856 tst_val = RUNNING_DIFF(4); 00857 mask = MASK(4); 00858 tst_val = RUNNING_DIFF(5); 00859 mask = MASK(5); 00860 tst_val = RUNNING_DIFF(6); 00861 if (tst_val >= 0) { 00862 break; 00863 } 00864 } /* for */ 00865 if (tst_val == 0) { 00866 goto EXIT; 00867 } 00868 else if (tst_val > 0) { 00869 last = idx; 00870 } 00871 first = idx - stride + 1; 00872 seg_len = last - first + 1; 00873 stride = STRIDE_CALC(seg_len); 00874 } /* end while seg_len > 32 */ 00875 00876 for (idx = first; idx <= last; idx += 1) { 00877 tst_val = DIFF(1); 00878 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 00879 tst_val = RUNNING_DIFF(2); 00880 mask = MASK(2); 00881 tst_val = RUNNING_DIFF(3); 00882 mask = MASK(3); 00883 tst_val = RUNNING_DIFF(4); 00884 mask = MASK(4); 00885 tst_val = RUNNING_DIFF(5); 00886 mask = MASK(5); 00887 tst_val = RUNNING_DIFF(6); 00888 if (tst_val >= 0) { 00889 break; 00890 } 00891 } 00892 break; 00893 00894 case 7: 00895 while (seg_len > 32) { 00896 for (idx = first + stride -1 ; idx <= last; idx += stride) { 00897 tst_val = DIFF(1); 00898 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 00899 tst_val = RUNNING_DIFF(2); 00900 mask = MASK(2); 00901 tst_val = RUNNING_DIFF(3); 00902 mask = MASK(3); 00903 tst_val = RUNNING_DIFF(4); 00904 mask = MASK(4); 00905 tst_val = RUNNING_DIFF(5); 00906 mask = MASK(5); 00907 tst_val = RUNNING_DIFF(6); 00908 mask = MASK(6); 00909 tst_val = RUNNING_DIFF(7); 00910 if (tst_val >= 0) { 00911 break; 00912 } 00913 } /* for */ 00914 if (tst_val == 0) { 00915 goto EXIT; 00916 } 00917 else if (tst_val > 0) { 00918 last = idx; 00919 } 00920 first = idx - stride + 1; 00921 seg_len = last - first + 1; 00922 stride = STRIDE_CALC(seg_len); 00923 } /* end while seg_len > 32 */ 00924 00925 for (idx = first; idx <= last; idx += 1) { 00926 tst_val = DIFF(1); 00927 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 00928 tst_val = RUNNING_DIFF(2); 00929 mask = MASK(2); 00930 tst_val = RUNNING_DIFF(3); 00931 mask = MASK(3); 00932 tst_val = RUNNING_DIFF(4); 00933 mask = MASK(4); 00934 tst_val = RUNNING_DIFF(5); 00935 mask = MASK(5); 00936 tst_val = RUNNING_DIFF(6); 00937 mask = MASK(6); 00938 tst_val = RUNNING_DIFF(7); 00939 if (tst_val >= 0) { 00940 break; 00941 } 00942 } 00943 break; 00944 00945 case 8: 00946 while (seg_len > 32) { 00947 for (idx = first + stride -1 ; idx <= last; idx += stride) { 00948 tst_val = DIFF(1); 00949 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 00950 tst_val = RUNNING_DIFF(2); 00951 mask = MASK(2); 00952 tst_val = RUNNING_DIFF(3); 00953 mask = MASK(3); 00954 tst_val = RUNNING_DIFF(4); 00955 mask = MASK(4); 00956 tst_val = RUNNING_DIFF(5); 00957 mask = MASK(5); 00958 tst_val = RUNNING_DIFF(6); 00959 mask = MASK(6); 00960 tst_val = RUNNING_DIFF(7); 00961 mask = MASK(7); 00962 tst_val = RUNNING_DIFF(8); 00963 if (tst_val >= 0) { 00964 break; 00965 } 00966 } /* for */ 00967 if (tst_val == 0) { 00968 goto EXIT; 00969 } 00970 else if (tst_val > 0) { 00971 last = idx; 00972 } 00973 first = idx - stride + 1; 00974 seg_len = last - first + 1; 00975 stride = STRIDE_CALC(seg_len); 00976 } /* end while seg_len > 32 */ 00977 00978 for (idx = first; idx <= last; idx += 1) { 00979 tst_val = DIFF(1); 00980 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 00981 tst_val = RUNNING_DIFF(2); 00982 mask = MASK(2); 00983 tst_val = RUNNING_DIFF(3); 00984 mask = MASK(3); 00985 tst_val = RUNNING_DIFF(4); 00986 mask = MASK(4); 00987 tst_val = RUNNING_DIFF(5); 00988 mask = MASK(5); 00989 tst_val = RUNNING_DIFF(6); 00990 mask = MASK(6); 00991 tst_val = RUNNING_DIFF(7); 00992 mask = MASK(7); 00993 tst_val = RUNNING_DIFF(8); 00994 if (tst_val >= 0) { 00995 break; 00996 } 00997 } 00998 break; 00999 01000 case 9: 01001 while (seg_len > 32) { 01002 for (idx = first + stride -1 ; idx <= last; idx += stride) { 01003 tst_val = DIFF(1); 01004 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01005 tst_val = RUNNING_DIFF(2); 01006 mask = MASK(2); 01007 tst_val = RUNNING_DIFF(3); 01008 mask = MASK(3); 01009 tst_val = RUNNING_DIFF(4); 01010 mask = MASK(4); 01011 tst_val = RUNNING_DIFF(5); 01012 mask = MASK(5); 01013 tst_val = RUNNING_DIFF(6); 01014 mask = MASK(6); 01015 tst_val = RUNNING_DIFF(7); 01016 mask = MASK(7); 01017 tst_val = RUNNING_DIFF(8); 01018 mask = MASK(8); 01019 tst_val = RUNNING_DIFF(9); 01020 if (tst_val >= 0) { 01021 break; 01022 } 01023 } /* for */ 01024 if (tst_val == 0) { 01025 goto EXIT; 01026 } 01027 else if (tst_val > 0) { 01028 last = idx; 01029 } 01030 first = idx - stride + 1; 01031 seg_len = last - first + 1; 01032 stride = STRIDE_CALC(seg_len); 01033 } /* end while seg_len > 32 */ 01034 01035 for (idx = first; idx <= last; idx += 1) { 01036 tst_val = DIFF(1); 01037 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01038 tst_val = RUNNING_DIFF(2); 01039 mask = MASK(2); 01040 tst_val = RUNNING_DIFF(3); 01041 mask = MASK(3); 01042 tst_val = RUNNING_DIFF(4); 01043 mask = MASK(4); 01044 tst_val = RUNNING_DIFF(5); 01045 mask = MASK(5); 01046 tst_val = RUNNING_DIFF(6); 01047 mask = MASK(6); 01048 tst_val = RUNNING_DIFF(7); 01049 mask = MASK(7); 01050 tst_val = RUNNING_DIFF(8); 01051 mask = MASK(8); 01052 tst_val = RUNNING_DIFF(9); 01053 if (tst_val >= 0) { 01054 break; 01055 } 01056 } 01057 break; 01058 01059 case 10: 01060 while (seg_len > 32) { 01061 for (idx = first + stride -1 ; idx <= last; idx += stride) { 01062 tst_val = DIFF(1); 01063 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01064 tst_val = RUNNING_DIFF(2); 01065 mask = MASK(2); 01066 tst_val = RUNNING_DIFF(3); 01067 mask = MASK(3); 01068 tst_val = RUNNING_DIFF(4); 01069 mask = MASK(4); 01070 tst_val = RUNNING_DIFF(5); 01071 mask = MASK(5); 01072 tst_val = RUNNING_DIFF(6); 01073 mask = MASK(6); 01074 tst_val = RUNNING_DIFF(7); 01075 mask = MASK(7); 01076 tst_val = RUNNING_DIFF(8); 01077 mask = MASK(8); 01078 tst_val = RUNNING_DIFF(9); 01079 mask = MASK(9); 01080 tst_val = RUNNING_DIFF(10); 01081 if (tst_val >= 0) { 01082 break; 01083 } 01084 } /* for */ 01085 if (tst_val == 0) { 01086 goto EXIT; 01087 } 01088 else if (tst_val > 0) { 01089 last = idx; 01090 } 01091 first = idx - stride + 1; 01092 seg_len = last - first + 1; 01093 stride = STRIDE_CALC(seg_len); 01094 } /* end while seg_len > 32 */ 01095 01096 for (idx = first; idx <= last; idx += 1) { 01097 tst_val = DIFF(1); 01098 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01099 tst_val = RUNNING_DIFF(2); 01100 mask = MASK(2); 01101 tst_val = RUNNING_DIFF(3); 01102 mask = MASK(3); 01103 tst_val = RUNNING_DIFF(4); 01104 mask = MASK(4); 01105 tst_val = RUNNING_DIFF(5); 01106 mask = MASK(5); 01107 tst_val = RUNNING_DIFF(6); 01108 mask = MASK(6); 01109 tst_val = RUNNING_DIFF(7); 01110 mask = MASK(7); 01111 tst_val = RUNNING_DIFF(8); 01112 mask = MASK(8); 01113 tst_val = RUNNING_DIFF(9); 01114 mask = MASK(9); 01115 tst_val = RUNNING_DIFF(10); 01116 if (tst_val >= 0) { 01117 break; 01118 } 01119 } 01120 break; 01121 01122 case 11: 01123 while (seg_len > 32) { 01124 for (idx = first + stride -1 ; idx <= last; idx += stride) { 01125 tst_val = DIFF(1); 01126 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01127 tst_val = RUNNING_DIFF(2); 01128 mask = MASK(2); 01129 tst_val = RUNNING_DIFF(3); 01130 mask = MASK(3); 01131 tst_val = RUNNING_DIFF(4); 01132 mask = MASK(4); 01133 tst_val = RUNNING_DIFF(5); 01134 mask = MASK(5); 01135 tst_val = RUNNING_DIFF(6); 01136 mask = MASK(6); 01137 tst_val = RUNNING_DIFF(7); 01138 mask = MASK(7); 01139 tst_val = RUNNING_DIFF(8); 01140 mask = MASK(8); 01141 tst_val = RUNNING_DIFF(9); 01142 mask = MASK(9); 01143 tst_val = RUNNING_DIFF(10); 01144 mask = MASK(10); 01145 tst_val = RUNNING_DIFF(11); 01146 if (tst_val >= 0) { 01147 break; 01148 } 01149 } /* for */ 01150 if (tst_val == 0) { 01151 goto EXIT; 01152 } 01153 else if (tst_val > 0) { 01154 last = idx; 01155 } 01156 first = idx - stride + 1; 01157 seg_len = last - first + 1; 01158 stride = STRIDE_CALC(seg_len); 01159 } /* end while seg_len > 32 */ 01160 01161 for (idx = first; idx <= last; idx += 1) { 01162 tst_val = DIFF(1); 01163 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01164 tst_val = RUNNING_DIFF(2); 01165 mask = MASK(2); 01166 tst_val = RUNNING_DIFF(3); 01167 mask = MASK(3); 01168 tst_val = RUNNING_DIFF(4); 01169 mask = MASK(4); 01170 tst_val = RUNNING_DIFF(5); 01171 mask = MASK(5); 01172 tst_val = RUNNING_DIFF(6); 01173 mask = MASK(6); 01174 tst_val = RUNNING_DIFF(7); 01175 mask = MASK(7); 01176 tst_val = RUNNING_DIFF(8); 01177 mask = MASK(8); 01178 tst_val = RUNNING_DIFF(9); 01179 mask = MASK(9); 01180 tst_val = RUNNING_DIFF(10); 01181 mask = MASK(10); 01182 tst_val = RUNNING_DIFF(11); 01183 if (tst_val >= 0) { 01184 break; 01185 } 01186 } 01187 break; 01188 01189 case 12: 01190 while (seg_len > 32) { 01191 for (idx = first + stride -1 ; idx <= last; idx += stride) { 01192 tst_val = DIFF(1); 01193 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01194 tst_val = RUNNING_DIFF(2); 01195 mask = MASK(2); 01196 tst_val = RUNNING_DIFF(3); 01197 mask = MASK(3); 01198 tst_val = RUNNING_DIFF(4); 01199 mask = MASK(4); 01200 tst_val = RUNNING_DIFF(5); 01201 mask = MASK(5); 01202 tst_val = RUNNING_DIFF(6); 01203 mask = MASK(6); 01204 tst_val = RUNNING_DIFF(7); 01205 mask = MASK(7); 01206 tst_val = RUNNING_DIFF(8); 01207 mask = MASK(8); 01208 tst_val = RUNNING_DIFF(9); 01209 mask = MASK(9); 01210 tst_val = RUNNING_DIFF(10); 01211 mask = MASK(10); 01212 tst_val = RUNNING_DIFF(11); 01213 mask = MASK(11); 01214 tst_val = RUNNING_DIFF(12); 01215 if (tst_val >= 0) { 01216 break; 01217 } 01218 } /* for */ 01219 if (tst_val == 0) { 01220 goto EXIT; 01221 } 01222 else if (tst_val > 0) { 01223 last = idx; 01224 } 01225 first = idx - stride + 1; 01226 seg_len = last - first + 1; 01227 stride = STRIDE_CALC(seg_len); 01228 } /* end while seg_len > 32 */ 01229 01230 for (idx = first; idx <= last; idx += 1) { 01231 tst_val = DIFF(1); 01232 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01233 tst_val = RUNNING_DIFF(2); 01234 mask = MASK(2); 01235 tst_val = RUNNING_DIFF(3); 01236 mask = MASK(3); 01237 tst_val = RUNNING_DIFF(4); 01238 mask = MASK(4); 01239 tst_val = RUNNING_DIFF(5); 01240 mask = MASK(5); 01241 tst_val = RUNNING_DIFF(6); 01242 mask = MASK(6); 01243 tst_val = RUNNING_DIFF(7); 01244 mask = MASK(7); 01245 tst_val = RUNNING_DIFF(8); 01246 mask = MASK(8); 01247 tst_val = RUNNING_DIFF(9); 01248 mask = MASK(9); 01249 tst_val = RUNNING_DIFF(10); 01250 mask = MASK(10); 01251 tst_val = RUNNING_DIFF(11); 01252 mask = MASK(11); 01253 tst_val = RUNNING_DIFF(12); 01254 if (tst_val >= 0) { 01255 break; 01256 } 01257 } 01258 break; 01259 01260 case 13: 01261 while (seg_len > 32) { 01262 for (idx = first + stride -1 ; idx <= last; idx += stride) { 01263 tst_val = DIFF(1); 01264 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01265 tst_val = RUNNING_DIFF(2); 01266 mask = MASK(2); 01267 tst_val = RUNNING_DIFF(3); 01268 mask = MASK(3); 01269 tst_val = RUNNING_DIFF(4); 01270 mask = MASK(4); 01271 tst_val = RUNNING_DIFF(5); 01272 mask = MASK(5); 01273 tst_val = RUNNING_DIFF(6); 01274 mask = MASK(6); 01275 tst_val = RUNNING_DIFF(7); 01276 mask = MASK(7); 01277 tst_val = RUNNING_DIFF(8); 01278 mask = MASK(8); 01279 tst_val = RUNNING_DIFF(9); 01280 mask = MASK(9); 01281 tst_val = RUNNING_DIFF(10); 01282 mask = MASK(10); 01283 tst_val = RUNNING_DIFF(11); 01284 mask = MASK(11); 01285 tst_val = RUNNING_DIFF(12); 01286 mask = MASK(12); 01287 tst_val = RUNNING_DIFF(13); 01288 if (tst_val >= 0) { 01289 break; 01290 } 01291 } /* for */ 01292 if (tst_val == 0) { 01293 goto EXIT; 01294 } 01295 else if (tst_val > 0) { 01296 last = idx; 01297 } 01298 first = idx - stride + 1; 01299 seg_len = last - first + 1; 01300 stride = STRIDE_CALC(seg_len); 01301 } /* end while seg_len > 32 */ 01302 01303 for (idx = first; idx <= last; idx += 1) { 01304 tst_val = DIFF(1); 01305 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01306 tst_val = RUNNING_DIFF(2); 01307 mask = MASK(2); 01308 tst_val = RUNNING_DIFF(3); 01309 mask = MASK(3); 01310 tst_val = RUNNING_DIFF(4); 01311 mask = MASK(4); 01312 tst_val = RUNNING_DIFF(5); 01313 mask = MASK(5); 01314 tst_val = RUNNING_DIFF(6); 01315 mask = MASK(6); 01316 tst_val = RUNNING_DIFF(7); 01317 mask = MASK(7); 01318 tst_val = RUNNING_DIFF(8); 01319 mask = MASK(8); 01320 tst_val = RUNNING_DIFF(9); 01321 mask = MASK(9); 01322 tst_val = RUNNING_DIFF(10); 01323 mask = MASK(10); 01324 tst_val = RUNNING_DIFF(11); 01325 mask = MASK(11); 01326 tst_val = RUNNING_DIFF(12); 01327 mask = MASK(12); 01328 tst_val = RUNNING_DIFF(13); 01329 if (tst_val >= 0) { 01330 break; 01331 } 01332 } 01333 break; 01334 01335 case 14: 01336 while (seg_len > 32) { 01337 for (idx = first + stride -1 ; idx <= last; idx += stride) { 01338 tst_val = DIFF(1); 01339 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01340 tst_val = RUNNING_DIFF(2); 01341 mask = MASK(2); 01342 tst_val = RUNNING_DIFF(3); 01343 mask = MASK(3); 01344 tst_val = RUNNING_DIFF(4); 01345 mask = MASK(4); 01346 tst_val = RUNNING_DIFF(5); 01347 mask = MASK(5); 01348 tst_val = RUNNING_DIFF(6); 01349 mask = MASK(6); 01350 tst_val = RUNNING_DIFF(7); 01351 mask = MASK(7); 01352 tst_val = RUNNING_DIFF(8); 01353 mask = MASK(8); 01354 tst_val = RUNNING_DIFF(9); 01355 mask = MASK(9); 01356 tst_val = RUNNING_DIFF(10); 01357 mask = MASK(10); 01358 tst_val = RUNNING_DIFF(11); 01359 mask = MASK(11); 01360 tst_val = RUNNING_DIFF(12); 01361 mask = MASK(12); 01362 tst_val = RUNNING_DIFF(13); 01363 mask = MASK(13); 01364 tst_val = RUNNING_DIFF(14); 01365 if (tst_val >= 0) { 01366 break; 01367 } 01368 } /* for */ 01369 if (tst_val == 0) { 01370 goto EXIT; 01371 } 01372 else if (tst_val > 0) { 01373 last = idx; 01374 } 01375 first = idx - stride + 1; 01376 seg_len = last - first + 1; 01377 stride = STRIDE_CALC(seg_len); 01378 } /* end while seg_len > 32 */ 01379 01380 for (idx = first; idx <= last; idx += 1) { 01381 tst_val = DIFF(1); 01382 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01383 tst_val = RUNNING_DIFF(2); 01384 mask = MASK(2); 01385 tst_val = RUNNING_DIFF(3); 01386 mask = MASK(3); 01387 tst_val = RUNNING_DIFF(4); 01388 mask = MASK(4); 01389 tst_val = RUNNING_DIFF(5); 01390 mask = MASK(5); 01391 tst_val = RUNNING_DIFF(6); 01392 mask = MASK(6); 01393 tst_val = RUNNING_DIFF(7); 01394 mask = MASK(7); 01395 tst_val = RUNNING_DIFF(8); 01396 mask = MASK(8); 01397 tst_val = RUNNING_DIFF(9); 01398 mask = MASK(9); 01399 tst_val = RUNNING_DIFF(10); 01400 mask = MASK(10); 01401 tst_val = RUNNING_DIFF(11); 01402 mask = MASK(11); 01403 tst_val = RUNNING_DIFF(12); 01404 mask = MASK(12); 01405 tst_val = RUNNING_DIFF(13); 01406 mask = MASK(13); 01407 tst_val = RUNNING_DIFF(14); 01408 if (tst_val >= 0) { 01409 break; 01410 } 01411 } 01412 break; 01413 01414 case 15: 01415 while (seg_len > 32) { 01416 for (idx = first + stride -1 ; idx <= last; idx += stride) { 01417 tst_val = DIFF(1); 01418 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01419 tst_val = RUNNING_DIFF(2); 01420 mask = MASK(2); 01421 tst_val = RUNNING_DIFF(3); 01422 mask = MASK(3); 01423 tst_val = RUNNING_DIFF(4); 01424 mask = MASK(4); 01425 tst_val = RUNNING_DIFF(5); 01426 mask = MASK(5); 01427 tst_val = RUNNING_DIFF(6); 01428 mask = MASK(6); 01429 tst_val = RUNNING_DIFF(7); 01430 mask = MASK(7); 01431 tst_val = RUNNING_DIFF(8); 01432 mask = MASK(8); 01433 tst_val = RUNNING_DIFF(9); 01434 mask = MASK(9); 01435 tst_val = RUNNING_DIFF(10); 01436 mask = MASK(10); 01437 tst_val = RUNNING_DIFF(11); 01438 mask = MASK(11); 01439 tst_val = RUNNING_DIFF(12); 01440 mask = MASK(12); 01441 tst_val = RUNNING_DIFF(13); 01442 mask = MASK(13); 01443 tst_val = RUNNING_DIFF(14); 01444 mask = MASK(14); 01445 tst_val = RUNNING_DIFF(15); 01446 if (tst_val >= 0) { 01447 break; 01448 } 01449 } /* for */ 01450 if (tst_val == 0) { 01451 goto EXIT; 01452 } 01453 else if (tst_val > 0) { 01454 last = idx; 01455 } 01456 first = idx - stride + 1; 01457 seg_len = last - first + 1; 01458 stride = STRIDE_CALC(seg_len); 01459 } /* end while seg_len > 32 */ 01460 01461 for (idx = first; idx <= last; idx += 1) { 01462 tst_val = DIFF(1); 01463 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01464 tst_val = RUNNING_DIFF(2); 01465 mask = MASK(2); 01466 tst_val = RUNNING_DIFF(3); 01467 mask = MASK(3); 01468 tst_val = RUNNING_DIFF(4); 01469 mask = MASK(4); 01470 tst_val = RUNNING_DIFF(5); 01471 mask = MASK(5); 01472 tst_val = RUNNING_DIFF(6); 01473 mask = MASK(6); 01474 tst_val = RUNNING_DIFF(7); 01475 mask = MASK(7); 01476 tst_val = RUNNING_DIFF(8); 01477 mask = MASK(8); 01478 tst_val = RUNNING_DIFF(9); 01479 mask = MASK(9); 01480 tst_val = RUNNING_DIFF(10); 01481 mask = MASK(10); 01482 tst_val = RUNNING_DIFF(11); 01483 mask = MASK(11); 01484 tst_val = RUNNING_DIFF(12); 01485 mask = MASK(12); 01486 tst_val = RUNNING_DIFF(13); 01487 mask = MASK(13); 01488 tst_val = RUNNING_DIFF(14); 01489 mask = MASK(14); 01490 tst_val = RUNNING_DIFF(15); 01491 if (tst_val >= 0) { 01492 break; 01493 } 01494 } 01495 break; 01496 01497 case 16: 01498 while (seg_len > 32) { 01499 for (idx = first + stride -1 ; idx <= last; idx += stride) { 01500 tst_val = DIFF(1); 01501 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01502 tst_val = RUNNING_DIFF(2); 01503 mask = MASK(2); 01504 tst_val = RUNNING_DIFF(3); 01505 mask = MASK(3); 01506 tst_val = RUNNING_DIFF(4); 01507 mask = MASK(4); 01508 tst_val = RUNNING_DIFF(5); 01509 mask = MASK(5); 01510 tst_val = RUNNING_DIFF(6); 01511 mask = MASK(6); 01512 tst_val = RUNNING_DIFF(7); 01513 mask = MASK(7); 01514 tst_val = RUNNING_DIFF(8); 01515 mask = MASK(8); 01516 tst_val = RUNNING_DIFF(9); 01517 mask = MASK(9); 01518 tst_val = RUNNING_DIFF(10); 01519 mask = MASK(10); 01520 tst_val = RUNNING_DIFF(11); 01521 mask = MASK(11); 01522 tst_val = RUNNING_DIFF(12); 01523 mask = MASK(12); 01524 tst_val = RUNNING_DIFF(13); 01525 mask = MASK(13); 01526 tst_val = RUNNING_DIFF(14); 01527 mask = MASK(14); 01528 tst_val = RUNNING_DIFF(15); 01529 mask = MASK(15); 01530 tst_val = RUNNING_DIFF(16); 01531 if (tst_val >= 0) { 01532 break; 01533 } 01534 } /* for */ 01535 if (tst_val == 0) { 01536 goto EXIT; 01537 } 01538 else if (tst_val > 0) { 01539 last = idx; 01540 } 01541 first = idx - stride + 1; 01542 seg_len = last - first + 1; 01543 stride = STRIDE_CALC(seg_len); 01544 } /* end while seg_len > 32 */ 01545 01546 for (idx = first; idx <= last; idx += 1) { 01547 tst_val = DIFF(1); 01548 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01549 tst_val = RUNNING_DIFF(2); 01550 mask = MASK(2); 01551 tst_val = RUNNING_DIFF(3); 01552 mask = MASK(3); 01553 tst_val = RUNNING_DIFF(4); 01554 mask = MASK(4); 01555 tst_val = RUNNING_DIFF(5); 01556 mask = MASK(5); 01557 tst_val = RUNNING_DIFF(6); 01558 mask = MASK(6); 01559 tst_val = RUNNING_DIFF(7); 01560 mask = MASK(7); 01561 tst_val = RUNNING_DIFF(8); 01562 mask = MASK(8); 01563 tst_val = RUNNING_DIFF(9); 01564 mask = MASK(9); 01565 tst_val = RUNNING_DIFF(10); 01566 mask = MASK(10); 01567 tst_val = RUNNING_DIFF(11); 01568 mask = MASK(11); 01569 tst_val = RUNNING_DIFF(12); 01570 mask = MASK(12); 01571 tst_val = RUNNING_DIFF(13); 01572 mask = MASK(13); 01573 tst_val = RUNNING_DIFF(14); 01574 mask = MASK(14); 01575 tst_val = RUNNING_DIFF(15); 01576 mask = MASK(15); 01577 tst_val = RUNNING_DIFF(16); 01578 if (tst_val >= 0) { 01579 break; 01580 } 01581 } 01582 break; 01583 01584 01585 case 17: 01586 while (seg_len > 32) { 01587 for (idx = first + stride -1 ; idx <= last; idx += stride) { 01588 tst_val = DIFF(1); 01589 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01590 tst_val = RUNNING_DIFF(2); 01591 mask = MASK(2); 01592 tst_val = RUNNING_DIFF(3); 01593 mask = MASK(3); 01594 tst_val = RUNNING_DIFF(4); 01595 mask = MASK(4); 01596 tst_val = RUNNING_DIFF(5); 01597 mask = MASK(5); 01598 tst_val = RUNNING_DIFF(6); 01599 mask = MASK(6); 01600 tst_val = RUNNING_DIFF(7); 01601 mask = MASK(7); 01602 tst_val = RUNNING_DIFF(8); 01603 mask = MASK(8); 01604 tst_val = RUNNING_DIFF(9); 01605 mask = MASK(9); 01606 tst_val = RUNNING_DIFF(10); 01607 mask = MASK(10); 01608 tst_val = RUNNING_DIFF(11); 01609 mask = MASK(11); 01610 tst_val = RUNNING_DIFF(12); 01611 mask = MASK(12); 01612 tst_val = RUNNING_DIFF(13); 01613 mask = MASK(13); 01614 tst_val = RUNNING_DIFF(14); 01615 mask = MASK(14); 01616 tst_val = RUNNING_DIFF(15); 01617 mask = MASK(15); 01618 tst_val = RUNNING_DIFF(16); 01619 mask = MASK(16); 01620 tst_val = RUNNING_DIFF(17); 01621 if (tst_val >= 0) { 01622 break; 01623 } 01624 } /* for */ 01625 if (tst_val == 0) { 01626 goto EXIT; 01627 } 01628 else if (tst_val > 0) { 01629 last = idx; 01630 } 01631 first = idx - stride + 1; 01632 seg_len = last - first + 1; 01633 stride = STRIDE_CALC(seg_len); 01634 } /* end while seg_len > 32 */ 01635 01636 for (idx = first; idx <= last; idx += 1) { 01637 tst_val = DIFF(1); 01638 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01639 tst_val = RUNNING_DIFF(2); 01640 mask = MASK(2); 01641 tst_val = RUNNING_DIFF(3); 01642 mask = MASK(3); 01643 tst_val = RUNNING_DIFF(4); 01644 mask = MASK(4); 01645 tst_val = RUNNING_DIFF(5); 01646 mask = MASK(5); 01647 tst_val = RUNNING_DIFF(6); 01648 mask = MASK(6); 01649 tst_val = RUNNING_DIFF(7); 01650 mask = MASK(7); 01651 tst_val = RUNNING_DIFF(8); 01652 mask = MASK(8); 01653 tst_val = RUNNING_DIFF(9); 01654 mask = MASK(9); 01655 tst_val = RUNNING_DIFF(10); 01656 mask = MASK(10); 01657 tst_val = RUNNING_DIFF(11); 01658 mask = MASK(11); 01659 tst_val = RUNNING_DIFF(12); 01660 mask = MASK(12); 01661 tst_val = RUNNING_DIFF(13); 01662 mask = MASK(13); 01663 tst_val = RUNNING_DIFF(14); 01664 mask = MASK(14); 01665 tst_val = RUNNING_DIFF(15); 01666 mask = MASK(15); 01667 tst_val = RUNNING_DIFF(16); 01668 mask = MASK(16); 01669 tst_val = RUNNING_DIFF(17); 01670 if (tst_val >= 0) { 01671 break; 01672 } 01673 } 01674 break; 01675 01676 # ifdef _HOST32 01677 01678 case 18: 01679 while (seg_len > 32) { 01680 for (idx = first + stride -1 ; idx <= last; idx += stride) { 01681 tst_val = DIFF(1); 01682 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01683 tst_val = RUNNING_DIFF(2); 01684 mask = MASK(2); 01685 tst_val = RUNNING_DIFF(3); 01686 mask = MASK(3); 01687 tst_val = RUNNING_DIFF(4); 01688 mask = MASK(4); 01689 tst_val = RUNNING_DIFF(5); 01690 mask = MASK(5); 01691 tst_val = RUNNING_DIFF(6); 01692 mask = MASK(6); 01693 tst_val = RUNNING_DIFF(7); 01694 mask = MASK(7); 01695 tst_val = RUNNING_DIFF(8); 01696 mask = MASK(8); 01697 tst_val = RUNNING_DIFF(9); 01698 mask = MASK(9); 01699 tst_val = RUNNING_DIFF(10); 01700 mask = MASK(10); 01701 tst_val = RUNNING_DIFF(11); 01702 mask = MASK(11); 01703 tst_val = RUNNING_DIFF(12); 01704 mask = MASK(12); 01705 tst_val = RUNNING_DIFF(13); 01706 mask = MASK(13); 01707 tst_val = RUNNING_DIFF(14); 01708 mask = MASK(14); 01709 tst_val = RUNNING_DIFF(15); 01710 mask = MASK(15); 01711 tst_val = RUNNING_DIFF(16); 01712 mask = MASK(16); 01713 tst_val = RUNNING_DIFF(17); 01714 mask = MASK(17); 01715 tst_val = RUNNING_DIFF(18); 01716 if (tst_val >= 0) { 01717 break; 01718 } 01719 } /* for */ 01720 if (tst_val == 0) { 01721 goto EXIT; 01722 } 01723 else if (tst_val > 0) { 01724 last = idx; 01725 } 01726 first = idx - stride + 1; 01727 seg_len = last - first + 1; 01728 stride = STRIDE_CALC(seg_len); 01729 } /* end while seg_len > 32 */ 01730 01731 for (idx = first; idx <= last; idx += 1) { 01732 tst_val = DIFF(1); 01733 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01734 tst_val = RUNNING_DIFF(2); 01735 mask = MASK(2); 01736 tst_val = RUNNING_DIFF(3); 01737 mask = MASK(3); 01738 tst_val = RUNNING_DIFF(4); 01739 mask = MASK(4); 01740 tst_val = RUNNING_DIFF(5); 01741 mask = MASK(5); 01742 tst_val = RUNNING_DIFF(6); 01743 mask = MASK(6); 01744 tst_val = RUNNING_DIFF(7); 01745 mask = MASK(7); 01746 tst_val = RUNNING_DIFF(8); 01747 mask = MASK(8); 01748 tst_val = RUNNING_DIFF(9); 01749 mask = MASK(9); 01750 tst_val = RUNNING_DIFF(10); 01751 mask = MASK(10); 01752 tst_val = RUNNING_DIFF(11); 01753 mask = MASK(11); 01754 tst_val = RUNNING_DIFF(12); 01755 mask = MASK(12); 01756 tst_val = RUNNING_DIFF(13); 01757 mask = MASK(13); 01758 tst_val = RUNNING_DIFF(14); 01759 mask = MASK(14); 01760 tst_val = RUNNING_DIFF(15); 01761 mask = MASK(15); 01762 tst_val = RUNNING_DIFF(16); 01763 mask = MASK(16); 01764 tst_val = RUNNING_DIFF(17); 01765 mask = MASK(17); 01766 tst_val = RUNNING_DIFF(18); 01767 if (tst_val >= 0) { 01768 break; 01769 } 01770 } 01771 break; 01772 01773 case 19: 01774 while (seg_len > 32) { 01775 for (idx = first + stride -1 ; idx <= last; idx += stride) { 01776 tst_val = DIFF(1); 01777 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01778 tst_val = RUNNING_DIFF(2); 01779 mask = MASK(2); 01780 tst_val = RUNNING_DIFF(3); 01781 mask = MASK(3); 01782 tst_val = RUNNING_DIFF(4); 01783 mask = MASK(4); 01784 tst_val = RUNNING_DIFF(5); 01785 mask = MASK(5); 01786 tst_val = RUNNING_DIFF(6); 01787 mask = MASK(6); 01788 tst_val = RUNNING_DIFF(7); 01789 mask = MASK(7); 01790 tst_val = RUNNING_DIFF(8); 01791 mask = MASK(8); 01792 tst_val = RUNNING_DIFF(9); 01793 mask = MASK(9); 01794 tst_val = RUNNING_DIFF(10); 01795 mask = MASK(10); 01796 tst_val = RUNNING_DIFF(11); 01797 mask = MASK(11); 01798 tst_val = RUNNING_DIFF(12); 01799 mask = MASK(12); 01800 tst_val = RUNNING_DIFF(13); 01801 mask = MASK(13); 01802 tst_val = RUNNING_DIFF(14); 01803 mask = MASK(14); 01804 tst_val = RUNNING_DIFF(15); 01805 mask = MASK(15); 01806 tst_val = RUNNING_DIFF(16); 01807 mask = MASK(16); 01808 tst_val = RUNNING_DIFF(17); 01809 mask = MASK(17); 01810 tst_val = RUNNING_DIFF(18); 01811 mask = MASK(18); 01812 tst_val = RUNNING_DIFF(19); 01813 if (tst_val >= 0) { 01814 break; 01815 } 01816 } /* for */ 01817 if (tst_val == 0) { 01818 goto EXIT; 01819 } 01820 else if (tst_val > 0) { 01821 last = idx; 01822 } 01823 first = idx - stride + 1; 01824 seg_len = last - first + 1; 01825 stride = STRIDE_CALC(seg_len); 01826 } /* end while seg_len > 32 */ 01827 01828 for (idx = first; idx <= last; idx += 1) { 01829 tst_val = DIFF(1); 01830 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01831 tst_val = RUNNING_DIFF(2); 01832 mask = MASK(2); 01833 tst_val = RUNNING_DIFF(3); 01834 mask = MASK(3); 01835 tst_val = RUNNING_DIFF(4); 01836 mask = MASK(4); 01837 tst_val = RUNNING_DIFF(5); 01838 mask = MASK(5); 01839 tst_val = RUNNING_DIFF(6); 01840 mask = MASK(6); 01841 tst_val = RUNNING_DIFF(7); 01842 mask = MASK(7); 01843 tst_val = RUNNING_DIFF(8); 01844 mask = MASK(8); 01845 tst_val = RUNNING_DIFF(9); 01846 mask = MASK(9); 01847 tst_val = RUNNING_DIFF(10); 01848 mask = MASK(10); 01849 tst_val = RUNNING_DIFF(11); 01850 mask = MASK(11); 01851 tst_val = RUNNING_DIFF(12); 01852 mask = MASK(12); 01853 tst_val = RUNNING_DIFF(13); 01854 mask = MASK(13); 01855 tst_val = RUNNING_DIFF(14); 01856 mask = MASK(14); 01857 tst_val = RUNNING_DIFF(15); 01858 mask = MASK(15); 01859 tst_val = RUNNING_DIFF(16); 01860 mask = MASK(16); 01861 tst_val = RUNNING_DIFF(17); 01862 mask = MASK(17); 01863 tst_val = RUNNING_DIFF(18); 01864 mask = MASK(18); 01865 tst_val = RUNNING_DIFF(19); 01866 if (tst_val >= 0) { 01867 break; 01868 } 01869 } 01870 break; 01871 01872 case 20: 01873 while (seg_len > 32) { 01874 for (idx = first + stride -1 ; idx <= last; idx += stride) { 01875 tst_val = DIFF(1); 01876 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01877 tst_val = RUNNING_DIFF(2); 01878 mask = MASK(2); 01879 tst_val = RUNNING_DIFF(3); 01880 mask = MASK(3); 01881 tst_val = RUNNING_DIFF(4); 01882 mask = MASK(4); 01883 tst_val = RUNNING_DIFF(5); 01884 mask = MASK(5); 01885 tst_val = RUNNING_DIFF(6); 01886 mask = MASK(6); 01887 tst_val = RUNNING_DIFF(7); 01888 mask = MASK(7); 01889 tst_val = RUNNING_DIFF(8); 01890 mask = MASK(8); 01891 tst_val = RUNNING_DIFF(9); 01892 mask = MASK(9); 01893 tst_val = RUNNING_DIFF(10); 01894 mask = MASK(10); 01895 tst_val = RUNNING_DIFF(11); 01896 mask = MASK(11); 01897 tst_val = RUNNING_DIFF(12); 01898 mask = MASK(12); 01899 tst_val = RUNNING_DIFF(13); 01900 mask = MASK(13); 01901 tst_val = RUNNING_DIFF(14); 01902 mask = MASK(14); 01903 tst_val = RUNNING_DIFF(15); 01904 mask = MASK(15); 01905 tst_val = RUNNING_DIFF(16); 01906 mask = MASK(16); 01907 tst_val = RUNNING_DIFF(17); 01908 mask = MASK(17); 01909 tst_val = RUNNING_DIFF(18); 01910 mask = MASK(18); 01911 tst_val = RUNNING_DIFF(19); 01912 mask = MASK(19); 01913 tst_val = RUNNING_DIFF(20); 01914 if (tst_val >= 0) { 01915 break; 01916 } 01917 } /* for */ 01918 if (tst_val == 0) { 01919 goto EXIT; 01920 } 01921 else if (tst_val > 0) { 01922 last = idx; 01923 } 01924 first = idx - stride + 1; 01925 seg_len = last - first + 1; 01926 stride = STRIDE_CALC(seg_len); 01927 } /* end while seg_len > 32 */ 01928 01929 for (idx = first; idx <= last; idx += 1) { 01930 tst_val = DIFF(1); 01931 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01932 tst_val = RUNNING_DIFF(2); 01933 mask = MASK(2); 01934 tst_val = RUNNING_DIFF(3); 01935 mask = MASK(3); 01936 tst_val = RUNNING_DIFF(4); 01937 mask = MASK(4); 01938 tst_val = RUNNING_DIFF(5); 01939 mask = MASK(5); 01940 tst_val = RUNNING_DIFF(6); 01941 mask = MASK(6); 01942 tst_val = RUNNING_DIFF(7); 01943 mask = MASK(7); 01944 tst_val = RUNNING_DIFF(8); 01945 mask = MASK(8); 01946 tst_val = RUNNING_DIFF(9); 01947 mask = MASK(9); 01948 tst_val = RUNNING_DIFF(10); 01949 mask = MASK(10); 01950 tst_val = RUNNING_DIFF(11); 01951 mask = MASK(11); 01952 tst_val = RUNNING_DIFF(12); 01953 mask = MASK(12); 01954 tst_val = RUNNING_DIFF(13); 01955 mask = MASK(13); 01956 tst_val = RUNNING_DIFF(14); 01957 mask = MASK(14); 01958 tst_val = RUNNING_DIFF(15); 01959 mask = MASK(15); 01960 tst_val = RUNNING_DIFF(16); 01961 mask = MASK(16); 01962 tst_val = RUNNING_DIFF(17); 01963 mask = MASK(17); 01964 tst_val = RUNNING_DIFF(18); 01965 mask = MASK(18); 01966 tst_val = RUNNING_DIFF(19); 01967 mask = MASK(19); 01968 tst_val = RUNNING_DIFF(20); 01969 if (tst_val >= 0) { 01970 break; 01971 } 01972 } 01973 break; 01974 01975 case 21: 01976 while (seg_len > 32) { 01977 for (idx = first + stride -1 ; idx <= last; idx += stride) { 01978 tst_val = DIFF(1); 01979 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 01980 tst_val = RUNNING_DIFF(2); 01981 mask = MASK(2); 01982 tst_val = RUNNING_DIFF(3); 01983 mask = MASK(3); 01984 tst_val = RUNNING_DIFF(4); 01985 mask = MASK(4); 01986 tst_val = RUNNING_DIFF(5); 01987 mask = MASK(5); 01988 tst_val = RUNNING_DIFF(6); 01989 mask = MASK(6); 01990 tst_val = RUNNING_DIFF(7); 01991 mask = MASK(7); 01992 tst_val = RUNNING_DIFF(8); 01993 mask = MASK(8); 01994 tst_val = RUNNING_DIFF(9); 01995 mask = MASK(9); 01996 tst_val = RUNNING_DIFF(10); 01997 mask = MASK(10); 01998 tst_val = RUNNING_DIFF(11); 01999 mask = MASK(11); 02000 tst_val = RUNNING_DIFF(12); 02001 mask = MASK(12); 02002 tst_val = RUNNING_DIFF(13); 02003 mask = MASK(13); 02004 tst_val = RUNNING_DIFF(14); 02005 mask = MASK(14); 02006 tst_val = RUNNING_DIFF(15); 02007 mask = MASK(15); 02008 tst_val = RUNNING_DIFF(16); 02009 mask = MASK(16); 02010 tst_val = RUNNING_DIFF(17); 02011 mask = MASK(17); 02012 tst_val = RUNNING_DIFF(18); 02013 mask = MASK(18); 02014 tst_val = RUNNING_DIFF(19); 02015 mask = MASK(19); 02016 tst_val = RUNNING_DIFF(20); 02017 mask = MASK(20); 02018 tst_val = RUNNING_DIFF(21); 02019 if (tst_val >= 0) { 02020 break; 02021 } 02022 } /* for */ 02023 if (tst_val == 0) { 02024 goto EXIT; 02025 } 02026 else if (tst_val > 0) { 02027 last = idx; 02028 } 02029 first = idx - stride + 1; 02030 seg_len = last - first + 1; 02031 stride = STRIDE_CALC(seg_len); 02032 } /* end while seg_len > 32 */ 02033 02034 for (idx = first; idx <= last; idx += 1) { 02035 tst_val = DIFF(1); 02036 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 02037 tst_val = RUNNING_DIFF(2); 02038 mask = MASK(2); 02039 tst_val = RUNNING_DIFF(3); 02040 mask = MASK(3); 02041 tst_val = RUNNING_DIFF(4); 02042 mask = MASK(4); 02043 tst_val = RUNNING_DIFF(5); 02044 mask = MASK(5); 02045 tst_val = RUNNING_DIFF(6); 02046 mask = MASK(6); 02047 tst_val = RUNNING_DIFF(7); 02048 mask = MASK(7); 02049 tst_val = RUNNING_DIFF(8); 02050 mask = MASK(8); 02051 tst_val = RUNNING_DIFF(9); 02052 mask = MASK(9); 02053 tst_val = RUNNING_DIFF(10); 02054 mask = MASK(10); 02055 tst_val = RUNNING_DIFF(11); 02056 mask = MASK(11); 02057 tst_val = RUNNING_DIFF(12); 02058 mask = MASK(12); 02059 tst_val = RUNNING_DIFF(13); 02060 mask = MASK(13); 02061 tst_val = RUNNING_DIFF(14); 02062 mask = MASK(14); 02063 tst_val = RUNNING_DIFF(15); 02064 mask = MASK(15); 02065 tst_val = RUNNING_DIFF(16); 02066 mask = MASK(16); 02067 tst_val = RUNNING_DIFF(17); 02068 mask = MASK(17); 02069 tst_val = RUNNING_DIFF(18); 02070 mask = MASK(18); 02071 tst_val = RUNNING_DIFF(19); 02072 mask = MASK(19); 02073 tst_val = RUNNING_DIFF(20); 02074 mask = MASK(20); 02075 tst_val = RUNNING_DIFF(21); 02076 if (tst_val >= 0) { 02077 break; 02078 } 02079 } 02080 break; 02081 02082 case 22: 02083 while (seg_len > 32) { 02084 for (idx = first + stride -1 ; idx <= last; idx += stride) { 02085 tst_val = DIFF(1); 02086 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 02087 tst_val = RUNNING_DIFF(2); 02088 mask = MASK(2); 02089 tst_val = RUNNING_DIFF(3); 02090 mask = MASK(3); 02091 tst_val = RUNNING_DIFF(4); 02092 mask = MASK(4); 02093 tst_val = RUNNING_DIFF(5); 02094 mask = MASK(5); 02095 tst_val = RUNNING_DIFF(6); 02096 mask = MASK(6); 02097 tst_val = RUNNING_DIFF(7); 02098 mask = MASK(7); 02099 tst_val = RUNNING_DIFF(8); 02100 mask = MASK(8); 02101 tst_val = RUNNING_DIFF(9); 02102 mask = MASK(9); 02103 tst_val = RUNNING_DIFF(10); 02104 mask = MASK(10); 02105 tst_val = RUNNING_DIFF(11); 02106 mask = MASK(11); 02107 tst_val = RUNNING_DIFF(12); 02108 mask = MASK(12); 02109 tst_val = RUNNING_DIFF(13); 02110 mask = MASK(13); 02111 tst_val = RUNNING_DIFF(14); 02112 mask = MASK(14); 02113 tst_val = RUNNING_DIFF(15); 02114 mask = MASK(15); 02115 tst_val = RUNNING_DIFF(16); 02116 mask = MASK(16); 02117 tst_val = RUNNING_DIFF(17); 02118 mask = MASK(17); 02119 tst_val = RUNNING_DIFF(18); 02120 mask = MASK(18); 02121 tst_val = RUNNING_DIFF(19); 02122 mask = MASK(19); 02123 tst_val = RUNNING_DIFF(20); 02124 mask = MASK(20); 02125 tst_val = RUNNING_DIFF(21); 02126 mask = MASK(21); 02127 tst_val = RUNNING_DIFF(22); 02128 if (tst_val >= 0) { 02129 break; 02130 } 02131 } /* for */ 02132 if (tst_val == 0) { 02133 goto EXIT; 02134 } 02135 else if (tst_val > 0) { 02136 last = idx; 02137 } 02138 first = idx - stride + 1; 02139 seg_len = last - first + 1; 02140 stride = STRIDE_CALC(seg_len); 02141 } /* end while seg_len > 32 */ 02142 02143 for (idx = first; idx <= last; idx += 1) { 02144 tst_val = DIFF(1); 02145 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 02146 tst_val = RUNNING_DIFF(2); 02147 mask = MASK(2); 02148 tst_val = RUNNING_DIFF(3); 02149 mask = MASK(3); 02150 tst_val = RUNNING_DIFF(4); 02151 mask = MASK(4); 02152 tst_val = RUNNING_DIFF(5); 02153 mask = MASK(5); 02154 tst_val = RUNNING_DIFF(6); 02155 mask = MASK(6); 02156 tst_val = RUNNING_DIFF(7); 02157 mask = MASK(7); 02158 tst_val = RUNNING_DIFF(8); 02159 mask = MASK(8); 02160 tst_val = RUNNING_DIFF(9); 02161 mask = MASK(9); 02162 tst_val = RUNNING_DIFF(10); 02163 mask = MASK(10); 02164 tst_val = RUNNING_DIFF(11); 02165 mask = MASK(11); 02166 tst_val = RUNNING_DIFF(12); 02167 mask = MASK(12); 02168 tst_val = RUNNING_DIFF(13); 02169 mask = MASK(13); 02170 tst_val = RUNNING_DIFF(14); 02171 mask = MASK(14); 02172 tst_val = RUNNING_DIFF(15); 02173 mask = MASK(15); 02174 tst_val = RUNNING_DIFF(16); 02175 mask = MASK(16); 02176 tst_val = RUNNING_DIFF(17); 02177 mask = MASK(17); 02178 tst_val = RUNNING_DIFF(18); 02179 mask = MASK(18); 02180 tst_val = RUNNING_DIFF(19); 02181 mask = MASK(19); 02182 tst_val = RUNNING_DIFF(20); 02183 mask = MASK(20); 02184 tst_val = RUNNING_DIFF(21); 02185 mask = MASK(21); 02186 tst_val = RUNNING_DIFF(22); 02187 if (tst_val >= 0) { 02188 break; 02189 } 02190 } 02191 break; 02192 02193 /* SGI's gcc -3.0 seems to have a bug? including the following cases cause 02194 * the switch to fall down to default no matter what the value of seg_len 02195 * is. 02196 */ 02197 /* #if 0 */ /* must if zero this and below! why? */ 02198 case 23: 02199 while (seg_len > 32) { 02200 for (idx = first + stride -1 ; idx <= last; idx += stride) { 02201 tst_val = DIFF(1); 02202 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 02203 tst_val = RUNNING_DIFF(2); 02204 mask = MASK(2); 02205 tst_val = RUNNING_DIFF(3); 02206 mask = MASK(3); 02207 tst_val = RUNNING_DIFF(4); 02208 mask = MASK(4); 02209 tst_val = RUNNING_DIFF(5); 02210 mask = MASK(5); 02211 tst_val = RUNNING_DIFF(6); 02212 mask = MASK(6); 02213 tst_val = RUNNING_DIFF(7); 02214 mask = MASK(7); 02215 tst_val = RUNNING_DIFF(8); 02216 mask = MASK(8); 02217 tst_val = RUNNING_DIFF(9); 02218 mask = MASK(9); 02219 tst_val = RUNNING_DIFF(10); 02220 mask = MASK(10); 02221 tst_val = RUNNING_DIFF(11); 02222 mask = MASK(11); 02223 tst_val = RUNNING_DIFF(12); 02224 mask = MASK(12); 02225 tst_val = RUNNING_DIFF(13); 02226 mask = MASK(13); 02227 tst_val = RUNNING_DIFF(14); 02228 mask = MASK(14); 02229 tst_val = RUNNING_DIFF(15); 02230 mask = MASK(15); 02231 tst_val = RUNNING_DIFF(16); 02232 mask = MASK(16); 02233 tst_val = RUNNING_DIFF(17); 02234 mask = MASK(17); 02235 tst_val = RUNNING_DIFF(18); 02236 mask = MASK(18); 02237 tst_val = RUNNING_DIFF(19); 02238 mask = MASK(19); 02239 tst_val = RUNNING_DIFF(20); 02240 mask = MASK(20); 02241 tst_val = RUNNING_DIFF(21); 02242 mask = MASK(21); 02243 tst_val = RUNNING_DIFF(22); 02244 mask = MASK(22); 02245 tst_val = RUNNING_DIFF(23); 02246 if (tst_val >= 0) { 02247 break; 02248 } 02249 } /* for */ 02250 if (tst_val == 0) { 02251 goto EXIT; 02252 } 02253 else if (tst_val > 0) { 02254 last = idx; 02255 } 02256 first = idx - stride + 1; 02257 seg_len = last - first + 1; 02258 stride = STRIDE_CALC(seg_len); 02259 } /* end while seg_len > 32 */ 02260 02261 for (idx = first; idx <= last; idx += 1) { 02262 tst_val = DIFF(1); 02263 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 02264 tst_val = RUNNING_DIFF(2); 02265 mask = MASK(2); 02266 tst_val = RUNNING_DIFF(3); 02267 mask = MASK(3); 02268 tst_val = RUNNING_DIFF(4); 02269 mask = MASK(4); 02270 tst_val = RUNNING_DIFF(5); 02271 mask = MASK(5); 02272 tst_val = RUNNING_DIFF(6); 02273 mask = MASK(6); 02274 tst_val = RUNNING_DIFF(7); 02275 mask = MASK(7); 02276 tst_val = RUNNING_DIFF(8); 02277 mask = MASK(8); 02278 tst_val = RUNNING_DIFF(9); 02279 mask = MASK(9); 02280 tst_val = RUNNING_DIFF(10); 02281 mask = MASK(10); 02282 tst_val = RUNNING_DIFF(11); 02283 mask = MASK(11); 02284 tst_val = RUNNING_DIFF(12); 02285 mask = MASK(12); 02286 tst_val = RUNNING_DIFF(13); 02287 mask = MASK(13); 02288 tst_val = RUNNING_DIFF(14); 02289 mask = MASK(14); 02290 tst_val = RUNNING_DIFF(15); 02291 mask = MASK(15); 02292 tst_val = RUNNING_DIFF(16); 02293 mask = MASK(16); 02294 tst_val = RUNNING_DIFF(17); 02295 mask = MASK(17); 02296 tst_val = RUNNING_DIFF(18); 02297 mask = MASK(18); 02298 tst_val = RUNNING_DIFF(19); 02299 mask = MASK(19); 02300 tst_val = RUNNING_DIFF(20); 02301 mask = MASK(20); 02302 tst_val = RUNNING_DIFF(21); 02303 mask = MASK(21); 02304 tst_val = RUNNING_DIFF(22); 02305 mask = MASK(22); 02306 tst_val = RUNNING_DIFF(23); 02307 if (tst_val >= 0) { 02308 break; 02309 } 02310 } 02311 break; 02312 02313 case 24: 02314 while (seg_len > 32) { 02315 for (idx = first + stride -1 ; idx <= last; idx += stride) { 02316 tst_val = DIFF(1); 02317 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 02318 tst_val = RUNNING_DIFF(2); 02319 mask = MASK(2); 02320 tst_val = RUNNING_DIFF(3); 02321 mask = MASK(3); 02322 tst_val = RUNNING_DIFF(4); 02323 mask = MASK(4); 02324 tst_val = RUNNING_DIFF(5); 02325 mask = MASK(5); 02326 tst_val = RUNNING_DIFF(6); 02327 mask = MASK(6); 02328 tst_val = RUNNING_DIFF(7); 02329 mask = MASK(7); 02330 tst_val = RUNNING_DIFF(8); 02331 mask = MASK(8); 02332 tst_val = RUNNING_DIFF(9); 02333 mask = MASK(9); 02334 tst_val = RUNNING_DIFF(10); 02335 mask = MASK(10); 02336 tst_val = RUNNING_DIFF(11); 02337 mask = MASK(11); 02338 tst_val = RUNNING_DIFF(12); 02339 mask = MASK(12); 02340 tst_val = RUNNING_DIFF(13); 02341 mask = MASK(13); 02342 tst_val = RUNNING_DIFF(14); 02343 mask = MASK(14); 02344 tst_val = RUNNING_DIFF(15); 02345 mask = MASK(15); 02346 tst_val = RUNNING_DIFF(16); 02347 mask = MASK(16); 02348 tst_val = RUNNING_DIFF(17); 02349 mask = MASK(17); 02350 tst_val = RUNNING_DIFF(18); 02351 mask = MASK(18); 02352 tst_val = RUNNING_DIFF(19); 02353 mask = MASK(19); 02354 tst_val = RUNNING_DIFF(20); 02355 mask = MASK(20); 02356 tst_val = RUNNING_DIFF(21); 02357 mask = MASK(21); 02358 tst_val = RUNNING_DIFF(22); 02359 mask = MASK(22); 02360 tst_val = RUNNING_DIFF(23); 02361 mask = MASK(23); 02362 tst_val = RUNNING_DIFF(24); 02363 if (tst_val >= 0) { 02364 break; 02365 } 02366 } /* for */ 02367 if (tst_val == 0) { 02368 goto EXIT; 02369 } 02370 else if (tst_val > 0) { 02371 last = idx; 02372 } 02373 first = idx - stride + 1; 02374 seg_len = last - first + 1; 02375 stride = STRIDE_CALC(seg_len); 02376 } /* end while seg_len > 32 */ 02377 02378 for (idx = first; idx <= last; idx += 1) { 02379 tst_val = DIFF(1); 02380 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 02381 tst_val = RUNNING_DIFF(2); 02382 mask = MASK(2); 02383 tst_val = RUNNING_DIFF(3); 02384 mask = MASK(3); 02385 tst_val = RUNNING_DIFF(4); 02386 mask = MASK(4); 02387 tst_val = RUNNING_DIFF(5); 02388 mask = MASK(5); 02389 tst_val = RUNNING_DIFF(6); 02390 mask = MASK(6); 02391 tst_val = RUNNING_DIFF(7); 02392 mask = MASK(7); 02393 tst_val = RUNNING_DIFF(8); 02394 mask = MASK(8); 02395 tst_val = RUNNING_DIFF(9); 02396 mask = MASK(9); 02397 tst_val = RUNNING_DIFF(10); 02398 mask = MASK(10); 02399 tst_val = RUNNING_DIFF(11); 02400 mask = MASK(11); 02401 tst_val = RUNNING_DIFF(12); 02402 mask = MASK(12); 02403 tst_val = RUNNING_DIFF(13); 02404 mask = MASK(13); 02405 tst_val = RUNNING_DIFF(14); 02406 mask = MASK(14); 02407 tst_val = RUNNING_DIFF(15); 02408 mask = MASK(15); 02409 tst_val = RUNNING_DIFF(16); 02410 mask = MASK(16); 02411 tst_val = RUNNING_DIFF(17); 02412 mask = MASK(17); 02413 tst_val = RUNNING_DIFF(18); 02414 mask = MASK(18); 02415 tst_val = RUNNING_DIFF(19); 02416 mask = MASK(19); 02417 tst_val = RUNNING_DIFF(20); 02418 mask = MASK(20); 02419 tst_val = RUNNING_DIFF(21); 02420 mask = MASK(21); 02421 tst_val = RUNNING_DIFF(22); 02422 mask = MASK(22); 02423 tst_val = RUNNING_DIFF(23); 02424 mask = MASK(23); 02425 tst_val = RUNNING_DIFF(24); 02426 if (tst_val >= 0) { 02427 break; 02428 } 02429 } 02430 break; 02431 02432 case 25: 02433 while (seg_len > 32) { 02434 for (idx = first + stride -1 ; idx <= last; idx += stride) { 02435 tst_val = DIFF(1); 02436 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 02437 tst_val = RUNNING_DIFF(2); 02438 mask = MASK(2); 02439 tst_val = RUNNING_DIFF(3); 02440 mask = MASK(3); 02441 tst_val = RUNNING_DIFF(4); 02442 mask = MASK(4); 02443 tst_val = RUNNING_DIFF(5); 02444 mask = MASK(5); 02445 tst_val = RUNNING_DIFF(6); 02446 mask = MASK(6); 02447 tst_val = RUNNING_DIFF(7); 02448 mask = MASK(7); 02449 tst_val = RUNNING_DIFF(8); 02450 mask = MASK(8); 02451 tst_val = RUNNING_DIFF(9); 02452 mask = MASK(9); 02453 tst_val = RUNNING_DIFF(10); 02454 mask = MASK(10); 02455 tst_val = RUNNING_DIFF(11); 02456 mask = MASK(11); 02457 tst_val = RUNNING_DIFF(12); 02458 mask = MASK(12); 02459 tst_val = RUNNING_DIFF(13); 02460 mask = MASK(13); 02461 tst_val = RUNNING_DIFF(14); 02462 mask = MASK(14); 02463 tst_val = RUNNING_DIFF(15); 02464 mask = MASK(15); 02465 tst_val = RUNNING_DIFF(16); 02466 mask = MASK(16); 02467 tst_val = RUNNING_DIFF(17); 02468 mask = MASK(17); 02469 tst_val = RUNNING_DIFF(18); 02470 mask = MASK(18); 02471 tst_val = RUNNING_DIFF(19); 02472 mask = MASK(19); 02473 tst_val = RUNNING_DIFF(20); 02474 mask = MASK(20); 02475 tst_val = RUNNING_DIFF(21); 02476 mask = MASK(21); 02477 tst_val = RUNNING_DIFF(22); 02478 mask = MASK(22); 02479 tst_val = RUNNING_DIFF(23); 02480 mask = MASK(23); 02481 tst_val = RUNNING_DIFF(24); 02482 mask = MASK(24); 02483 tst_val = RUNNING_DIFF(25); 02484 if (tst_val >= 0) { 02485 break; 02486 } 02487 } /* for */ 02488 if (tst_val == 0) { 02489 goto EXIT; 02490 } 02491 else if (tst_val > 0) { 02492 last = idx; 02493 } 02494 first = idx - stride + 1; 02495 seg_len = last - first + 1; 02496 stride = STRIDE_CALC(seg_len); 02497 } /* end while seg_len > 32 */ 02498 02499 for (idx = first; idx <= last; idx += 1) { 02500 tst_val = DIFF(1); 02501 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 02502 tst_val = RUNNING_DIFF(2); 02503 mask = MASK(2); 02504 tst_val = RUNNING_DIFF(3); 02505 mask = MASK(3); 02506 tst_val = RUNNING_DIFF(4); 02507 mask = MASK(4); 02508 tst_val = RUNNING_DIFF(5); 02509 mask = MASK(5); 02510 tst_val = RUNNING_DIFF(6); 02511 mask = MASK(6); 02512 tst_val = RUNNING_DIFF(7); 02513 mask = MASK(7); 02514 tst_val = RUNNING_DIFF(8); 02515 mask = MASK(8); 02516 tst_val = RUNNING_DIFF(9); 02517 mask = MASK(9); 02518 tst_val = RUNNING_DIFF(10); 02519 mask = MASK(10); 02520 tst_val = RUNNING_DIFF(11); 02521 mask = MASK(11); 02522 tst_val = RUNNING_DIFF(12); 02523 mask = MASK(12); 02524 tst_val = RUNNING_DIFF(13); 02525 mask = MASK(13); 02526 tst_val = RUNNING_DIFF(14); 02527 mask = MASK(14); 02528 tst_val = RUNNING_DIFF(15); 02529 mask = MASK(15); 02530 tst_val = RUNNING_DIFF(16); 02531 mask = MASK(16); 02532 tst_val = RUNNING_DIFF(17); 02533 mask = MASK(17); 02534 tst_val = RUNNING_DIFF(18); 02535 mask = MASK(18); 02536 tst_val = RUNNING_DIFF(19); 02537 mask = MASK(19); 02538 tst_val = RUNNING_DIFF(20); 02539 mask = MASK(20); 02540 tst_val = RUNNING_DIFF(21); 02541 mask = MASK(21); 02542 tst_val = RUNNING_DIFF(22); 02543 mask = MASK(22); 02544 tst_val = RUNNING_DIFF(23); 02545 mask = MASK(23); 02546 tst_val = RUNNING_DIFF(24); 02547 mask = MASK(24); 02548 tst_val = RUNNING_DIFF(25); 02549 if (tst_val >= 0) { 02550 break; 02551 } 02552 } 02553 break; 02554 02555 case 26: 02556 while (seg_len > 32) { 02557 for (idx = first + stride -1 ; idx <= last; idx += stride) { 02558 tst_val = DIFF(1); 02559 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 02560 tst_val = RUNNING_DIFF(2); 02561 mask = MASK(2); 02562 tst_val = RUNNING_DIFF(3); 02563 mask = MASK(3); 02564 tst_val = RUNNING_DIFF(4); 02565 mask = MASK(4); 02566 tst_val = RUNNING_DIFF(5); 02567 mask = MASK(5); 02568 tst_val = RUNNING_DIFF(6); 02569 mask = MASK(6); 02570 tst_val = RUNNING_DIFF(7); 02571 mask = MASK(7); 02572 tst_val = RUNNING_DIFF(8); 02573 mask = MASK(8); 02574 tst_val = RUNNING_DIFF(9); 02575 mask = MASK(9); 02576 tst_val = RUNNING_DIFF(10); 02577 mask = MASK(10); 02578 tst_val = RUNNING_DIFF(11); 02579 mask = MASK(11); 02580 tst_val = RUNNING_DIFF(12); 02581 mask = MASK(12); 02582 tst_val = RUNNING_DIFF(13); 02583 mask = MASK(13); 02584 tst_val = RUNNING_DIFF(14); 02585 mask = MASK(14); 02586 tst_val = RUNNING_DIFF(15); 02587 mask = MASK(15); 02588 tst_val = RUNNING_DIFF(16); 02589 mask = MASK(16); 02590 tst_val = RUNNING_DIFF(17); 02591 mask = MASK(17); 02592 tst_val = RUNNING_DIFF(18); 02593 mask = MASK(18); 02594 tst_val = RUNNING_DIFF(19); 02595 mask = MASK(19); 02596 tst_val = RUNNING_DIFF(20); 02597 mask = MASK(20); 02598 tst_val = RUNNING_DIFF(21); 02599 mask = MASK(21); 02600 tst_val = RUNNING_DIFF(22); 02601 mask = MASK(22); 02602 tst_val = RUNNING_DIFF(23); 02603 mask = MASK(23); 02604 tst_val = RUNNING_DIFF(24); 02605 mask = MASK(24); 02606 tst_val = RUNNING_DIFF(25); 02607 mask = MASK(25); 02608 tst_val = RUNNING_DIFF(26); 02609 if (tst_val >= 0) { 02610 break; 02611 } 02612 } /* for */ 02613 if (tst_val == 0) { 02614 goto EXIT; 02615 } 02616 else if (tst_val > 0) { 02617 last = idx; 02618 } 02619 first = idx - stride + 1; 02620 seg_len = last - first + 1; 02621 stride = STRIDE_CALC(seg_len); 02622 } /* end while seg_len > 32 */ 02623 02624 for (idx = first; idx <= last; idx += 1) { 02625 tst_val = DIFF(1); 02626 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 02627 tst_val = RUNNING_DIFF(2); 02628 mask = MASK(2); 02629 tst_val = RUNNING_DIFF(3); 02630 mask = MASK(3); 02631 tst_val = RUNNING_DIFF(4); 02632 mask = MASK(4); 02633 tst_val = RUNNING_DIFF(5); 02634 mask = MASK(5); 02635 tst_val = RUNNING_DIFF(6); 02636 mask = MASK(6); 02637 tst_val = RUNNING_DIFF(7); 02638 mask = MASK(7); 02639 tst_val = RUNNING_DIFF(8); 02640 mask = MASK(8); 02641 tst_val = RUNNING_DIFF(9); 02642 mask = MASK(9); 02643 tst_val = RUNNING_DIFF(10); 02644 mask = MASK(10); 02645 tst_val = RUNNING_DIFF(11); 02646 mask = MASK(11); 02647 tst_val = RUNNING_DIFF(12); 02648 mask = MASK(12); 02649 tst_val = RUNNING_DIFF(13); 02650 mask = MASK(13); 02651 tst_val = RUNNING_DIFF(14); 02652 mask = MASK(14); 02653 tst_val = RUNNING_DIFF(15); 02654 mask = MASK(15); 02655 tst_val = RUNNING_DIFF(16); 02656 mask = MASK(16); 02657 tst_val = RUNNING_DIFF(17); 02658 mask = MASK(17); 02659 tst_val = RUNNING_DIFF(18); 02660 mask = MASK(18); 02661 tst_val = RUNNING_DIFF(19); 02662 mask = MASK(19); 02663 tst_val = RUNNING_DIFF(20); 02664 mask = MASK(20); 02665 tst_val = RUNNING_DIFF(21); 02666 mask = MASK(21); 02667 tst_val = RUNNING_DIFF(22); 02668 mask = MASK(22); 02669 tst_val = RUNNING_DIFF(23); 02670 mask = MASK(23); 02671 tst_val = RUNNING_DIFF(24); 02672 mask = MASK(24); 02673 tst_val = RUNNING_DIFF(25); 02674 mask = MASK(25); 02675 tst_val = RUNNING_DIFF(26); 02676 if (tst_val >= 0) { 02677 break; 02678 } 02679 } 02680 break; 02681 02682 case 27: 02683 while (seg_len > 32) { 02684 for (idx = first + stride -1 ; idx <= last; idx += stride) { 02685 tst_val = DIFF(1); 02686 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 02687 tst_val = RUNNING_DIFF(2); 02688 mask = MASK(2); 02689 tst_val = RUNNING_DIFF(3); 02690 mask = MASK(3); 02691 tst_val = RUNNING_DIFF(4); 02692 mask = MASK(4); 02693 tst_val = RUNNING_DIFF(5); 02694 mask = MASK(5); 02695 tst_val = RUNNING_DIFF(6); 02696 mask = MASK(6); 02697 tst_val = RUNNING_DIFF(7); 02698 mask = MASK(7); 02699 tst_val = RUNNING_DIFF(8); 02700 mask = MASK(8); 02701 tst_val = RUNNING_DIFF(9); 02702 mask = MASK(9); 02703 tst_val = RUNNING_DIFF(10); 02704 mask = MASK(10); 02705 tst_val = RUNNING_DIFF(11); 02706 mask = MASK(11); 02707 tst_val = RUNNING_DIFF(12); 02708 mask = MASK(12); 02709 tst_val = RUNNING_DIFF(13); 02710 mask = MASK(13); 02711 tst_val = RUNNING_DIFF(14); 02712 mask = MASK(14); 02713 tst_val = RUNNING_DIFF(15); 02714 mask = MASK(15); 02715 tst_val = RUNNING_DIFF(16); 02716 mask = MASK(16); 02717 tst_val = RUNNING_DIFF(17); 02718 mask = MASK(17); 02719 tst_val = RUNNING_DIFF(18); 02720 mask = MASK(18); 02721 tst_val = RUNNING_DIFF(19); 02722 mask = MASK(19); 02723 tst_val = RUNNING_DIFF(20); 02724 mask = MASK(20); 02725 tst_val = RUNNING_DIFF(21); 02726 mask = MASK(21); 02727 tst_val = RUNNING_DIFF(22); 02728 mask = MASK(22); 02729 tst_val = RUNNING_DIFF(23); 02730 mask = MASK(23); 02731 tst_val = RUNNING_DIFF(24); 02732 mask = MASK(24); 02733 tst_val = RUNNING_DIFF(25); 02734 mask = MASK(25); 02735 tst_val = RUNNING_DIFF(26); 02736 mask = MASK(26); 02737 tst_val = RUNNING_DIFF(27); 02738 if (tst_val >= 0) { 02739 break; 02740 } 02741 } /* for */ 02742 if (tst_val == 0) { 02743 goto EXIT; 02744 } 02745 else if (tst_val > 0) { 02746 last = idx; 02747 } 02748 first = idx - stride + 1; 02749 seg_len = last - first + 1; 02750 stride = STRIDE_CALC(seg_len); 02751 } /* end while seg_len > 32 */ 02752 02753 for (idx = first; idx <= last; idx += 1) { 02754 tst_val = DIFF(1); 02755 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 02756 tst_val = RUNNING_DIFF(2); 02757 mask = MASK(2); 02758 tst_val = RUNNING_DIFF(3); 02759 mask = MASK(3); 02760 tst_val = RUNNING_DIFF(4); 02761 mask = MASK(4); 02762 tst_val = RUNNING_DIFF(5); 02763 mask = MASK(5); 02764 tst_val = RUNNING_DIFF(6); 02765 mask = MASK(6); 02766 tst_val = RUNNING_DIFF(7); 02767 mask = MASK(7); 02768 tst_val = RUNNING_DIFF(8); 02769 mask = MASK(8); 02770 tst_val = RUNNING_DIFF(9); 02771 mask = MASK(9); 02772 tst_val = RUNNING_DIFF(10); 02773 mask = MASK(10); 02774 tst_val = RUNNING_DIFF(11); 02775 mask = MASK(11); 02776 tst_val = RUNNING_DIFF(12); 02777 mask = MASK(12); 02778 tst_val = RUNNING_DIFF(13); 02779 mask = MASK(13); 02780 tst_val = RUNNING_DIFF(14); 02781 mask = MASK(14); 02782 tst_val = RUNNING_DIFF(15); 02783 mask = MASK(15); 02784 tst_val = RUNNING_DIFF(16); 02785 mask = MASK(16); 02786 tst_val = RUNNING_DIFF(17); 02787 mask = MASK(17); 02788 tst_val = RUNNING_DIFF(18); 02789 mask = MASK(18); 02790 tst_val = RUNNING_DIFF(19); 02791 mask = MASK(19); 02792 tst_val = RUNNING_DIFF(20); 02793 mask = MASK(20); 02794 tst_val = RUNNING_DIFF(21); 02795 mask = MASK(21); 02796 tst_val = RUNNING_DIFF(22); 02797 mask = MASK(22); 02798 tst_val = RUNNING_DIFF(23); 02799 mask = MASK(23); 02800 tst_val = RUNNING_DIFF(24); 02801 mask = MASK(24); 02802 tst_val = RUNNING_DIFF(25); 02803 mask = MASK(25); 02804 tst_val = RUNNING_DIFF(26); 02805 mask = MASK(26); 02806 tst_val = RUNNING_DIFF(27); 02807 if (tst_val >= 0) { 02808 break; 02809 } 02810 } 02811 break; 02812 02813 case 28: 02814 while (seg_len > 32) { 02815 for (idx = first + stride -1 ; idx <= last; idx += stride) { 02816 tst_val = DIFF(1); 02817 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 02818 tst_val = RUNNING_DIFF(2); 02819 mask = MASK(2); 02820 tst_val = RUNNING_DIFF(3); 02821 mask = MASK(3); 02822 tst_val = RUNNING_DIFF(4); 02823 mask = MASK(4); 02824 tst_val = RUNNING_DIFF(5); 02825 mask = MASK(5); 02826 tst_val = RUNNING_DIFF(6); 02827 mask = MASK(6); 02828 tst_val = RUNNING_DIFF(7); 02829 mask = MASK(7); 02830 tst_val = RUNNING_DIFF(8); 02831 mask = MASK(8); 02832 tst_val = RUNNING_DIFF(9); 02833 mask = MASK(9); 02834 tst_val = RUNNING_DIFF(10); 02835 mask = MASK(10); 02836 tst_val = RUNNING_DIFF(11); 02837 mask = MASK(11); 02838 tst_val = RUNNING_DIFF(12); 02839 mask = MASK(12); 02840 tst_val = RUNNING_DIFF(13); 02841 mask = MASK(13); 02842 tst_val = RUNNING_DIFF(14); 02843 mask = MASK(14); 02844 tst_val = RUNNING_DIFF(15); 02845 mask = MASK(15); 02846 tst_val = RUNNING_DIFF(16); 02847 mask = MASK(16); 02848 tst_val = RUNNING_DIFF(17); 02849 mask = MASK(17); 02850 tst_val = RUNNING_DIFF(18); 02851 mask = MASK(18); 02852 tst_val = RUNNING_DIFF(19); 02853 mask = MASK(19); 02854 tst_val = RUNNING_DIFF(20); 02855 mask = MASK(20); 02856 tst_val = RUNNING_DIFF(21); 02857 mask = MASK(21); 02858 tst_val = RUNNING_DIFF(22); 02859 mask = MASK(22); 02860 tst_val = RUNNING_DIFF(23); 02861 mask = MASK(23); 02862 tst_val = RUNNING_DIFF(24); 02863 mask = MASK(24); 02864 tst_val = RUNNING_DIFF(25); 02865 mask = MASK(25); 02866 tst_val = RUNNING_DIFF(26); 02867 mask = MASK(26); 02868 tst_val = RUNNING_DIFF(27); 02869 mask = MASK(27); 02870 tst_val = RUNNING_DIFF(28); 02871 if (tst_val >= 0) { 02872 break; 02873 } 02874 } /* for */ 02875 if (tst_val == 0) { 02876 goto EXIT; 02877 } 02878 else if (tst_val > 0) { 02879 last = idx; 02880 } 02881 first = idx - stride + 1; 02882 seg_len = last - first + 1; 02883 stride = STRIDE_CALC(seg_len); 02884 } /* end while seg_len > 32 */ 02885 02886 for (idx = first; idx <= last; idx += 1) { 02887 tst_val = DIFF(1); 02888 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 02889 tst_val = RUNNING_DIFF(2); 02890 mask = MASK(2); 02891 tst_val = RUNNING_DIFF(3); 02892 mask = MASK(3); 02893 tst_val = RUNNING_DIFF(4); 02894 mask = MASK(4); 02895 tst_val = RUNNING_DIFF(5); 02896 mask = MASK(5); 02897 tst_val = RUNNING_DIFF(6); 02898 mask = MASK(6); 02899 tst_val = RUNNING_DIFF(7); 02900 mask = MASK(7); 02901 tst_val = RUNNING_DIFF(8); 02902 mask = MASK(8); 02903 tst_val = RUNNING_DIFF(9); 02904 mask = MASK(9); 02905 tst_val = RUNNING_DIFF(10); 02906 mask = MASK(10); 02907 tst_val = RUNNING_DIFF(11); 02908 mask = MASK(11); 02909 tst_val = RUNNING_DIFF(12); 02910 mask = MASK(12); 02911 tst_val = RUNNING_DIFF(13); 02912 mask = MASK(13); 02913 tst_val = RUNNING_DIFF(14); 02914 mask = MASK(14); 02915 tst_val = RUNNING_DIFF(15); 02916 mask = MASK(15); 02917 tst_val = RUNNING_DIFF(16); 02918 mask = MASK(16); 02919 tst_val = RUNNING_DIFF(17); 02920 mask = MASK(17); 02921 tst_val = RUNNING_DIFF(18); 02922 mask = MASK(18); 02923 tst_val = RUNNING_DIFF(19); 02924 mask = MASK(19); 02925 tst_val = RUNNING_DIFF(20); 02926 mask = MASK(20); 02927 tst_val = RUNNING_DIFF(21); 02928 mask = MASK(21); 02929 tst_val = RUNNING_DIFF(22); 02930 mask = MASK(22); 02931 tst_val = RUNNING_DIFF(23); 02932 mask = MASK(23); 02933 tst_val = RUNNING_DIFF(24); 02934 mask = MASK(24); 02935 tst_val = RUNNING_DIFF(25); 02936 mask = MASK(25); 02937 tst_val = RUNNING_DIFF(26); 02938 mask = MASK(26); 02939 tst_val = RUNNING_DIFF(27); 02940 mask = MASK(27); 02941 tst_val = RUNNING_DIFF(28); 02942 if (tst_val >= 0) { 02943 break; 02944 } 02945 } 02946 break; 02947 02948 case 29: 02949 while (seg_len > 32) { 02950 for (idx = first + stride -1 ; idx <= last; idx += stride) { 02951 tst_val = DIFF(1); 02952 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 02953 tst_val = RUNNING_DIFF(2); 02954 mask = MASK(2); 02955 tst_val = RUNNING_DIFF(3); 02956 mask = MASK(3); 02957 tst_val = RUNNING_DIFF(4); 02958 mask = MASK(4); 02959 tst_val = RUNNING_DIFF(5); 02960 mask = MASK(5); 02961 tst_val = RUNNING_DIFF(6); 02962 mask = MASK(6); 02963 tst_val = RUNNING_DIFF(7); 02964 mask = MASK(7); 02965 tst_val = RUNNING_DIFF(8); 02966 mask = MASK(8); 02967 tst_val = RUNNING_DIFF(9); 02968 mask = MASK(9); 02969 tst_val = RUNNING_DIFF(10); 02970 mask = MASK(10); 02971 tst_val = RUNNING_DIFF(11); 02972 mask = MASK(11); 02973 tst_val = RUNNING_DIFF(12); 02974 mask = MASK(12); 02975 tst_val = RUNNING_DIFF(13); 02976 mask = MASK(13); 02977 tst_val = RUNNING_DIFF(14); 02978 mask = MASK(14); 02979 tst_val = RUNNING_DIFF(15); 02980 mask = MASK(15); 02981 tst_val = RUNNING_DIFF(16); 02982 mask = MASK(16); 02983 tst_val = RUNNING_DIFF(17); 02984 mask = MASK(17); 02985 tst_val = RUNNING_DIFF(18); 02986 mask = MASK(18); 02987 tst_val = RUNNING_DIFF(19); 02988 mask = MASK(19); 02989 tst_val = RUNNING_DIFF(20); 02990 mask = MASK(20); 02991 tst_val = RUNNING_DIFF(21); 02992 mask = MASK(21); 02993 tst_val = RUNNING_DIFF(22); 02994 mask = MASK(22); 02995 tst_val = RUNNING_DIFF(23); 02996 mask = MASK(23); 02997 tst_val = RUNNING_DIFF(24); 02998 mask = MASK(24); 02999 tst_val = RUNNING_DIFF(25); 03000 mask = MASK(25); 03001 tst_val = RUNNING_DIFF(26); 03002 mask = MASK(26); 03003 tst_val = RUNNING_DIFF(27); 03004 mask = MASK(27); 03005 tst_val = RUNNING_DIFF(28); 03006 mask = MASK(28); 03007 tst_val = RUNNING_DIFF(29); 03008 if (tst_val >= 0) { 03009 break; 03010 } 03011 } /* for */ 03012 if (tst_val == 0) { 03013 goto EXIT; 03014 } 03015 else if (tst_val > 0) { 03016 last = idx; 03017 } 03018 first = idx - stride + 1; 03019 seg_len = last - first + 1; 03020 stride = STRIDE_CALC(seg_len); 03021 } /* end while seg_len > 32 */ 03022 03023 for (idx = first; idx <= last; idx += 1) { 03024 tst_val = DIFF(1); 03025 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 03026 tst_val = RUNNING_DIFF(2); 03027 mask = MASK(2); 03028 tst_val = RUNNING_DIFF(3); 03029 mask = MASK(3); 03030 tst_val = RUNNING_DIFF(4); 03031 mask = MASK(4); 03032 tst_val = RUNNING_DIFF(5); 03033 mask = MASK(5); 03034 tst_val = RUNNING_DIFF(6); 03035 mask = MASK(6); 03036 tst_val = RUNNING_DIFF(7); 03037 mask = MASK(7); 03038 tst_val = RUNNING_DIFF(8); 03039 mask = MASK(8); 03040 tst_val = RUNNING_DIFF(9); 03041 mask = MASK(9); 03042 tst_val = RUNNING_DIFF(10); 03043 mask = MASK(10); 03044 tst_val = RUNNING_DIFF(11); 03045 mask = MASK(11); 03046 tst_val = RUNNING_DIFF(12); 03047 mask = MASK(12); 03048 tst_val = RUNNING_DIFF(13); 03049 mask = MASK(13); 03050 tst_val = RUNNING_DIFF(14); 03051 mask = MASK(14); 03052 tst_val = RUNNING_DIFF(15); 03053 mask = MASK(15); 03054 tst_val = RUNNING_DIFF(16); 03055 mask = MASK(16); 03056 tst_val = RUNNING_DIFF(17); 03057 mask = MASK(17); 03058 tst_val = RUNNING_DIFF(18); 03059 mask = MASK(18); 03060 tst_val = RUNNING_DIFF(19); 03061 mask = MASK(19); 03062 tst_val = RUNNING_DIFF(20); 03063 mask = MASK(20); 03064 tst_val = RUNNING_DIFF(21); 03065 mask = MASK(21); 03066 tst_val = RUNNING_DIFF(22); 03067 mask = MASK(22); 03068 tst_val = RUNNING_DIFF(23); 03069 mask = MASK(23); 03070 tst_val = RUNNING_DIFF(24); 03071 mask = MASK(24); 03072 tst_val = RUNNING_DIFF(25); 03073 mask = MASK(25); 03074 tst_val = RUNNING_DIFF(26); 03075 mask = MASK(26); 03076 tst_val = RUNNING_DIFF(27); 03077 mask = MASK(27); 03078 tst_val = RUNNING_DIFF(28); 03079 mask = MASK(28); 03080 tst_val = RUNNING_DIFF(29); 03081 if (tst_val >= 0) { 03082 break; 03083 } 03084 } 03085 break; 03086 03087 case 30: 03088 while (seg_len > 32) { 03089 for (idx = first + stride -1 ; idx <= last; idx += stride) { 03090 tst_val = DIFF(1); 03091 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 03092 tst_val = RUNNING_DIFF(2); 03093 mask = MASK(2); 03094 tst_val = RUNNING_DIFF(3); 03095 mask = MASK(3); 03096 tst_val = RUNNING_DIFF(4); 03097 mask = MASK(4); 03098 tst_val = RUNNING_DIFF(5); 03099 mask = MASK(5); 03100 tst_val = RUNNING_DIFF(6); 03101 mask = MASK(6); 03102 tst_val = RUNNING_DIFF(7); 03103 mask = MASK(7); 03104 tst_val = RUNNING_DIFF(8); 03105 mask = MASK(8); 03106 tst_val = RUNNING_DIFF(9); 03107 mask = MASK(9); 03108 tst_val = RUNNING_DIFF(10); 03109 mask = MASK(10); 03110 tst_val = RUNNING_DIFF(11); 03111 mask = MASK(11); 03112 tst_val = RUNNING_DIFF(12); 03113 mask = MASK(12); 03114 tst_val = RUNNING_DIFF(13); 03115 mask = MASK(13); 03116 tst_val = RUNNING_DIFF(14); 03117 mask = MASK(14); 03118 tst_val = RUNNING_DIFF(15); 03119 mask = MASK(15); 03120 tst_val = RUNNING_DIFF(16); 03121 mask = MASK(16); 03122 tst_val = RUNNING_DIFF(17); 03123 mask = MASK(17); 03124 tst_val = RUNNING_DIFF(18); 03125 mask = MASK(18); 03126 tst_val = RUNNING_DIFF(19); 03127 mask = MASK(19); 03128 tst_val = RUNNING_DIFF(20); 03129 mask = MASK(20); 03130 tst_val = RUNNING_DIFF(21); 03131 mask = MASK(21); 03132 tst_val = RUNNING_DIFF(22); 03133 mask = MASK(22); 03134 tst_val = RUNNING_DIFF(23); 03135 mask = MASK(23); 03136 tst_val = RUNNING_DIFF(24); 03137 mask = MASK(24); 03138 tst_val = RUNNING_DIFF(25); 03139 mask = MASK(25); 03140 tst_val = RUNNING_DIFF(26); 03141 mask = MASK(26); 03142 tst_val = RUNNING_DIFF(27); 03143 mask = MASK(27); 03144 tst_val = RUNNING_DIFF(28); 03145 mask = MASK(28); 03146 tst_val = RUNNING_DIFF(29); 03147 mask = MASK(29); 03148 tst_val = RUNNING_DIFF(30); 03149 if (tst_val >= 0) { 03150 break; 03151 } 03152 } /* for */ 03153 if (tst_val == 0) { 03154 goto EXIT; 03155 } 03156 else if (tst_val > 0) { 03157 last = idx; 03158 } 03159 first = idx - stride + 1; 03160 seg_len = last - first + 1; 03161 stride = STRIDE_CALC(seg_len); 03162 } /* end while seg_len > 32 */ 03163 03164 for (idx = first; idx <= last; idx += 1) { 03165 tst_val = DIFF(1); 03166 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 03167 tst_val = RUNNING_DIFF(2); 03168 mask = MASK(2); 03169 tst_val = RUNNING_DIFF(3); 03170 mask = MASK(3); 03171 tst_val = RUNNING_DIFF(4); 03172 mask = MASK(4); 03173 tst_val = RUNNING_DIFF(5); 03174 mask = MASK(5); 03175 tst_val = RUNNING_DIFF(6); 03176 mask = MASK(6); 03177 tst_val = RUNNING_DIFF(7); 03178 mask = MASK(7); 03179 tst_val = RUNNING_DIFF(8); 03180 mask = MASK(8); 03181 tst_val = RUNNING_DIFF(9); 03182 mask = MASK(9); 03183 tst_val = RUNNING_DIFF(10); 03184 mask = MASK(10); 03185 tst_val = RUNNING_DIFF(11); 03186 mask = MASK(11); 03187 tst_val = RUNNING_DIFF(12); 03188 mask = MASK(12); 03189 tst_val = RUNNING_DIFF(13); 03190 mask = MASK(13); 03191 tst_val = RUNNING_DIFF(14); 03192 mask = MASK(14); 03193 tst_val = RUNNING_DIFF(15); 03194 mask = MASK(15); 03195 tst_val = RUNNING_DIFF(16); 03196 mask = MASK(16); 03197 tst_val = RUNNING_DIFF(17); 03198 mask = MASK(17); 03199 tst_val = RUNNING_DIFF(18); 03200 mask = MASK(18); 03201 tst_val = RUNNING_DIFF(19); 03202 mask = MASK(19); 03203 tst_val = RUNNING_DIFF(20); 03204 mask = MASK(20); 03205 tst_val = RUNNING_DIFF(21); 03206 mask = MASK(21); 03207 tst_val = RUNNING_DIFF(22); 03208 mask = MASK(22); 03209 tst_val = RUNNING_DIFF(23); 03210 mask = MASK(23); 03211 tst_val = RUNNING_DIFF(24); 03212 mask = MASK(24); 03213 tst_val = RUNNING_DIFF(25); 03214 mask = MASK(25); 03215 tst_val = RUNNING_DIFF(26); 03216 mask = MASK(26); 03217 tst_val = RUNNING_DIFF(27); 03218 mask = MASK(27); 03219 tst_val = RUNNING_DIFF(28); 03220 mask = MASK(28); 03221 tst_val = RUNNING_DIFF(29); 03222 mask = MASK(29); 03223 tst_val = RUNNING_DIFF(30); 03224 if (tst_val >= 0) { 03225 break; 03226 } 03227 } 03228 break; 03229 03230 case 31: 03231 while (seg_len > 32) { 03232 for (idx = first + stride -1 ; idx <= last; idx += stride) { 03233 tst_val = DIFF(1); 03234 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 03235 tst_val = RUNNING_DIFF(2); 03236 mask = MASK(2); 03237 tst_val = RUNNING_DIFF(3); 03238 mask = MASK(3); 03239 tst_val = RUNNING_DIFF(4); 03240 mask = MASK(4); 03241 tst_val = RUNNING_DIFF(5); 03242 mask = MASK(5); 03243 tst_val = RUNNING_DIFF(6); 03244 mask = MASK(6); 03245 tst_val = RUNNING_DIFF(7); 03246 mask = MASK(7); 03247 tst_val = RUNNING_DIFF(8); 03248 mask = MASK(8); 03249 tst_val = RUNNING_DIFF(9); 03250 mask = MASK(9); 03251 tst_val = RUNNING_DIFF(10); 03252 mask = MASK(10); 03253 tst_val = RUNNING_DIFF(11); 03254 mask = MASK(11); 03255 tst_val = RUNNING_DIFF(12); 03256 mask = MASK(12); 03257 tst_val = RUNNING_DIFF(13); 03258 mask = MASK(13); 03259 tst_val = RUNNING_DIFF(14); 03260 mask = MASK(14); 03261 tst_val = RUNNING_DIFF(15); 03262 mask = MASK(15); 03263 tst_val = RUNNING_DIFF(16); 03264 mask = MASK(16); 03265 tst_val = RUNNING_DIFF(17); 03266 mask = MASK(17); 03267 tst_val = RUNNING_DIFF(18); 03268 mask = MASK(18); 03269 tst_val = RUNNING_DIFF(19); 03270 mask = MASK(19); 03271 tst_val = RUNNING_DIFF(20); 03272 mask = MASK(20); 03273 tst_val = RUNNING_DIFF(21); 03274 mask = MASK(21); 03275 tst_val = RUNNING_DIFF(22); 03276 mask = MASK(22); 03277 tst_val = RUNNING_DIFF(23); 03278 mask = MASK(23); 03279 tst_val = RUNNING_DIFF(24); 03280 mask = MASK(24); 03281 tst_val = RUNNING_DIFF(25); 03282 mask = MASK(25); 03283 tst_val = RUNNING_DIFF(26); 03284 mask = MASK(26); 03285 tst_val = RUNNING_DIFF(27); 03286 mask = MASK(27); 03287 tst_val = RUNNING_DIFF(28); 03288 mask = MASK(28); 03289 tst_val = RUNNING_DIFF(29); 03290 mask = MASK(29); 03291 tst_val = RUNNING_DIFF(30); 03292 mask = MASK(30); 03293 tst_val = RUNNING_DIFF(31); 03294 if (tst_val >= 0) { 03295 break; 03296 } 03297 } /* for */ 03298 if (tst_val == 0) { 03299 goto EXIT; 03300 } 03301 else if (tst_val > 0) { 03302 last = idx; 03303 } 03304 first = idx - stride + 1; 03305 seg_len = last - first + 1; 03306 stride = STRIDE_CALC(seg_len); 03307 } /* end while seg_len > 32 */ 03308 03309 for (idx = first; idx <= last; idx += 1) { 03310 tst_val = DIFF(1); 03311 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 03312 tst_val = RUNNING_DIFF(2); 03313 mask = MASK(2); 03314 tst_val = RUNNING_DIFF(3); 03315 mask = MASK(3); 03316 tst_val = RUNNING_DIFF(4); 03317 mask = MASK(4); 03318 tst_val = RUNNING_DIFF(5); 03319 mask = MASK(5); 03320 tst_val = RUNNING_DIFF(6); 03321 mask = MASK(6); 03322 tst_val = RUNNING_DIFF(7); 03323 mask = MASK(7); 03324 tst_val = RUNNING_DIFF(8); 03325 mask = MASK(8); 03326 tst_val = RUNNING_DIFF(9); 03327 mask = MASK(9); 03328 tst_val = RUNNING_DIFF(10); 03329 mask = MASK(10); 03330 tst_val = RUNNING_DIFF(11); 03331 mask = MASK(11); 03332 tst_val = RUNNING_DIFF(12); 03333 mask = MASK(12); 03334 tst_val = RUNNING_DIFF(13); 03335 mask = MASK(13); 03336 tst_val = RUNNING_DIFF(14); 03337 mask = MASK(14); 03338 tst_val = RUNNING_DIFF(15); 03339 mask = MASK(15); 03340 tst_val = RUNNING_DIFF(16); 03341 mask = MASK(16); 03342 tst_val = RUNNING_DIFF(17); 03343 mask = MASK(17); 03344 tst_val = RUNNING_DIFF(18); 03345 mask = MASK(18); 03346 tst_val = RUNNING_DIFF(19); 03347 mask = MASK(19); 03348 tst_val = RUNNING_DIFF(20); 03349 mask = MASK(20); 03350 tst_val = RUNNING_DIFF(21); 03351 mask = MASK(21); 03352 tst_val = RUNNING_DIFF(22); 03353 mask = MASK(22); 03354 tst_val = RUNNING_DIFF(23); 03355 mask = MASK(23); 03356 tst_val = RUNNING_DIFF(24); 03357 mask = MASK(24); 03358 tst_val = RUNNING_DIFF(25); 03359 mask = MASK(25); 03360 tst_val = RUNNING_DIFF(26); 03361 mask = MASK(26); 03362 tst_val = RUNNING_DIFF(27); 03363 mask = MASK(27); 03364 tst_val = RUNNING_DIFF(28); 03365 mask = MASK(28); 03366 tst_val = RUNNING_DIFF(29); 03367 mask = MASK(29); 03368 tst_val = RUNNING_DIFF(30); 03369 mask = MASK(30); 03370 tst_val = RUNNING_DIFF(31); 03371 if (tst_val >= 0) { 03372 break; 03373 } 03374 } 03375 break; 03376 03377 case 32: 03378 while (seg_len > 32) { 03379 for (idx = first + stride -1 ; idx <= last; idx += stride) { 03380 tst_val = DIFF(1); 03381 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 03382 tst_val = RUNNING_DIFF(2); 03383 mask = MASK(2); 03384 tst_val = RUNNING_DIFF(3); 03385 mask = MASK(3); 03386 tst_val = RUNNING_DIFF(4); 03387 mask = MASK(4); 03388 tst_val = RUNNING_DIFF(5); 03389 mask = MASK(5); 03390 tst_val = RUNNING_DIFF(6); 03391 mask = MASK(6); 03392 tst_val = RUNNING_DIFF(7); 03393 mask = MASK(7); 03394 tst_val = RUNNING_DIFF(8); 03395 mask = MASK(8); 03396 tst_val = RUNNING_DIFF(9); 03397 mask = MASK(9); 03398 tst_val = RUNNING_DIFF(10); 03399 mask = MASK(10); 03400 tst_val = RUNNING_DIFF(11); 03401 mask = MASK(11); 03402 tst_val = RUNNING_DIFF(12); 03403 mask = MASK(12); 03404 tst_val = RUNNING_DIFF(13); 03405 mask = MASK(13); 03406 tst_val = RUNNING_DIFF(14); 03407 mask = MASK(14); 03408 tst_val = RUNNING_DIFF(15); 03409 mask = MASK(15); 03410 tst_val = RUNNING_DIFF(16); 03411 mask = MASK(16); 03412 tst_val = RUNNING_DIFF(17); 03413 mask = MASK(17); 03414 tst_val = RUNNING_DIFF(18); 03415 mask = MASK(18); 03416 tst_val = RUNNING_DIFF(19); 03417 mask = MASK(19); 03418 tst_val = RUNNING_DIFF(20); 03419 mask = MASK(20); 03420 tst_val = RUNNING_DIFF(21); 03421 mask = MASK(21); 03422 tst_val = RUNNING_DIFF(22); 03423 mask = MASK(22); 03424 tst_val = RUNNING_DIFF(23); 03425 mask = MASK(23); 03426 tst_val = RUNNING_DIFF(24); 03427 mask = MASK(24); 03428 tst_val = RUNNING_DIFF(25); 03429 mask = MASK(25); 03430 tst_val = RUNNING_DIFF(26); 03431 mask = MASK(26); 03432 tst_val = RUNNING_DIFF(27); 03433 mask = MASK(27); 03434 tst_val = RUNNING_DIFF(28); 03435 mask = MASK(28); 03436 tst_val = RUNNING_DIFF(29); 03437 mask = MASK(29); 03438 tst_val = RUNNING_DIFF(30); 03439 mask = MASK(30); 03440 tst_val = RUNNING_DIFF(31); 03441 mask = MASK(31); 03442 tst_val = RUNNING_DIFF(32); 03443 if (tst_val >= 0) { 03444 break; 03445 } 03446 } /* for */ 03447 if (tst_val == 0) { 03448 goto EXIT; 03449 } 03450 else if (tst_val > 0) { 03451 last = idx; 03452 } 03453 first = idx - stride + 1; 03454 seg_len = last - first + 1; 03455 stride = STRIDE_CALC(seg_len); 03456 } /* end while seg_len > 32 */ 03457 03458 for (idx = first; idx <= last; idx += 1) { 03459 tst_val = DIFF(1); 03460 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 03461 tst_val = RUNNING_DIFF(2); 03462 mask = MASK(2); 03463 tst_val = RUNNING_DIFF(3); 03464 mask = MASK(3); 03465 tst_val = RUNNING_DIFF(4); 03466 mask = MASK(4); 03467 tst_val = RUNNING_DIFF(5); 03468 mask = MASK(5); 03469 tst_val = RUNNING_DIFF(6); 03470 mask = MASK(6); 03471 tst_val = RUNNING_DIFF(7); 03472 mask = MASK(7); 03473 tst_val = RUNNING_DIFF(8); 03474 mask = MASK(8); 03475 tst_val = RUNNING_DIFF(9); 03476 mask = MASK(9); 03477 tst_val = RUNNING_DIFF(10); 03478 mask = MASK(10); 03479 tst_val = RUNNING_DIFF(11); 03480 mask = MASK(11); 03481 tst_val = RUNNING_DIFF(12); 03482 mask = MASK(12); 03483 tst_val = RUNNING_DIFF(13); 03484 mask = MASK(13); 03485 tst_val = RUNNING_DIFF(14); 03486 mask = MASK(14); 03487 tst_val = RUNNING_DIFF(15); 03488 mask = MASK(15); 03489 tst_val = RUNNING_DIFF(16); 03490 mask = MASK(16); 03491 tst_val = RUNNING_DIFF(17); 03492 mask = MASK(17); 03493 tst_val = RUNNING_DIFF(18); 03494 mask = MASK(18); 03495 tst_val = RUNNING_DIFF(19); 03496 mask = MASK(19); 03497 tst_val = RUNNING_DIFF(20); 03498 mask = MASK(20); 03499 tst_val = RUNNING_DIFF(21); 03500 mask = MASK(21); 03501 tst_val = RUNNING_DIFF(22); 03502 mask = MASK(22); 03503 tst_val = RUNNING_DIFF(23); 03504 mask = MASK(23); 03505 tst_val = RUNNING_DIFF(24); 03506 mask = MASK(24); 03507 tst_val = RUNNING_DIFF(25); 03508 mask = MASK(25); 03509 tst_val = RUNNING_DIFF(26); 03510 mask = MASK(26); 03511 tst_val = RUNNING_DIFF(27); 03512 mask = MASK(27); 03513 tst_val = RUNNING_DIFF(28); 03514 mask = MASK(28); 03515 tst_val = RUNNING_DIFF(29); 03516 mask = MASK(29); 03517 tst_val = RUNNING_DIFF(30); 03518 mask = MASK(30); 03519 tst_val = RUNNING_DIFF(31); 03520 mask = MASK(31); 03521 tst_val = RUNNING_DIFF(32); 03522 if (tst_val >= 0) { 03523 break; 03524 } 03525 } 03526 break; 03527 03528 case 33: 03529 while (seg_len > 32) { 03530 for (idx = first + stride -1 ; idx <= last; idx += stride) { 03531 tst_val = DIFF(1); 03532 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 03533 tst_val = RUNNING_DIFF(2); 03534 mask = MASK(2); 03535 tst_val = RUNNING_DIFF(3); 03536 mask = MASK(3); 03537 tst_val = RUNNING_DIFF(4); 03538 mask = MASK(4); 03539 tst_val = RUNNING_DIFF(5); 03540 mask = MASK(5); 03541 tst_val = RUNNING_DIFF(6); 03542 mask = MASK(6); 03543 tst_val = RUNNING_DIFF(7); 03544 mask = MASK(7); 03545 tst_val = RUNNING_DIFF(8); 03546 mask = MASK(8); 03547 tst_val = RUNNING_DIFF(9); 03548 mask = MASK(9); 03549 tst_val = RUNNING_DIFF(10); 03550 mask = MASK(10); 03551 tst_val = RUNNING_DIFF(11); 03552 mask = MASK(11); 03553 tst_val = RUNNING_DIFF(12); 03554 mask = MASK(12); 03555 tst_val = RUNNING_DIFF(13); 03556 mask = MASK(13); 03557 tst_val = RUNNING_DIFF(14); 03558 mask = MASK(14); 03559 tst_val = RUNNING_DIFF(15); 03560 mask = MASK(15); 03561 tst_val = RUNNING_DIFF(16); 03562 mask = MASK(16); 03563 tst_val = RUNNING_DIFF(17); 03564 mask = MASK(17); 03565 tst_val = RUNNING_DIFF(18); 03566 mask = MASK(18); 03567 tst_val = RUNNING_DIFF(19); 03568 mask = MASK(19); 03569 tst_val = RUNNING_DIFF(20); 03570 mask = MASK(20); 03571 tst_val = RUNNING_DIFF(21); 03572 mask = MASK(21); 03573 tst_val = RUNNING_DIFF(22); 03574 mask = MASK(22); 03575 tst_val = RUNNING_DIFF(23); 03576 mask = MASK(23); 03577 tst_val = RUNNING_DIFF(24); 03578 mask = MASK(24); 03579 tst_val = RUNNING_DIFF(25); 03580 mask = MASK(25); 03581 tst_val = RUNNING_DIFF(26); 03582 mask = MASK(26); 03583 tst_val = RUNNING_DIFF(27); 03584 mask = MASK(27); 03585 tst_val = RUNNING_DIFF(28); 03586 mask = MASK(28); 03587 tst_val = RUNNING_DIFF(29); 03588 mask = MASK(29); 03589 tst_val = RUNNING_DIFF(30); 03590 mask = MASK(30); 03591 tst_val = RUNNING_DIFF(31); 03592 mask = MASK(31); 03593 tst_val = RUNNING_DIFF(32); 03594 mask = MASK(32); 03595 tst_val = RUNNING_DIFF(33); 03596 if (tst_val >= 0) { 03597 break; 03598 } 03599 } /* for */ 03600 if (tst_val == 0) { 03601 goto EXIT; 03602 } 03603 else if (tst_val > 0) { 03604 last = idx; 03605 } 03606 first = idx - stride + 1; 03607 seg_len = last - first + 1; 03608 stride = STRIDE_CALC(seg_len); 03609 } /* end while seg_len > 32 */ 03610 03611 for (idx = first; idx <= last; idx += 1) { 03612 tst_val = DIFF(1); 03613 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 03614 tst_val = RUNNING_DIFF(2); 03615 mask = MASK(2); 03616 tst_val = RUNNING_DIFF(3); 03617 mask = MASK(3); 03618 tst_val = RUNNING_DIFF(4); 03619 mask = MASK(4); 03620 tst_val = RUNNING_DIFF(5); 03621 mask = MASK(5); 03622 tst_val = RUNNING_DIFF(6); 03623 mask = MASK(6); 03624 tst_val = RUNNING_DIFF(7); 03625 mask = MASK(7); 03626 tst_val = RUNNING_DIFF(8); 03627 mask = MASK(8); 03628 tst_val = RUNNING_DIFF(9); 03629 mask = MASK(9); 03630 tst_val = RUNNING_DIFF(10); 03631 mask = MASK(10); 03632 tst_val = RUNNING_DIFF(11); 03633 mask = MASK(11); 03634 tst_val = RUNNING_DIFF(12); 03635 mask = MASK(12); 03636 tst_val = RUNNING_DIFF(13); 03637 mask = MASK(13); 03638 tst_val = RUNNING_DIFF(14); 03639 mask = MASK(14); 03640 tst_val = RUNNING_DIFF(15); 03641 mask = MASK(15); 03642 tst_val = RUNNING_DIFF(16); 03643 mask = MASK(16); 03644 tst_val = RUNNING_DIFF(17); 03645 mask = MASK(17); 03646 tst_val = RUNNING_DIFF(18); 03647 mask = MASK(18); 03648 tst_val = RUNNING_DIFF(19); 03649 mask = MASK(19); 03650 tst_val = RUNNING_DIFF(20); 03651 mask = MASK(20); 03652 tst_val = RUNNING_DIFF(21); 03653 mask = MASK(21); 03654 tst_val = RUNNING_DIFF(22); 03655 mask = MASK(22); 03656 tst_val = RUNNING_DIFF(23); 03657 mask = MASK(23); 03658 tst_val = RUNNING_DIFF(24); 03659 mask = MASK(24); 03660 tst_val = RUNNING_DIFF(25); 03661 mask = MASK(25); 03662 tst_val = RUNNING_DIFF(26); 03663 mask = MASK(26); 03664 tst_val = RUNNING_DIFF(27); 03665 mask = MASK(27); 03666 tst_val = RUNNING_DIFF(28); 03667 mask = MASK(28); 03668 tst_val = RUNNING_DIFF(29); 03669 mask = MASK(29); 03670 tst_val = RUNNING_DIFF(30); 03671 mask = MASK(30); 03672 tst_val = RUNNING_DIFF(31); 03673 mask = MASK(31); 03674 tst_val = RUNNING_DIFF(32); 03675 mask = MASK(32); 03676 tst_val = RUNNING_DIFF(33); 03677 if (tst_val >= 0) { 03678 break; 03679 } 03680 } 03681 break; 03682 03683 case 34: 03684 while (seg_len > 32) { 03685 for (idx = first + stride -1 ; idx <= last; idx += stride) { 03686 tst_val = DIFF(1); 03687 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 03688 tst_val = RUNNING_DIFF(2); 03689 mask = MASK(2); 03690 tst_val = RUNNING_DIFF(3); 03691 mask = MASK(3); 03692 tst_val = RUNNING_DIFF(4); 03693 mask = MASK(4); 03694 tst_val = RUNNING_DIFF(5); 03695 mask = MASK(5); 03696 tst_val = RUNNING_DIFF(6); 03697 mask = MASK(6); 03698 tst_val = RUNNING_DIFF(7); 03699 mask = MASK(7); 03700 tst_val = RUNNING_DIFF(8); 03701 mask = MASK(8); 03702 tst_val = RUNNING_DIFF(9); 03703 mask = MASK(9); 03704 tst_val = RUNNING_DIFF(10); 03705 mask = MASK(10); 03706 tst_val = RUNNING_DIFF(11); 03707 mask = MASK(11); 03708 tst_val = RUNNING_DIFF(12); 03709 mask = MASK(12); 03710 tst_val = RUNNING_DIFF(13); 03711 mask = MASK(13); 03712 tst_val = RUNNING_DIFF(14); 03713 mask = MASK(14); 03714 tst_val = RUNNING_DIFF(15); 03715 mask = MASK(15); 03716 tst_val = RUNNING_DIFF(16); 03717 mask = MASK(16); 03718 tst_val = RUNNING_DIFF(17); 03719 mask = MASK(17); 03720 tst_val = RUNNING_DIFF(18); 03721 mask = MASK(18); 03722 tst_val = RUNNING_DIFF(19); 03723 mask = MASK(19); 03724 tst_val = RUNNING_DIFF(20); 03725 mask = MASK(20); 03726 tst_val = RUNNING_DIFF(21); 03727 mask = MASK(21); 03728 tst_val = RUNNING_DIFF(22); 03729 mask = MASK(22); 03730 tst_val = RUNNING_DIFF(23); 03731 mask = MASK(23); 03732 tst_val = RUNNING_DIFF(24); 03733 mask = MASK(24); 03734 tst_val = RUNNING_DIFF(25); 03735 mask = MASK(25); 03736 tst_val = RUNNING_DIFF(26); 03737 mask = MASK(26); 03738 tst_val = RUNNING_DIFF(27); 03739 mask = MASK(27); 03740 tst_val = RUNNING_DIFF(28); 03741 mask = MASK(28); 03742 tst_val = RUNNING_DIFF(29); 03743 mask = MASK(29); 03744 tst_val = RUNNING_DIFF(30); 03745 mask = MASK(30); 03746 tst_val = RUNNING_DIFF(31); 03747 mask = MASK(31); 03748 tst_val = RUNNING_DIFF(32); 03749 mask = MASK(32); 03750 tst_val = RUNNING_DIFF(33); 03751 mask = MASK(33); 03752 tst_val = RUNNING_DIFF(34); 03753 if (tst_val >= 0) { 03754 break; 03755 } 03756 } /* for */ 03757 if (tst_val == 0) { 03758 goto EXIT; 03759 } 03760 else if (tst_val > 0) { 03761 last = idx; 03762 } 03763 first = idx - stride + 1; 03764 seg_len = last - first + 1; 03765 stride = STRIDE_CALC(seg_len); 03766 } /* end while seg_len > 32 */ 03767 03768 for (idx = first; idx <= last; idx += 1) { 03769 tst_val = DIFF(1); 03770 mask = -(RIGHT_JUSTIFY_SIGN_BIT(DIFF(1) | -DIFF(1))); 03771 tst_val = RUNNING_DIFF(2); 03772 mask = MASK(2); 03773 tst_val = RUNNING_DIFF(3); 03774 mask = MASK(3); 03775 tst_val = RUNNING_DIFF(4); 03776 mask = MASK(4); 03777 tst_val = RUNNING_DIFF(5); 03778 mask = MASK(5); 03779 tst_val = RUNNING_DIFF(6); 03780 mask = MASK(6); 03781 tst_val = RUNNING_DIFF(7); 03782 mask = MASK(7); 03783 tst_val = RUNNING_DIFF(8); 03784 mask = MASK(8); 03785 tst_val = RUNNING_DIFF(9); 03786 mask = MASK(9); 03787 tst_val = RUNNING_DIFF(10); 03788 mask = MASK(10); 03789 tst_val = RUNNING_DIFF(11); 03790 mask = MASK(11); 03791 tst_val = RUNNING_DIFF(12); 03792 mask = MASK(12); 03793 tst_val = RUNNING_DIFF(13); 03794 mask = MASK(13); 03795 tst_val = RUNNING_DIFF(14); 03796 mask = MASK(14); 03797 tst_val = RUNNING_DIFF(15); 03798 mask = MASK(15); 03799 tst_val = RUNNING_DIFF(16); 03800 mask = MASK(16); 03801 tst_val = RUNNING_DIFF(17); 03802 mask = MASK(17); 03803 tst_val = RUNNING_DIFF(18); 03804 mask = MASK(18); 03805 tst_val = RUNNING_DIFF(19); 03806 mask = MASK(19); 03807 tst_val = RUNNING_DIFF(20); 03808 mask = MASK(20); 03809 tst_val = RUNNING_DIFF(21); 03810 mask = MASK(21); 03811 tst_val = RUNNING_DIFF(22); 03812 mask = MASK(22); 03813 tst_val = RUNNING_DIFF(23); 03814 mask = MASK(23); 03815 tst_val = RUNNING_DIFF(24); 03816 mask = MASK(24); 03817 tst_val = RUNNING_DIFF(25); 03818 mask = MASK(25); 03819 tst_val = RUNNING_DIFF(26); 03820 mask = MASK(26); 03821 tst_val = RUNNING_DIFF(27); 03822 mask = MASK(27); 03823 tst_val = RUNNING_DIFF(28); 03824 mask = MASK(28); 03825 tst_val = RUNNING_DIFF(29); 03826 mask = MASK(29); 03827 tst_val = RUNNING_DIFF(30); 03828 mask = MASK(30); 03829 tst_val = RUNNING_DIFF(31); 03830 mask = MASK(31); 03831 tst_val = RUNNING_DIFF(32); 03832 mask = MASK(32); 03833 tst_val = RUNNING_DIFF(33); 03834 mask = MASK(33); 03835 tst_val = RUNNING_DIFF(34); 03836 if (tst_val >= 0) { 03837 break; 03838 } 03839 } 03840 break; 03841 # endif 03842 /* # endif */ /* if 0 */ 03843 03844 default: 03845 03846 PRINTMSG(stmt_start_line, 196, Internal, 1, 03847 "srch_name_tbl", 256); 03848 break; 03849 } /* switch (id_len) */ 03850 03851 EXIT: 03852 03853 *name_idx = idx; 03854 03855 TRACE (Func_Exit, "srch_name_tbl", NULL); 03856 03857 return (tst_val); 03858 03859 } /* srch_name_tbl */ 03860 /******************************************************************************\ 03861 |* *| 03862 |* Description: *| 03863 |* *| 03864 |* Convert a host integer to a string to be used in printf. *| 03865 |* *| 03866 |* Input parameters: *| 03867 |* the_constant : address of the constant to be "converted" *| 03868 |* type_idx : the data type of the constant (index into Type Table) *| 03869 |* *| 03870 |* Output parameters: *| 03871 |* result : the_constant converted to a string (also returned as *| 03872 |* the result of this function) *| 03873 |* *| 03874 |* Returns: *| 03875 |* A character string version of the_constant (in result). *| 03876 |* *| 03877 \******************************************************************************/ 03878 03879 char * convert_cval_to_string (long64 *the_constant, 03880 int type_idx, 03881 char *result) 03882 03883 { 03884 long_type cn_val[MAX_WORDS_FOR_INTEGER]; 03885 03886 03887 TRACE (Func_Entry, "convert_cval_to_string", NULL); 03888 03889 C_TO_F_INT(cn_val, *the_constant, TYP_LINEAR(type_idx)); 03890 03891 result = convert_to_string(cn_val, 03892 type_idx, 03893 result); 03894 03895 TRACE (Func_Exit, "convert_cval_to_string", NULL); 03896 03897 return(result); 03898 03899 } /* convert_cval_to_string */
1.7.6.1 
