merge from open-source master (5dc0f5db) · Commits · e / os / android_system_core

adb/Android.mk

+1 −1

Original line number	Diff line number	Diff line
		@@ -74,7 +74,7 @@ else
		endif

		LOCAL_CFLAGS += -O2 -g -DADB_HOST=1 -Wall -Wno-unused-parameter
		LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE -DSH_HISTORY
		LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE
		LOCAL_MODULE := adb

		LOCAL_STATIC_LIBRARIES := libzipfile libunz $(EXTRA_STATIC_LIBS)

liblinenoise/Android.mk

0 → 100644

+12 −0

Original line number	Diff line number	Diff line
		LOCAL_PATH:= $(call my-dir)
		include $(CLEAR_VARS)

		# Static library
		# ========================================================

		include $(CLEAR_VARS)
		LOCAL_MODULE:= liblinenoise
		LOCAL_SRC_FILES := linenoise.c


		include $(BUILD_STATIC_LIBRARY)

liblinenoise/MODULE_LICENSE_BSD_LIKE

0 → 100644

+0 −0

Empty file added.

liblinenoise/NOTICE

0 → 100644

+28 −0

Original line number	Diff line number	Diff line
		Copyright (c) 2010, Salvatore Sanfilippo <antirez at gmail dot com>
		All rights reserved.

		Redistribution and use in source and binary forms, with or without
		modification, are permitted provided that the following conditions are met:

		* Redistributions of source code must retain the above copyright notice,
		this list of conditions and the following disclaimer.

		* Redistributions in binary form must reproduce the above copyright
		notice, this list of conditions and the following disclaimer in the
		documentation and/or other materials provided with the distribution.

		* Neither the name of Redis nor the names of its contributors may be used
		to endorse or promote products derived from this software without
		specific prior written permission.

		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
		AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
		ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
		LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
		INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
		CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
		POSSIBILITY OF SUCH DAMAGE.
		No newline at end of file

liblinenoise/linenoise.c

0 → 100644

+435 −0

