New applet "less", from Rob Sullivan.
diff --git a/miscutils/Config.in b/miscutils/Config.in
index 1f14d21..a104880 100644
--- a/miscutils/Config.in
+++ b/miscutils/Config.in
@@ -104,6 +104,53 @@
help
'last' displays a list of the last users that logged into the system.
+config CONFIG_LESS
+ bool "less"
+ default n
+ help
+ 'less' is a pager, meaning that it displays text files. It possesses
+ a wide array of features, and is an improvement over 'more'.
+
+config CONFIG_FEATURE_LESS_BRACKETS
+ bool " Enable bracket searching"
+ default y
+ depends on CONFIG_LESS
+ help
+ This option adds the capability to search for matching left and right
+ brackets, facilitating programming.
+
+config CONFIG_FEATURE_LESS_FLAGS
+ bool " Enable extra flags"
+ default y
+ depends on CONFIG_LESS
+ help
+ The extra flags provided do the following:
+
+ The -M flag enables a more sophisticated status line.
+ The -m flag enables a simpler status line with a percentage.
+
+config CONFIG_FEATURE_LESS_FLAGCS
+ bool " Enable flag changes"
+ default n
+ depends on CONFIG_LESS
+ help
+ This enables the ability to change command-line flags within
+ less itself.
+
+config CONFIG_FEATURE_LESS_MARKS
+ bool " Enable marks"
+ default n
+ depends on CONFIG_LESS
+ help
+ Marks enable positions in a file to be stored for easy reference.
+
+config CONFIG_FEATURE_LESS_REGEXP
+ bool " Enable regular expressions"
+ default n
+ depends on CONFIG_LESS
+ help
+ Enable regular expressions, allowing complex file searches.
+
config CONFIG_HDPARM
bool "hdparm"
default n
diff --git a/miscutils/Makefile.in b/miscutils/Makefile.in
index ee1cc75..ba8069c 100644
--- a/miscutils/Makefile.in
+++ b/miscutils/Makefile.in
@@ -33,6 +33,7 @@
MISCUTILS-$(CONFIG_EJECT) += eject.o
MISCUTILS-$(CONFIG_HDPARM) += hdparm.o
MISCUTILS-$(CONFIG_LAST) += last.o
+MISCUTILS-${CONFIG_LESS} += less.o
MISCUTILS-$(CONFIG_MAKEDEVS) += makedevs.o
MISCUTILS-$(CONFIG_MOUNTPOINT) += mountpoint.o
MISCUTILS-$(CONFIG_MT) += mt.o
diff --git a/miscutils/less.c b/miscutils/less.c
new file mode 100644
index 0000000..43bc673
--- /dev/null
+++ b/miscutils/less.c
@@ -0,0 +1,1262 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini less implementation for busybox
+ *
+ *
+ * Copyright (C) 2005 by Rob Sullivan <cogito.ergo.cogito@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ * 02111-1307 USA
+ *
+ * This program needs a lot of development, so consider it in a beta stage
+ * at best.
+ *
+ * TODO:
+ * - Add more regular expression support - search modifiers, certain matches, etc.
+ * - Add more complex bracket searching - currently, nested brackets are
+ * not considered.
+ * - Add support for "F" as an input. This causes less to act in
+ * a similar way to tail -f.
+ * - Check for binary files, and prompt the user if a binary file
+ * is detected.
+ * - Allow horizontal scrolling. Currently, lines simply continue onto
+ * the next line, per the terminal's discretion
+ *
+ * Notes:
+ * - filename is an array and not a pointer because that avoids all sorts
+ * of complications involving the fact that something that is pointed to
+ * will be changed if the pointer is changed.
+ * - the inp file pointer is used so that keyboard input works after
+ * redirected input has been read from stdin
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <termios.h>
+#include <unistd.h>
+#include <regex.h>
+#include <ctype.h>
+#include "busybox.h"
+
+/* These are the escape sequences corresponding to special keys */
+#define REAL_KEY_UP 'A'
+#define REAL_KEY_DOWN 'B'
+#define REAL_KEY_RIGHT 'C'
+#define REAL_KEY_LEFT 'D'
+#define REAL_PAGE_UP '5'
+#define REAL_PAGE_DOWN '6'
+
+/* These are the special codes assigned by this program to the special keys */
+#define PAGE_UP 20
+#define PAGE_DOWN 21
+#define KEY_UP 22
+#define KEY_DOWN 23
+#define KEY_RIGHT 24
+#define KEY_LEFT 25
+
+/* The escape codes for highlighted and normal text */
+#define HIGHLIGHT "\033[7m"
+#define NORMAL "\033[0m"
+
+/* The escape code to clear the screen */
+#define CLEAR "\033[2J"
+
+/* Maximum number of lines in a file */
+#define MAXLINES 10000
+
+/* Get height and width of terminal */
+#define tty_width_height() get_terminal_width_height(0, &width, &height)
+
+/* Function prototypes */
+static void set_tty_cooked(void);
+static void set_tty_raw(void);
+static void tless_exit(int code);
+static int tless_getch(void);
+static void move_cursor(int x, int y);
+static void clear_line(void);
+static void data_readlines(void);
+static void free_flines(void);
+#ifdef CONFIG_FEATURE_LESS_FLAGS
+static int calc_percent(void);
+#endif
+static int reverse_percent(int percentage);
+#ifdef CONFIG_FEATURE_LESS_FLAGS
+static void m_status_print(void);
+static void medium_status_print(void);
+#endif
+static void status_print(void);
+static void buffer_print(void);
+static void buffer_init(void);
+static void buffer_down(int nlines);
+static void buffer_up(int nlines);
+static void buffer_line(int linenum);
+static void keypress_process(int keypress);
+static void colon_process(void);
+static void number_process(int first_digit);
+#ifdef CONFIG_FEATURE_LESS_FLAGCS
+static void flag_change(void);
+static void show_flag_status(void);
+#endif
+static void examine_file(void);
+static void next_file(void);
+static void previous_file(void);
+static void first_file(void);
+static void remove_current_file(void);
+static void full_repaint(void);
+static void add_linenumbers(void);
+static void save_input_to_file(void);
+#ifdef CONFIG_FEATURE_LESS_MARKS
+static void add_mark(void);
+static void goto_mark(void);
+#endif
+#ifdef CONFIG_FEATURE_LESS_REGEXP
+static void regex_process(void);
+char *process_regex_on_line(char *line, regex_t *pattern);
+char *insert_highlights(char *line, int start, int end);
+static void goto_match (int match);
+static void search_backwards(void);
+#endif
+#ifdef CONFIG_FEATURE_LESS_BRACKETS
+static char opp_bracket (char bracket);
+static void match_right_bracket (char bracket);
+static void match_left_bracket (char bracket);
+#endif
+int less_main(int argc, char *argv[]);
+
+static int height;
+static int width;
+static char **files;
+static char filename[256];
+static char buffer[100][256];
+static char *flines[MAXLINES];
+static int current_file = 1;
+static int line_pos = 0;
+static int num_flines;
+static int num_files = 1;
+static int past_eof = 0;
+
+/* Command line options */
+static int E_FLAG = 0;
+static int M_FLAG = 0;
+static int N_FLAG = 0;
+static int m_FLAG = 0;
+static int TILDE_FLAG = 0;
+
+/* This is needed so that program behaviour changes when input comes from
+ stdin */
+static int inp_stdin = 0;
+/* This is required so that when a file is requested to be examined after
+ input has come from stdin (e.g. dmesg | less), the input stream from
+ the keyboard still stays the same. If it switched back to stdin, keyboard
+ input wouldn't work. */
+static int ea_inp_stdin = 0;
+
+#ifdef CONFIG_FEATURE_LESS_MARKS
+static int mark_lines[15][2];
+static int num_marks = 0;
+#endif
+
+#ifdef CONFIG_FEATURE_LESS_REGEXP
+static int match_found = 0;
+static int match_lines[100];
+static int match_pos = 0;
+static int num_matches = 0;
+static int match_backwards = 0;
+static int num_back_match = 1;
+#endif
+
+/* Needed termios structures */
+static struct termios term_orig, term_vi;
+
+/* File pointer to get input from */
+static FILE *inp;
+
+/* Reset terminal input to normal */
+static void set_tty_cooked() {
+ fflush(stdout);
+ tcsetattr(0, TCSANOW, &term_orig);
+}
+
+/* Set terminal input to raw mode */
+static void set_tty_raw() {
+ tcgetattr(0, &term_orig);
+ term_vi = term_orig;
+ term_vi.c_lflag &= (~ICANON & ~ECHO);
+ term_vi.c_iflag &= (~IXON & ~ICRNL);
+ term_vi.c_oflag &= (~ONLCR);
+ term_vi.c_cc[VMIN] = 1;
+ term_vi.c_cc[VTIME] = 0;
+ tcsetattr(0, TCSANOW, &term_vi);
+}
+
+/* Exit the program gracefully */
+static void tless_exit(int code) {
+
+ /* TODO: We really should save the terminal state when we start,
+ and restore it when we exit. Less does this with the
+ "ti" and "te" termcap commands; can this be done with
+ only termios.h? */
+
+ putchar('\n');
+ exit(code);
+}
+
+/* Grab a character from input without requiring the return key. If the
+ character is ASCII \033, get more characters and assign certain sequences
+ special return codes. Note that this function works best with raw input. */
+int tless_getch() {
+
+ set_tty_raw();
+ char input_key[3];
+
+ input_key[0] = getc(inp);
+ /* Detect escape sequences (i.e. arrow keys) and handle
+ them accordingly */
+
+ if (input_key[0] == '\033') {
+ input_key[1] = getc(inp);
+ input_key[2] = getc(inp);
+ set_tty_cooked();
+ if (input_key[1] == '[') {
+ if (input_key[2] == REAL_KEY_UP)
+ return KEY_UP;
+ else if (input_key[2] == REAL_KEY_DOWN)
+ return KEY_DOWN;
+ else if (input_key[2] == REAL_KEY_RIGHT)
+ return KEY_RIGHT;
+ else if (input_key[2] == REAL_KEY_LEFT)
+ return KEY_LEFT;
+ else if (input_key[2] == REAL_PAGE_UP)
+ return PAGE_UP;
+ else if (input_key[2] == REAL_PAGE_DOWN)
+ return PAGE_DOWN;
+ }
+ }
+ /* The input is a normal ASCII value */
+ else {
+ set_tty_cooked();
+ return input_key[0];
+ }
+ return 0;
+}
+
+/* Move the cursor to a position (x,y), where (0,0) is the
+ top-left corner of the console */
+static void move_cursor(int x, int y) {
+ printf("\033[%i;%iH", x, y);
+}
+
+static void clear_line() {
+ move_cursor(height, 0);
+ printf("\033[K");
+}
+
+static void data_readlines() {
+
+ int i;
+ char current_line[256];
+ FILE *fp;
+
+ fp = (inp_stdin) ? stdin : bb_xfopen(filename, "rt");
+
+ for (i = 0; (!feof(fp)) && (i <= MAXLINES); i++) {
+ strcpy(current_line, "");
+ fgets(current_line, 256, fp);
+ bb_xferror(fp, filename);
+ flines[i] = (char *) bb_xstrndup(current_line, (strlen(current_line) + 1) * sizeof(char));
+ }
+ num_flines = i - 2;
+
+/* Reset variables for a new file */
+
+ line_pos = 0;
+ past_eof = 0;
+
+ fclose(fp);
+
+ if (inp_stdin)
+ inp = fopen(CURRENT_TTY, "r");
+ else
+ inp = stdin;
+
+ if (ea_inp_stdin) {
+ fclose(inp);
+ inp = fopen(CURRENT_TTY, "r");
+ }
+
+ if (N_FLAG)
+ add_linenumbers();
+}
+
+/* Free the file data */
+static void free_flines() {
+
+ int i;
+
+ for (i = 0; i <= num_flines; i++)
+ free(flines[i]);
+}
+
+#ifdef CONFIG_FEATURE_LESS_FLAGS
+/* Calculate the percentage the current line position is through the file */
+int calc_percent() {
+ return ((100 * (line_pos + height - 2) / num_flines) + 1);
+}
+#endif
+
+/* Turn a percentage into a line number */
+int reverse_percent(int percentage) {
+ double linenum = percentage;
+ linenum = ((linenum / 100) * num_flines) - 1;
+ return(linenum);
+}
+
+#ifdef CONFIG_FEATURE_LESS_FLAGS
+/* Print a status line if -M was specified */
+static void m_status_print() {
+
+ int percentage;
+
+ if (!past_eof) {
+ if (!line_pos) {
+ if (num_files > 1)
+ printf("%s%s %s%i%s%i%s%i-%i/%i ", HIGHLIGHT, filename, "(file ", current_file, " of ", num_files, ") lines ", line_pos + 1, line_pos + height - 1, num_flines + 1);
+ else {
+ printf("%s%s lines %i-%i/%i ", HIGHLIGHT, filename, line_pos + 1, line_pos + height - 1, num_flines + 1);
+ }
+ }
+ else {
+ printf("%s %s lines %i-%i/%i ", HIGHLIGHT, filename, line_pos + 1, line_pos + height - 1, num_flines + 1);
+ }
+
+ if (line_pos == num_flines - height + 2) {
+ printf("(END) %s", NORMAL);
+ if ((num_files > 1) && (current_file != num_files))
+ printf("%s- Next: %s%s", HIGHLIGHT, files[current_file], NORMAL);
+ }
+ else {
+ percentage = calc_percent();
+ printf("%i%s %s", percentage, "%", NORMAL);
+ }
+ }
+ else {
+ printf("%s%s lines %i-%i/%i (END) ", HIGHLIGHT, filename, line_pos + 1, num_flines + 1, num_flines + 1);
+ if ((num_files > 1) && (current_file != num_files))
+ printf("- Next: %s", files[current_file]);
+ printf("%s", NORMAL);
+ }
+}
+
+/* Print a status line if -m was specified */
+static void medium_status_print() {
+
+ int percentage;
+ percentage = calc_percent();
+
+ if (!line_pos)
+ printf("%s%s %i%s%s", HIGHLIGHT, filename, percentage, "%", NORMAL);
+ else if (line_pos == num_flines - height + 2)
+ printf("%s(END)%s", HIGHLIGHT, NORMAL);
+ else
+ printf("%s%i%s%s", HIGHLIGHT, percentage, "%", NORMAL);
+}
+#endif
+
+/* Print the status line */
+static void status_print() {
+
+ /* Change the status if flags have been set */
+#ifdef CONFIG_FEATURE_LESS_FLAGS
+ if (M_FLAG)
+ m_status_print();
+ else if (m_FLAG)
+ medium_status_print();
+ /* No flags set */
+ else {
+#endif
+ if (!line_pos) {
+ printf("%s%s %s", HIGHLIGHT, filename, NORMAL);
+ if (num_files > 1)
+ printf("%s%s%i%s%i%s%s", HIGHLIGHT, "(file ", current_file, " of ", num_files, ")", NORMAL);
+ }
+ else if (line_pos == num_flines - height + 2) {
+ printf("%s%s %s", HIGHLIGHT, "(END)", NORMAL);
+ if ((num_files > 1) && (current_file != num_files))
+ printf("%s%s%s%s", HIGHLIGHT, "- Next: ", files[current_file], NORMAL);
+ }
+ else {
+ printf("%c", ':');
+ }
+#ifdef CONFIG_FEATURE_LESS_FLAGS
+ }
+#endif
+}
+
+/* Print the buffer */
+static void buffer_print() {
+
+ int i;
+
+ if (num_flines >= height - 2) {
+ printf("%s", CLEAR);
+ move_cursor(0,0);
+ for (i = 0; i < height - 1; i++)
+ printf("%s", buffer[i]);
+ status_print();
+ }
+ else {
+ printf("%s", CLEAR);
+ move_cursor(0,0);
+ for (i = 1; i < (height - 1 - num_flines); i++)
+ putchar('\n');
+ for (i = 0; i < height - 1; i++)
+ printf("%s", buffer[i]);
+ status_print();
+ }
+}
+
+/* Initialise the buffer */
+static void buffer_init() {
+
+ int i;
+
+ for (i = 0; i < (height - 1); i++)
+ memset(buffer[i], '\0', 256);
+
+ /* Fill the buffer until the end of the file or the
+ end of the buffer is reached */
+ for (i = 0; (i < (height - 1)) && (i <= num_flines); i++) {
+ strcpy(buffer[i], flines[i]);
+ }
+
+ /* If the buffer still isn't full, fill it with blank lines */
+ for (; i < (height - 1); i++) {
+ strcpy(buffer[i], "");
+ }
+}
+
+/* Move the buffer up and down in the file in order to scroll */
+static void buffer_down(int nlines) {
+
+ int i;
+
+ if (!past_eof) {
+ if (line_pos + (height - 3) + nlines < num_flines) {
+ line_pos += nlines;
+ for (i = 0; i < (height - 1); i++)
+ strcpy(buffer[i], flines[line_pos + i]);
+ }
+ else {
+ /* As the number of lines requested was too large, we just move
+ to the end of the file */
+ while (line_pos + (height - 3) + 1 < num_flines) {
+ line_pos += 1;
+ for (i = 0; i < (height - 1); i++)
+ strcpy(buffer[i], flines[line_pos + i]);
+ }
+ }
+
+ /* We exit if the -E flag has been set */
+ if (E_FLAG && (line_pos + (height - 2) == num_flines))
+ tless_exit(0);
+ }
+}
+
+static void buffer_up(int nlines) {
+
+ int i;
+ int tilde_line;
+
+ if (!past_eof) {
+ if (line_pos - nlines >= 0) {
+ line_pos -= nlines;
+ for (i = 0; i < (height - 1); i++)
+ strcpy(buffer[i], flines[line_pos + i]);
+ }
+ else {
+ /* As the requested number of lines to move was too large, we
+ move one line up at a time until we can't. */
+ while (line_pos != 0) {
+ line_pos -= 1;
+ for (i = 0; i < (height - 1); i++)
+ strcpy(buffer[i], flines[line_pos + i]);
+ }
+ }
+ }
+ else {
+ /* Work out where the tildes start */
+ tilde_line = num_flines - line_pos + 3;
+
+ line_pos -= nlines;
+ /* Going backwards nlines lines has taken us to a point where
+ nothing is past the EOF, so we revert to normal. */
+ if (line_pos < num_flines - height + 3) {
+ past_eof = 0;
+ buffer_up(nlines);
+ }
+ else {
+ /* We only move part of the buffer, as the rest
+ is past the EOF */
+ for (i = 0; i < (height - 1); i++) {
+ if (i < tilde_line - nlines + 1)
+ strcpy(buffer[i], flines[line_pos + i]);
+ else {
+ if (line_pos >= num_flines - height + 2)
+ strcpy(buffer[i], "~\n");
+ }
+ }
+ }
+ }
+}
+
+static void buffer_line(int linenum) {
+
+ int i;
+
+ past_eof = 0;
+
+ if (linenum < 1 || linenum > num_flines) {
+ clear_line();
+ printf("%s%s%i%s", HIGHLIGHT, "Cannot seek to line number ", linenum, NORMAL);
+ }
+ else if (linenum < (num_flines - height - 2)) {
+ for (i = 0; i < (height - 1); i++)
+ strcpy(buffer[i], flines[linenum + i]);
+ line_pos = linenum;
+ }
+ else {
+ for (i = 0; i < (height - 1); i++) {
+ if (linenum + i < num_flines + 2)
+ strcpy(buffer[i], flines[linenum + i]);
+ else
+ strcpy(buffer[i], (TILDE_FLAG) ? "\n" : "~\n");
+ }
+ line_pos = linenum;
+ /* Set past_eof so buffer_down and buffer_up act differently */
+ past_eof = 1;
+ }
+}
+
+static void keypress_process(int keypress) {
+ switch (keypress) {
+ case KEY_DOWN: case 'e': case 'j': case '\015':
+ buffer_down(1);
+ buffer_print();
+ break;
+ case KEY_UP: case 'y': case 'k':
+ buffer_up(1);
+ buffer_print();
+ break;
+ case PAGE_DOWN: case ' ': case 'z':
+ buffer_down(height - 1);
+ buffer_print();
+ break;
+ case PAGE_UP: case 'w': case 'b':
+ buffer_up(height - 1);
+ buffer_print();
+ break;
+ case 'd':
+ buffer_down((height - 1) / 2);
+ buffer_print();
+ break;
+ case 'u':
+ buffer_up((height - 1) / 2);
+ buffer_print();
+ break;
+ case 'g': case 'p': case '<': case '%':
+ buffer_up(num_flines + 1);
+ buffer_print();
+ break;
+ case 'G': case '>':
+ buffer_down(num_flines + 1);
+ buffer_print();
+ break;
+ case 'q': case 'Q':
+ tless_exit(0);
+ break;
+#ifdef CONFIG_FEATURE_LESS_MARKS
+ case 'm':
+ add_mark();
+ buffer_print();
+ break;
+ case '\'':
+ goto_mark();
+ buffer_print();
+ break;
+#endif
+ case 'r':
+ buffer_print();
+ break;
+ case 'R':
+ full_repaint();
+ break;
+ case 's':
+ if (inp_stdin)
+ save_input_to_file();
+ break;
+ case 'E':
+ examine_file();
+ break;
+#ifdef CONFIG_FEATURE_LESS_FLAGS
+ case '=':
+ clear_line();
+ m_status_print();
+ break;
+#endif
+#ifdef CONFIG_FEATURE_LESS_REGEXP
+ case '/':
+ regex_process();
+ buffer_print();
+ break;
+ case 'n':
+ goto_match(match_pos + 1);
+ buffer_print();
+ break;
+ case 'N':
+ goto_match(match_pos - 1);
+ buffer_print();
+ break;
+ case '?':
+ search_backwards();
+ buffer_print();
+ break;
+#endif
+#ifdef CONFIG_FEATURE_LESS_FLAGCS
+ case '-':
+ flag_change();
+ buffer_print();
+ break;
+ case '_':
+ show_flag_status();
+ break;
+#endif
+#ifdef CONFIG_FEATURE_LESS_BRACKETS
+ case '{': case '(': case '[':
+ match_right_bracket(keypress);
+ break;
+ case '}': case ')': case ']':
+ match_left_bracket(keypress);
+ break;
+#endif
+ case ':':
+ colon_process();
+ break;
+ default:
+ break;
+ }
+ if (isdigit(keypress))
+ number_process(keypress);
+}
+
+static void colon_process() {
+
+ int keypress;
+
+ /* Clear the current line and print a prompt */
+ clear_line();
+ printf(" :");
+
+ keypress = tless_getch();
+ switch (keypress) {
+ case 'd':
+ remove_current_file();
+ break;
+ case 'e':
+ examine_file();
+ break;
+#ifdef CONFIG_FEATURE_LESS_FLAGS
+ case 'f':
+ clear_line();
+ m_status_print();
+ break;
+#endif
+ case 'n':
+ next_file();
+ break;
+ case 'p':
+ previous_file();
+ break;
+ case 'q':
+ tless_exit(0);
+ break;
+ case 'x':
+ first_file();
+ break;
+ default:
+ break;
+ }
+}
+
+static void number_process(int first_digit) {
+
+ int i = 1;
+ int num;
+ char num_input[80];
+ char keypress;
+ num_input[0] = first_digit;
+
+ /* Clear the current line, print a prompt, and then print the digit */
+ clear_line();
+ printf(":%c", first_digit);
+
+ /* Receive input until a letter is given */
+ while((num_input[i] = tless_getch()) && isdigit(num_input[i])) {
+ printf("%c",num_input[i]);
+ i++;
+ }
+
+ /* Take the final letter out of the digits string */
+ keypress = num_input[i];
+ num_input[i] = '\0';
+ i--;
+ num = atoi(num_input);
+
+ /* We now know the number and the letter entered, so we process them */
+ switch (keypress) {
+ case KEY_DOWN: case 'z': case 'd': case 'e': case ' ': case '\015':
+ buffer_down(num);
+ buffer_print();
+ break;
+ case KEY_UP: case 'b': case 'w': case 'y': case 'u':
+ buffer_up(num);
+ buffer_print();
+ break;
+ case 'g': case '<': case 'G': case '>':
+ if (num_flines >= height - 2)
+ buffer_line(num - 1);
+ buffer_print();
+ break;
+ case 'p': case '%':
+ buffer_line(reverse_percent(num));
+ buffer_print();
+ break;
+#ifdef CONFIG_FEATURE_LESS_REGEXP
+ case 'n':
+ goto_match(match_pos + num - 1);
+ buffer_print();
+ break;
+ case '/':
+ regex_process();
+ goto_match(num - 1);
+ buffer_print();
+ break;
+ case '?':
+ num_back_match = num;
+ search_backwards();
+ buffer_print();
+ break;
+#endif
+ default:
+ break;
+ }
+}
+
+#ifdef CONFIG_FEATURE_LESS_FLAGCS
+static void flag_change() {
+
+ int keypress;
+
+ clear_line();
+ printf("-");
+ keypress = tless_getch();
+
+ switch (keypress) {
+ case 'M':
+ M_FLAG = !M_FLAG;
+ break;
+ case 'm':
+ m_FLAG = !m_FLAG;
+ break;
+ case 'E':
+ E_FLAG = !E_FLAG;
+ break;
+ case '~':
+ TILDE_FLAG = !TILDE_FLAG;
+ break;
+ default:
+ break;
+ }
+}
+
+static void show_flag_status() {
+
+ int keypress;
+ int flag_val;
+
+ clear_line();
+ printf("_");
+ keypress = tless_getch();
+
+ switch (keypress) {
+ case 'M':
+ flag_val = M_FLAG;
+ break;
+ case 'm':
+ flag_val = m_FLAG;
+ break;
+ case '~':
+ flag_val = TILDE_FLAG;
+ break;
+ case 'N':
+ flag_val = N_FLAG;
+ break;
+ case 'E':
+ flag_val = E_FLAG;
+ break;
+ default:
+ flag_val = 0;
+ break;
+ }
+
+ clear_line();
+ printf("%s%s%i%s", HIGHLIGHT, "The status of the flag is: ", flag_val, NORMAL);
+}
+#endif
+
+static void examine_file() {
+
+ int newline_offset;
+
+ clear_line();
+ printf("Examine: ");
+ fgets(filename, 256, inp);
+
+ /* As fgets adds a newline to the end of an input string, we
+ need to remove it */
+ newline_offset = strlen(filename) - 1;
+ filename[newline_offset] = '\0';
+
+ files[num_files] = bb_xstrndup(filename, (strlen(filename) + 1) * sizeof(char));
+ current_file = num_files + 1;
+ num_files++;
+
+ inp_stdin = 0;
+ ea_inp_stdin = 1;
+ free_flines();
+ data_readlines();
+ buffer_init();
+ buffer_print();
+}
+
+static void next_file() {
+ if (current_file != num_files) {
+ current_file++;
+ strcpy(filename, files[current_file - 1]);
+ free_flines();
+ data_readlines();
+ buffer_init();
+ buffer_print();
+ }
+ else {
+ clear_line();
+ printf("%s%s%s", HIGHLIGHT, "No next file", NORMAL);
+ }
+}
+
+static void previous_file() {
+ if (current_file != 1) {
+ current_file--;
+ strcpy(filename, files[current_file - 1]);
+
+ free_flines();
+ data_readlines();
+ buffer_init();
+ buffer_print();
+ }
+ else {
+ clear_line();
+ printf("%s%s%s", HIGHLIGHT, "No previous file", NORMAL);
+ }
+}
+
+static void first_file() {
+ if (current_file != 1) {
+ current_file = 1;
+ strcpy(filename, files[current_file - 1]);
+ free_flines();
+ data_readlines();
+ buffer_init();
+ buffer_print();
+ }
+}
+
+static void remove_current_file() {
+
+ int i;
+
+ if (current_file != 1) {
+ previous_file();
+ for (i = 3; i <= num_files; i++)
+ files[i - 2] = files[i - 1];
+ num_files--;
+ buffer_print();
+ }
+ else {
+ next_file();
+ for (i = 2; i <= num_files; i++)
+ files[i - 2] = files[i - 1];
+ num_files--;
+ current_file--;
+ buffer_print();
+ }
+}
+
+static void full_repaint() {
+
+ int temp_line_pos = line_pos;
+ data_readlines();
+ buffer_init();
+ buffer_line(temp_line_pos);
+ buffer_print();
+}
+
+/* This adds line numbers to every line, as the -N flag necessitates */
+static void add_linenumbers() {
+
+ char current_line[256];
+ int i;
+
+ for (i = 0; i <= num_flines; i++) {
+ safe_strncpy(current_line, flines[i], 256);
+ flines[i] = xrealloc(flines[i], strlen(current_line) + 7 );
+ sprintf(flines[i],"%5d %s", i+1, current_line);
+ }
+}
+
+static void save_input_to_file() {
+
+ char current_line[256];
+ int i;
+ FILE *fp;
+
+ clear_line();
+ printf("Log file: ");
+ fgets(current_line, 256, inp);
+ current_line[strlen(current_line) - 1] = '\0';
+ if (strlen(current_line)) {
+ fp = bb_xfopen(current_line, "w");
+ for (i = 0; i < num_flines; i++)
+ fprintf(fp, "%s", flines[i]);
+ fclose(fp);
+ buffer_print();
+ }
+ else
+ printf("%sNo log file%s", HIGHLIGHT, NORMAL);
+}
+
+#ifdef CONFIG_FEATURE_LESS_MARKS
+static void add_mark() {
+
+ int letter;
+ int mark_line;
+
+ clear_line();
+ printf("Mark: ");
+ letter = tless_getch();
+
+ if (isalpha(letter)) {
+ mark_line = line_pos;
+
+ /* If we exceed 15 marks, start overwriting previous ones */
+ if (num_marks == 14)
+ num_marks = 0;
+
+ mark_lines[num_marks][0] = letter;
+ mark_lines[num_marks][1] = line_pos;
+ num_marks++;
+ }
+ else {
+ clear_line();
+ printf("%s%s%s", HIGHLIGHT, "Invalid mark letter", NORMAL);
+ }
+}
+
+static void goto_mark() {
+
+ int letter;
+ int i;
+
+ clear_line();
+ printf("Go to mark: ");
+ letter = tless_getch();
+ if (isalpha(letter)) {
+ for (i = 0; i <= num_marks; i++)
+ if (letter == mark_lines[i][0]) {
+ buffer_line(mark_lines[i][1]);
+ break;
+ }
+ if ((num_marks == 14) && (letter != mark_lines[14][0])) {
+ clear_line();
+ printf("%s%s%s", HIGHLIGHT, "Mark not set", NORMAL);
+ }
+ }
+ else {
+ clear_line();
+ printf("%s%s%s", HIGHLIGHT, "Invalid mark letter", NORMAL);
+ }
+}
+#endif
+
+#ifdef CONFIG_FEATURE_LESS_REGEXP
+/* The below two regular expression handler functions NEED development. */
+
+/* Get a regular expression from the user, and then go through the current
+ file line by line, running a processing regex function on each one. */
+static void regex_process() {
+
+ char uncomp_regex[100];
+ char current_line[256];
+ int i;
+ int j = 0;
+ regex_t *pattern;
+
+ /* Reset variables */
+ match_lines[0] = -1;
+ match_pos = 0;
+ num_matches = 0;
+ match_found = 0;
+
+ pattern = (regex_t *) malloc(sizeof(regex_t));
+ memset(pattern, 0, sizeof(regex_t));
+
+ /* Get the uncompiled regular expression from the user */
+ clear_line();
+ if (match_backwards)
+ printf("?");
+ else
+ printf("/");
+ scanf("%s", uncomp_regex);
+
+ /* Compile the regex and check for errors */
+ xregcomp(pattern, uncomp_regex, 0);
+
+ /* Run the regex on each line of the current file here */
+ for (i = 0; i <= num_flines; i++) {
+ strcpy(current_line, process_regex_on_line(flines[i], pattern));
+ flines[i] = (char *) bb_xstrndup(current_line, sizeof(char) * (strlen(current_line)+1));
+
+ if (match_found) {
+ match_lines[j] = i;
+ j++;
+ }
+ }
+
+ num_matches = j;
+
+ if ((match_lines[0] != -1) && (num_flines > height - 2))
+ buffer_line(match_lines[0]);
+ else
+ buffer_init();
+}
+
+char *process_regex_on_line(char *line, regex_t *pattern) {
+ /* This function takes the regex and applies it to the line.
+ Each part of the line that matches has the HIGHLIGHT
+ and NORMAL escape sequences placed around it by
+ insert_highlights, and then the line is returned. */
+
+ int match_status;
+ char *line2 = (char *) malloc((sizeof(char) * (strlen(line) + 1)) + 64);
+ char sub_line[256];
+ int prev_eo = 0;
+ memset(sub_line, 0, 256);
+ strcpy(line2, line);
+ regmatch_t match_structs;
+
+ match_found = 0;
+ match_status = regexec(pattern, line2, 1, &match_structs, 0);
+
+ while (match_status == 0) {
+
+ memset(sub_line, 0, 256);
+
+ if (match_found == 0)
+ match_found = 1;
+
+ line2 = insert_highlights(line2, match_structs.rm_so + prev_eo, match_structs.rm_eo + prev_eo);
+ if (match_structs.rm_eo + 11 + prev_eo < strlen(line2))
+ strcat(sub_line, line2 + match_structs.rm_eo + 11 + prev_eo);
+
+ prev_eo += match_structs.rm_eo + 11;
+ match_status = regexec(pattern, sub_line, 1, &match_structs, REG_NOTBOL);
+ }
+
+ return line2;
+}
+
+char *insert_highlights (char *line, int start, int end) {
+
+ char *new_line = (char *) malloc((sizeof(char) * (strlen(line) + 1)) + 10);
+ memset(new_line, 0, ((sizeof(char) * (strlen(line) + 1)) + 10));
+ strncat(new_line, line, start);
+ strcat(new_line, HIGHLIGHT);
+ strncat(new_line, line + start, end - start);
+ strcat(new_line, NORMAL);
+ strncat(new_line, line + end, strlen(line) - end);
+
+ return new_line;
+}
+
+static void goto_match(int match) {
+
+ /* This goes to a specific match - all line positions of matches are
+ stored within the match_lines[] array. */
+ if ((match < num_matches) && (match >= 0)) {
+ buffer_line(match_lines[match]);
+ match_pos = match;
+ }
+}
+
+static void search_backwards() {
+
+ int current_linepos = line_pos;
+ int i;
+
+ match_backwards = 1;
+ regex_process();
+
+ for (i = 0; i < num_matches; i++) {
+ if (match_lines[i] > current_linepos) {
+ buffer_line(match_lines[i - num_back_match]);
+ break;
+ }
+ }
+
+ /* Reset variables */
+ match_backwards = 0;
+ num_back_match = 1;
+
+}
+#endif
+
+#ifdef CONFIG_FEATURE_LESS_BRACKETS
+
+static char opp_bracket (char bracket) {
+
+ switch (bracket) {
+ case '{': case '[':
+ return bracket + 2;
+ break;
+ case '(':
+ return ')';
+ break;
+ case '}': case ']':
+ return bracket - 2;
+ break;
+ case ')':
+ return '(';
+ break;
+ default:
+ return 0;
+ break;
+ }
+}
+
+static void match_right_bracket(char bracket) {
+
+ int bracket_line = -1;
+ int i;
+
+ if (strchr(flines[line_pos], bracket) == NULL) {
+ clear_line();
+ printf("%s%s%s", HIGHLIGHT, "No bracket in top line", NORMAL);
+ }
+ else {
+ for (i = line_pos + 1; i < num_flines; i++) {
+ if (strchr(flines[i], opp_bracket(bracket)) != NULL) {
+ bracket_line = i;
+ break;
+ }
+ }
+
+ if (bracket_line == -1) {
+ clear_line();
+ printf("%s%s%s", HIGHLIGHT, "No matching bracket found", NORMAL);
+ }
+
+ buffer_line(bracket_line - height + 2);
+ buffer_print();
+ }
+}
+
+static void match_left_bracket (char bracket) {
+
+ int bracket_line = -1;
+ int i;
+
+ if (strchr(flines[line_pos + height - 2], bracket) == NULL) {
+ clear_line();
+ printf("%s%s%s", HIGHLIGHT, "No bracket in bottom line", NORMAL);
+ printf("%s", flines[line_pos + height]);
+ sleep(4);
+ }
+ else {
+ for (i = line_pos + height - 2; i >= 0; i--) {
+ if (strchr(flines[i], opp_bracket(bracket)) != NULL) {
+ bracket_line = i;
+ break;
+ }
+ }
+
+ if (bracket_line == -1) {
+ clear_line();
+ printf("%s%s%s", HIGHLIGHT, "No matching bracket found", NORMAL);
+ }
+
+ buffer_line(bracket_line);
+ buffer_print();
+ }
+}
+
+#endif
+
+int less_main(int argc, char **argv) {
+
+ unsigned long flags;
+ int keypress;
+
+ flags = bb_getopt_ulflags(argc, argv, "EMNm~");
+ E_FLAG = (flags & 1);
+ M_FLAG = (flags & 2);
+ N_FLAG = (flags & 4);
+ m_FLAG = (flags & 8);
+ TILDE_FLAG = (flags & 16);
+
+ argc -= optind;
+ argv += optind;
+ files = argv;
+ num_files = argc;
+
+ if (!num_files) {
+ if (ttyname(STDIN_FILENO) == NULL)
+ inp_stdin = 1;
+ else {
+ bb_error_msg("Missing filename");
+ bb_show_usage();
+ }
+ }
+
+ strcpy(filename, (inp_stdin) ? "stdin" : files[0]);
+ tty_width_height();
+ data_readlines();
+ buffer_init();
+ buffer_print();
+
+ while (1) {
+ keypress = tless_getch();
+ keypress_process(keypress);
+ }
+}