1 /* 2 * Copyright (C) 1984-2009 Mark Nudelman 3 * 4 * You may distribute under the terms of either the GNU General Public 5 * License or the Less License, as specified in the README file. 6 * 7 * For more information about less, or for information on how to 8 * contact the author, see the README file. 9 */ 10 11 12 /* 13 * High level routines dealing with getting lines of input 14 * from the file being viewed. 15 * 16 * When we speak of "lines" here, we mean PRINTABLE lines; 17 * lines processed with respect to the screen width. 18 * We use the term "raw line" to refer to lines simply 19 * delimited by newlines; not processed with respect to screen width. 20 */ 21 22 #include "less.h" 23 24 extern int squeeze; 25 extern int chopline; 26 extern int hshift; 27 extern int quit_if_one_screen; 28 extern int sigs; 29 extern int ignore_eoi; 30 extern int status_col; 31 extern POSITION start_attnpos; 32 extern POSITION end_attnpos; 33 #if HILITE_SEARCH 34 extern int hilite_search; 35 extern int size_linebuf; 36 #endif 37 38 /* 39 * Get the next line. 40 * A "current" position is passed and a "new" position is returned. 41 * The current position is the position of the first character of 42 * a line. The new position is the position of the first character 43 * of the NEXT line. The line obtained is the line starting at curr_pos. 44 */ 45 public POSITION 46 forw_line(curr_pos) 47 POSITION curr_pos; 48 { 49 POSITION base_pos; 50 POSITION new_pos; 51 register int c; 52 int blankline; 53 int endline; 54 int backchars; 55 56 get_forw_line: 57 if (curr_pos == NULL_POSITION) 58 { 59 null_line(); 60 return (NULL_POSITION); 61 } 62 #if HILITE_SEARCH 63 if (hilite_search == OPT_ONPLUS || is_filtering() || status_col) 64 /* 65 * If we are ignoring EOI (command F), only prepare 66 * one line ahead, to avoid getting stuck waiting for 67 * slow data without displaying the data we already have. 68 * If we're not ignoring EOI, we *could* do the same, but 69 * for efficiency we prepare several lines ahead at once. 70 */ 71 prep_hilite(curr_pos, curr_pos + 3*size_linebuf, 72 ignore_eoi ? 1 : -1); 73 #endif 74 if (ch_seek(curr_pos)) 75 { 76 null_line(); 77 return (NULL_POSITION); 78 } 79 80 /* 81 * Step back to the beginning of the line. 82 */ 83 base_pos = curr_pos; 84 for (;;) 85 { 86 if (ABORT_SIGS()) 87 { 88 null_line(); 89 return (NULL_POSITION); 90 } 91 c = ch_back_get(); 92 if (c == EOI) 93 break; 94 if (c == '\n') 95 { 96 (void) ch_forw_get(); 97 break; 98 } 99 --base_pos; 100 } 101 102 /* 103 * Read forward again to the position we should start at. 104 */ 105 prewind(); 106 plinenum(base_pos); 107 (void) ch_seek(base_pos); 108 new_pos = base_pos; 109 while (new_pos < curr_pos) 110 { 111 if (ABORT_SIGS()) 112 { 113 null_line(); 114 return (NULL_POSITION); 115 } 116 c = ch_forw_get(); 117 backchars = pappend(c, new_pos); 118 new_pos++; 119 if (backchars > 0) 120 { 121 pshift_all(); 122 new_pos -= backchars; 123 while (--backchars >= 0) 124 (void) ch_back_get(); 125 } 126 } 127 (void) pflushmbc(); 128 pshift_all(); 129 130 /* 131 * Read the first character to display. 132 */ 133 c = ch_forw_get(); 134 if (c == EOI) 135 { 136 null_line(); 137 return (NULL_POSITION); 138 } 139 blankline = (c == '\n' || c == '\r'); 140 141 /* 142 * Read each character in the line and append to the line buffer. 143 */ 144 for (;;) 145 { 146 if (ABORT_SIGS()) 147 { 148 null_line(); 149 return (NULL_POSITION); 150 } 151 if (c == '\n' || c == EOI) 152 { 153 /* 154 * End of the line. 155 */ 156 backchars = pflushmbc(); 157 new_pos = ch_tell(); 158 if (backchars > 0 && !chopline && hshift == 0) 159 { 160 new_pos -= backchars + 1; 161 endline = FALSE; 162 } else 163 endline = TRUE; 164 break; 165 } 166 if (c != '\r') 167 blankline = 0; 168 169 /* 170 * Append the char to the line and get the next char. 171 */ 172 backchars = pappend(c, ch_tell()-1); 173 if (backchars > 0) 174 { 175 /* 176 * The char won't fit in the line; the line 177 * is too long to print in the screen width. 178 * End the line here. 179 */ 180 if (chopline || hshift > 0) 181 { 182 do 183 { 184 c = ch_forw_get(); 185 } while (c != '\n' && c != EOI); 186 new_pos = ch_tell(); 187 endline = TRUE; 188 quit_if_one_screen = FALSE; 189 } else 190 { 191 new_pos = ch_tell() - backchars; 192 endline = FALSE; 193 } 194 break; 195 } 196 c = ch_forw_get(); 197 } 198 199 pdone(endline, 1); 200 201 #if HILITE_SEARCH 202 if (is_filtered(base_pos)) 203 { 204 /* 205 * We don't want to display this line. 206 * Get the next line. 207 */ 208 curr_pos = new_pos; 209 goto get_forw_line; 210 } 211 212 if (status_col && is_hilited(base_pos, ch_tell()-1, 1, NULL)) 213 set_status_col('*'); 214 #endif 215 216 if (squeeze && blankline) 217 { 218 /* 219 * This line is blank. 220 * Skip down to the last contiguous blank line 221 * and pretend it is the one which we are returning. 222 */ 223 while ((c = ch_forw_get()) == '\n' || c == '\r') 224 if (ABORT_SIGS()) 225 { 226 null_line(); 227 return (NULL_POSITION); 228 } 229 if (c != EOI) 230 (void) ch_back_get(); 231 new_pos = ch_tell(); 232 } 233 234 return (new_pos); 235 } 236 237 /* 238 * Get the previous line. 239 * A "current" position is passed and a "new" position is returned. 240 * The current position is the position of the first character of 241 * a line. The new position is the position of the first character 242 * of the PREVIOUS line. The line obtained is the one starting at new_pos. 243 */ 244 public POSITION 245 back_line(curr_pos) 246 POSITION curr_pos; 247 { 248 POSITION new_pos, begin_new_pos, base_pos; 249 int c; 250 int endline; 251 int backchars; 252 253 get_back_line: 254 if (curr_pos == NULL_POSITION || curr_pos <= ch_zero()) 255 { 256 null_line(); 257 return (NULL_POSITION); 258 } 259 #if HILITE_SEARCH 260 if (hilite_search == OPT_ONPLUS || is_filtering() || status_col) 261 prep_hilite((curr_pos < 3*size_linebuf) ? 262 0 : curr_pos - 3*size_linebuf, curr_pos, -1); 263 #endif 264 if (ch_seek(curr_pos-1)) 265 { 266 null_line(); 267 return (NULL_POSITION); 268 } 269 270 if (squeeze) 271 { 272 /* 273 * Find out if the "current" line was blank. 274 */ 275 (void) ch_forw_get(); /* Skip the newline */ 276 c = ch_forw_get(); /* First char of "current" line */ 277 (void) ch_back_get(); /* Restore our position */ 278 (void) ch_back_get(); 279 280 if (c == '\n' || c == '\r') 281 { 282 /* 283 * The "current" line was blank. 284 * Skip over any preceding blank lines, 285 * since we skipped them in forw_line(). 286 */ 287 while ((c = ch_back_get()) == '\n' || c == '\r') 288 if (ABORT_SIGS()) 289 { 290 null_line(); 291 return (NULL_POSITION); 292 } 293 if (c == EOI) 294 { 295 null_line(); 296 return (NULL_POSITION); 297 } 298 (void) ch_forw_get(); 299 } 300 } 301 302 /* 303 * Scan backwards until we hit the beginning of the line. 304 */ 305 for (;;) 306 { 307 if (ABORT_SIGS()) 308 { 309 null_line(); 310 return (NULL_POSITION); 311 } 312 c = ch_back_get(); 313 if (c == '\n') 314 { 315 /* 316 * This is the newline ending the previous line. 317 * We have hit the beginning of the line. 318 */ 319 base_pos = ch_tell() + 1; 320 break; 321 } 322 if (c == EOI) 323 { 324 /* 325 * We have hit the beginning of the file. 326 * This must be the first line in the file. 327 * This must, of course, be the beginning of the line. 328 */ 329 base_pos = ch_tell(); 330 break; 331 } 332 } 333 334 /* 335 * Now scan forwards from the beginning of this line. 336 * We keep discarding "printable lines" (based on screen width) 337 * until we reach the curr_pos. 338 * 339 * {{ This algorithm is pretty inefficient if the lines 340 * are much longer than the screen width, 341 * but I don't know of any better way. }} 342 */ 343 new_pos = base_pos; 344 if (ch_seek(new_pos)) 345 { 346 null_line(); 347 return (NULL_POSITION); 348 } 349 endline = FALSE; 350 prewind(); 351 plinenum(new_pos); 352 loop: 353 begin_new_pos = new_pos; 354 (void) ch_seek(new_pos); 355 356 do 357 { 358 c = ch_forw_get(); 359 if (c == EOI || ABORT_SIGS()) 360 { 361 null_line(); 362 return (NULL_POSITION); 363 } 364 new_pos++; 365 if (c == '\n') 366 { 367 backchars = pflushmbc(); 368 if (backchars > 0 && !chopline && hshift == 0) 369 { 370 backchars++; 371 goto shift; 372 } 373 endline = TRUE; 374 break; 375 } 376 backchars = pappend(c, ch_tell()-1); 377 if (backchars > 0) 378 { 379 /* 380 * Got a full printable line, but we haven't 381 * reached our curr_pos yet. Discard the line 382 * and start a new one. 383 */ 384 if (chopline || hshift > 0) 385 { 386 endline = TRUE; 387 quit_if_one_screen = FALSE; 388 break; 389 } 390 shift: 391 pshift_all(); 392 while (backchars-- > 0) 393 { 394 (void) ch_back_get(); 395 new_pos--; 396 } 397 goto loop; 398 } 399 } while (new_pos < curr_pos); 400 401 pdone(endline, 0); 402 403 #if HILITE_SEARCH 404 if (is_filtered(base_pos)) 405 { 406 /* 407 * We don't want to display this line. 408 * Get the previous line. 409 */ 410 curr_pos = begin_new_pos; 411 goto get_back_line; 412 } 413 414 if (status_col && is_hilited(base_pos, ch_tell()-1, 1, NULL)) 415 set_status_col('*'); 416 #endif 417 418 return (begin_new_pos); 419 } 420 421 /* 422 * Set attnpos. 423 */ 424 public void 425 set_attnpos(pos) 426 POSITION pos; 427 { 428 int c; 429 430 if (pos != NULL_POSITION) 431 { 432 if (ch_seek(pos)) 433 return; 434 for (;;) 435 { 436 c = ch_forw_get(); 437 if (c == EOI) 438 return; 439 if (c != '\n' && c != '\r') 440 break; 441 pos++; 442 } 443 } 444 start_attnpos = pos; 445 for (;;) 446 { 447 c = ch_forw_get(); 448 pos++; 449 if (c == EOI || c == '\n' || c == '\r') 450 break; 451 } 452 end_attnpos = pos; 453 } 454