Original line number	Diff line number	Diff line
		/* linenoise.c -- guerrilla line editing library against the idea that a
		* line editing lib needs to be 20,000 lines of C code.
		*
		* You can find the latest source code at:
		*
		* http://github.com/antirez/linenoise
		*
		* Does a number of crazy assumptions that happen to be true in 99.9999% of
		* the 2010 UNIX computers around.
		*
		* Copyright (c) 2010, Salvatore Sanfilippo <antirez at gmail dot com>
		* All rights reserved.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions are met:
		*
		* * Redistributions of source code must retain the above copyright notice,
		* this list of conditions and the following disclaimer.
		* * Redistributions in binary form must reproduce the above copyright
		* notice, this list of conditions and the following disclaimer in the
		* documentation and/or other materials provided with the distribution.
		* * Neither the name of Redis nor the names of its contributors may be used
		* to endorse or promote products derived from this software without
		* specific prior written permission.
		*
		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
		* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
		* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
		* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
		* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
		* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
		* POSSIBILITY OF SUCH DAMAGE.
		*
		* References:
		* - http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
		* - http://www.3waylabs.com/nw/WWW/products/wizcon/vt220.html
		*
		* Todo list:
		* - Switch to gets() if $TERM is something we can't support.
		* - Filter bogus Ctrl+<char> combinations.
		* - Win32 support
		*
		* Bloat:
		* - Completion?
		* - History search like Ctrl+r in readline?
		*
		* List of escape sequences used by this program, we do everything just
		* with three sequences. In order to be so cheap we may have some
		* flickering effect with some slow terminal, but the lesser sequences
		* the more compatible.
		*
		* CHA (Cursor Horizontal Absolute)
		* Sequence: ESC [ n G
		* Effect: moves cursor to column n
		*
		* EL (Erase Line)
		* Sequence: ESC [ n K
		* Effect: if n is 0 or missing, clear from cursor to end of line
		* Effect: if n is 1, clear from beginning of line to cursor
		* Effect: if n is 2, clear entire line
		*
		* CUF (CUrsor Forward)
		* Sequence: ESC [ n C
		* Effect: moves cursor forward of n chars
		*
		*/

		#include <termios.h>
		#include <unistd.h>
		#include <stdlib.h>
		#include <stdio.h>
		#include <errno.h>
		#include <string.h>
		#include <stdlib.h>
		#include <sys/types.h>
		#include <sys/ioctl.h>
		#include <unistd.h>

		#define LINENOISE_MAX_LINE 4096
		static char *unsupported_term[] = {"dumb","cons25",NULL};

		static struct termios orig_termios; /* in order to restore at exit */
		static int rawmode = 0; /* for atexit() function to check if restore is needed*/
		static int atexit_registered = 0; /* register atexit just 1 time */
		static int history_max_len = 100;
		static int history_len = 0;
		char **history = NULL;

		static void linenoiseAtExit(void);
		int linenoiseHistoryAdd(const char *line);

		static int isUnsupportedTerm(void) {
		char *term = getenv("TERM");
		int j;

		if (term == NULL) return 0;
		for (j = 0; unsupported_term[j]; j++)
		if (!strcasecmp(term,unsupported_term[j])) return 1;
		return 0;
		}

		static void freeHistory(void) {
		if (history) {
		int j;

		for (j = 0; j < history_len; j++)
		free(history[j]);
		free(history);
		}
		}

		static int enableRawMode(int fd) {
		struct termios raw;

		if (!isatty(STDIN_FILENO)) goto fatal;
		if (!atexit_registered) {
		atexit(linenoiseAtExit);
		atexit_registered = 1;
		}
		if (tcgetattr(fd,&orig_termios) == -1) goto fatal;

		raw = orig_termios; /* modify the original mode */
		/* input modes: no break, no CR to NL, no parity check, no strip char,
		* no start/stop output control. */
		raw.c_iflag &= ~(BRKINT \| ICRNL \| INPCK \| ISTRIP \| IXON);
		/* output modes - disable post processing */
		raw.c_oflag &= ~(OPOST);
		/* control modes - set 8 bit chars */
		raw.c_cflag \|= (CS8);
		/* local modes - choing off, canonical off, no extended functions,
		* no signal chars (^Z,^C) */
		raw.c_lflag &= ~(ECHO \| ICANON \| IEXTEN \| ISIG);
		/* control chars - set return condition: min number of bytes and timer.
		* We want read to return every single byte, without timeout. */
		raw.c_cc[VMIN] = 1; raw.c_cc[VTIME] = 0; /* 1 byte, no timer */

		/* put terminal in raw mode after flushing */
		if (tcsetattr(fd,TCSAFLUSH,&raw) < 0) goto fatal;
		rawmode = 1;
		return 0;

		fatal:
		errno = ENOTTY;
		return -1;
		}

		static void disableRawMode(int fd) {
		/* Don't even check the return value as it's too late. */
		if (rawmode && tcsetattr(fd,TCSAFLUSH,&orig_termios) != -1)
		rawmode = 0;
		}

		/* At exit we'll try to fix the terminal to the initial conditions. */
		static void linenoiseAtExit(void) {
		disableRawMode(STDIN_FILENO);
		freeHistory();
		}

		static int getColumns(void) {
		struct winsize ws;

		if (ioctl(1, TIOCGWINSZ, &ws) == -1) return 80;
		if (ws.ws_col == 0) {
		return 80;
		}
		return ws.ws_col;
		}

		static void refreshLine(int fd, const char prompt, char buf, size_t len, size_t pos, size_t cols) {
		char seq[64];
		size_t plen = strlen(prompt);

		while((plen+pos) >= cols) {
		buf++;
		len--;
		pos--;
		}
		while (plen+len > cols) {
		len--;
		}

		/* Cursor to left edge */
		snprintf(seq,64,"\x1b[0G");
		if (write(fd,seq,strlen(seq)) == -1) return;
		/* Write the prompt and the current buffer content */
		if (write(fd,prompt,strlen(prompt)) == -1) return;
		if (write(fd,buf,len) == -1) return;
		/* Erase to right */
		snprintf(seq,64,"\x1b[0K");
		if (write(fd,seq,strlen(seq)) == -1) return;
		/* Move cursor to original position. */
		snprintf(seq,64,"\x1b[0G\x1b[%dC", (int)(pos+plen));
		if (write(fd,seq,strlen(seq)) == -1) return;
		}

		static int linenoisePrompt(int fd, char buf, size_t buflen, const char prompt) {
		size_t plen = strlen(prompt);
		size_t pos = 0;
		size_t len = 0;
		size_t cols = getColumns();
		int history_index = 0;

		buf[0] = '\0';
		buflen--; /* Make sure there is always space for the nulterm */

		/* The latest history entry is always our current buffer, that
		* initially is just an empty string. */
		linenoiseHistoryAdd("");

		if (write(fd,prompt,plen) == -1) return -1;
		while(1) {
		char c;
		int nread;
		char seq[2];

		nread = read(fd,&c,1);
		if (nread <= 0) return len;
		switch(c) {
		case 10: /* line feed. */
		case 13: /* enter */
		history_len--;
		return len;
		case 4: /* ctrl-d */
		history_len--;
		return (len == 0) ? -1 : (int)len;
		case 3: /* ctrl-c */
		errno = EAGAIN;
		return -1;
		case 127: /* backspace */
		case 8: /* ctrl-h */
		if (pos > 0 && len > 0) {
		memmove(buf+pos-1,buf+pos,len-pos);
		pos--;
		len--;
		buf[len] = '\0';
		refreshLine(fd,prompt,buf,len,pos,cols);
		}
		break;
		case 20: /* ctrl-t */
		if (pos > 0 && pos < len) {
		int aux = buf[pos-1];
		buf[pos-1] = buf[pos];
		buf[pos] = aux;
		if (pos != len-1) pos++;
		refreshLine(fd,prompt,buf,len,pos,cols);
		}
		break;
		case 2: /* ctrl-b */
		goto left_arrow;
		case 6: /* ctrl-f */
		goto right_arrow;
		case 16: /* ctrl-p */
		seq[1] = 65;
		goto up_down_arrow;
		case 14: /* ctrl-n */
		seq[1] = 66;
		goto up_down_arrow;
		break;
		case 27: /* escape sequence */
		if (read(fd,seq,2) == -1) break;
		if (seq[0] == 91 && seq[1] == 68) {
		left_arrow:
		/* left arrow */
		if (pos > 0) {
		pos--;
		refreshLine(fd,prompt,buf,len,pos,cols);
		}
		} else if (seq[0] == 91 && seq[1] == 67) {
		right_arrow:
		/* right arrow */
		if (pos != len) {
		pos++;
		refreshLine(fd,prompt,buf,len,pos,cols);
		}
		} else if (seq[0] == 91 && (seq[1] == 65 \|\| seq[1] == 66)) {
		up_down_arrow:
		/* up and down arrow: history */
		if (history_len > 1) {
		/* Update the current history entry before to
		* overwrite it with tne next one. */
		free(history[history_len-1-history_index]);
		history[history_len-1-history_index] = strdup(buf);
		/* Show the new entry */
		history_index += (seq[1] == 65) ? 1 : -1;
		if (history_index < 0) {
		history_index = 0;
		break;
		} else if (history_index >= history_len) {
		history_index = history_len-1;
		break;
		}
		strncpy(buf,history[history_len-1-history_index],buflen);
		buf[buflen] = '\0';
		len = pos = strlen(buf);
		refreshLine(fd,prompt,buf,len,pos,cols);
		}
		}
		break;
		default:
		if (len < buflen) {
		if (len == pos) {
		buf[pos] = c;
		pos++;
		len++;
		buf[len] = '\0';
		if (plen+len < cols) {
		/* Avoid a full update of the line in the
		* trivial case. */
		if (write(fd,&c,1) == -1) return -1;
		} else {
		refreshLine(fd,prompt,buf,len,pos,cols);
		}
		} else {
		memmove(buf+pos+1,buf+pos,len-pos);
		buf[pos] = c;
		len++;
		pos++;
		buf[len] = '\0';
		refreshLine(fd,prompt,buf,len,pos,cols);
		}
		}
		break;
		case 21: /* Ctrl+u, delete the whole line. */
		buf[0] = '\0';
		pos = len = 0;
		refreshLine(fd,prompt,buf,len,pos,cols);
		break;
		case 11: /* Ctrl+k, delete from current to end of line. */
		buf[pos] = '\0';
		len = pos;
		refreshLine(fd,prompt,buf,len,pos,cols);
		break;
		case 1: /* Ctrl+a, go to the start of the line */
		pos = 0;
		refreshLine(fd,prompt,buf,len,pos,cols);
		break;
		case 5: /* ctrl+e, go to the end of the line */
		pos = len;
		refreshLine(fd,prompt,buf,len,pos,cols);
		break;
		}
		}
		return len;
		}

		static int linenoiseRaw(char buf, size_t buflen, const char prompt) {
		int fd = STDIN_FILENO;
		int count;

		if (buflen == 0) {
		errno = EINVAL;
		return -1;
		}
		if (!isatty(STDIN_FILENO)) {
		if (fgets(buf, buflen, stdin) == NULL) return -1;
		count = strlen(buf);
		if (count && buf[count-1] == '\n') {
		count--;
		buf[count] = '\0';
		}
		} else {
		if (enableRawMode(fd) == -1) return -1;
		count = linenoisePrompt(fd, buf, buflen, prompt);
		disableRawMode(fd);
		}
		return count;
		}

		char linenoise(const char prompt) {
		char buf[LINENOISE_MAX_LINE];
		int count;

		if (isUnsupportedTerm()) {
		size_t len;

		printf("%s",prompt);
		fflush(stdout);
		if (fgets(buf,LINENOISE_MAX_LINE,stdin) == NULL) return NULL;
		len = strlen(buf);
		while(len && (buf[len-1] == '\n' \|\| buf[len-1] == '\r')) {
		len--;
		buf[len] = '\0';
		}
		return strdup(buf);
		} else {
		count = linenoiseRaw(buf,LINENOISE_MAX_LINE,prompt);
		if (count == -1) return NULL;
		return strdup(buf);
		}
		}

		/* Using a circular buffer is smarter, but a bit more complex to handle. */
		int linenoiseHistoryAdd(const char *line) {
		char *linecopy;

		if (history_max_len == 0) return 0;
		if (history == 0) {
		history = malloc(sizeof(char)history_max_len);
		if (history == NULL) return 0;
		memset(history,0,(sizeof(char)history_max_len));
		}
		linecopy = strdup(line);
		if (!linecopy) return 0;
		if (history_len == history_max_len) {
		memmove(history,history+1,sizeof(char)(history_max_len-1));
		history_len--;
		}
		history[history_len] = linecopy;
		history_len++;
		return 1;
		}

		int linenoiseHistorySetMaxLen(int len) {
		char **new;

		if (len < 1) return 0;
		if (history) {
		int tocopy = history_len;

		new = malloc(sizeof(char)len);
		if (new == NULL) return 0;
		if (len < tocopy) tocopy = len;
		memcpy(new,history+(history_max_len-tocopy), sizeof(char)tocopy);
		free(history);
		history = new;
		}
		history_max_len = len;
		if (history_len > history_max_len)
		history_len = history_max_len;
		return 1;
		}