diff options
Diffstat (limited to 'lib/wrappers')
| -rw-r--r-- | lib/wrappers/readline/history.nim | 281 | ||||
| -rw-r--r-- | lib/wrappers/readline/readline.nim | 1198 | ||||
| -rw-r--r-- | lib/wrappers/readline/rltypedefs.nim | 74 | ||||
| -rw-r--r-- | lib/wrappers/readline/tweaked/history.h | 257 | ||||
| -rw-r--r-- | lib/wrappers/readline/tweaked/readline.h | 956 | ||||
| -rw-r--r-- | lib/wrappers/readline/tweaked/rltypedefs.h | 78 | ||||
| -rw-r--r-- | lib/wrappers/readline/tweaked/tilde.h | 77 | ||||
| -rwxr-xr-x | lib/wrappers/tcl.nim | 1 |
8 files changed, 2921 insertions, 1 deletions
diff --git a/lib/wrappers/readline/history.nim b/lib/wrappers/readline/history.nim new file mode 100644 index 000000000..48e71e434 --- /dev/null +++ b/lib/wrappers/readline/history.nim @@ -0,0 +1,281 @@ +# history.h -- the names of functions that you can call in history. +# Copyright (C) 1989-2009 Free Software Foundation, Inc. +# +# This file contains the GNU History Library (History), a set of +# routines for managing the text of previously typed lines. +# +# History 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 3 of the License, or +# (at your option) any later version. +# +# History 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 History. If not, see <http://www.gnu.org/licenses/>. +# + +{.deadCodeElim: on.} +when defined(windows): + const + historyDll = "history.dll" +elif defined(macosx): + const + historyDll = "libhistory.dynlib" +else: + const + historyDll = "libhistory.so.6(|.0)" + +import times, rltypedefs + +type + Thistdata* = pointer + +# The structure used to store a history entry. + +type + THIST_ENTRY*{.pure, final.} = object + line*: cstring + timestamp*: cstring # char * rather than time_t for read/write + data*: Thistdata + + +# Size of the history-library-managed space in history entry HS. + +template HISTENT_BYTES*(hs: expr): expr = + (strlen(hs.line) + strlen(hs.timestamp)) + +# A structure used to pass the current state of the history stuff around. + +type + THISTORY_STATE*{.pure, final.} = object + entries*: ptr ptr THIST_ENTRY # Pointer to the entries themselves. + offset*: cint # The location pointer within this array. + length*: cint # Number of elements within this array. + size*: cint # Number of slots allocated to this array. + flags*: cint + + +# Flag values for the `flags' member of HISTORY_STATE. + +const + HS_STIFLED* = 0x00000001 + +# Initialization and state management. +# Begin a session in which the history functions might be used. This +# just initializes the interactive variables. + +proc using_history*(){.cdecl, importc: "using_history", dynlib: historyDll.} +# Return the current HISTORY_STATE of the history. + +proc history_get_history_state*(): ptr THISTORY_STATE{.cdecl, + importc: "history_get_history_state", dynlib: historyDll.} +# Set the state of the current history array to STATE. + +proc history_set_history_state*(a2: ptr THISTORY_STATE){.cdecl, + importc: "history_set_history_state", dynlib: historyDll.} +# Manage the history list. +# Place STRING at the end of the history list. +# The associated data field (if any) is set to NULL. + +proc add_history*(a2: cstring){.cdecl, importc: "add_history", + dynlib: historyDll.} +# Change the timestamp associated with the most recent history entry to +# STRING. + +proc add_history_time*(a2: cstring){.cdecl, importc: "add_history_time", + dynlib: historyDll.} +# A reasonably useless function, only here for completeness. WHICH +# is the magic number that tells us which element to delete. The +# elements are numbered from 0. + +proc remove_history*(a2: cint): ptr THIST_ENTRY{.cdecl, + importc: "remove_history", dynlib: historyDll.} +# Free the history entry H and return any application-specific data +# associated with it. + +proc free_history_entry*(a2: ptr THIST_ENTRY): Thistdata{.cdecl, + importc: "free_history_entry", dynlib: historyDll.} +# Make the history entry at WHICH have LINE and DATA. This returns +# the old entry so you can dispose of the data. In the case of an +# invalid WHICH, a NULL pointer is returned. + +proc replace_history_entry*(a2: cint, a3: cstring, a4: Thistdata): ptr THIST_ENTRY{. + cdecl, importc: "replace_history_entry", dynlib: historyDll.} +# Clear the history list and start over. + +proc clear_history*(){.cdecl, importc: "clear_history", dynlib: historyDll.} +# Stifle the history list, remembering only MAX number of entries. + +proc stifle_history*(a2: cint){.cdecl, importc: "stifle_history", + dynlib: historyDll.} +# Stop stifling the history. This returns the previous amount the +# history was stifled by. The value is positive if the history was +# stifled, negative if it wasn't. + +proc unstifle_history*(): cint{.cdecl, importc: "unstifle_history", + dynlib: historyDll.} +# Return 1 if the history is stifled, 0 if it is not. + +proc history_is_stifled*(): cint{.cdecl, importc: "history_is_stifled", + dynlib: historyDll.} +# Information about the history list. +# Return a NULL terminated array of HIST_ENTRY which is the current input +# history. Element 0 of this list is the beginning of time. If there +# is no history, return NULL. + +proc history_list*(): ptr ptr THIST_ENTRY{.cdecl, importc: "history_list", + dynlib: historyDll.} +# Returns the number which says what history element we are now +# looking at. + +proc where_history*(): cint{.cdecl, importc: "where_history", dynlib: historyDll.} +# Return the history entry at the current position, as determined by +# history_offset. If there is no entry there, return a NULL pointer. + +proc current_history*(): ptr THIST_ENTRY{.cdecl, importc: "current_history", + dynlib: historyDll.} +# Return the history entry which is logically at OFFSET in the history +# array. OFFSET is relative to history_base. + +proc history_get*(a2: cint): ptr THIST_ENTRY{.cdecl, importc: "history_get", + dynlib: historyDll.} +# Return the timestamp associated with the HIST_ENTRY * passed as an +# argument + +proc history_get_time*(a2: ptr THIST_ENTRY): TTime{.cdecl, + importc: "history_get_time", dynlib: historyDll.} +# Return the number of bytes that the primary history entries are using. +# This just adds up the lengths of the_history->lines. + +proc history_total_bytes*(): cint{.cdecl, importc: "history_total_bytes", + dynlib: historyDll.} +# Moving around the history list. +# Set the position in the history list to POS. + +proc history_set_pos*(a2: cint): cint{.cdecl, importc: "history_set_pos", + dynlib: historyDll.} +# Back up history_offset to the previous history entry, and return +# a pointer to that entry. If there is no previous entry, return +# a NULL pointer. + +proc previous_history*(): ptr THIST_ENTRY{.cdecl, importc: "previous_history", + dynlib: historyDll.} +# Move history_offset forward to the next item in the input_history, +# and return the a pointer to that entry. If there is no next entry, +# return a NULL pointer. + +proc next_history*(): ptr THIST_ENTRY{.cdecl, importc: "next_history", + dynlib: historyDll.} +# Searching the history list. +# Search the history for STRING, starting at history_offset. +# If DIRECTION < 0, then the search is through previous entries, +# else through subsequent. If the string is found, then +# current_history () is the history entry, and the value of this function +# is the offset in the line of that history entry that the string was +# found in. Otherwise, nothing is changed, and a -1 is returned. + +proc history_search*(a2: cstring, a3: cint): cint{.cdecl, + importc: "history_search", dynlib: historyDll.} +# Search the history for STRING, starting at history_offset. +# The search is anchored: matching lines must begin with string. +# DIRECTION is as in history_search(). + +proc history_search_prefix*(a2: cstring, a3: cint): cint{.cdecl, + importc: "history_search_prefix", dynlib: historyDll.} +# Search for STRING in the history list, starting at POS, an +# absolute index into the list. DIR, if negative, says to search +# backwards from POS, else forwards. +# Returns the absolute index of the history element where STRING +# was found, or -1 otherwise. + +proc history_search_pos*(a2: cstring, a3: cint, a4: cint): cint{.cdecl, + importc: "history_search_pos", dynlib: historyDll.} +# Managing the history file. +# Add the contents of FILENAME to the history list, a line at a time. +# If FILENAME is NULL, then read from ~/.history. Returns 0 if +# successful, or errno if not. + +proc read_history*(a2: cstring): cint{.cdecl, importc: "read_history", + dynlib: historyDll.} +# Read a range of lines from FILENAME, adding them to the history list. +# Start reading at the FROM'th line and end at the TO'th. If FROM +# is zero, start at the beginning. If TO is less than FROM, read +# until the end of the file. If FILENAME is NULL, then read from +# ~/.history. Returns 0 if successful, or errno if not. + +proc read_history_range*(a2: cstring, a3: cint, a4: cint): cint{.cdecl, + importc: "read_history_range", dynlib: historyDll.} +# Write the current history to FILENAME. If FILENAME is NULL, +# then write the history list to ~/.history. Values returned +# are as in read_history (). + +proc write_history*(a2: cstring): cint{.cdecl, importc: "write_history", + dynlib: historyDll.} +# Append NELEMENT entries to FILENAME. The entries appended are from +# the end of the list minus NELEMENTs up to the end of the list. + +proc append_history*(a2: cint, a3: cstring): cint{.cdecl, + importc: "append_history", dynlib: historyDll.} +# Truncate the history file, leaving only the last NLINES lines. + +proc history_truncate_file*(a2: cstring, a3: cint): cint{.cdecl, + importc: "history_truncate_file", dynlib: historyDll.} +# History expansion. +# Expand the string STRING, placing the result into OUTPUT, a pointer +# to a string. Returns: +# +# 0) If no expansions took place (or, if the only change in +# the text was the de-slashifying of the history expansion +# character) +# 1) If expansions did take place +# -1) If there was an error in expansion. +# 2) If the returned line should just be printed. +# +# If an error ocurred in expansion, then OUTPUT contains a descriptive +# error message. + +proc history_expand*(a2: cstring, a3: cstringArray): cint{.cdecl, + importc: "history_expand", dynlib: historyDll.} +# Extract a string segment consisting of the FIRST through LAST +# arguments present in STRING. Arguments are broken up as in +# the shell. + +proc history_arg_extract*(a2: cint, a3: cint, a4: cstring): cstring{.cdecl, + importc: "history_arg_extract", dynlib: historyDll.} +# Return the text of the history event beginning at the current +# offset into STRING. Pass STRING with *INDEX equal to the +# history_expansion_char that begins this specification. +# DELIMITING_QUOTE is a character that is allowed to end the string +# specification for what to search for in addition to the normal +# characters `:', ` ', `\t', `\n', and sometimes `?'. + +proc get_history_event*(a2: cstring, a3: ptr cint, a4: cint): cstring{.cdecl, + importc: "get_history_event", dynlib: historyDll.} +# Return an array of tokens, much as the shell might. The tokens are +# parsed out of STRING. + +proc history_tokenize*(a2: cstring): cstringArray{.cdecl, + importc: "history_tokenize", dynlib: historyDll.} +when false: + # Exported history variables. + var history_base*{.importc: "history_base", dynlib: historyDll.}: cint + var history_length*{.importc: "history_length", dynlib: historyDll.}: cint + var history_max_entries*{.importc: "history_max_entries", dynlib: historyDll.}: cint + var history_expansion_char*{.importc: "history_expansion_char", + dynlib: historyDll.}: char + var history_subst_char*{.importc: "history_subst_char", dynlib: historyDll.}: char + var history_word_delimiters*{.importc: "history_word_delimiters", + dynlib: historyDll.}: cstring + var history_comment_char*{.importc: "history_comment_char", dynlib: historyDll.}: char + var history_no_expand_chars*{.importc: "history_no_expand_chars", + dynlib: historyDll.}: cstring + var history_search_delimiter_chars*{.importc: "history_search_delimiter_chars", + dynlib: historyDll.}: cstring + var history_quotes_inhibit_expansion*{. + importc: "history_quotes_inhibit_expansion", dynlib: historyDll.}: cint + var history_write_timestamps*{.importc: "history_write_timestamps", + dynlib: historyDll.}: cint diff --git a/lib/wrappers/readline/readline.nim b/lib/wrappers/readline/readline.nim new file mode 100644 index 000000000..96dab2049 --- /dev/null +++ b/lib/wrappers/readline/readline.nim @@ -0,0 +1,1198 @@ +# Readline.h -- the names of functions callable from within readline. +# Copyright (C) 1987-2009 Free Software Foundation, Inc. +# +# This file is part of the GNU Readline Library (Readline), a library +# for reading lines of text with interactive input and history editing. +# +# Readline 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 3 of the License, or +# (at your option) any later version. +# +# Readline 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 Readline. If not, see <http://www.gnu.org/licenses/>. +# + +{.deadCodeElim: on.} +when defined(windows): + const + readlineDll = "readline.dll" +elif defined(macosx): + const + readlineDll = "libreadline.dynlib" +else: + const + readlineDll = "libreadline.so.6(|.0)" +## mangle "'TCommandFunc'" TCommandFunc +## mangle TvcpFunc TvcpFunc + +import rltypedefs + +# Some character stuff. + +const + control_character_threshold* = 0x00000020 # Smaller than this is control. + control_character_mask* = 0x0000001F # 0x20 - 1 + meta_character_threshold* = 0x0000007F # Larger than this is Meta. + control_character_bit* = 0x00000040 # 0x000000, must be off. + meta_character_bit* = 0x00000080 # x0000000, must be on. + largest_char* = 255 # Largest character value. + +template CTRL_CHAR*(c: expr): expr = + (c < control_character_threshold and ((c and 0x00000080) == 0)) + +template META_CHAR*(c: expr): expr = + (c > meta_character_threshold and c <= largest_char) + +template CTRL*(c: expr): expr = + (c and control_character_mask) + +template META*(c: expr): expr = + (c or meta_character_bit) + +template UNMETA*(c: expr): expr = + (c and not meta_character_bit) + +template UNCTRL*(c: expr): expr = + (c or 32 or control_character_bit) + +# Beware: these only work with single-byte ASCII characters. + +const + RETURN_CHAR* = CTRL('M'.ord) + RUBOUT_CHAR* = 0x0000007F + ABORT_CHAR* = CTRL('G'.ord) + PAGE_CHAR* = CTRL('L'.ord) + ESC_CHAR* = CTRL('['.ord) + +# A keymap contains one entry for each key in the ASCII set. +# Each entry consists of a type and a pointer. +# FUNCTION is the address of a function to run, or the +# address of a keymap to indirect through. +# TYPE says which kind of thing FUNCTION is. + +type + TKEYMAP_ENTRY*{.pure, final.} = object + typ*: char + function*: TCommandFunc + + +# This must be large enough to hold bindings for all of the characters +# in a desired character set (e.g, 128 for ASCII, 256 for ISO Latin-x, +# and so on) plus one for subsequence matching. + +const + KEYMAP_SIZE* = 257 + ANYOTHERKEY* = KEYMAP_SIZE - 1 + +# I wanted to make the above structure contain a union of: +# union { rl_TCommandFunc_t *function; struct _keymap_entry *keymap; } value; +# but this made it impossible for me to create a static array. +# Maybe I need C lessons. + +type + TKEYMAP_ENTRY_ARRAY* = array[0..KEYMAP_SIZE - 1, TKEYMAP_ENTRY] + PKeymap* = ptr TKEYMAP_ENTRY + +# The values that TYPE can have in a keymap entry. + +const + ISFUNC* = 0 + ISKMAP* = 1 + ISMACR* = 2 + +when false: + var + emacs_standard_keymap*{.importc: "emacs_standard_keymap", + dynlib: readlineDll.}: TKEYMAP_ENTRY_ARRAY + emacs_meta_keymap*{.importc: "emacs_meta_keymap", dynlib: readlineDll.}: TKEYMAP_ENTRY_ARRAY + emacs_ctlx_keymap*{.importc: "emacs_ctlx_keymap", dynlib: readlineDll.}: TKEYMAP_ENTRY_ARRAY + var + vi_insertion_keymap*{.importc: "vi_insertion_keymap", dynlib: readlineDll.}: TKEYMAP_ENTRY_ARRAY + vi_movement_keymap*{.importc: "vi_movement_keymap", dynlib: readlineDll.}: TKEYMAP_ENTRY_ARRAY +# Return a new, empty keymap. +# Free it with free() when you are done. + +proc make_bare_keymap*(): PKeymap{.cdecl, importc: "rl_make_bare_keymap", + dynlib: readlineDll.} +# Return a new keymap which is a copy of MAP. + +proc copy_keymap*(a2: PKeymap): PKeymap{.cdecl, importc: "rl_copy_keymap", + dynlib: readlineDll.} +# Return a new keymap with the printing characters bound to rl_insert, +# the lowercase Meta characters bound to run their equivalents, and +# the Meta digits bound to produce numeric arguments. + +proc make_keymap*(): PKeymap{.cdecl, importc: "rl_make_keymap", + dynlib: readlineDll.} +# Free the storage associated with a keymap. + +proc discard_keymap*(a2: PKeymap){.cdecl, importc: "rl_discard_keymap", + dynlib: readlineDll.} +# These functions actually appear in bind.c +# Return the keymap corresponding to a given name. Names look like +# `emacs' or `emacs-meta' or `vi-insert'. + +proc get_keymap_by_name*(a2: cstring): PKeymap{.cdecl, + importc: "rl_get_keymap_by_name", dynlib: readlineDll.} +# Return the current keymap. + +proc get_keymap*(): PKeymap{.cdecl, importc: "rl_get_keymap", + dynlib: readlineDll.} +# Set the current keymap to MAP. + +proc set_keymap*(a2: PKeymap){.cdecl, importc: "rl_set_keymap", + dynlib: readlineDll.} + +const + tildeDll = readlineDll + +type + Thook_func* = proc (a2: cstring): cstring{.cdecl.} + +# If non-null, this contains the address of a function that the application +# wants called before trying the standard tilde expansions. The function +# is called with the text sans tilde, and returns a malloc()'ed string +# which is the expansion, or a NULL pointer if the expansion fails. + +var expansion_preexpansion_hook*{.importc: "tilde_expansion_preexpansion_hook", + dynlib: tildeDll.}: Thook_func + +# If non-null, this contains the address of a function to call if the +# standard meaning for expanding a tilde fails. The function is called +# with the text (sans tilde, as in "foo"), and returns a malloc()'ed string +# which is the expansion, or a NULL pointer if there is no expansion. + +var expansion_failure_hook*{.importc: "tilde_expansion_failure_hook", + dynlib: tildeDll.}: Thook_func + +# When non-null, this is a NULL terminated array of strings which +# are duplicates for a tilde prefix. Bash uses this to expand +# `=~' and `:~'. + +var additional_prefixes*{.importc: "tilde_additional_prefixes", dynlib: tildeDll.}: cstringArray + +# When non-null, this is a NULL terminated array of strings which match +# the end of a username, instead of just "/". Bash sets this to +# `:' and `=~'. + +var additional_suffixes*{.importc: "tilde_additional_suffixes", dynlib: tildeDll.}: cstringArray + +# Return a new string which is the result of tilde expanding STRING. + +proc expand*(a2: cstring): cstring{.cdecl, importc: "tilde_expand", + dynlib: tildeDll.} +# Do the work of tilde expansion on FILENAME. FILENAME starts with a +# tilde. If there is no expansion, call tilde_expansion_failure_hook. + +proc expand_word*(a2: cstring): cstring{.cdecl, importc: "tilde_expand_word", + dynlib: tildeDll.} +# Find the portion of the string beginning with ~ that should be expanded. + +proc find_word*(a2: cstring, a3: cint, a4: ptr cint): cstring{.cdecl, + importc: "tilde_find_word", dynlib: tildeDll.} + +# Hex-encoded Readline version number. + +const + READLINE_VERSION* = 0x00000600 # Readline 6.0 + VERSION_MAJOR* = 6 + VERSION_MINOR* = 0 + +# Readline data structures. +# Maintaining the state of undo. We remember individual deletes and inserts +# on a chain of things to do. +# The actions that undo knows how to undo. Notice that UNDO_DELETE means +# to insert some text, and UNDO_INSERT means to delete some text. I.e., +# the code tells undo what to undo, not how to undo it. + +type + Tundo_code* = enum + UNDO_DELETE, UNDO_INSERT, UNDO_BEGIN, UNDO_END + +# What an element of THE_UNDO_LIST looks like. + +type + TUNDO_LIST*{.pure, final.} = object + next*: ptr Tundo_list + start*: cint + theEnd*: cint # Where the change took place. + text*: cstring # The text to insert, if undoing a delete. + what*: Tundo_code # Delete, Insert, Begin, End. + + +# The current undo list for RL_LINE_BUFFER. + +var undo_list*{.importc: "rl_undo_list", dynlib: readlineDll.}: ptr TUNDO_LIST + +# The data structure for mapping textual names to code addresses. + +type + TFUNMAP*{.pure, final.} = object + name*: cstring + function*: TCommandFunc + + +var funmap*{.importc: "funmap", dynlib: readlineDll.}: ptr ptr TFUNMAP + +# **************************************************************** +# +# Functions available to bind to key sequences +# +# **************************************************************** +# Bindable commands for numeric arguments. + +proc digit_argument*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_digit_argument", dynlib: readlineDll.} +proc universal_argument*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_universal_argument", dynlib: readlineDll.} +# Bindable commands for moving the cursor. + +proc forward_byte*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_forward_byte", + dynlib: readlineDll.} +proc forward_char*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_forward_char", + dynlib: readlineDll.} +proc forward*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_forward", + dynlib: readlineDll.} +proc backward_byte*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_backward_byte", dynlib: readlineDll.} +proc backward_char*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_backward_char", dynlib: readlineDll.} +proc backward*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_backward", + dynlib: readlineDll.} +proc beg_of_line*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_beg_of_line", + dynlib: readlineDll.} +proc end_of_line*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_end_of_line", + dynlib: readlineDll.} +proc forward_word*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_forward_word", + dynlib: readlineDll.} +proc backward_word*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_backward_word", dynlib: readlineDll.} +proc refresh_line*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_refresh_line", + dynlib: readlineDll.} +proc clear_screen*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_clear_screen", + dynlib: readlineDll.} +proc skip_csi_sequence*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_skip_csi_sequence", dynlib: readlineDll.} +proc arrow_keys*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_arrow_keys", + dynlib: readlineDll.} +# Bindable commands for inserting and deleting text. + +proc insert*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_insert", + dynlib: readlineDll.} +proc quoted_insert*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_quoted_insert", dynlib: readlineDll.} +proc tab_insert*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_tab_insert", + dynlib: readlineDll.} +proc newline*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_newline", + dynlib: readlineDll.} +proc do_lowercase_version*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_do_lowercase_version", dynlib: readlineDll.} +proc rubout*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_rubout", + dynlib: readlineDll.} +proc delete*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_delete", + dynlib: readlineDll.} +proc rubout_or_delete*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_rubout_or_delete", dynlib: readlineDll.} +proc delete_horizontal_space*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_delete_horizontal_space", dynlib: readlineDll.} +proc delete_or_show_completions*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_delete_or_show_completions", dynlib: readlineDll.} +proc insert_comment*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_insert_comment", dynlib: readlineDll.} +# Bindable commands for changing case. + +proc upcase_word*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_upcase_word", + dynlib: readlineDll.} +proc downcase_word*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_downcase_word", dynlib: readlineDll.} +proc capitalize_word*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_capitalize_word", dynlib: readlineDll.} +# Bindable commands for transposing characters and words. + +proc transpose_words*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_transpose_words", dynlib: readlineDll.} +proc transpose_chars*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_transpose_chars", dynlib: readlineDll.} +# Bindable commands for searching within a line. + +proc char_search*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_char_search", + dynlib: readlineDll.} +proc backward_char_search*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_backward_char_search", dynlib: readlineDll.} +# Bindable commands for readline's interface to the command history. + +proc beginning_of_history*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_beginning_of_history", dynlib: readlineDll.} +proc end_of_history*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_end_of_history", dynlib: readlineDll.} +proc get_next_history*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_get_next_history", dynlib: readlineDll.} +proc get_previous_history*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_get_previous_history", dynlib: readlineDll.} +# Bindable commands for managing the mark and region. + +proc set_mark*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_set_mark", + dynlib: readlineDll.} +proc exchange_point_and_mark*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_exchange_point_and_mark", dynlib: readlineDll.} +# Bindable commands to set the editing mode (emacs or vi). + +proc vi_editing_mode*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_vi_editing_mode", dynlib: readlineDll.} +proc emacs_editing_mode*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_emacs_editing_mode", dynlib: readlineDll.} +# Bindable commands to change the insert mode (insert or overwrite) + +proc overwrite_mode*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_overwrite_mode", dynlib: readlineDll.} +# Bindable commands for managing key bindings. + +proc re_read_init_file*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_re_read_init_file", dynlib: readlineDll.} +proc dump_functions*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_dump_functions", dynlib: readlineDll.} +proc dump_macros*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_dump_macros", + dynlib: readlineDll.} +proc dump_variables*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_dump_variables", dynlib: readlineDll.} +# Bindable commands for word completion. + +proc complete*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_complete", + dynlib: readlineDll.} +proc possible_completions*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_possible_completions", dynlib: readlineDll.} +proc insert_completions*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_insert_completions", dynlib: readlineDll.} +proc old_menu_complete*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_old_menu_complete", dynlib: readlineDll.} +proc menu_complete*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_menu_complete", dynlib: readlineDll.} +proc backward_menu_complete*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_backward_menu_complete", dynlib: readlineDll.} +# Bindable commands for killing and yanking text, and managing the kill ring. + +proc kill_word*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_kill_word", + dynlib: readlineDll.} +proc backward_kill_word*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_backward_kill_word", dynlib: readlineDll.} +proc kill_line*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_kill_line", + dynlib: readlineDll.} +proc backward_kill_line*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_backward_kill_line", dynlib: readlineDll.} +proc kill_full_line*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_kill_full_line", dynlib: readlineDll.} +proc unix_word_rubout*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_unix_word_rubout", dynlib: readlineDll.} +proc unix_filename_rubout*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_unix_filename_rubout", dynlib: readlineDll.} +proc unix_line_discard*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_unix_line_discard", dynlib: readlineDll.} +proc copy_region_to_kill*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_copy_region_to_kill", dynlib: readlineDll.} +proc kill_region*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_kill_region", + dynlib: readlineDll.} +proc copy_forward_word*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_copy_forward_word", dynlib: readlineDll.} +proc copy_backward_word*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_copy_backward_word", dynlib: readlineDll.} +proc yank*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_yank", + dynlib: readlineDll.} +proc yank_pop*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_yank_pop", + dynlib: readlineDll.} +proc yank_nth_arg*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_yank_nth_arg", + dynlib: readlineDll.} +proc yank_last_arg*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_yank_last_arg", dynlib: readlineDll.} +when defined(Windows): + proc paste_from_clipboard*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_paste_from_clipboard", dynlib: readlineDll.} +# Bindable commands for incremental searching. + +proc reverse_search_history*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_reverse_search_history", dynlib: readlineDll.} +proc forward_search_history*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_forward_search_history", dynlib: readlineDll.} +# Bindable keyboard macro commands. + +proc start_kbd_macro*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_start_kbd_macro", dynlib: readlineDll.} +proc end_kbd_macro*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_end_kbd_macro", dynlib: readlineDll.} +proc call_last_kbd_macro*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_call_last_kbd_macro", dynlib: readlineDll.} +# Bindable undo commands. + +proc revert_line*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_revert_line", + dynlib: readlineDll.} +proc undo_command*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_undo_command", + dynlib: readlineDll.} +# Bindable tilde expansion commands. + +proc tilde_expand*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_tilde_expand", + dynlib: readlineDll.} +# Bindable terminal control commands. + +proc restart_output*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_restart_output", dynlib: readlineDll.} +proc stop_output*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_stop_output", + dynlib: readlineDll.} +# Miscellaneous bindable commands. + +proc abort*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_abort", + dynlib: readlineDll.} +proc tty_status*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_tty_status", + dynlib: readlineDll.} +# Bindable commands for incremental and non-incremental history searching. + +proc history_search_forward*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_history_search_forward", dynlib: readlineDll.} +proc history_search_backward*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_history_search_backward", dynlib: readlineDll.} +proc noninc_forward_search*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_noninc_forward_search", dynlib: readlineDll.} +proc noninc_reverse_search*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_noninc_reverse_search", dynlib: readlineDll.} +proc noninc_forward_search_again*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_noninc_forward_search_again", dynlib: readlineDll.} +proc noninc_reverse_search_again*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_noninc_reverse_search_again", dynlib: readlineDll.} +# Bindable command used when inserting a matching close character. + +proc insert_close*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_insert_close", + dynlib: readlineDll.} +# Not available unless READLINE_CALLBACKS is defined. + +proc callback_handler_install*(a2: cstring, a3: TvcpFunc){.cdecl, + importc: "rl_callback_handler_install", dynlib: readlineDll.} +proc callback_read_char*(){.cdecl, importc: "rl_callback_read_char", + dynlib: readlineDll.} +proc callback_handler_remove*(){.cdecl, importc: "rl_callback_handler_remove", + dynlib: readlineDll.} +# Things for vi mode. Not available unless readline is compiled -DVI_MODE. +# VI-mode bindable commands. + +proc vi_redo*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_redo", + dynlib: readlineDll.} +proc vi_undo*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_undo", + dynlib: readlineDll.} +proc vi_yank_arg*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_yank_arg", + dynlib: readlineDll.} +proc vi_fetch_history*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_vi_fetch_history", dynlib: readlineDll.} +proc vi_search_again*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_vi_search_again", dynlib: readlineDll.} +proc vi_search*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_search", + dynlib: readlineDll.} +proc vi_complete*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_complete", + dynlib: readlineDll.} +proc vi_tilde_expand*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_vi_tilde_expand", dynlib: readlineDll.} +proc vi_prev_word*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_prev_word", + dynlib: readlineDll.} +proc vi_next_word*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_next_word", + dynlib: readlineDll.} +proc vi_end_word*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_end_word", + dynlib: readlineDll.} +proc vi_insert_beg*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_vi_insert_beg", dynlib: readlineDll.} +proc vi_append_mode*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_vi_append_mode", dynlib: readlineDll.} +proc vi_append_eol*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_vi_append_eol", dynlib: readlineDll.} +proc vi_eof_maybe*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_eof_maybe", + dynlib: readlineDll.} +proc vi_insertion_mode*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_vi_insertion_mode", dynlib: readlineDll.} +proc vi_insert_mode*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_vi_insert_mode", dynlib: readlineDll.} +proc vi_movement_mode*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_vi_movement_mode", dynlib: readlineDll.} +proc vi_arg_digit*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_arg_digit", + dynlib: readlineDll.} +proc vi_change_case*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_vi_change_case", dynlib: readlineDll.} +proc vi_put*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_put", + dynlib: readlineDll.} +proc vi_column*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_column", + dynlib: readlineDll.} +proc vi_delete_to*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_delete_to", + dynlib: readlineDll.} +proc vi_change_to*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_change_to", + dynlib: readlineDll.} +proc vi_yank_to*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_yank_to", + dynlib: readlineDll.} +proc vi_rubout*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_rubout", + dynlib: readlineDll.} +proc vi_delete*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_delete", + dynlib: readlineDll.} +proc vi_back_to_indent*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_vi_back_to_indent", dynlib: readlineDll.} +proc vi_first_print*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_vi_first_print", dynlib: readlineDll.} +proc vi_char_search*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_vi_char_search", dynlib: readlineDll.} +proc vi_match*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_match", + dynlib: readlineDll.} +proc vi_change_char*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_vi_change_char", dynlib: readlineDll.} +proc vi_subst*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_subst", + dynlib: readlineDll.} +proc vi_overstrike*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_vi_overstrike", dynlib: readlineDll.} +proc vi_overstrike_delete*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_vi_overstrike_delete", dynlib: readlineDll.} +proc vi_replace*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_replace", + dynlib: readlineDll.} +proc vi_set_mark*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_set_mark", + dynlib: readlineDll.} +proc vi_goto_mark*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_goto_mark", + dynlib: readlineDll.} +# VI-mode utility functions. + +proc vi_check*(): cint{.cdecl, importc: "rl_vi_check", dynlib: readlineDll.} +proc vi_domove*(a2: cint, a3: ptr cint): cint{.cdecl, importc: "rl_vi_domove", + dynlib: readlineDll.} +proc vi_bracktype*(a2: cint): cint{.cdecl, importc: "rl_vi_bracktype", + dynlib: readlineDll.} +proc vi_start_inserting*(a2: cint, a3: cint, a4: cint){.cdecl, + importc: "rl_vi_start_inserting", dynlib: readlineDll.} +# VI-mode pseudo-bindable commands, used as utility functions. + +proc vi_fXWord*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_fWord", + dynlib: readlineDll.} +proc vi_bXWord*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_bWord", + dynlib: readlineDll.} +proc vi_eXWord*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_eWord", + dynlib: readlineDll.} +proc vi_fword*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_fword", + dynlib: readlineDll.} +proc vi_bword*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_bword", + dynlib: readlineDll.} +proc vi_eword*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_eword", + dynlib: readlineDll.} +# **************************************************************** +# +# Well Published Functions +# +# **************************************************************** +# Readline functions. +# Read a line of input. Prompt with PROMPT. A NULL PROMPT means none. + +proc readline*(a2: cstring): cstring{.cdecl, importc: "readline", + dynlib: readlineDll.} +proc free*(mem: cstring) {.importc: "free", nodecl.} + ## free the buffer that `readline` returned. + +proc set_prompt*(a2: cstring): cint{.cdecl, importc: "rl_set_prompt", + dynlib: readlineDll.} +proc expand_prompt*(a2: cstring): cint{.cdecl, importc: "rl_expand_prompt", + dynlib: readlineDll.} +proc initialize*(): cint{.cdecl, importc: "rl_initialize", dynlib: readlineDll.} +# Undocumented; unused by readline + +proc discard_argument*(): cint{.cdecl, importc: "rl_discard_argument", + dynlib: readlineDll.} +# Utility functions to bind keys to readline commands. + +proc add_defun*(a2: cstring, a3: TCommandFunc, a4: cint): cint{.cdecl, + importc: "rl_add_defun", dynlib: readlineDll.} +proc bind_key*(a2: cint, a3: TCommandFunc): cint{.cdecl, + importc: "rl_bind_key", dynlib: readlineDll.} +proc bind_key_in_map*(a2: cint, a3: TCommandFunc, a4: PKeymap): cint{.cdecl, + importc: "rl_bind_key_in_map", dynlib: readlineDll.} +proc unbind_key*(a2: cint): cint{.cdecl, importc: "rl_unbind_key", + dynlib: readlineDll.} +proc unbind_key_in_map*(a2: cint, a3: PKeymap): cint{.cdecl, + importc: "rl_unbind_key_in_map", dynlib: readlineDll.} +proc bind_key_if_unbound*(a2: cint, a3: TCommandFunc): cint{.cdecl, + importc: "rl_bind_key_if_unbound", dynlib: readlineDll.} +proc bind_key_if_unbound_in_map*(a2: cint, a3: TCommandFunc, a4: PKeymap): cint{. + cdecl, importc: "rl_bind_key_if_unbound_in_map", dynlib: readlineDll.} +proc unbind_function_in_map*(a2: TCommandFunc, a3: PKeymap): cint{.cdecl, + importc: "rl_unbind_function_in_map", dynlib: readlineDll.} +proc unbind_command_in_map*(a2: cstring, a3: PKeymap): cint{.cdecl, + importc: "rl_unbind_command_in_map", dynlib: readlineDll.} +proc bind_keyseq*(a2: cstring, a3: TCommandFunc): cint{.cdecl, + importc: "rl_bind_keyseq", dynlib: readlineDll.} +proc bind_keyseq_in_map*(a2: cstring, a3: TCommandFunc, a4: PKeymap): cint{. + cdecl, importc: "rl_bind_keyseq_in_map", dynlib: readlineDll.} +proc bind_keyseq_if_unbound*(a2: cstring, a3: TCommandFunc): cint{.cdecl, + importc: "rl_bind_keyseq_if_unbound", dynlib: readlineDll.} +proc bind_keyseq_if_unbound_in_map*(a2: cstring, a3: TCommandFunc, + a4: PKeymap): cint{.cdecl, + importc: "rl_bind_keyseq_if_unbound_in_map", dynlib: readlineDll.} +proc generic_bind*(a2: cint, a3: cstring, a4: cstring, a5: PKeymap): cint{. + cdecl, importc: "rl_generic_bind", dynlib: readlineDll.} +proc variable_value*(a2: cstring): cstring{.cdecl, importc: "rl_variable_value", + dynlib: readlineDll.} +proc variable_bind*(a2: cstring, a3: cstring): cint{.cdecl, + importc: "rl_variable_bind", dynlib: readlineDll.} +# Backwards compatibility, use rl_bind_keyseq_in_map instead. + +proc set_key*(a2: cstring, a3: TCommandFunc, a4: PKeymap): cint{.cdecl, + importc: "rl_set_key", dynlib: readlineDll.} +# Backwards compatibility, use rl_generic_bind instead. + +proc macro_bind*(a2: cstring, a3: cstring, a4: PKeymap): cint{.cdecl, + importc: "rl_macro_bind", dynlib: readlineDll.} +# Undocumented in the texinfo manual; not really useful to programs. + +proc translate_keyseq*(a2: cstring, a3: cstring, a4: ptr cint): cint{.cdecl, + importc: "rl_translate_keyseq", dynlib: readlineDll.} +proc untranslate_keyseq*(a2: cint): cstring{.cdecl, + importc: "rl_untranslate_keyseq", dynlib: readlineDll.} +proc named_function*(a2: cstring): TCommandFunc{.cdecl, + importc: "rl_named_function", dynlib: readlineDll.} +proc function_of_keyseq*(a2: cstring, a3: PKeymap, a4: ptr cint): TCommandFunc{. + cdecl, importc: "rl_function_of_keyseq", dynlib: readlineDll.} +proc list_funmap_names*(){.cdecl, importc: "rl_list_funmap_names", + dynlib: readlineDll.} +proc invoking_keyseqs_in_map*(a2: TCommandFunc, a3: PKeymap): cstringArray{. + cdecl, importc: "rl_invoking_keyseqs_in_map", dynlib: readlineDll.} +proc invoking_keyseqs*(a2: TCommandFunc): cstringArray{.cdecl, + importc: "rl_invoking_keyseqs", dynlib: readlineDll.} +proc function_dumper*(a2: cint){.cdecl, importc: "rl_function_dumper", + dynlib: readlineDll.} +proc macro_dumper*(a2: cint){.cdecl, importc: "rl_macro_dumper", + dynlib: readlineDll.} +proc variable_dumper*(a2: cint){.cdecl, importc: "rl_variable_dumper", + dynlib: readlineDll.} +proc read_init_file*(a2: cstring): cint{.cdecl, importc: "rl_read_init_file", + dynlib: readlineDll.} +proc parse_and_bind*(a2: cstring): cint{.cdecl, importc: "rl_parse_and_bind", + dynlib: readlineDll.} + +proc get_keymap_name*(a2: PKeymap): cstring{.cdecl, + importc: "rl_get_keymap_name", dynlib: readlineDll.} + +proc set_keymap_from_edit_mode*(){.cdecl, + importc: "rl_set_keymap_from_edit_mode", + dynlib: readlineDll.} +proc get_keymap_name_from_edit_mode*(): cstring{.cdecl, + importc: "rl_get_keymap_name_from_edit_mode", dynlib: readlineDll.} +# Functions for manipulating the funmap, which maps command names to functions. + +proc add_funmap_entry*(a2: cstring, a3: TCommandFunc): cint{.cdecl, + importc: "rl_add_funmap_entry", dynlib: readlineDll.} +proc funmap_names*(): cstringArray{.cdecl, importc: "rl_funmap_names", + dynlib: readlineDll.} +# Undocumented, only used internally -- there is only one funmap, and this +# function may be called only once. + +proc initialize_funmap*(){.cdecl, importc: "rl_initialize_funmap", + dynlib: readlineDll.} +# Utility functions for managing keyboard macros. + +proc push_macro_input*(a2: cstring){.cdecl, importc: "rl_push_macro_input", + dynlib: readlineDll.} +# Functions for undoing, from undo.c + +proc add_undo*(a2: Tundo_code, a3: cint, a4: cint, a5: cstring){.cdecl, + importc: "rl_add_undo", dynlib: readlineDll.} +proc free_undo_list*(){.cdecl, importc: "rl_free_undo_list", dynlib: readlineDll.} +proc do_undo*(): cint{.cdecl, importc: "rl_do_undo", dynlib: readlineDll.} +proc begin_undo_group*(): cint{.cdecl, importc: "rl_begin_undo_group", + dynlib: readlineDll.} +proc end_undo_group*(): cint{.cdecl, importc: "rl_end_undo_group", + dynlib: readlineDll.} +proc modifying*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_modifying", + dynlib: readlineDll.} +# Functions for redisplay. + +proc redisplay*(){.cdecl, importc: "rl_redisplay", dynlib: readlineDll.} +proc on_new_line*(): cint{.cdecl, importc: "rl_on_new_line", dynlib: readlineDll.} +proc on_new_line_with_prompt*(): cint{.cdecl, + importc: "rl_on_new_line_with_prompt", + dynlib: readlineDll.} +proc forced_update_display*(): cint{.cdecl, importc: "rl_forced_update_display", + dynlib: readlineDll.} +proc clear_message*(): cint{.cdecl, importc: "rl_clear_message", + dynlib: readlineDll.} +proc reset_line_state*(): cint{.cdecl, importc: "rl_reset_line_state", + dynlib: readlineDll.} +proc crlf*(): cint{.cdecl, importc: "rl_crlf", dynlib: readlineDll.} +proc message*(a2: cstring): cint{.varargs, cdecl, importc: "rl_message", + dynlib: readlineDll.} +proc show_char*(a2: cint): cint{.cdecl, importc: "rl_show_char", + dynlib: readlineDll.} +# Undocumented in texinfo manual. + +proc character_len*(a2: cint, a3: cint): cint{.cdecl, + importc: "rl_character_len", dynlib: readlineDll.} +# Save and restore internal prompt redisplay information. + +proc save_prompt*(){.cdecl, importc: "rl_save_prompt", dynlib: readlineDll.} +proc restore_prompt*(){.cdecl, importc: "rl_restore_prompt", dynlib: readlineDll.} +# Modifying text. + +proc replace_line*(a2: cstring, a3: cint){.cdecl, importc: "rl_replace_line", + dynlib: readlineDll.} +proc insert_text*(a2: cstring): cint{.cdecl, importc: "rl_insert_text", + dynlib: readlineDll.} +proc delete_text*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_delete_text", + dynlib: readlineDll.} +proc kill_text*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_kill_text", + dynlib: readlineDll.} +proc copy_text*(a2: cint, a3: cint): cstring{.cdecl, importc: "rl_copy_text", + dynlib: readlineDll.} +# Terminal and tty mode management. + +proc prep_terminal*(a2: cint){.cdecl, importc: "rl_prep_terminal", + dynlib: readlineDll.} +proc deprep_terminal*(){.cdecl, importc: "rl_deprep_terminal", + dynlib: readlineDll.} +proc tty_set_default_bindings*(a2: PKeymap){.cdecl, + importc: "rl_tty_set_default_bindings", dynlib: readlineDll.} +proc tty_unset_default_bindings*(a2: PKeymap){.cdecl, + importc: "rl_tty_unset_default_bindings", dynlib: readlineDll.} +proc reset_terminal*(a2: cstring): cint{.cdecl, importc: "rl_reset_terminal", + dynlib: readlineDll.} +proc resize_terminal*(){.cdecl, importc: "rl_resize_terminal", + dynlib: readlineDll.} +proc set_screen_size*(a2: cint, a3: cint){.cdecl, importc: "rl_set_screen_size", + dynlib: readlineDll.} +proc get_screen_size*(a2: ptr cint, a3: ptr cint){.cdecl, + importc: "rl_get_screen_size", dynlib: readlineDll.} +proc reset_screen_size*(){.cdecl, importc: "rl_reset_screen_size", + dynlib: readlineDll.} +proc get_termcap*(a2: cstring): cstring{.cdecl, importc: "rl_get_termcap", + dynlib: readlineDll.} +# Functions for character input. + +proc stuff_char*(a2: cint): cint{.cdecl, importc: "rl_stuff_char", + dynlib: readlineDll.} +proc execute_next*(a2: cint): cint{.cdecl, importc: "rl_execute_next", + dynlib: readlineDll.} +proc clear_pending_input*(): cint{.cdecl, importc: "rl_clear_pending_input", + dynlib: readlineDll.} +proc read_key*(): cint{.cdecl, importc: "rl_read_key", dynlib: readlineDll.} +proc getc*(a2: TFile): cint{.cdecl, importc: "rl_getc", dynlib: readlineDll.} +proc set_keyboard_input_timeout*(a2: cint): cint{.cdecl, + importc: "rl_set_keyboard_input_timeout", dynlib: readlineDll.} +# `Public' utility functions . + +proc extend_line_buffer*(a2: cint){.cdecl, importc: "rl_extend_line_buffer", + dynlib: readlineDll.} +proc ding*(): cint{.cdecl, importc: "rl_ding", dynlib: readlineDll.} +proc alphabetic*(a2: cint): cint{.cdecl, importc: "rl_alphabetic", + dynlib: readlineDll.} +proc free*(a2: pointer){.cdecl, importc: "rl_free", dynlib: readlineDll.} +# Readline signal handling, from signals.c + +proc set_signals*(): cint{.cdecl, importc: "rl_set_signals", dynlib: readlineDll.} +proc clear_signals*(): cint{.cdecl, importc: "rl_clear_signals", + dynlib: readlineDll.} +proc cleanup_after_signal*(){.cdecl, importc: "rl_cleanup_after_signal", + dynlib: readlineDll.} +proc reset_after_signal*(){.cdecl, importc: "rl_reset_after_signal", + dynlib: readlineDll.} +proc free_line_state*(){.cdecl, importc: "rl_free_line_state", + dynlib: readlineDll.} +proc echo_signal_char*(a2: cint){.cdecl, importc: "rl_echo_signal_char", + dynlib: readlineDll.} +proc set_paren_blink_timeout*(a2: cint): cint{.cdecl, + importc: "rl_set_paren_blink_timeout", dynlib: readlineDll.} +# Undocumented. + +proc maybe_save_line*(): cint{.cdecl, importc: "rl_maybe_save_line", + dynlib: readlineDll.} +proc maybe_unsave_line*(): cint{.cdecl, importc: "rl_maybe_unsave_line", + dynlib: readlineDll.} +proc maybe_replace_line*(): cint{.cdecl, importc: "rl_maybe_replace_line", + dynlib: readlineDll.} +# Completion functions. + +proc complete_internal*(a2: cint): cint{.cdecl, importc: "rl_complete_internal", + dynlib: readlineDll.} +proc display_match_list*(a2: cstringArray, a3: cint, a4: cint){.cdecl, + importc: "rl_display_match_list", dynlib: readlineDll.} +proc completion_matches*(a2: cstring, a3: Tcompentry_func): cstringArray{. + cdecl, importc: "rl_completion_matches", dynlib: readlineDll.} +proc username_completion_function*(a2: cstring, a3: cint): cstring{.cdecl, + importc: "rl_username_completion_function", dynlib: readlineDll.} +proc filename_completion_function*(a2: cstring, a3: cint): cstring{.cdecl, + importc: "rl_filename_completion_function", dynlib: readlineDll.} +proc completion_mode*(a2: TCommandFunc): cint{.cdecl, + importc: "rl_completion_mode", dynlib: readlineDll.} +# **************************************************************** +# +# Well Published Variables +# +# **************************************************************** + +when false: + # The version of this incarnation of the readline library. + var library_version*{.importc: "rl_library_version", dynlib: readlineDll.}: cstring + # e.g., "4.2" + var readline_version*{.importc: "rl_readline_version", dynlib: readlineDll.}: cint + # e.g., 0x0402 + # True if this is real GNU readline. + var gnu_readline_p*{.importc: "rl_gnu_readline_p", dynlib: readlineDll.}: cint + # Flags word encapsulating the current readline state. + var readline_state*{.importc: "rl_readline_state", dynlib: readlineDll.}: cint + # Says which editing mode readline is currently using. 1 means emacs mode; + # 0 means vi mode. + var editing_mode*{.importc: "rl_editing_mode", dynlib: readlineDll.}: cint + # Insert or overwrite mode for emacs mode. 1 means insert mode; 0 means + # overwrite mode. Reset to insert mode on each input line. + var insert_mode*{.importc: "rl_insert_mode", dynlib: readlineDll.}: cint + # The name of the calling program. You should initialize this to + # whatever was in argv[0]. It is used when parsing conditionals. + var readline_name*{.importc: "rl_readline_name", dynlib: readlineDll.}: cstring + # The prompt readline uses. This is set from the argument to + # readline (), and should not be assigned to directly. + var prompt*{.importc: "rl_prompt", dynlib: readlineDll.}: cstring + # The prompt string that is actually displayed by rl_redisplay. Public so + # applications can more easily supply their own redisplay functions. + var display_prompt*{.importc: "rl_display_prompt", dynlib: readlineDll.}: cstring + # The line buffer that is in use. + var line_buffer*{.importc: "rl_line_buffer", dynlib: readlineDll.}: cstring + # The location of point, and end. + var point*{.importc: "rl_point", dynlib: readlineDll.}: cint + var theEnd*{.importc: "rl_end", dynlib: readlineDll.}: cint + # The mark, or saved cursor position. + var mark*{.importc: "rl_mark", dynlib: readlineDll.}: cint + # Flag to indicate that readline has finished with the current input + # line and should return it. + var done*{.importc: "rl_done", dynlib: readlineDll.}: cint + # If set to a character value, that will be the next keystroke read. + var pending_input*{.importc: "rl_pending_input", dynlib: readlineDll.}: cint + # Non-zero if we called this function from _rl_dispatch(). It's present + # so functions can find out whether they were called from a key binding + # or directly from an application. + var dispatching*{.importc: "rl_dispatching", dynlib: readlineDll.}: cint + # Non-zero if the user typed a numeric argument before executing the + # current function. + var explicit_arg*{.importc: "rl_explicit_arg", dynlib: readlineDll.}: cint + # The current value of the numeric argument specified by the user. + var numeric_arg*{.importc: "rl_numeric_arg", dynlib: readlineDll.}: cint + # The address of the last command function Readline executed. + var last_func*{.importc: "rl_last_func", dynlib: readlineDll.}: TCommandFunc + # The name of the terminal to use. + var terminal_name*{.importc: "rl_terminal_name", dynlib: readlineDll.}: cstring + # The input and output streams. + var instream*{.importc: "rl_instream", dynlib: readlineDll.}: TFile + var outstream*{.importc: "rl_outstream", dynlib: readlineDll.}: TFile + # If non-zero, Readline gives values of LINES and COLUMNS from the environment + # greater precedence than values fetched from the kernel when computing the + # screen dimensions. + var prefer_env_winsize*{.importc: "rl_prefer_env_winsize", dynlib: readlineDll.}: cint + # If non-zero, then this is the address of a function to call just + # before readline_internal () prints the first prompt. + var startup_hook*{.importc: "rl_startup_hook", dynlib: readlineDll.}: hook_func + # If non-zero, this is the address of a function to call just before + # readline_internal_setup () returns and readline_internal starts + # reading input characters. + var pre_input_hook*{.importc: "rl_pre_input_hook", dynlib: readlineDll.}: hook_func + # The address of a function to call periodically while Readline is + # awaiting character input, or NULL, for no event handling. + var event_hook*{.importc: "rl_event_hook", dynlib: readlineDll.}: hook_func + # The address of the function to call to fetch a character from the current + # Readline input stream + var getc_function*{.importc: "rl_getc_function", dynlib: readlineDll.}: getc_func + var redisplay_function*{.importc: "rl_redisplay_function", dynlib: readlineDll.}: voidfunc + var prep_term_function*{.importc: "rl_prep_term_function", dynlib: readlineDll.}: vintfunc + var deprep_term_function*{.importc: "rl_deprep_term_function", + dynlib: readlineDll.}: voidfunc + # Dispatch variables. + var executing_keymap*{.importc: "rl_executing_keymap", dynlib: readlineDll.}: PKeymap + var binding_keymap*{.importc: "rl_binding_keymap", dynlib: readlineDll.}: PKeymap + # Display variables. + # If non-zero, readline will erase the entire line, including any prompt, + # if the only thing typed on an otherwise-blank line is something bound to + # rl_newline. + var erase_empty_line*{.importc: "rl_erase_empty_line", dynlib: readlineDll.}: cint + # If non-zero, the application has already printed the prompt (rl_prompt) + # before calling readline, so readline should not output it the first time + # redisplay is done. + var already_prompted*{.importc: "rl_already_prompted", dynlib: readlineDll.}: cint + # A non-zero value means to read only this many characters rather than + # up to a character bound to accept-line. + var num_chars_to_read*{.importc: "rl_num_chars_to_read", dynlib: readlineDll.}: cint + # The text of a currently-executing keyboard macro. + var executing_macro*{.importc: "rl_executing_macro", dynlib: readlineDll.}: cstring + # Variables to control readline signal handling. + # If non-zero, readline will install its own signal handlers for + # SIGINT, SIGTERM, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. + var catch_signals*{.importc: "rl_catch_signals", dynlib: readlineDll.}: cint + # If non-zero, readline will install a signal handler for SIGWINCH + # that also attempts to call any calling application's SIGWINCH signal + # handler. Note that the terminal is not cleaned up before the + # application's signal handler is called; use rl_cleanup_after_signal() + # to do that. + var catch_sigwinch*{.importc: "rl_catch_sigwinch", dynlib: readlineDll.}: cint + # Completion variables. + # Pointer to the generator function for completion_matches (). + # NULL means to use rl_filename_completion_function (), the default + # filename completer. + var completion_entry_function*{.importc: "rl_completion_entry_function", + dynlib: readlineDll.}: compentry_func + # Optional generator for menu completion. Default is + # rl_completion_entry_function (rl_filename_completion_function). + var menu_completion_entry_function*{.importc: "rl_menu_completion_entry_function", + dynlib: readlineDll.}: compentry_func + # If rl_ignore_some_completions_function is non-NULL it is the address + # of a function to call after all of the possible matches have been + # generated, but before the actual completion is done to the input line. + # The function is called with one argument; a NULL terminated array + # of (char *). If your function removes any of the elements, they + # must be free()'ed. + var ignore_some_completions_function*{. + importc: "rl_ignore_some_completions_function", dynlib: readlineDll.}: compignore_func + # Pointer to alternative function to create matches. + # Function is called with TEXT, START, and END. + # START and END are indices in RL_LINE_BUFFER saying what the boundaries + # of TEXT are. + # If this function exists and returns NULL then call the value of + # rl_completion_entry_function to try to match, otherwise use the + # array of strings returned. + var attempted_completion_function*{.importc: "rl_attempted_completion_function", + dynlib: readlineDll.}: completion_func + # The basic list of characters that signal a break between words for the + # completer routine. The initial contents of this variable is what + # breaks words in the shell, i.e. "n\"\\'`@$>". + var basic_word_break_characters*{.importc: "rl_basic_word_break_characters", + dynlib: readlineDll.}: cstring + # The list of characters that signal a break between words for + # rl_complete_internal. The default list is the contents of + # rl_basic_word_break_characters. + var completer_word_break_characters*{.importc: "rl_completer_word_break_characters", + dynlib: readlineDll.}: cstring + # Hook function to allow an application to set the completion word + # break characters before readline breaks up the line. Allows + # position-dependent word break characters. + var completion_word_break_hook*{.importc: "rl_completion_word_break_hook", + dynlib: readlineDll.}: cpvfunc + # List of characters which can be used to quote a substring of the line. + # Completion occurs on the entire substring, and within the substring + # rl_completer_word_break_characters are treated as any other character, + # unless they also appear within this list. + var completer_quote_characters*{.importc: "rl_completer_quote_characters", + dynlib: readlineDll.}: cstring + # List of quote characters which cause a word break. + var basic_quote_characters*{.importc: "rl_basic_quote_characters", + dynlib: readlineDll.}: cstring + # List of characters that need to be quoted in filenames by the completer. + var filename_quote_characters*{.importc: "rl_filename_quote_characters", + dynlib: readlineDll.}: cstring + # List of characters that are word break characters, but should be left + # in TEXT when it is passed to the completion function. The shell uses + # this to help determine what kind of completing to do. + var special_prefixes*{.importc: "rl_special_prefixes", dynlib: readlineDll.}: cstring + # If non-zero, then this is the address of a function to call when + # completing on a directory name. The function is called with + # the address of a string (the current directory name) as an arg. It + # changes what is displayed when the possible completions are printed + # or inserted. + var directory_completion_hook*{.importc: "rl_directory_completion_hook", + dynlib: readlineDll.}: icppfunc + # If non-zero, this is the address of a function to call when completing + # a directory name. This function takes the address of the directory name + # to be modified as an argument. Unlike rl_directory_completion_hook, it + # only modifies the directory name used in opendir(2), not what is displayed + # when the possible completions are printed or inserted. It is called + # before rl_directory_completion_hook. I'm not happy with how this works + # yet, so it's undocumented. + var directory_rewrite_hook*{.importc: "rl_directory_rewrite_hook", + dynlib: readlineDll.}: icppfunc + # If non-zero, this is the address of a function to call when reading + # directory entries from the filesystem for completion and comparing + # them to the partial word to be completed. The function should + # either return its first argument (if no conversion takes place) or + # newly-allocated memory. This can, for instance, convert filenames + # between character sets for comparison against what's typed at the + # keyboard. The returned value is what is added to the list of + # matches. The second argument is the length of the filename to be + # converted. + var filename_rewrite_hook*{.importc: "rl_filename_rewrite_hook", + dynlib: readlineDll.}: dequote_func + # If non-zero, then this is the address of a function to call when + # completing a word would normally display the list of possible matches. + # This function is called instead of actually doing the display. + # It takes three arguments: (char **matches, int num_matches, int max_length) + # where MATCHES is the array of strings that matched, NUM_MATCHES is the + # number of strings in that array, and MAX_LENGTH is the length of the + # longest string in that array. + var completion_display_matches_hook*{.importc: "rl_completion_display_matches_hook", + dynlib: readlineDll.}: compdisp_func + # Non-zero means that the results of the matches are to be treated + # as filenames. This is ALWAYS zero on entry, and can only be changed + # within a completion entry finder function. + var filename_completion_desired*{.importc: "rl_filename_completion_desired", + dynlib: readlineDll.}: cint + # Non-zero means that the results of the matches are to be quoted using + # double quotes (or an application-specific quoting mechanism) if the + # filename contains any characters in rl_word_break_chars. This is + # ALWAYS non-zero on entry, and can only be changed within a completion + # entry finder function. + var filename_quoting_desired*{.importc: "rl_filename_quoting_desired", + dynlib: readlineDll.}: cint + # Set to a function to quote a filename in an application-specific fashion. + # Called with the text to quote, the type of match found (single or multiple) + # and a pointer to the quoting character to be used, which the function can + # reset if desired. + var filename_quoting_function*{.importc: "rl_filename_quoting_function", + dynlib: readlineDll.}: quote_func + # Function to call to remove quoting characters from a filename. Called + # before completion is attempted, so the embedded quotes do not interfere + # with matching names in the file system. + var filename_dequoting_function*{.importc: "rl_filename_dequoting_function", + dynlib: readlineDll.}: dequote_func + # Function to call to decide whether or not a word break character is + # quoted. If a character is quoted, it does not break words for the + # completer. + var char_is_quoted_p*{.importc: "rl_char_is_quoted_p", dynlib: readlineDll.}: linebuf_func + # Non-zero means to suppress normal filename completion after the + # user-specified completion function has been called. + var attempted_completion_over*{.importc: "rl_attempted_completion_over", + dynlib: readlineDll.}: cint + # Set to a character describing the type of completion being attempted by + # rl_complete_internal; available for use by application completion + # functions. + var completion_type*{.importc: "rl_completion_type", dynlib: readlineDll.}: cint + # Set to the last key used to invoke one of the completion functions + var completion_invoking_key*{.importc: "rl_completion_invoking_key", + dynlib: readlineDll.}: cint + # Up to this many items will be displayed in response to a + # possible-completions call. After that, we ask the user if she + # is sure she wants to see them all. The default value is 100. + var completion_query_items*{.importc: "rl_completion_query_items", + dynlib: readlineDll.}: cint + # Character appended to completed words when at the end of the line. The + # default is a space. Nothing is added if this is '\0'. + var completion_append_character*{.importc: "rl_completion_append_character", + dynlib: readlineDll.}: cint + # If set to non-zero by an application completion function, + # rl_completion_append_character will not be appended. + var completion_suppress_append*{.importc: "rl_completion_suppress_append", + dynlib: readlineDll.}: cint + # Set to any quote character readline thinks it finds before any application + # completion function is called. + var completion_quote_character*{.importc: "rl_completion_quote_character", + dynlib: readlineDll.}: cint + # Set to a non-zero value if readline found quoting anywhere in the word to + # be completed; set before any application completion function is called. + var completion_found_quote*{.importc: "rl_completion_found_quote", + dynlib: readlineDll.}: cint + # If non-zero, the completion functions don't append any closing quote. + # This is set to 0 by rl_complete_internal and may be changed by an + # application-specific completion function. + var completion_suppress_quote*{.importc: "rl_completion_suppress_quote", + dynlib: readlineDll.}: cint + # If non-zero, readline will sort the completion matches. On by default. + var sort_completion_matches*{.importc: "rl_sort_completion_matches", + dynlib: readlineDll.}: cint + # If non-zero, a slash will be appended to completed filenames that are + # symbolic links to directory names, subject to the value of the + # mark-directories variable (which is user-settable). This exists so + # that application completion functions can override the user's preference + # (set via the mark-symlinked-directories variable) if appropriate. + # It's set to the value of _rl_complete_mark_symlink_dirs in + # rl_complete_internal before any application-specific completion + # function is called, so without that function doing anything, the user's + # preferences are honored. + var completion_mark_symlink_dirs*{.importc: "rl_completion_mark_symlink_dirs", + dynlib: readlineDll.}: cint + # If non-zero, then disallow duplicates in the matches. + var ignore_completion_duplicates*{.importc: "rl_ignore_completion_duplicates", + dynlib: readlineDll.}: cint + # If this is non-zero, completion is (temporarily) inhibited, and the + # completion character will be inserted as any other. + var inhibit_completion*{.importc: "rl_inhibit_completion", dynlib: readlineDll.}: cint +# Input error; can be returned by (*rl_getc_function) if readline is reading +# a top-level command (RL_ISSTATE (RL_STATE_READCMD)). + +const + READERR* = (- 2) + +# Definitions available for use by readline clients. + +const + PROMPT_START_IGNORE* = '\x01' + PROMPT_END_IGNORE* = '\x02' + +# Possible values for do_replace argument to rl_filename_quoting_function, +# called by rl_complete_internal. + +const + NO_MATCH* = 0 + SINGLE_MATCH* = 1 + MULT_MATCH* = 2 + +# Possible state values for rl_readline_state + +const + STATE_NONE* = 0x00000000 # no state; before first call + STATE_INITIALIZING* = 0x00000001 # initializing + STATE_INITIALIZED* = 0x00000002 # initialization done + STATE_TERMPREPPED* = 0x00000004 # terminal is prepped + STATE_READCMD* = 0x00000008 # reading a command key + STATE_METANEXT* = 0x00000010 # reading input after ESC + STATE_DISPATCHING* = 0x00000020 # dispatching to a command + STATE_MOREINPUT* = 0x00000040 # reading more input in a command function + STATE_ISEARCH* = 0x00000080 # doing incremental search + STATE_NSEARCH* = 0x00000100 # doing non-inc search + STATE_SEARCH* = 0x00000200 # doing a history search + STATE_NUMERICARG* = 0x00000400 # reading numeric argument + STATE_MACROINPUT* = 0x00000800 # getting input from a macro + STATE_MACRODEF* = 0x00001000 # defining keyboard macro + STATE_OVERWRITE* = 0x00002000 # overwrite mode + STATE_COMPLETING* = 0x00004000 # doing completion + STATE_SIGHANDLER* = 0x00008000 # in readline sighandler + STATE_UNDOING* = 0x00010000 # doing an undo + STATE_INPUTPENDING* = 0x00020000 # rl_execute_next called + STATE_TTYCSAVED* = 0x00040000 # tty special chars saved + STATE_CALLBACK* = 0x00080000 # using the callback interface + STATE_VIMOTION* = 0x00100000 # reading vi motion arg + STATE_MULTIKEY* = 0x00200000 # reading multiple-key command + STATE_VICMDONCE* = 0x00400000 # entered vi command mode at least once + STATE_REDISPLAYING* = 0x00800000 # updating terminal display + STATE_DONE* = 0x01000000 # done; accepted line + +template SETSTATE*(x: expr): stmt = + readline_state = readline_state or (x) + +template UNSETSTATE*(x: expr): stmt = + readline_state = readline_state and not (x) + +template ISSTATE*(x: expr): expr = + (readline_state and x) != 0 + +type + Treadline_state*{.pure, final.} = object + point*: cint # line state + theEnd*: cint + mark*: cint + buffer*: cstring + buflen*: cint + ul*: ptr TUNDO_LIST + prompt*: cstring # global state + rlstate*: cint + done*: cint + kmap*: PKeymap # input state + lastfunc*: TCommandFunc + insmode*: cint + edmode*: cint + kseqlen*: cint + inf*: TFile + outf*: TFile + pendingin*: cint + theMacro*: cstring # signal state + catchsigs*: cint + catchsigwinch*: cint # search state + # completion state + # options state + # reserved for future expansion, so the struct size doesn't change + reserved*: array[0..64 - 1, char] + + +proc save_state*(a2: ptr Treadline_state): cint{.cdecl, + importc: "rl_save_state", dynlib: readlineDll.} +proc restore_state*(a2: ptr Treadline_state): cint{.cdecl, + importc: "rl_restore_state", dynlib: readlineDll.} diff --git a/lib/wrappers/readline/rltypedefs.nim b/lib/wrappers/readline/rltypedefs.nim new file mode 100644 index 000000000..202cf925d --- /dev/null +++ b/lib/wrappers/readline/rltypedefs.nim @@ -0,0 +1,74 @@ +# rltypedefs.h -- Type declarations for readline functions. +# Copyright (C) 2000-2009 Free Software Foundation, Inc. +# +# This file is part of the GNU Readline Library (Readline), a library +# for reading lines of text with interactive input and history editing. +# +# Readline 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 3 of the License, or +# (at your option) any later version. +# +# Readline 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 Readline. If not, see <http://www.gnu.org/licenses/>. +# + +type + TFunction* = proc (): cint{.cdecl.} + TVFunction* = proc (){.cdecl.} + TCPFunction* = proc (): cstring{.cdecl.} + TCPPFunction* = proc (): cstringArray{.cdecl.} + +# Bindable functions + +type + Tcommand_func* = proc (a2: cint, a3: cint): cint{.cdecl.} + +# Typedefs for the completion system + +type + Tcompentry_func* = proc (a2: cstring, a3: cint): cstring{.cdecl.} + Tcompletion_func* = proc (a2: cstring, a3: cint, a4: cint): cstringArray{. + cdecl.} + Tquote_func* = proc (a2: cstring, a3: cint, a4: cstring): cstring{.cdecl.} + Tdequote_func* = proc (a2: cstring, a3: cint): cstring{.cdecl.} + Tcompignore_func* = proc (a2: cstringArray): cint{.cdecl.} + Tcompdisp_func* = proc (a2: cstringArray, a3: cint, a4: cint){.cdecl.} + +# Type for input and pre-read hook functions like rl_event_hook + +type + Thook_func* = proc (): cint{.cdecl.} + +# Input function type + +type + Tgetc_func* = proc (a2: TFile): cint{.cdecl.} + +# Generic function that takes a character buffer (which could be the readline +# line buffer) and an index into it (which could be rl_point) and returns +# an int. + +type + Tlinebuf_func* = proc (a2: cstring, a3: cint): cint{.cdecl.} + +# `Generic' function pointer typedefs + +type + Tintfunc* = proc (a2: cint): cint{.cdecl.} + Tivoidfunc* = proc (): cint{.cdecl.} + Ticpfunc* = proc (a2: cstring): cint{.cdecl.} + Ticppfunc* = proc (a2: cstringArray): cint{.cdecl.} + Tvoidfunc* = proc (){.cdecl.} + Tvintfunc* = proc (a2: cint){.cdecl.} + Tvcpfunc* = proc (a2: cstring){.cdecl.} + Tvcppfunc* = proc (a2: cstringArray){.cdecl.} + Tcpvfunc* = proc (): cstring{.cdecl.} + Tcpifunc* = proc (a2: cint): cstring{.cdecl.} + Tcpcpfunc* = proc (a2: cstring): cstring{.cdecl.} + Tcpcppfunc* = proc (a2: cstringArray): cstring{.cdecl.} diff --git a/lib/wrappers/readline/tweaked/history.h b/lib/wrappers/readline/tweaked/history.h new file mode 100644 index 000000000..53bd642b1 --- /dev/null +++ b/lib/wrappers/readline/tweaked/history.h @@ -0,0 +1,257 @@ +/* history.h -- the names of functions that you can call in history. */ + +/* Copyright (C) 1989-2009 Free Software Foundation, Inc. + + This file contains the GNU History Library (History), a set of + routines for managing the text of previously typed lines. + + History 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 3 of the License, or + (at your option) any later version. + + History 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 History. If not, see <http://www.gnu.org/licenses/>. +*/ + +#ifdef C2NIM +# private historyDll +# dynlib historyDll +# cdecl +# if defined(windows) +# define historyDll "history.dll" +# elif defined(macosx) +# define historyDll "libhistory.dynlib" +# else +# define historyDll "libhistory.so.6(|.0)" +# endif +# prefix rl_ +# prefix RL_ +# suffix _t +# typeprefixes +# def PARAMS(x) x +# def time_t TTime +#endif + +# include "times" +# include "rltypedefs.h" + +typedef void *histdata_t; + +/* The structure used to store a history entry. */ +typedef struct _hist_entry { + char *line; + char *timestamp; /* char * rather than time_t for read/write */ + histdata_t data; +} HIST_ENTRY; + +/* Size of the history-library-managed space in history entry HS. */ +#define HISTENT_BYTES(hs) (strlen(hs.line) + strlen(hs.timestamp)) + +/* A structure used to pass the current state of the history stuff around. */ +typedef struct _hist_state { + HIST_ENTRY **entries; /* Pointer to the entries themselves. */ + int offset; /* The location pointer within this array. */ + int length; /* Number of elements within this array. */ + int size; /* Number of slots allocated to this array. */ + int flags; +} HISTORY_STATE; + +/* Flag values for the `flags' member of HISTORY_STATE. */ +#define HS_STIFLED 0x01 + +/* Initialization and state management. */ + +/* Begin a session in which the history functions might be used. This + just initializes the interactive variables. */ +extern void using_history PARAMS((void)); + +/* Return the current HISTORY_STATE of the history. */ +extern HISTORY_STATE *history_get_history_state PARAMS((void)); + +/* Set the state of the current history array to STATE. */ +extern void history_set_history_state PARAMS((HISTORY_STATE *)); + +/* Manage the history list. */ + +/* Place STRING at the end of the history list. + The associated data field (if any) is set to NULL. */ +extern void add_history PARAMS((const char *)); + +/* Change the timestamp associated with the most recent history entry to + STRING. */ +extern void add_history_time PARAMS((const char *)); + +/* A reasonably useless function, only here for completeness. WHICH + is the magic number that tells us which element to delete. The + elements are numbered from 0. */ +extern HIST_ENTRY *remove_history PARAMS((int)); + +/* Free the history entry H and return any application-specific data + associated with it. */ +extern histdata_t free_history_entry PARAMS((HIST_ENTRY *)); + +/* Make the history entry at WHICH have LINE and DATA. This returns + the old entry so you can dispose of the data. In the case of an + invalid WHICH, a NULL pointer is returned. */ +extern HIST_ENTRY *replace_history_entry PARAMS((int, const char *, histdata_t)); + +/* Clear the history list and start over. */ +extern void clear_history PARAMS((void)); + +/* Stifle the history list, remembering only MAX number of entries. */ +extern void stifle_history PARAMS((int)); + +/* Stop stifling the history. This returns the previous amount the + history was stifled by. The value is positive if the history was + stifled, negative if it wasn't. */ +extern int unstifle_history PARAMS((void)); + +/* Return 1 if the history is stifled, 0 if it is not. */ +extern int history_is_stifled PARAMS((void)); + +/* Information about the history list. */ + +/* Return a NULL terminated array of HIST_ENTRY which is the current input + history. Element 0 of this list is the beginning of time. If there + is no history, return NULL. */ +extern HIST_ENTRY **history_list PARAMS((void)); + +/* Returns the number which says what history element we are now + looking at. */ +extern int where_history PARAMS((void)); + +/* Return the history entry at the current position, as determined by + history_offset. If there is no entry there, return a NULL pointer. */ +extern HIST_ENTRY *current_history PARAMS((void)); + +/* Return the history entry which is logically at OFFSET in the history + array. OFFSET is relative to history_base. */ +extern HIST_ENTRY *history_get PARAMS((int)); + +/* Return the timestamp associated with the HIST_ENTRY * passed as an + argument */ +extern time_t history_get_time PARAMS((HIST_ENTRY *)); + +/* Return the number of bytes that the primary history entries are using. + This just adds up the lengths of the_history->lines. */ +extern int history_total_bytes PARAMS((void)); + +/* Moving around the history list. */ + +/* Set the position in the history list to POS. */ +extern int history_set_pos PARAMS((int)); + +/* Back up history_offset to the previous history entry, and return + a pointer to that entry. If there is no previous entry, return + a NULL pointer. */ +extern HIST_ENTRY *previous_history PARAMS((void)); + +/* Move history_offset forward to the next item in the input_history, + and return the a pointer to that entry. If there is no next entry, + return a NULL pointer. */ +extern HIST_ENTRY *next_history PARAMS((void)); + +/* Searching the history list. */ + +/* Search the history for STRING, starting at history_offset. + If DIRECTION < 0, then the search is through previous entries, + else through subsequent. If the string is found, then + current_history () is the history entry, and the value of this function + is the offset in the line of that history entry that the string was + found in. Otherwise, nothing is changed, and a -1 is returned. */ +extern int history_search PARAMS((const char *, int)); + +/* Search the history for STRING, starting at history_offset. + The search is anchored: matching lines must begin with string. + DIRECTION is as in history_search(). */ +extern int history_search_prefix PARAMS((const char *, int)); + +/* Search for STRING in the history list, starting at POS, an + absolute index into the list. DIR, if negative, says to search + backwards from POS, else forwards. + Returns the absolute index of the history element where STRING + was found, or -1 otherwise. */ +extern int history_search_pos PARAMS((const char *, int, int)); + +/* Managing the history file. */ + +/* Add the contents of FILENAME to the history list, a line at a time. + If FILENAME is NULL, then read from ~/.history. Returns 0 if + successful, or errno if not. */ +extern int read_history PARAMS((const char *)); + +/* Read a range of lines from FILENAME, adding them to the history list. + Start reading at the FROM'th line and end at the TO'th. If FROM + is zero, start at the beginning. If TO is less than FROM, read + until the end of the file. If FILENAME is NULL, then read from + ~/.history. Returns 0 if successful, or errno if not. */ +extern int read_history_range PARAMS((const char *, int, int)); + +/* Write the current history to FILENAME. If FILENAME is NULL, + then write the history list to ~/.history. Values returned + are as in read_history (). */ +extern int write_history PARAMS((const char *)); + +/* Append NELEMENT entries to FILENAME. The entries appended are from + the end of the list minus NELEMENTs up to the end of the list. */ +extern int append_history PARAMS((int, const char *)); + +/* Truncate the history file, leaving only the last NLINES lines. */ +extern int history_truncate_file PARAMS((const char *, int)); + +/* History expansion. */ + +/* Expand the string STRING, placing the result into OUTPUT, a pointer + to a string. Returns: + + 0) If no expansions took place (or, if the only change in + the text was the de-slashifying of the history expansion + character) + 1) If expansions did take place + -1) If there was an error in expansion. + 2) If the returned line should just be printed. + + If an error ocurred in expansion, then OUTPUT contains a descriptive + error message. */ +extern int history_expand PARAMS((char *, char **)); + +/* Extract a string segment consisting of the FIRST through LAST + arguments present in STRING. Arguments are broken up as in + the shell. */ +extern char *history_arg_extract PARAMS((int, int, const char *)); + +/* Return the text of the history event beginning at the current + offset into STRING. Pass STRING with *INDEX equal to the + history_expansion_char that begins this specification. + DELIMITING_QUOTE is a character that is allowed to end the string + specification for what to search for in addition to the normal + characters `:', ` ', `\t', `\n', and sometimes `?'. */ +extern char *get_history_event PARAMS((const char *, int *, int)); + +/* Return an array of tokens, much as the shell might. The tokens are + parsed out of STRING. */ +extern char **history_tokenize PARAMS((const char *)); + +#if false +/* Exported history variables. */ +extern int history_base; +extern int history_length; +extern int history_max_entries; +extern char history_expansion_char; +extern char history_subst_char; +extern char *history_word_delimiters; +extern char history_comment_char; +extern char *history_no_expand_chars; +extern char *history_search_delimiter_chars; +extern int history_quotes_inhibit_expansion; + +extern int history_write_timestamps; + +#endif + diff --git a/lib/wrappers/readline/tweaked/readline.h b/lib/wrappers/readline/tweaked/readline.h new file mode 100644 index 000000000..b13fbdbbe --- /dev/null +++ b/lib/wrappers/readline/tweaked/readline.h @@ -0,0 +1,956 @@ +/* Readline.h -- the names of functions callable from within readline. */ + +/* Copyright (C) 1987-2009 Free Software Foundation, Inc. + + This file is part of the GNU Readline Library (Readline), a library + for reading lines of text with interactive input and history editing. + + Readline 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 3 of the License, or + (at your option) any later version. + + Readline 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 Readline. If not, see <http://www.gnu.org/licenses/>. +*/ + +#ifdef C2NIM +# private readlineDll +# dynlib readlineDll +# cdecl +# if defined(windows) +# define readlineDll "readline.dll" +# elif defined(macosx) +# define readlineDll "libreadline.dynlib" +# else +# define readlineDll "libreadline.so.6(|.0)" +# endif +# prefix rl_ +# prefix RL_ +# suffix _t +# typeprefixes +# def PARAMS(x) x +# mangle end theEnd +# mangle type typ +# mangle macro theMacro +/*# mangle "'command_func'" TCommandFunc +# mangle vcpfunc TvcpFunc*/ +#endif + +# include "rltypedefs.h" + + +/* Some character stuff. */ +#define control_character_threshold 0x020 /* Smaller than this is control. */ +#define control_character_mask 0x1f /* 0x20 - 1 */ +#define meta_character_threshold 0x07f /* Larger than this is Meta. */ +#define control_character_bit 0x40 /* 0x000000, must be off. */ +#define meta_character_bit 0x080 /* x0000000, must be on. */ +#define largest_char 255 /* Largest character value. */ + +#define CTRL_CHAR(c) (c < control_character_threshold && ((c & 0x80) == 0)) +#define META_CHAR(c) (c > meta_character_threshold && c <= largest_char) + +#define CTRL(c) (c & control_character_mask) +#define META(c) (c | meta_character_bit) + +#define UNMETA(c) (c & ~meta_character_bit) +#define UNCTRL(c) (c|32|control_character_bit) + +/* Beware: these only work with single-byte ASCII characters. */ + +#define RETURN_CHAR CTRL('M'.ord) +#define RUBOUT_CHAR 0x7f +#define ABORT_CHAR CTRL('G'.ord) +#define PAGE_CHAR CTRL('L'.ord) +#define ESC_CHAR CTRL('['.ord) + +/* A keymap contains one entry for each key in the ASCII set. + Each entry consists of a type and a pointer. + FUNCTION is the address of a function to run, or the + address of a keymap to indirect through. + TYPE says which kind of thing FUNCTION is. */ +typedef struct _keymap_entry { + char type; + rl_command_func_t *function; +} KEYMAP_ENTRY; + +/* This must be large enough to hold bindings for all of the characters + in a desired character set (e.g, 128 for ASCII, 256 for ISO Latin-x, + and so on) plus one for subsequence matching. */ +#define KEYMAP_SIZE 257 +#define ANYOTHERKEY KEYMAP_SIZE-1 + +/* I wanted to make the above structure contain a union of: + union { rl_command_func_t *function; struct _keymap_entry *keymap; } value; + but this made it impossible for me to create a static array. + Maybe I need C lessons. */ + +typedef KEYMAP_ENTRY KEYMAP_ENTRY_ARRAY[KEYMAP_SIZE]; +typedef KEYMAP_ENTRY *Keymap; + +/* The values that TYPE can have in a keymap entry. */ +#define ISFUNC 0 +#define ISKMAP 1 +#define ISMACR 2 + +#if false +extern KEYMAP_ENTRY_ARRAY emacs_standard_keymap, emacs_meta_keymap, emacs_ctlx_keymap; +extern KEYMAP_ENTRY_ARRAY vi_insertion_keymap, vi_movement_keymap; +#endif + +/* Return a new, empty keymap. + Free it with free() when you are done. */ +extern Keymap rl_make_bare_keymap PARAMS((void)); + +/* Return a new keymap which is a copy of MAP. */ +extern Keymap rl_copy_keymap PARAMS((Keymap)); + +/* Return a new keymap with the printing characters bound to rl_insert, + the lowercase Meta characters bound to run their equivalents, and + the Meta digits bound to produce numeric arguments. */ +extern Keymap rl_make_keymap PARAMS((void)); + +/* Free the storage associated with a keymap. */ +extern void rl_discard_keymap PARAMS((Keymap)); + +/* These functions actually appear in bind.c */ + +/* Return the keymap corresponding to a given name. Names look like + `emacs' or `emacs-meta' or `vi-insert'. */ +extern Keymap rl_get_keymap_by_name PARAMS((const char *)); + +/* Return the current keymap. */ +extern Keymap rl_get_keymap PARAMS((void)); + +/* Set the current keymap to MAP. */ +extern void rl_set_keymap PARAMS((Keymap)); + +# include "tilde.h" + +/* Hex-encoded Readline version number. */ +#define RL_READLINE_VERSION 0x0600 /* Readline 6.0 */ +#define RL_VERSION_MAJOR 6 +#define RL_VERSION_MINOR 0 + +/* Readline data structures. */ + +/* Maintaining the state of undo. We remember individual deletes and inserts + on a chain of things to do. */ + +/* The actions that undo knows how to undo. Notice that UNDO_DELETE means + to insert some text, and UNDO_INSERT means to delete some text. I.e., + the code tells undo what to undo, not how to undo it. */ +enum undo_code { UNDO_DELETE, UNDO_INSERT, UNDO_BEGIN, UNDO_END }; + +/* What an element of THE_UNDO_LIST looks like. */ +typedef struct undo_list { + struct undo_list *next; + int start, end; /* Where the change took place. */ + char *text; /* The text to insert, if undoing a delete. */ + enum undo_code what; /* Delete, Insert, Begin, End. */ +} UNDO_LIST; + +/* The current undo list for RL_LINE_BUFFER. */ +extern UNDO_LIST *rl_undo_list; + +/* The data structure for mapping textual names to code addresses. */ +typedef struct _funmap { + const char *name; + rl_command_func_t *function; +} FUNMAP; + +extern FUNMAP **funmap; + +/* **************************************************************** */ +/* */ +/* Functions available to bind to key sequences */ +/* */ +/* **************************************************************** */ + +/* Bindable commands for numeric arguments. */ +extern int rl_digit_argument PARAMS((int, int)); +extern int rl_universal_argument PARAMS((int, int)); + +/* Bindable commands for moving the cursor. */ +extern int rl_forward_byte PARAMS((int, int)); +extern int rl_forward_char PARAMS((int, int)); +extern int rl_forward PARAMS((int, int)); +extern int rl_backward_byte PARAMS((int, int)); +extern int rl_backward_char PARAMS((int, int)); +extern int rl_backward PARAMS((int, int)); +extern int rl_beg_of_line PARAMS((int, int)); +extern int rl_end_of_line PARAMS((int, int)); +extern int rl_forward_word PARAMS((int, int)); +extern int rl_backward_word PARAMS((int, int)); +extern int rl_refresh_line PARAMS((int, int)); +extern int rl_clear_screen PARAMS((int, int)); +extern int rl_skip_csi_sequence PARAMS((int, int)); +extern int rl_arrow_keys PARAMS((int, int)); + +/* Bindable commands for inserting and deleting text. */ +extern int rl_insert PARAMS((int, int)); +extern int rl_quoted_insert PARAMS((int, int)); +extern int rl_tab_insert PARAMS((int, int)); +extern int rl_newline PARAMS((int, int)); +extern int rl_do_lowercase_version PARAMS((int, int)); +extern int rl_rubout PARAMS((int, int)); +extern int rl_delete PARAMS((int, int)); +extern int rl_rubout_or_delete PARAMS((int, int)); +extern int rl_delete_horizontal_space PARAMS((int, int)); +extern int rl_delete_or_show_completions PARAMS((int, int)); +extern int rl_insert_comment PARAMS((int, int)); + +/* Bindable commands for changing case. */ +extern int rl_upcase_word PARAMS((int, int)); +extern int rl_downcase_word PARAMS((int, int)); +extern int rl_capitalize_word PARAMS((int, int)); + +/* Bindable commands for transposing characters and words. */ +extern int rl_transpose_words PARAMS((int, int)); +extern int rl_transpose_chars PARAMS((int, int)); + +/* Bindable commands for searching within a line. */ +extern int rl_char_search PARAMS((int, int)); +extern int rl_backward_char_search PARAMS((int, int)); + +/* Bindable commands for readline's interface to the command history. */ +extern int rl_beginning_of_history PARAMS((int, int)); +extern int rl_end_of_history PARAMS((int, int)); +extern int rl_get_next_history PARAMS((int, int)); +extern int rl_get_previous_history PARAMS((int, int)); + +/* Bindable commands for managing the mark and region. */ +extern int rl_set_mark PARAMS((int, int)); +extern int rl_exchange_point_and_mark PARAMS((int, int)); + +/* Bindable commands to set the editing mode (emacs or vi). */ +extern int rl_vi_editing_mode PARAMS((int, int)); +extern int rl_emacs_editing_mode PARAMS((int, int)); + +/* Bindable commands to change the insert mode (insert or overwrite) */ +extern int rl_overwrite_mode PARAMS((int, int)); + +/* Bindable commands for managing key bindings. */ +extern int rl_re_read_init_file PARAMS((int, int)); +extern int rl_dump_functions PARAMS((int, int)); +extern int rl_dump_macros PARAMS((int, int)); +extern int rl_dump_variables PARAMS((int, int)); + +/* Bindable commands for word completion. */ +extern int rl_complete PARAMS((int, int)); +extern int rl_possible_completions PARAMS((int, int)); +extern int rl_insert_completions PARAMS((int, int)); +extern int rl_old_menu_complete PARAMS((int, int)); +extern int rl_menu_complete PARAMS((int, int)); +extern int rl_backward_menu_complete PARAMS((int, int)); + +/* Bindable commands for killing and yanking text, and managing the kill ring. */ +extern int rl_kill_word PARAMS((int, int)); +extern int rl_backward_kill_word PARAMS((int, int)); +extern int rl_kill_line PARAMS((int, int)); +extern int rl_backward_kill_line PARAMS((int, int)); +extern int rl_kill_full_line PARAMS((int, int)); +extern int rl_unix_word_rubout PARAMS((int, int)); +extern int rl_unix_filename_rubout PARAMS((int, int)); +extern int rl_unix_line_discard PARAMS((int, int)); +extern int rl_copy_region_to_kill PARAMS((int, int)); +extern int rl_kill_region PARAMS((int, int)); +extern int rl_copy_forward_word PARAMS((int, int)); +extern int rl_copy_backward_word PARAMS((int, int)); +extern int rl_yank PARAMS((int, int)); +extern int rl_yank_pop PARAMS((int, int)); +extern int rl_yank_nth_arg PARAMS((int, int)); +extern int rl_yank_last_arg PARAMS((int, int)); + +#ifdef Windows +extern int rl_paste_from_clipboard PARAMS((int, int)); +#endif + +/* Bindable commands for incremental searching. */ +extern int rl_reverse_search_history PARAMS((int, int)); +extern int rl_forward_search_history PARAMS((int, int)); + +/* Bindable keyboard macro commands. */ +extern int rl_start_kbd_macro PARAMS((int, int)); +extern int rl_end_kbd_macro PARAMS((int, int)); +extern int rl_call_last_kbd_macro PARAMS((int, int)); + +/* Bindable undo commands. */ +extern int rl_revert_line PARAMS((int, int)); +extern int rl_undo_command PARAMS((int, int)); + +/* Bindable tilde expansion commands. */ +extern int rl_tilde_expand PARAMS((int, int)); + +/* Bindable terminal control commands. */ +extern int rl_restart_output PARAMS((int, int)); +extern int rl_stop_output PARAMS((int, int)); + +/* Miscellaneous bindable commands. */ +extern int rl_abort PARAMS((int, int)); +extern int rl_tty_status PARAMS((int, int)); + +/* Bindable commands for incremental and non-incremental history searching. */ +extern int rl_history_search_forward PARAMS((int, int)); +extern int rl_history_search_backward PARAMS((int, int)); +extern int rl_noninc_forward_search PARAMS((int, int)); +extern int rl_noninc_reverse_search PARAMS((int, int)); +extern int rl_noninc_forward_search_again PARAMS((int, int)); +extern int rl_noninc_reverse_search_again PARAMS((int, int)); + +/* Bindable command used when inserting a matching close character. */ +extern int rl_insert_close PARAMS((int, int)); + +/* Not available unless READLINE_CALLBACKS is defined. */ +extern void rl_callback_handler_install PARAMS((const char *, rl_vcpfunc_t *)); +extern void rl_callback_read_char PARAMS((void)); +extern void rl_callback_handler_remove PARAMS((void)); + +/* Things for vi mode. Not available unless readline is compiled -DVI_MODE. */ +/* VI-mode bindable commands. */ +extern int rl_vi_redo PARAMS((int, int)); +extern int rl_vi_undo PARAMS((int, int)); +extern int rl_vi_yank_arg PARAMS((int, int)); +extern int rl_vi_fetch_history PARAMS((int, int)); +extern int rl_vi_search_again PARAMS((int, int)); +extern int rl_vi_search PARAMS((int, int)); +extern int rl_vi_complete PARAMS((int, int)); +extern int rl_vi_tilde_expand PARAMS((int, int)); +extern int rl_vi_prev_word PARAMS((int, int)); +extern int rl_vi_next_word PARAMS((int, int)); +extern int rl_vi_end_word PARAMS((int, int)); +extern int rl_vi_insert_beg PARAMS((int, int)); +extern int rl_vi_append_mode PARAMS((int, int)); +extern int rl_vi_append_eol PARAMS((int, int)); +extern int rl_vi_eof_maybe PARAMS((int, int)); +extern int rl_vi_insertion_mode PARAMS((int, int)); +extern int rl_vi_insert_mode PARAMS((int, int)); +extern int rl_vi_movement_mode PARAMS((int, int)); +extern int rl_vi_arg_digit PARAMS((int, int)); +extern int rl_vi_change_case PARAMS((int, int)); +extern int rl_vi_put PARAMS((int, int)); +extern int rl_vi_column PARAMS((int, int)); +extern int rl_vi_delete_to PARAMS((int, int)); +extern int rl_vi_change_to PARAMS((int, int)); +extern int rl_vi_yank_to PARAMS((int, int)); +extern int rl_vi_rubout PARAMS((int, int)); +extern int rl_vi_delete PARAMS((int, int)); +extern int rl_vi_back_to_indent PARAMS((int, int)); +extern int rl_vi_first_print PARAMS((int, int)); +extern int rl_vi_char_search PARAMS((int, int)); +extern int rl_vi_match PARAMS((int, int)); +extern int rl_vi_change_char PARAMS((int, int)); +extern int rl_vi_subst PARAMS((int, int)); +extern int rl_vi_overstrike PARAMS((int, int)); +extern int rl_vi_overstrike_delete PARAMS((int, int)); +extern int rl_vi_replace PARAMS((int, int)); +extern int rl_vi_set_mark PARAMS((int, int)); +extern int rl_vi_goto_mark PARAMS((int, int)); + +/* VI-mode utility functions. */ +extern int rl_vi_check PARAMS((void)); +extern int rl_vi_domove PARAMS((int, int *)); +extern int rl_vi_bracktype PARAMS((int)); + +extern void rl_vi_start_inserting PARAMS((int, int, int)); + +/* VI-mode pseudo-bindable commands, used as utility functions. */ +extern int rl_vi_fWord PARAMS((int, int)); +extern int rl_vi_bWord PARAMS((int, int)); +extern int rl_vi_eWord PARAMS((int, int)); +extern int rl_vi_fword PARAMS((int, int)); +extern int rl_vi_bword PARAMS((int, int)); +extern int rl_vi_eword PARAMS((int, int)); + +/* **************************************************************** */ +/* */ +/* Well Published Functions */ +/* */ +/* **************************************************************** */ + +/* Readline functions. */ +/* Read a line of input. Prompt with PROMPT. A NULL PROMPT means none. */ +extern char *readline PARAMS((const char *)); + +extern int rl_set_prompt PARAMS((const char *)); +extern int rl_expand_prompt PARAMS((char *)); + +extern int rl_initialize PARAMS((void)); + +/* Undocumented; unused by readline */ +extern int rl_discard_argument PARAMS((void)); + +/* Utility functions to bind keys to readline commands. */ +extern int rl_add_defun PARAMS((const char *, rl_command_func_t *, int)); +extern int rl_bind_key PARAMS((int, rl_command_func_t *)); +extern int rl_bind_key_in_map PARAMS((int, rl_command_func_t *, Keymap)); +extern int rl_unbind_key PARAMS((int)); +extern int rl_unbind_key_in_map PARAMS((int, Keymap)); +extern int rl_bind_key_if_unbound PARAMS((int, rl_command_func_t *)); +extern int rl_bind_key_if_unbound_in_map PARAMS((int, rl_command_func_t *, Keymap)); +extern int rl_unbind_function_in_map PARAMS((rl_command_func_t *, Keymap)); +extern int rl_unbind_command_in_map PARAMS((const char *, Keymap)); +extern int rl_bind_keyseq PARAMS((const char *, rl_command_func_t *)); +extern int rl_bind_keyseq_in_map PARAMS((const char *, rl_command_func_t *, Keymap)); +extern int rl_bind_keyseq_if_unbound PARAMS((const char *, rl_command_func_t *)); +extern int rl_bind_keyseq_if_unbound_in_map PARAMS((const char *, rl_command_func_t *, Keymap)); +extern int rl_generic_bind PARAMS((int, const char *, char *, Keymap)); + +extern char *rl_variable_value PARAMS((const char *)); +extern int rl_variable_bind PARAMS((const char *, const char *)); + +/* Backwards compatibility, use rl_bind_keyseq_in_map instead. */ +extern int rl_set_key PARAMS((const char *, rl_command_func_t *, Keymap)); + +/* Backwards compatibility, use rl_generic_bind instead. */ +extern int rl_macro_bind PARAMS((const char *, const char *, Keymap)); + +/* Undocumented in the texinfo manual; not really useful to programs. */ +extern int rl_translate_keyseq PARAMS((const char *, char *, int *)); +extern char *rl_untranslate_keyseq PARAMS((int)); + +extern rl_command_func_t *rl_named_function PARAMS((const char *)); +extern rl_command_func_t *rl_function_of_keyseq PARAMS((const char *, Keymap, int *)); + +extern void rl_list_funmap_names PARAMS((void)); +extern char **rl_invoking_keyseqs_in_map PARAMS((rl_command_func_t *, Keymap)); +extern char **rl_invoking_keyseqs PARAMS((rl_command_func_t *)); + +extern void rl_function_dumper PARAMS((int)); +extern void rl_macro_dumper PARAMS((int)); +extern void rl_variable_dumper PARAMS((int)); + +extern int rl_read_init_file PARAMS((const char *)); +extern int rl_parse_and_bind PARAMS((char *)); + +/* Functions for manipulating keymaps. */ +extern Keymap rl_make_bare_keymap PARAMS((void)); +extern Keymap rl_copy_keymap PARAMS((Keymap)); +extern Keymap rl_make_keymap PARAMS((void)); +extern void rl_discard_keymap PARAMS((Keymap)); + +extern Keymap rl_get_keymap_by_name PARAMS((const char *)); +extern char *rl_get_keymap_name PARAMS((Keymap)); +extern void rl_set_keymap PARAMS((Keymap)); +extern Keymap rl_get_keymap PARAMS((void)); +/* Undocumented; used internally only. */ +extern void rl_set_keymap_from_edit_mode PARAMS((void)); +extern char *rl_get_keymap_name_from_edit_mode PARAMS((void)); + +/* Functions for manipulating the funmap, which maps command names to functions. */ +extern int rl_add_funmap_entry PARAMS((const char *, rl_command_func_t *)); +extern const char **rl_funmap_names PARAMS((void)); +/* Undocumented, only used internally -- there is only one funmap, and this + function may be called only once. */ +extern void rl_initialize_funmap PARAMS((void)); + +/* Utility functions for managing keyboard macros. */ +extern void rl_push_macro_input PARAMS((char *)); + +/* Functions for undoing, from undo.c */ +extern void rl_add_undo PARAMS((enum undo_code, int, int, char *)); +extern void rl_free_undo_list PARAMS((void)); +extern int rl_do_undo PARAMS((void)); +extern int rl_begin_undo_group PARAMS((void)); +extern int rl_end_undo_group PARAMS((void)); +extern int rl_modifying PARAMS((int, int)); + +/* Functions for redisplay. */ +extern void rl_redisplay PARAMS((void)); +extern int rl_on_new_line PARAMS((void)); +extern int rl_on_new_line_with_prompt PARAMS((void)); +extern int rl_forced_update_display PARAMS((void)); +extern int rl_clear_message PARAMS((void)); +extern int rl_reset_line_state PARAMS((void)); +extern int rl_crlf PARAMS((void)); + +extern int rl_message (const char *, ...); + +extern int rl_show_char PARAMS((int)); + +/* Undocumented in texinfo manual. */ +extern int rl_character_len PARAMS((int, int)); + +/* Save and restore internal prompt redisplay information. */ +extern void rl_save_prompt PARAMS((void)); +extern void rl_restore_prompt PARAMS((void)); + +/* Modifying text. */ +extern void rl_replace_line PARAMS((const char *, int)); +extern int rl_insert_text PARAMS((const char *)); +extern int rl_delete_text PARAMS((int, int)); +extern int rl_kill_text PARAMS((int, int)); +extern char *rl_copy_text PARAMS((int, int)); + +/* Terminal and tty mode management. */ +extern void rl_prep_terminal PARAMS((int)); +extern void rl_deprep_terminal PARAMS((void)); +extern void rl_tty_set_default_bindings PARAMS((Keymap)); +extern void rl_tty_unset_default_bindings PARAMS((Keymap)); + +extern int rl_reset_terminal PARAMS((const char *)); +extern void rl_resize_terminal PARAMS((void)); +extern void rl_set_screen_size PARAMS((int, int)); +extern void rl_get_screen_size PARAMS((int *, int *)); +extern void rl_reset_screen_size PARAMS((void)); + +extern char *rl_get_termcap PARAMS((const char *)); + +/* Functions for character input. */ +extern int rl_stuff_char PARAMS((int)); +extern int rl_execute_next PARAMS((int)); +extern int rl_clear_pending_input PARAMS((void)); +extern int rl_read_key PARAMS((void)); +extern int rl_getc PARAMS((TFile)); +extern int rl_set_keyboard_input_timeout PARAMS((int)); + +/* `Public' utility functions . */ +extern void rl_extend_line_buffer PARAMS((int)); +extern int rl_ding PARAMS((void)); +extern int rl_alphabetic PARAMS((int)); +extern void rl_free PARAMS((void *)); + +/* Readline signal handling, from signals.c */ +extern int rl_set_signals PARAMS((void)); +extern int rl_clear_signals PARAMS((void)); +extern void rl_cleanup_after_signal PARAMS((void)); +extern void rl_reset_after_signal PARAMS((void)); +extern void rl_free_line_state PARAMS((void)); + +extern void rl_echo_signal_char PARAMS((int)); + +extern int rl_set_paren_blink_timeout PARAMS((int)); + +/* Undocumented. */ +extern int rl_maybe_save_line PARAMS((void)); +extern int rl_maybe_unsave_line PARAMS((void)); +extern int rl_maybe_replace_line PARAMS((void)); + +/* Completion functions. */ +extern int rl_complete_internal PARAMS((int)); +extern void rl_display_match_list PARAMS((char **, int, int)); + +extern char **rl_completion_matches PARAMS((const char *, rl_compentry_func_t *)); +extern char *rl_username_completion_function PARAMS((const char *, int)); +extern char *rl_filename_completion_function PARAMS((const char *, int)); + +extern int rl_completion_mode PARAMS((rl_command_func_t *)); + +/* **************************************************************** */ +/* */ +/* Well Published Variables */ +/* */ +/* **************************************************************** */ + +#if false + +/* The version of this incarnation of the readline library. */ +extern const char *rl_library_version; /* e.g., "4.2" */ +extern int rl_readline_version; /* e.g., 0x0402 */ + +/* True if this is real GNU readline. */ +extern int rl_gnu_readline_p; + +/* Flags word encapsulating the current readline state. */ +extern int rl_readline_state; + +/* Says which editing mode readline is currently using. 1 means emacs mode; + 0 means vi mode. */ +extern int rl_editing_mode; + +/* Insert or overwrite mode for emacs mode. 1 means insert mode; 0 means + overwrite mode. Reset to insert mode on each input line. */ +extern int rl_insert_mode; + +/* The name of the calling program. You should initialize this to + whatever was in argv[0]. It is used when parsing conditionals. */ +extern const char *rl_readline_name; + +/* The prompt readline uses. This is set from the argument to + readline (), and should not be assigned to directly. */ +extern char *rl_prompt; + +/* The prompt string that is actually displayed by rl_redisplay. Public so + applications can more easily supply their own redisplay functions. */ +extern char *rl_display_prompt; + +/* The line buffer that is in use. */ +extern char *rl_line_buffer; + +/* The location of point, and end. */ +extern int rl_point; +extern int rl_end; + +/* The mark, or saved cursor position. */ +extern int rl_mark; + +/* Flag to indicate that readline has finished with the current input + line and should return it. */ +extern int rl_done; + +/* If set to a character value, that will be the next keystroke read. */ +extern int rl_pending_input; + +/* Non-zero if we called this function from _rl_dispatch(). It's present + so functions can find out whether they were called from a key binding + or directly from an application. */ +extern int rl_dispatching; + +/* Non-zero if the user typed a numeric argument before executing the + current function. */ +extern int rl_explicit_arg; + +/* The current value of the numeric argument specified by the user. */ +extern int rl_numeric_arg; + +/* The address of the last command function Readline executed. */ +extern rl_command_func_t *rl_last_func; + +/* The name of the terminal to use. */ +extern const char *rl_terminal_name; + +/* The input and output streams. */ +extern FILE *rl_instream; +extern FILE *rl_outstream; + +/* If non-zero, Readline gives values of LINES and COLUMNS from the environment + greater precedence than values fetched from the kernel when computing the + screen dimensions. */ +extern int rl_prefer_env_winsize; + +/* If non-zero, then this is the address of a function to call just + before readline_internal () prints the first prompt. */ +extern rl_hook_func_t *rl_startup_hook; + +/* If non-zero, this is the address of a function to call just before + readline_internal_setup () returns and readline_internal starts + reading input characters. */ +extern rl_hook_func_t *rl_pre_input_hook; + +/* The address of a function to call periodically while Readline is + awaiting character input, or NULL, for no event handling. */ +extern rl_hook_func_t *rl_event_hook; + +/* The address of the function to call to fetch a character from the current + Readline input stream */ +extern rl_getc_func_t *rl_getc_function; + +extern rl_voidfunc_t *rl_redisplay_function; + +extern rl_vintfunc_t *rl_prep_term_function; +extern rl_voidfunc_t *rl_deprep_term_function; + +/* Dispatch variables. */ +extern Keymap rl_executing_keymap; +extern Keymap rl_binding_keymap; + +/* Display variables. */ +/* If non-zero, readline will erase the entire line, including any prompt, + if the only thing typed on an otherwise-blank line is something bound to + rl_newline. */ +extern int rl_erase_empty_line; + +/* If non-zero, the application has already printed the prompt (rl_prompt) + before calling readline, so readline should not output it the first time + redisplay is done. */ +extern int rl_already_prompted; + +/* A non-zero value means to read only this many characters rather than + up to a character bound to accept-line. */ +extern int rl_num_chars_to_read; + +/* The text of a currently-executing keyboard macro. */ +extern char *rl_executing_macro; + +/* Variables to control readline signal handling. */ +/* If non-zero, readline will install its own signal handlers for + SIGINT, SIGTERM, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. */ +extern int rl_catch_signals; + +/* If non-zero, readline will install a signal handler for SIGWINCH + that also attempts to call any calling application's SIGWINCH signal + handler. Note that the terminal is not cleaned up before the + application's signal handler is called; use rl_cleanup_after_signal() + to do that. */ +extern int rl_catch_sigwinch; + +/* Completion variables. */ +/* Pointer to the generator function for completion_matches (). + NULL means to use rl_filename_completion_function (), the default + filename completer. */ +extern rl_compentry_func_t *rl_completion_entry_function; + +/* Optional generator for menu completion. Default is + rl_completion_entry_function (rl_filename_completion_function). */ + extern rl_compentry_func_t *rl_menu_completion_entry_function; + +/* If rl_ignore_some_completions_function is non-NULL it is the address + of a function to call after all of the possible matches have been + generated, but before the actual completion is done to the input line. + The function is called with one argument; a NULL terminated array + of (char *). If your function removes any of the elements, they + must be free()'ed. */ +extern rl_compignore_func_t *rl_ignore_some_completions_function; + +/* Pointer to alternative function to create matches. + Function is called with TEXT, START, and END. + START and END are indices in RL_LINE_BUFFER saying what the boundaries + of TEXT are. + If this function exists and returns NULL then call the value of + rl_completion_entry_function to try to match, otherwise use the + array of strings returned. */ +extern rl_completion_func_t *rl_attempted_completion_function; + +/* The basic list of characters that signal a break between words for the + completer routine. The initial contents of this variable is what + breaks words in the shell, i.e. "n\"\\'`@$>". */ +extern const char *rl_basic_word_break_characters; + +/* The list of characters that signal a break between words for + rl_complete_internal. The default list is the contents of + rl_basic_word_break_characters. */ +extern /*const*/ char *rl_completer_word_break_characters; + +/* Hook function to allow an application to set the completion word + break characters before readline breaks up the line. Allows + position-dependent word break characters. */ +extern rl_cpvfunc_t *rl_completion_word_break_hook; + +/* List of characters which can be used to quote a substring of the line. + Completion occurs on the entire substring, and within the substring + rl_completer_word_break_characters are treated as any other character, + unless they also appear within this list. */ +extern const char *rl_completer_quote_characters; + +/* List of quote characters which cause a word break. */ +extern const char *rl_basic_quote_characters; + +/* List of characters that need to be quoted in filenames by the completer. */ +extern const char *rl_filename_quote_characters; + +/* List of characters that are word break characters, but should be left + in TEXT when it is passed to the completion function. The shell uses + this to help determine what kind of completing to do. */ +extern const char *rl_special_prefixes; + +/* If non-zero, then this is the address of a function to call when + completing on a directory name. The function is called with + the address of a string (the current directory name) as an arg. It + changes what is displayed when the possible completions are printed + or inserted. */ +extern rl_icppfunc_t *rl_directory_completion_hook; + +/* If non-zero, this is the address of a function to call when completing + a directory name. This function takes the address of the directory name + to be modified as an argument. Unlike rl_directory_completion_hook, it + only modifies the directory name used in opendir(2), not what is displayed + when the possible completions are printed or inserted. It is called + before rl_directory_completion_hook. I'm not happy with how this works + yet, so it's undocumented. */ +extern rl_icppfunc_t *rl_directory_rewrite_hook; + +/* If non-zero, this is the address of a function to call when reading + directory entries from the filesystem for completion and comparing + them to the partial word to be completed. The function should + either return its first argument (if no conversion takes place) or + newly-allocated memory. This can, for instance, convert filenames + between character sets for comparison against what's typed at the + keyboard. The returned value is what is added to the list of + matches. The second argument is the length of the filename to be + converted. */ +extern rl_dequote_func_t *rl_filename_rewrite_hook; + +/* If non-zero, then this is the address of a function to call when + completing a word would normally display the list of possible matches. + This function is called instead of actually doing the display. + It takes three arguments: (char **matches, int num_matches, int max_length) + where MATCHES is the array of strings that matched, NUM_MATCHES is the + number of strings in that array, and MAX_LENGTH is the length of the + longest string in that array. */ +extern rl_compdisp_func_t *rl_completion_display_matches_hook; + +/* Non-zero means that the results of the matches are to be treated + as filenames. This is ALWAYS zero on entry, and can only be changed + within a completion entry finder function. */ +extern int rl_filename_completion_desired; + +/* Non-zero means that the results of the matches are to be quoted using + double quotes (or an application-specific quoting mechanism) if the + filename contains any characters in rl_word_break_chars. This is + ALWAYS non-zero on entry, and can only be changed within a completion + entry finder function. */ +extern int rl_filename_quoting_desired; + +/* Set to a function to quote a filename in an application-specific fashion. + Called with the text to quote, the type of match found (single or multiple) + and a pointer to the quoting character to be used, which the function can + reset if desired. */ +extern rl_quote_func_t *rl_filename_quoting_function; + +/* Function to call to remove quoting characters from a filename. Called + before completion is attempted, so the embedded quotes do not interfere + with matching names in the file system. */ +extern rl_dequote_func_t *rl_filename_dequoting_function; + +/* Function to call to decide whether or not a word break character is + quoted. If a character is quoted, it does not break words for the + completer. */ +extern rl_linebuf_func_t *rl_char_is_quoted_p; + +/* Non-zero means to suppress normal filename completion after the + user-specified completion function has been called. */ +extern int rl_attempted_completion_over; + +/* Set to a character describing the type of completion being attempted by + rl_complete_internal; available for use by application completion + functions. */ +extern int rl_completion_type; + +/* Set to the last key used to invoke one of the completion functions */ +extern int rl_completion_invoking_key; + +/* Up to this many items will be displayed in response to a + possible-completions call. After that, we ask the user if she + is sure she wants to see them all. The default value is 100. */ +extern int rl_completion_query_items; + +/* Character appended to completed words when at the end of the line. The + default is a space. Nothing is added if this is '\0'. */ +extern int rl_completion_append_character; + +/* If set to non-zero by an application completion function, + rl_completion_append_character will not be appended. */ +extern int rl_completion_suppress_append; + +/* Set to any quote character readline thinks it finds before any application + completion function is called. */ +extern int rl_completion_quote_character; + +/* Set to a non-zero value if readline found quoting anywhere in the word to + be completed; set before any application completion function is called. */ +extern int rl_completion_found_quote; + +/* If non-zero, the completion functions don't append any closing quote. + This is set to 0 by rl_complete_internal and may be changed by an + application-specific completion function. */ +extern int rl_completion_suppress_quote; + +/* If non-zero, readline will sort the completion matches. On by default. */ +extern int rl_sort_completion_matches; + +/* If non-zero, a slash will be appended to completed filenames that are + symbolic links to directory names, subject to the value of the + mark-directories variable (which is user-settable). This exists so + that application completion functions can override the user's preference + (set via the mark-symlinked-directories variable) if appropriate. + It's set to the value of _rl_complete_mark_symlink_dirs in + rl_complete_internal before any application-specific completion + function is called, so without that function doing anything, the user's + preferences are honored. */ +extern int rl_completion_mark_symlink_dirs; + +/* If non-zero, then disallow duplicates in the matches. */ +extern int rl_ignore_completion_duplicates; + +/* If this is non-zero, completion is (temporarily) inhibited, and the + completion character will be inserted as any other. */ +extern int rl_inhibit_completion; + +#endif + +/* Input error; can be returned by (*rl_getc_function) if readline is reading + a top-level command (RL_ISSTATE (RL_STATE_READCMD)). */ +#define READERR (-2) + +/* Definitions available for use by readline clients. */ +#define RL_PROMPT_START_IGNORE '\001' +#define RL_PROMPT_END_IGNORE '\002' + +/* Possible values for do_replace argument to rl_filename_quoting_function, + called by rl_complete_internal. */ +#define NO_MATCH 0 +#define SINGLE_MATCH 1 +#define MULT_MATCH 2 + +/* Possible state values for rl_readline_state */ +#define RL_STATE_NONE 0x000000 /* no state; before first call */ + +#define RL_STATE_INITIALIZING 0x000001 /* initializing */ +#define RL_STATE_INITIALIZED 0x000002 /* initialization done */ +#define RL_STATE_TERMPREPPED 0x000004 /* terminal is prepped */ +#define RL_STATE_READCMD 0x000008 /* reading a command key */ +#define RL_STATE_METANEXT 0x000010 /* reading input after ESC */ +#define RL_STATE_DISPATCHING 0x000020 /* dispatching to a command */ +#define RL_STATE_MOREINPUT 0x000040 /* reading more input in a command function */ +#define RL_STATE_ISEARCH 0x000080 /* doing incremental search */ +#define RL_STATE_NSEARCH 0x000100 /* doing non-inc search */ +#define RL_STATE_SEARCH 0x000200 /* doing a history search */ +#define RL_STATE_NUMERICARG 0x000400 /* reading numeric argument */ +#define RL_STATE_MACROINPUT 0x000800 /* getting input from a macro */ +#define RL_STATE_MACRODEF 0x001000 /* defining keyboard macro */ +#define RL_STATE_OVERWRITE 0x002000 /* overwrite mode */ +#define RL_STATE_COMPLETING 0x004000 /* doing completion */ +#define RL_STATE_SIGHANDLER 0x008000 /* in readline sighandler */ +#define RL_STATE_UNDOING 0x010000 /* doing an undo */ +#define RL_STATE_INPUTPENDING 0x020000 /* rl_execute_next called */ +#define RL_STATE_TTYCSAVED 0x040000 /* tty special chars saved */ +#define RL_STATE_CALLBACK 0x080000 /* using the callback interface */ +#define RL_STATE_VIMOTION 0x100000 /* reading vi motion arg */ +#define RL_STATE_MULTIKEY 0x200000 /* reading multiple-key command */ +#define RL_STATE_VICMDONCE 0x400000 /* entered vi command mode at least once */ +#define RL_STATE_REDISPLAYING 0x800000 /* updating terminal display */ + +#define RL_STATE_DONE 0x1000000 /* done; accepted line */ + +#define RL_SETSTATE(x) (rl_readline_state |= (x)) +#define RL_UNSETSTATE(x) (rl_readline_state &= ~(x)) +#define RL_ISSTATE(x) (rl_readline_state & (x)) + +struct readline_state { + /* line state */ + int point; + int end; + int mark; + char *buffer; + int buflen; + UNDO_LIST *ul; + char *prompt; + + /* global state */ + int rlstate; + int done; + Keymap kmap; + + /* input state */ + rl_command_func_t *lastfunc; + int insmode; + int edmode; + int kseqlen; + FILE *inf; + FILE *outf; + int pendingin; + char *macro; + + /* signal state */ + int catchsigs; + int catchsigwinch; + + /* search state */ + + /* completion state */ + + /* options state */ + + /* reserved for future expansion, so the struct size doesn't change */ + char reserved[64]; +}; + +extern int rl_save_state PARAMS((struct readline_state *)); +extern int rl_restore_state PARAMS((struct readline_state *)); + diff --git a/lib/wrappers/readline/tweaked/rltypedefs.h b/lib/wrappers/readline/tweaked/rltypedefs.h new file mode 100644 index 000000000..46bb42567 --- /dev/null +++ b/lib/wrappers/readline/tweaked/rltypedefs.h @@ -0,0 +1,78 @@ +/* rltypedefs.h -- Type declarations for readline functions. */ + +/* Copyright (C) 2000-2009 Free Software Foundation, Inc. + + This file is part of the GNU Readline Library (Readline), a library + for reading lines of text with interactive input and history editing. + + Readline 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 3 of the License, or + (at your option) any later version. + + Readline 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 Readline. If not, see <http://www.gnu.org/licenses/>. +*/ + +#ifdef C2NIM +# cdecl +# prefix rl_ +# prefix RL_ +# suffix _t +# typeprefixes +# def PARAMS(x) x +#endif + +typedef int (*Function) (); +typedef void VFunction (); +typedef char *CPFunction (); +typedef char **CPPFunction (); + +/* Bindable functions */ +typedef int rl_command_func_t PARAMS((int, int)); + +/* Typedefs for the completion system */ +typedef char *rl_compentry_func_t PARAMS((const char *, int)); +typedef char **rl_completion_func_t PARAMS((const char *, int, int)); + +typedef char *rl_quote_func_t PARAMS((char *, int, char *)); +typedef char *rl_dequote_func_t PARAMS((char *, int)); + +typedef int rl_compignore_func_t PARAMS((char **)); + +typedef void rl_compdisp_func_t PARAMS((char **, int, int)); + +/* Type for input and pre-read hook functions like rl_event_hook */ +typedef int rl_hook_func_t PARAMS((void)); + +/* Input function type */ +typedef int rl_getc_func_t PARAMS((TFile)); + +/* Generic function that takes a character buffer (which could be the readline + line buffer) and an index into it (which could be rl_point) and returns + an int. */ +typedef int rl_linebuf_func_t PARAMS((char *, int)); + +/* `Generic' function pointer typedefs */ +typedef int rl_intfunc_t PARAMS((int)); +typedef int rl_ivoidfunc_t PARAMS((void)); + +typedef int rl_icpfunc_t PARAMS((char *)); +typedef int rl_icppfunc_t PARAMS((char **)); + +typedef void rl_voidfunc_t PARAMS((void)); +typedef void rl_vintfunc_t PARAMS((int)); +typedef void rl_vcpfunc_t PARAMS((char *)); +typedef void rl_vcppfunc_t PARAMS((char **)); + +typedef char *rl_cpvfunc_t PARAMS((void)); +typedef char *rl_cpifunc_t PARAMS((int)); +typedef char *rl_cpcpfunc_t PARAMS((char *)); +typedef char *rl_cpcppfunc_t PARAMS((char **)); + + diff --git a/lib/wrappers/readline/tweaked/tilde.h b/lib/wrappers/readline/tweaked/tilde.h new file mode 100644 index 000000000..d91d0418d --- /dev/null +++ b/lib/wrappers/readline/tweaked/tilde.h @@ -0,0 +1,77 @@ +/* tilde.h: Externally available variables and function in libtilde.a. */ + +/* Copyright (C) 1992-2009 Free Software Foundation, Inc. + + This file contains the Readline Library (Readline), a set of + routines for providing Emacs style line input to programs that ask + for it. + + Readline 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 3 of the License, or + (at your option) any later version. + + Readline 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 Readline. If not, see <http://www.gnu.org/licenses/>. +*/ + +#ifdef C2NIM +# private tildeDll +# dynlib tildeDll +# cdecl +# if defined(windows) +# define tildeDll "tilde.dll" +# elif defined(macosx) +# define tildeDll "libtilde.dynlib" +# else +# define tildeDll "libtilde.so.6(|.0)" +# endif +# prefix tilde_ +# suffix _t +# typeprefixes +# def PARAMS(x) x +#endif + +typedef char *tilde_hook_func_t PARAMS((char *)); + +#if false + +/* If non-null, this contains the address of a function that the application + wants called before trying the standard tilde expansions. The function + is called with the text sans tilde, and returns a malloc()'ed string + which is the expansion, or a NULL pointer if the expansion fails. */ +extern tilde_hook_func_t *tilde_expansion_preexpansion_hook; + +/* If non-null, this contains the address of a function to call if the + standard meaning for expanding a tilde fails. The function is called + with the text (sans tilde, as in "foo"), and returns a malloc()'ed string + which is the expansion, or a NULL pointer if there is no expansion. */ +extern tilde_hook_func_t *tilde_expansion_failure_hook; + +/* When non-null, this is a NULL terminated array of strings which + are duplicates for a tilde prefix. Bash uses this to expand + `=~' and `:~'. */ +extern char **tilde_additional_prefixes; + +/* When non-null, this is a NULL terminated array of strings which match + the end of a username, instead of just "/". Bash sets this to + `:' and `=~'. */ +extern char **tilde_additional_suffixes; + +/* Return a new string which is the result of tilde expanding STRING. */ +extern char *tilde_expand PARAMS((const char *)); + +/* Do the work of tilde expansion on FILENAME. FILENAME starts with a + tilde. If there is no expansion, call tilde_expansion_failure_hook. */ +extern char *tilde_expand_word PARAMS((const char *)); + +/* Find the portion of the string beginning with ~ that should be expanded. */ +extern char *tilde_find_word PARAMS((const char *, int, int *)); + +#endif + diff --git a/lib/wrappers/tcl.nim b/lib/wrappers/tcl.nim index f2ecf558d..0134abad7 100755 --- a/lib/wrappers/tcl.nim +++ b/lib/wrappers/tcl.nim @@ -377,7 +377,6 @@ type result*: cstring # Do not access this directly. Use # Tcl_GetStringResult since result # may be pointing to an object - # freeProc*: TFreeProc errorLine*: int |