9200e79d2

Rob Landley

2005-09-15

SOURCE BUG Duration: 6s

Subject

New applet "less", from Rob Sullivan.

SOURCE BUG

This commit was genuinely broken at the time (not related to our build system): scripts/config/mkconfigs.c (2005-08-01 - 2006-10-05 arasi) uretilen bbconfigopts.h icine .config satirlarini kacissiz, ham newline'larla gömüyordu - gecerli C degildi, busybox'un kendi bb_mkdep araci bile parse edemiyordu (7d219aab7 ile duzeltildi, mkconfigs shell scripte cevrildi)

→ Bu hatanin tam hikayesini ve duzeltme diffini gor

Binary

No binary (build failed)

Architecture & Compiler Flags

Architecture: x86_64-linux-gnu Compiler: gcc (Ubuntu 11.4.0-1ubuntu1~22.04.3) 11.4.0

—

Build Log

(log yok)

Commit Diff GitHub →

include/applets.h +3 -0 include/usage.h +16 -0 miscutils/Config.in +47 -0 miscutils/Makefile.in +1 -0 miscutils/less.c +1262 -0

include/applets.h+3 -0

@@ -359,6 +359,9 @@
	#ifdef CONFIG_FEATURE_INITRD
	APPLET_NOUSAGE("linuxrc", init_main, _BB_DIR_ROOT, _BB_SUID_NEVER)
	#endif
+	#ifdef CONFIG_LESS
+	APPLET(less, less_main, _BB_DIR_USR_BIN, _BB_SUID_NEVER)
+	#endif
	#ifdef CONFIG_LN
	APPLET(ln, ln_main, _BB_DIR_BIN, _BB_SUID_NEVER)
	#endif

include/usage.h+16 -0

@@ -1498,6 +1498,22 @@
	"$ length Hello\n" \
	"5\n"

+	#define less_trivial_usage \
+	"[-EMNmh~?] FILE1 FILE2..."
+	#define less_full_usage \
+	"View a file or list of files. The position within files can be\n" \
+	"changed, and files can be manipulated in various ways with the\n" \
+	"following options:\n\n" \
+	"\t-E\tQuit once the end of a file is reached\n" \
+	"\t-M\tDisplay a status line containing the current line numbers\n" \
+	"\t\tand the percentage through the file\n" \
+	"\t-N\tPrefix line numbers to each line\n" \
+	"\t-m\tDisplay a status line containing the percentage through the\n" \
+	"\t\tfile\n" \
+	"\t-~\tSuppress ~s displayed when input past the end of the file is\n" \
+	"\t\treached.\n" \
+	"\t-h, -?\tDisplay this help message\n"
+
	#define ln_trivial_usage \
	"[OPTION] TARGET... LINK_NAME\|DIRECTORY"
	#define ln_full_usage \

miscutils/Config.in+47 -0

@@ -104,6 +104,53 @@ config CONFIG_LAST
	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

miscutils/Makefile.in+1 -0

@@ -33,6 +33,7 @@ MISCUTILS-$(CONFIG_DEVFSD) += devfsd.o
	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

miscutils/less.c+1262 -0

@@ -0,0 +1,1262 @@
+	/* vi: set sw=4 ts=4: */
+	/*
+	* Mini less implementation for busybox
+	*
+	*
+	* Copyright (C) 2005 by Rob Sullivan <[email protected]>
+	*
+	* 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);
+	}
+	}