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