nfile; i++)
*node->files[i] = PCA_F_ENIGMA;
};
};
return;
}
#endif /* ifndef WITHOUT_FILE_SYSTEM */
yuma123_2.14/libtecla/update_html 0000775 0001750 0001750 00000002172 14770023131 017140 0 ustar vladimir vladimir #!/bin/sh
# Convert man pages to html files.
for dir in man/prog man/libr man/func man/misc man/file; do
for template in $dir/*.in;do
page=`basename "$template" .in`
if [ `wc -l < $template` -gt 1 ]; then
html="html/$page.html"
man2html $template > $html
for ref in libtecla cpl_complete_word ef_expand_file gl_get_line pca_lookup_file enhance gl_io_mode tecla; do
link="$ref.html"
ed -s $html << EOF
%s|$ref[(][^)][^) ]*[)]|$ref|g
w
q
EOF
done
fi
done
done
# Convert the change log into a web page.
cd html
echo 'The tecla library change log' > changes.html
echo '' >> changes.html
sed 's/&/&/g; s//\>/g' ../CHANGES >> changes.html
echo '
' >> changes.html
# Do the same to the release-notes file.
cd ../html
echo 'The tecla library release notes' > release.html
echo '' >> release.html
sed 's/&/&/g; s/> release.html
echo '
' >> release.html
yuma123_2.14/libtecla/history.c 0000664 0001750 0001750 00000246204 14770023131 016557 0 ustar vladimir vladimir /*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
#include
#include
#include
#include
#include
#include
#include "ioutil.h"
#include "history.h"
#include "freelist.h"
#include "errmsg.h"
/*
* History lines are split into sub-strings of GLH_SEG_SIZE
* characters. To avoid wasting space in the GlhLineSeg structure,
* this should be a multiple of the size of a pointer.
*/
#define GLH_SEG_SIZE 16
/*
* GlhLineSeg structures contain fixed sized segments of a larger
* string. These are linked into lists to record strings, with all but
* the last segment having GLH_SEG_SIZE characters. The last segment
* of a string is terminated within the GLH_SEG_SIZE characters with a
* '\0'.
*/
typedef struct GlhLineSeg GlhLineSeg;
struct GlhLineSeg {
GlhLineSeg *next; /* The next sub-string of the history line */
char s[GLH_SEG_SIZE]; /* The sub-string. Beware that only the final */
/* substring of a line, as indicated by 'next' */
/* being NULL, is '\0' terminated. */
};
/*
* History lines are recorded in a hash table, such that repeated
* lines are stored just once.
*
* Start by defining the size of the hash table. This should be a
* prime number.
*/
#define GLH_HASH_SIZE 113
typedef struct GlhHashBucket GlhHashBucket;
/*
* Each history line will be represented in the hash table by a
* structure of the following type.
*/
typedef struct GlhHashNode GlhHashNode;
struct GlhHashNode {
GlhHashBucket *bucket; /* The parent hash-table bucket of this node */
GlhHashNode *next; /* The next in the list of nodes within the */
/* parent hash-table bucket. */
GlhLineSeg *head; /* The list of sub-strings which make up a line */
int len; /* The length of the line, excluding any '\0' */
int used; /* The number of times this string is pointed to by */
/* the time-ordered list of history lines. */
int reported; /* A flag that is used when searching to ensure that */
/* a line isn't reported redundantly. */
};
/*
* How many new GlhHashNode elements should be allocated at a time?
*/
#define GLH_HASH_INCR 50
static int _glh_is_line(GlhHashNode *hash, const char *line, size_t n);
static int _glh_line_matches_prefix(GlhHashNode *line, GlhHashNode *prefix);
static void _glh_return_line(GlhHashNode *hash, char *line, size_t dim);
/*
* All history lines which hash to a given bucket in the hash table, are
* recorded in a structure of the following type.
*/
struct GlhHashBucket {
GlhHashNode *lines; /* The list of history lines which fall in this bucket */
};
static GlhHashBucket *glh_find_bucket(GlHistory *glh, const char *line,
size_t n);
static GlhHashNode *glh_find_hash_node(GlhHashBucket *bucket, const char *line,
size_t n);
typedef struct {
FreeList *node_mem; /* A free-list of GlhHashNode structures */
GlhHashBucket bucket[GLH_HASH_SIZE]; /* The buckets of the hash table */
} GlhLineHash;
/*
* GlhLineNode's are used to record history lines in time order.
*/
typedef struct GlhLineNode GlhLineNode;
struct GlhLineNode {
long id; /* The unique identifier of this history line */
time_t timestamp; /* The time at which the line was archived */
unsigned group; /* The identifier of the history group to which the */
/* the line belongs. */
GlhLineNode *next; /* The next youngest line in the list */
GlhLineNode *prev; /* The next oldest line in the list */
GlhHashNode *line; /* The hash-table entry of the history line */
};
/*
* The number of GlhLineNode elements per freelist block.
*/
#define GLH_LINE_INCR 100
/*
* Encapsulate the time-ordered list of historical lines.
*/
typedef struct {
FreeList *node_mem; /* A freelist of GlhLineNode objects */
GlhLineNode *head; /* The oldest line in the list */
GlhLineNode *tail; /* The newest line in the list */
} GlhLineList;
/*
* The _glh_lookup_history() returns copies of history lines in a
* dynamically allocated array. This array is initially allocated
* GLH_LOOKUP_SIZE bytes. If subsequently this size turns out to be
* too small, realloc() is used to increase its size to the required
* size plus GLH_LOOKUP_MARGIN. The idea of the later parameter is to
* reduce the number of realloc() operations needed.
*/
#define GLH_LBUF_SIZE 300
#define GLH_LBUF_MARGIN 100
/*
* Encapsulate all of the resources needed to store historical input lines.
*/
struct GlHistory {
ErrMsg *err; /* The error-reporting buffer */
GlhLineSeg *buffer; /* An array of sub-line nodes to be partitioned */
/* into lists of sub-strings recording input lines. */
int nbuff; /* The allocated dimension of buffer[] */
GlhLineSeg *unused; /* The list of free nodes in buffer[] */
GlhLineList list; /* A time ordered list of history lines */
GlhLineNode *recall; /* The last line recalled, or NULL if no recall */
/* session is currently active. */
GlhLineNode *id_node;/* The node at which the last ID search terminated */
GlhLineHash hash; /* A hash-table of reference-counted history lines */
GlhHashNode *prefix; /* A pointer to a line containing the prefix that */
/* is being searched for. Note that if prefix==NULL */
/* and prefix_len>0, this means that no line in */
/* the buffer starts with the requested prefix. */
int prefix_len; /* The length of the prefix being searched for. */
char *lbuf; /* The array in which _glh_lookup_history() returns */
/* history lines */
int lbuf_dim; /* The allocated size of lbuf[] */
int nbusy; /* The number of line segments in buffer[] that are */
/* currently being used to record sub-lines */
int nfree; /* The number of line segments in buffer that are */
/* not currently being used to record sub-lines */
unsigned long seq; /* The next ID to assign to a line node */
unsigned group; /* The identifier of the current history group */
int nline; /* The number of lines currently in the history list */
int max_lines; /* Either -1 or a ceiling on the number of lines */
int enable; /* If false, ignore history additions and lookups */
};
#ifndef WITHOUT_FILE_SYSTEM
static int _glh_cant_load_history(GlHistory *glh, const char *filename,
int lineno, const char *message, FILE *fp);
static int _glh_cant_save_history(GlHistory *glh, const char *message,
const char *filename, FILE *fp);
static int _glh_write_timestamp(FILE *fp, time_t timestamp);
static int _glh_decode_timestamp(char *string, char **endp, time_t *timestamp);
#endif
static void _glh_discard_line(GlHistory *glh, GlhLineNode *node);
static GlhLineNode *_glh_find_id(GlHistory *glh, GlhLineID id);
static GlhHashNode *_glh_acquire_copy(GlHistory *glh, const char *line,
size_t n);
static GlhHashNode *_glh_discard_copy(GlHistory *glh, GlhHashNode *hnode);
static int _glh_prepare_for_recall(GlHistory *glh, char *line);
/*
* The following structure and functions are used to iterate through
* the characters of a segmented history line.
*/
typedef struct {
GlhLineSeg *seg; /* The line segment that the next character will */
/* be returned from. */
int posn; /* The index in the above line segment, containing */
/* the next unread character. */
char c; /* The current character in the input line */
} GlhLineStream;
static void glh_init_stream(GlhLineStream *str, GlhHashNode *line);
static void glh_step_stream(GlhLineStream *str);
/*
* See if search prefix contains any globbing characters.
*/
static int glh_contains_glob(GlhHashNode *prefix);
/*
* Match a line against a search pattern.
*/
static int glh_line_matches_glob(GlhLineStream *lstr, GlhLineStream *pstr);
static int glh_matches_range(char c, GlhLineStream *pstr);
/*.......................................................................
* Create a line history maintenance object.
*
* Input:
* buflen size_t The number of bytes to allocate to the
* buffer that is used to record all of the
* most recent lines of user input that will fit.
* If buflen==0, no buffer will be allocated.
* Output:
* return GlHistory * The new object, or NULL on error.
*/
GlHistory *_new_GlHistory(size_t buflen)
{
GlHistory *glh; /* The object to be returned */
int i;
/*
* Allocate the container.
*/
glh = (GlHistory *) malloc(sizeof(GlHistory));
if(!glh) {
errno = ENOMEM;
return NULL;
};
/*
* Before attempting any operation that might fail, initialize the
* container at least up to the point at which it can safely be passed
* to _del_GlHistory().
*/
glh->err = NULL;
glh->buffer = NULL;
glh->nbuff = (buflen+GLH_SEG_SIZE-1) / GLH_SEG_SIZE;
glh->unused = NULL;
glh->list.node_mem = NULL;
glh->list.head = glh->list.tail = NULL;
glh->recall = NULL;
glh->id_node = NULL;
glh->hash.node_mem = NULL;
for(i=0; ihash.bucket[i].lines = NULL;
glh->prefix = NULL;
glh->lbuf = NULL;
glh->lbuf_dim = 0;
glh->nbusy = 0;
glh->nfree = glh->nbuff;
glh->seq = 0;
glh->group = 0;
glh->nline = 0;
glh->max_lines = -1;
glh->enable = 1;
/*
* Allocate a place to record error messages.
*/
glh->err = _new_ErrMsg();
if(!glh->err)
return _del_GlHistory(glh);
/*
* Allocate the buffer, if required.
*/
if(glh->nbuff > 0) {
glh->nbuff = glh->nfree;
glh->buffer = (GlhLineSeg *) malloc(sizeof(GlhLineSeg) * glh->nbuff);
if(!glh->buffer) {
errno = ENOMEM;
return _del_GlHistory(glh);
};
/*
* All nodes of the buffer are currently unused, so link them all into
* a list and make glh->unused point to the head of this list.
*/
glh->unused = glh->buffer;
for(i=0; inbuff-1; i++) {
GlhLineSeg *seg = glh->unused + i;
seg->next = seg + 1;
};
glh->unused[i].next = NULL;
};
/*
* Allocate the GlhLineNode freelist.
*/
glh->list.node_mem = _new_FreeList(sizeof(GlhLineNode), GLH_LINE_INCR);
if(!glh->list.node_mem)
return _del_GlHistory(glh);
/*
* Allocate the GlhHashNode freelist.
*/
glh->hash.node_mem = _new_FreeList(sizeof(GlhLineNode), GLH_HASH_INCR);
if(!glh->hash.node_mem)
return _del_GlHistory(glh);
/*
* Allocate the array that _glh_lookup_history() uses to return a
* copy of a given history line. This will be resized when necessary.
*/
glh->lbuf_dim = GLH_LBUF_SIZE;
glh->lbuf = (char *) malloc(glh->lbuf_dim);
if(!glh->lbuf) {
errno = ENOMEM;
return _del_GlHistory(glh);
};
return glh;
}
/*.......................................................................
* Delete a GlHistory object.
*
* Input:
* glh GlHistory * The object to be deleted.
* Output:
* return GlHistory * The deleted object (always NULL).
*/
GlHistory *_del_GlHistory(GlHistory *glh)
{
if(glh) {
/*
* Delete the error-message buffer.
*/
glh->err = _del_ErrMsg(glh->err);
/*
* Delete the buffer.
*/
if(glh->buffer) {
free(glh->buffer);
glh->buffer = NULL;
glh->unused = NULL;
};
/*
* Delete the freelist of GlhLineNode's.
*/
glh->list.node_mem = _del_FreeList(glh->list.node_mem, 1);
/*
* The contents of the list were deleted by deleting the freelist.
*/
glh->list.head = NULL;
glh->list.tail = NULL;
/*
* Delete the freelist of GlhHashNode's.
*/
glh->hash.node_mem = _del_FreeList(glh->hash.node_mem, 1);
/*
* Delete the lookup buffer.
*/
if(glh->lbuf)
free(glh->lbuf);
/*
* Delete the container.
*/
free(glh);
};
return NULL;
}
/*.......................................................................
* Append a new line to the history list, deleting old lines to make
* room, if needed.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* line char * The line to be archived.
* force int Unless this flag is non-zero, empty lines aren't
* archived. This flag requests that the line be
* archived regardless.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
int _glh_add_history(GlHistory *glh, const char *line, int force)
{
int slen; /* The length of the line to be recorded (minus the '\0') */
int empty; /* True if the string is empty */
const char *nlptr; /* A pointer to a newline character in line[] */
GlhHashNode *hnode; /* The hash-table node of the line */
GlhLineNode *lnode; /* A node in the time-ordered list of lines */
int i;
/*
* Check the arguments.
*/
if(!glh || !line) {
errno = EINVAL;
return 1;
};
/*
* Is history enabled?
*/
if(!glh->enable || !glh->buffer || glh->max_lines == 0)
return 0;
/*
* Cancel any ongoing search.
*/
if(_glh_cancel_search(glh))
return 1;
/*
* How long is the string to be recorded, being careful not to include
* any terminating '\n' character.
*/
nlptr = strchr(line, '\n');
if(nlptr)
slen = (nlptr - line);
else
slen = strlen(line);
/*
* Is the line empty?
*/
empty = 1;
for(i=0; imax_lines >= 0) {
/*
* If necessary, remove old lines until there is room to add one new
* line without exceeding the specified line limit.
*/
while(glh->nline > 0 && glh->nline >= glh->max_lines)
_glh_discard_line(glh, glh->list.head);
/*
* We can't archive the line if the maximum number of lines allowed is
* zero.
*/
if(glh->max_lines == 0)
return 0;
};
/*
* Unless already stored, store a copy of the line in the history buffer,
* then return a reference-counted hash-node pointer to this copy.
*/
hnode = _glh_acquire_copy(glh, line, slen);
if(!hnode) {
_err_record_msg(glh->err, "No room to store history line", END_ERR_MSG);
errno = ENOMEM;
return 1;
};
/*
* Allocate a new node in the time-ordered list of lines.
*/
lnode = (GlhLineNode *) _new_FreeListNode(glh->list.node_mem);
/*
* If a new line-node couldn't be allocated, discard our copy of the
* stored line before reporting the error.
*/
if(!lnode) {
hnode = _glh_discard_copy(glh, hnode);
_err_record_msg(glh->err, "No room to store history line", END_ERR_MSG);
errno = ENOMEM;
return 1;
};
/*
* Record a pointer to the hash-table record of the line in the new
* list node.
*/
lnode->id = glh->seq++;
lnode->timestamp = time(NULL);
lnode->group = glh->group;
lnode->line = hnode;
/*
* Append the new node to the end of the time-ordered list.
*/
if(glh->list.head)
glh->list.tail->next = lnode;
else
glh->list.head = lnode;
lnode->next = NULL;
lnode->prev = glh->list.tail;
glh->list.tail = lnode;
/*
* Record the addition of a line to the list.
*/
glh->nline++;
return 0;
}
/*.......................................................................
* Recall the next oldest line that has the search prefix last recorded
* by _glh_search_prefix().
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* line char * The input line buffer. On input this should contain
* the current input line, and on output, if anything
* was found, its contents will have been replaced
* with the matching line.
* dim size_t The allocated dimension of the line buffer.
* Output:
* return char * A pointer to line[0], or NULL if not found.
*/
char *_glh_find_backwards(GlHistory *glh, char *line, size_t dim)
{
GlhLineNode *node; /* The line location node being checked */
GlhHashNode *old_line; /* The previous recalled line */
/*
* Check the arguments.
*/
if(!glh || !line) {
if(glh)
_err_record_msg(glh->err, "NULL argument(s)", END_ERR_MSG);
errno = EINVAL;
return NULL;
};
/*
* Is history enabled?
*/
if(!glh->enable || !glh->buffer || glh->max_lines == 0)
return NULL;
/*
* Check the line dimensions.
*/
if(dim < strlen(line) + 1) {
_err_record_msg(glh->err, "'dim' argument inconsistent with strlen(line)",
END_ERR_MSG);
errno = EINVAL;
return NULL;
};
/*
* Preserve the input line if needed.
*/
if(_glh_prepare_for_recall(glh, line))
return NULL;
/*
* From where should we start the search?
*/
if(glh->recall) {
node = glh->recall->prev;
old_line = glh->recall->line;
} else {
node = glh->list.tail;
old_line = NULL;
};
/*
* Search backwards through the list for the first match with the
* prefix string that differs from the last line that was recalled.
*/
while(node && (node->group != glh->group || node->line == old_line ||
!_glh_line_matches_prefix(node->line, glh->prefix)))
node = node->prev;
/*
* Was a matching line found?
*/
if(node) {
/*
* Recall the found node as the starting point for subsequent
* searches.
*/
glh->recall = node;
/*
* Copy the matching line into the provided line buffer.
*/
_glh_return_line(node->line, line, dim);
/*
* Return it.
*/
return line;
};
/*
* No match was found.
*/
return NULL;
}
/*.......................................................................
* Recall the next newest line that has the search prefix last recorded
* by _glh_search_prefix().
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* line char * The input line buffer. On input this should contain
* the current input line, and on output, if anything
* was found, its contents will have been replaced
* with the matching line.
* dim size_t The allocated dimensions of the line buffer.
* Output:
* return char * The line requested, or NULL if no matching line
* was found.
*/
char *_glh_find_forwards(GlHistory *glh, char *line, size_t dim)
{
GlhLineNode *node; /* The line location node being checked */
GlhHashNode *old_line; /* The previous recalled line */
/*
* Check the arguments.
*/
if(!glh || !line) {
if(glh)
_err_record_msg(glh->err, "NULL argument(s)", END_ERR_MSG);
errno = EINVAL;
return NULL;
};
/*
* Is history enabled?
*/
if(!glh->enable || !glh->buffer || glh->max_lines == 0)
return NULL;
/*
* Check the line dimensions.
*/
if(dim < strlen(line) + 1) {
_err_record_msg(glh->err, "'dim' argument inconsistent with strlen(line)",
END_ERR_MSG);
errno = EINVAL;
return NULL;
};
/*
* From where should we start the search?
*/
if(glh->recall) {
node = glh->recall->next;
old_line = glh->recall->line;
} else {
return NULL;
};
/*
* Search forwards through the list for the first match with the
* prefix string.
*/
while(node && (node->group != glh->group || node->line == old_line ||
!_glh_line_matches_prefix(node->line, glh->prefix)))
node = node->next;
/*
* Was a matching line found?
*/
if(node) {
/*
* Copy the matching line into the provided line buffer.
*/
_glh_return_line(node->line, line, dim);
/*
* Record the starting point of the next search.
*/
glh->recall = node;
/*
* If we just returned the line that was being entered when the search
* session first started, cancel the search.
*/
if(node == glh->list.tail)
_glh_cancel_search(glh);
/*
* Return the matching line to the user.
*/
return line;
};
/*
* No match was found.
*/
return NULL;
}
/*.......................................................................
* If a search is in progress, cancel it.
*
* This involves discarding the line that was temporarily saved by
* _glh_find_backwards() when the search was originally started,
* and reseting the search iteration pointer to NULL.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
int _glh_cancel_search(GlHistory *glh)
{
/*
* Check the arguments.
*/
if(!glh) {
errno = EINVAL;
return 1;
};
/*
* If there wasn't a search in progress, do nothing.
*/
if(!glh->recall)
return 0;
/*
* Reset the search pointers. Note that it is essential to set
* glh->recall to NULL before calling _glh_discard_line(), to avoid an
* infinite recursion.
*/
glh->recall = NULL;
/*
* Delete the node of the preserved line.
*/
_glh_discard_line(glh, glh->list.tail);
return 0;
}
/*.......................................................................
* Set the prefix of subsequent history searches.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* line const char * The command line who's prefix is to be used.
* prefix_len int The length of the prefix.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
int _glh_search_prefix(GlHistory *glh, const char *line, int prefix_len)
{
/*
* Check the arguments.
*/
if(!glh) {
errno = EINVAL;
return 1;
};
/*
* Is history enabled?
*/
if(!glh->enable || !glh->buffer || glh->max_lines == 0)
return 0;
/*
* Discard any existing prefix.
*/
glh->prefix = _glh_discard_copy(glh, glh->prefix);
/*
* Only store a copy of the prefix string if it isn't a zero-length string.
*/
if(prefix_len > 0) {
/*
* Get a reference-counted copy of the prefix from the history cache buffer.
*/
glh->prefix = _glh_acquire_copy(glh, line, prefix_len);
/*
* Was there insufficient buffer space?
*/
if(!glh->prefix) {
_err_record_msg(glh->err, "The search prefix is too long to store",
END_ERR_MSG);
errno = ENOMEM;
return 1;
};
};
return 0;
}
/*.......................................................................
* Recall the oldest recorded line.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* line char * The input line buffer. On input this should contain
* the current input line, and on output, its contents
* will have been replaced with the oldest line.
* dim size_t The allocated dimensions of the line buffer.
* Output:
* return char * A pointer to line[0], or NULL if not found.
*/
char *_glh_oldest_line(GlHistory *glh, char *line, size_t dim)
{
GlhLineNode *node; /* The line location node being checked */
/*
* Check the arguments.
*/
if(!glh || !line) {
if(glh)
_err_record_msg(glh->err, "NULL argument(s)", END_ERR_MSG);
errno = EINVAL;
return NULL;
};
/*
* Is history enabled?
*/
if(!glh->enable || !glh->buffer || glh->max_lines == 0)
return NULL;
/*
* Check the line dimensions.
*/
if(dim < strlen(line) + 1) {
_err_record_msg(glh->err, "'dim' argument inconsistent with strlen(line)",
END_ERR_MSG);
errno = EINVAL;
return NULL;
};
/*
* Preserve the input line if needed.
*/
if(_glh_prepare_for_recall(glh, line))
return NULL;
/*
* Locate the oldest line that belongs to the current group.
*/
for(node=glh->list.head; node && node->group != glh->group;
node = node->next)
;
/*
* No line found?
*/
if(!node)
return NULL;
/*
* Record the above node as the starting point for subsequent
* searches.
*/
glh->recall = node;
/*
* Copy the recalled line into the provided line buffer.
*/
_glh_return_line(node->line, line, dim);
/*
* If we just returned the line that was being entered when the search
* session first started, cancel the search.
*/
if(node == glh->list.tail)
_glh_cancel_search(glh);
return line;
}
/*.......................................................................
* Recall the line that was being entered when the search started.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* line char * The input line buffer. On input this should contain
* the current input line, and on output, its contents
* will have been replaced with the line that was
* being entered when the search was started.
* dim size_t The allocated dimensions of the line buffer.
* Output:
* return char * A pointer to line[0], or NULL if not found.
*/
char *_glh_current_line(GlHistory *glh, char *line, size_t dim)
{
/*
* Check the arguments.
*/
if(!glh || !line) {
if(glh)
_err_record_msg(glh->err, "NULL argument(s)", END_ERR_MSG);
errno = EINVAL;
return NULL;
};
/*
* If history isn't enabled, or no history search has yet been started,
* ignore the call.
*/
if(!glh->enable || !glh->buffer || glh->max_lines == 0 || !glh->recall)
return NULL;
/*
* Check the line dimensions.
*/
if(dim < strlen(line) + 1) {
_err_record_msg(glh->err, "'dim' argument inconsistent with strlen(line)",
END_ERR_MSG);
errno = EINVAL;
return NULL;
};
/*
* Copy the recalled line into the provided line buffer.
*/
_glh_return_line(glh->list.tail->line, line, dim);
/*
* Since we have returned to the starting point of the search, cancel it.
*/
_glh_cancel_search(glh);
return line;
}
/*.......................................................................
* Query the id of a history line offset by a given number of lines from
* the one that is currently being recalled. If a recall session isn't
* in progress, or the offset points outside the history list, 0 is
* returned.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* offset int The line offset (0 for the current line, < 0
* for an older line, > 0 for a newer line.
* Output:
* return GlhLineID The identifier of the line that is currently
* being recalled, or 0 if no recall session is
* currently in progress.
*/
GlhLineID _glh_line_id(GlHistory *glh, int offset)
{
GlhLineNode *node; /* The line location node being checked */
/*
* Is history enabled?
*/
if(!glh->enable || !glh->buffer || glh->max_lines == 0)
return 0;
/*
* Search forward 'offset' lines to find the required line.
*/
if(offset >= 0) {
for(node=glh->recall; node && offset != 0; node=node->next) {
if(node->group == glh->group)
offset--;
};
} else {
for(node=glh->recall; node && offset != 0; node=node->prev) {
if(node->group == glh->group)
offset++;
};
};
return node ? node->id : 0;
}
/*.......................................................................
* Recall a line by its history buffer ID. If the line is no longer
* in the buffer, or the id is zero, NULL is returned.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* id GlhLineID The ID of the line to be returned.
* line char * The input line buffer. On input this should contain
* the current input line, and on output, its contents
* will have been replaced with the saved line.
* dim size_t The allocated dimensions of the line buffer.
* Output:
* return char * A pointer to line[0], or NULL if not found.
*/
char *_glh_recall_line(GlHistory *glh, GlhLineID id, char *line, size_t dim)
{
GlhLineNode *node; /* The line location node being checked */
/*
* Is history enabled?
*/
if(!glh->enable || !glh->buffer || glh->max_lines == 0)
return NULL;
/*
* Preserve the input line if needed.
*/
if(_glh_prepare_for_recall(glh, line))
return NULL;
/*
* Search for the specified line.
*/
node = _glh_find_id(glh, id);
/*
* Not found?
*/
if(!node || node->group != glh->group)
return NULL;
/*
* Record the node of the matching line as the starting point
* for subsequent searches.
*/
glh->recall = node;
/*
* Copy the recalled line into the provided line buffer.
*/
_glh_return_line(node->line, line, dim);
return line;
}
/*.......................................................................
* Save the current history in a specified file.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* filename const char * The name of the new file to record the
* history in.
* comment const char * Extra information such as timestamps will
* be recorded on a line started with this
* string, the idea being that the file can
* double as a command file. Specify "" if
* you don't care.
* max_lines int The maximum number of lines to save, or -1
* to save all of the lines in the history
* list.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
int _glh_save_history(GlHistory *glh, const char *filename, const char *comment,
int max_lines)
{
#ifdef WITHOUT_FILE_SYSTEM
_err_record_msg(glh->err, "Can't save history without filesystem access",
END_ERR_MSG);
errno = EINVAL;
return 1;
#else
FILE *fp; /* The output file */
GlhLineNode *node; /* The line being saved */
GlhLineNode *head; /* The head of the list of lines to be saved */
GlhLineSeg *seg; /* One segment of a line being saved */
/*
* Check the arguments.
*/
if(!glh || !filename || !comment) {
if(glh)
_err_record_msg(glh->err, "NULL argument(s)", END_ERR_MSG);
errno = EINVAL;
return 1;
};
/*
* Attempt to open the specified file.
*/
fp = fopen(filename, "w");
if(!fp)
return _glh_cant_save_history(glh, "Can't open", filename, NULL);
/*
* If a ceiling on the number of lines to save was specified, count
* that number of lines backwards, to find the first line to be saved.
*/
head = NULL;
if(max_lines >= 0) {
for(head=glh->list.tail; head && --max_lines > 0; head=head->prev)
;
};
if(!head)
head = glh->list.head;
/*
* Write the contents of the history buffer to the history file, writing
* associated data such as timestamps, to a line starting with the
* specified comment string.
*/
for(node=head; node; node=node->next) {
/*
* Write peripheral information associated with the line, as a comment.
*/
if(fprintf(fp, "%s ", comment) < 0 ||
_glh_write_timestamp(fp, node->timestamp) ||
fprintf(fp, " %u\n", node->group) < 0) {
return _glh_cant_save_history(glh, "Error writing", filename, fp);
};
/*
* Write the history line.
*/
for(seg=node->line->head; seg; seg=seg->next) {
size_t slen = seg->next ? GLH_SEG_SIZE : strlen(seg->s);
if(fwrite(seg->s, sizeof(char), slen, fp) != slen)
return _glh_cant_save_history(glh, "Error writing", filename, fp);
};
fputc('\n', fp);
};
/*
* Close the history file.
*/
if(fclose(fp) == EOF)
return _glh_cant_save_history(glh, "Error writing", filename, NULL);
return 0;
#endif
}
#ifndef WITHOUT_FILE_SYSTEM
/*.......................................................................
* This is a private error return function of _glh_save_history(). It
* composes an error report in the error buffer, composed using
* sprintf("%s %s (%s)", message, filename, strerror(errno)). It then
* closes fp and returns the error return code of _glh_save_history().
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* message const char * A message to be followed by the filename.
* filename const char * The name of the offending output file.
* fp FILE * The stream to be closed (send NULL if not
* open).
* Output:
* return int Always 1.
*/
static int _glh_cant_save_history(GlHistory *glh, const char *message,
const char *filename, FILE *fp)
{
_err_record_msg(glh->err, message, filename, " (",
strerror(errno), ")", END_ERR_MSG);
if(fp)
(void) fclose(fp);
return 1;
}
/*.......................................................................
* Write a timestamp to a given stdio stream, in the format
* yyyymmddhhmmss
*
* Input:
* fp FILE * The stream to write to.
* timestamp time_t The timestamp to be written.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int _glh_write_timestamp(FILE *fp, time_t timestamp)
{
struct tm *t; /* THe broken-down calendar time */
/*
* Get the calendar components corresponding to the given timestamp.
*/
if(timestamp < 0 || (t = localtime(×tamp)) == NULL) {
if(fprintf(fp, "?") < 0)
return 1;
return 0;
};
/*
* Write the calendar time as yyyymmddhhmmss.
*/
if(fprintf(fp, "%04d%02d%02d%02d%02d%02d", t->tm_year + 1900, t->tm_mon + 1,
t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec) < 0)
return 1;
return 0;
}
#endif
/*.......................................................................
* Restore previous history lines from a given file.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* filename const char * The name of the file to read from.
* comment const char * The same comment string that was passed to
* _glh_save_history() when this file was
* written.
* line char * A buffer into which lines can be read.
* dim size_t The allocated dimension of line[].
* Output:
* return int 0 - OK.
* 1 - Error.
*/
int _glh_load_history(GlHistory *glh, const char *filename, const char *comment,
char *line, size_t dim)
{
#ifdef WITHOUT_FILE_SYSTEM
_err_record_msg(glh->err, "Can't load history without filesystem access",
END_ERR_MSG);
errno = EINVAL;
return 1;
#else
FILE *fp; /* The output file */
size_t comment_len; /* The length of the comment string */
time_t timestamp; /* The timestamp of the history line */
unsigned group; /* The identifier of the history group to which */
/* the line belongs. */
int lineno; /* The line number being read */
/*
* Check the arguments.
*/
if(!glh || !filename || !comment || !line) {
if(glh)
_err_record_msg(glh->err, "NULL argument(s)", END_ERR_MSG);
errno = EINVAL;
return 1;
};
/*
* Measure the length of the comment string.
*/
comment_len = strlen(comment);
/*
* Clear the history list.
*/
_glh_clear_history(glh, 1);
/*
* Attempt to open the specified file. Don't treat it as an error
* if the file doesn't exist.
*/
fp = fopen(filename, "r");
if(!fp)
return 0;
/*
* Attempt to read each line and preceding peripheral info, and add these
* to the history list.
*/
for(lineno=1; fgets(line, dim, fp) != NULL; lineno++) {
char *lptr; /* A pointer into the input line */
/*
* Check that the line starts with the comment string.
*/
if(strncmp(line, comment, comment_len) != 0) {
return _glh_cant_load_history(glh, filename, lineno,
"Corrupt history parameter line", fp);
};
/*
* Skip spaces and tabs after the comment.
*/
for(lptr=line+comment_len; *lptr && (*lptr==' ' || *lptr=='\t'); lptr++)
;
/*
* The next word must be a timestamp.
*/
if(_glh_decode_timestamp(lptr, &lptr, ×tamp)) {
return _glh_cant_load_history(glh, filename, lineno,
"Corrupt timestamp", fp);
};
/*
* Skip spaces and tabs.
*/
while(*lptr==' ' || *lptr=='\t')
lptr++;
/*
* The next word must be an unsigned integer group number.
*/
group = (int) strtoul(lptr, &lptr, 10);
if(*lptr != ' ' && *lptr != '\n') {
return _glh_cant_load_history(glh, filename, lineno,
"Corrupt group id", fp);
};
/*
* Skip spaces and tabs.
*/
while(*lptr==' ' || *lptr=='\t')
lptr++;
/*
* There shouldn't be anything left on the line.
*/
if(*lptr != '\n') {
return _glh_cant_load_history(glh, filename, lineno,
"Corrupt parameter line", fp);
};
/*
* Now read the history line itself.
*/
lineno++;
if(fgets(line, dim, fp) == NULL)
return _glh_cant_load_history(glh, filename, lineno, "Read error", fp);
/*
* Append the line to the history buffer.
*/
if(_glh_add_history(glh, line, 1)) {
return _glh_cant_load_history(glh, filename, lineno,
"Insufficient memory to record line", fp);
};
/*
* Record the group and timestamp information along with the line.
*/
if(glh->list.tail) {
glh->list.tail->timestamp = timestamp;
glh->list.tail->group = group;
};
};
/*
* Close the file.
*/
(void) fclose(fp);
return 0;
#endif
}
#ifndef WITHOUT_FILE_SYSTEM
/*.......................................................................
* This is a private error return function of _glh_load_history().
*/
static int _glh_cant_load_history(GlHistory *glh, const char *filename,
int lineno, const char *message, FILE *fp)
{
char lnum[20];
/*
* Convert the line number to a string.
*/
sprintf(lnum, "%d", lineno);
/*
* Render an error message.
*/
_err_record_msg(glh->err, filename, ":", lnum, ":", message, END_ERR_MSG);
/*
* Close the file.
*/
if(fp)
(void) fclose(fp);
return 1;
}
/*.......................................................................
* Read a timestamp from a string.
*
* Input:
* string char * The string to read from.
* Input/Output:
* endp char ** On output *endp will point to the next unprocessed
* character in string[].
* timestamp time_t * The timestamp will be assigned to *t.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int _glh_decode_timestamp(char *string, char **endp, time_t *timestamp)
{
unsigned year,month,day,hour,min,sec; /* Calendar time components */
struct tm t;
/*
* There are 14 characters in the date format yyyymmddhhmmss.
*/
enum {TSLEN=14};
char timestr[TSLEN+1]; /* The timestamp part of the string */
/*
* If the time wasn't available at the time that the line was recorded
* it will have been written as "?". Check for this before trying
* to read the timestamp.
*/
if(string[0] == '\?') {
*endp = string+1;
*timestamp = -1;
return 0;
};
/*
* The timestamp is expected to be written in the form yyyymmddhhmmss.
*/
if(strlen(string) < TSLEN) {
*endp = string;
return 1;
};
/*
* Copy the timestamp out of the string.
*/
strncpy(timestr, string, TSLEN);
timestr[TSLEN] = '\0';
/*
* Decode the timestamp.
*/
if(sscanf(timestr, "%4u%2u%2u%2u%2u%2u", &year, &month, &day, &hour, &min,
&sec) != 6) {
*endp = string;
return 1;
};
/*
* Advance the string pointer over the successfully read timestamp.
*/
*endp = string + TSLEN;
/*
* Copy the read values into a struct tm.
*/
t.tm_sec = sec;
t.tm_min = min;
t.tm_hour = hour;
t.tm_mday = day;
t.tm_wday = 0;
t.tm_yday = 0;
t.tm_mon = month - 1;
t.tm_year = year - 1900;
t.tm_isdst = -1;
/*
* Convert the contents of the struct tm to a time_t.
*/
*timestamp = mktime(&t);
return 0;
}
#endif
/*.......................................................................
* Switch history groups.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* group unsigned The new group identifier. This will be recorded
* with subsequent history lines, and subsequent
* history searches will only return lines with
* this group identifier. This allows multiple
* separate history lists to exist within
* a single GlHistory object. Note that the
* default group identifier is 0.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
int _glh_set_group(GlHistory *glh, unsigned group)
{
/*
* Check the arguments.
*/
if(!glh) {
if(glh)
_err_record_msg(glh->err, "NULL argument(s)", END_ERR_MSG);
errno = EINVAL;
return 1;
};
/*
* Is the group being changed?
*/
if(group != glh->group) {
/*
* Cancel any ongoing search.
*/
if(_glh_cancel_search(glh))
return 1;
/*
* Record the new group.
*/
glh->group = group;
};
return 0;
}
/*.......................................................................
* Query the current history group.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* Output:
* return unsigned The group identifier.
*/
int _glh_get_group(GlHistory *glh)
{
return glh ? glh->group : 0;
}
/*.......................................................................
* Display the contents of the history list.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* write_fn GlWriteFn * The function to call to write the line, or
* 0 to discard the output.
* data void * Anonymous data to pass to write_fn().
* fmt const char * A format string. This can contain arbitrary
* characters, which are written verbatim, plus
* any of the following format directives:
* %D - The date, like 2001-11-20
* %T - The time of day, like 23:59:59
* %N - The sequential entry number of the
* line in the history buffer.
* %G - The history group number of the line.
* %% - A literal % character.
* %H - The history line.
* all_groups int If true, display history lines from all
* history groups. Otherwise only display
* those of the current history group.
* max_lines int If max_lines is < 0, all available lines
* are displayed. Otherwise only the most
* recent max_lines lines will be displayed.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
int _glh_show_history(GlHistory *glh, GlWriteFn *write_fn, void *data,
const char *fmt, int all_groups, int max_lines)
{
GlhLineNode *node; /* The line being displayed */
GlhLineNode *oldest; /* The oldest line to display */
GlhLineSeg *seg; /* One segment of a line being displayed */
enum {TSMAX=32}; /* The maximum length of the date and time string */
char buffer[TSMAX+1]; /* The buffer in which to write the date and time */
int idlen; /* The length of displayed ID strings */
unsigned grpmax; /* The maximum group number in the buffer */
int grplen; /* The number of characters needed to print grpmax */
int len; /* The length of a string to be written */
/*
* Check the arguments.
*/
if(!glh || !write_fn || !fmt) {
if(glh)
_err_record_msg(glh->err, "NULL argument(s)", END_ERR_MSG);
errno = EINVAL;
return 1;
};
/*
* Is history enabled?
*/
if(!glh->enable || !glh->list.head)
return 0;
/*
* Work out the length to display ID numbers, choosing the length of
* the biggest number in the buffer. Smaller numbers will be padded
* with leading zeroes if needed.
*/
sprintf(buffer, "%lu", (unsigned long) glh->list.tail->id);
idlen = strlen(buffer);
/*
* Find the largest group number.
*/
grpmax = 0;
for(node=glh->list.head; node; node=node->next) {
if(node->group > grpmax)
grpmax = node->group;
};
/*
* Find out how many characters are needed to display the group number.
*/
sprintf(buffer, "%u", (unsigned) grpmax);
grplen = strlen(buffer);
/*
* Find the node that follows the oldest line to be displayed.
*/
if(max_lines < 0) {
oldest = glh->list.head;
} else if(max_lines==0) {
return 0;
} else {
for(oldest=glh->list.tail; oldest; oldest=oldest->prev) {
if((all_groups || oldest->group == glh->group) && --max_lines <= 0)
break;
};
/*
* If the number of lines in the buffer doesn't exceed the specified
* maximum, start from the oldest line in the buffer.
*/
if(!oldest)
oldest = glh->list.head;
};
/*
* List the history lines in increasing time order.
*/
for(node=oldest; node; node=node->next) {
/*
* Only display lines from the current history group, unless
* told otherwise.
*/
if(all_groups || node->group == glh->group) {
const char *fptr; /* A pointer into the format string */
struct tm *t = NULL; /* The broken time version of the timestamp */
/*
* Work out the calendar representation of the node timestamp.
*/
if(node->timestamp != (time_t) -1)
t = localtime(&node->timestamp);
/*
* Parse the format string.
*/
fptr = fmt;
while(*fptr) {
/*
* Search for the start of the next format directive or the end of the string.
*/
const char *start = fptr;
while(*fptr && *fptr != '%')
fptr++;
/*
* Display any literal characters that precede the located directive.
*/
if(fptr > start) {
len = (int) (fptr - start);
if(write_fn(data, start, len) != len)
return 1;
};
/*
* Did we hit a new directive before the end of the line?
*/
if(*fptr) {
/*
* Obey the directive. Ignore unknown directives.
*/
switch(*++fptr) {
case 'D': /* Display the date */
if(t && strftime(buffer, TSMAX, "%Y-%m-%d", t) != 0) {
len = strlen(buffer);
if(write_fn(data, buffer, len) != len)
return 1;
};
break;
case 'T': /* Display the time of day */
if(t && strftime(buffer, TSMAX, "%H:%M:%S", t) != 0) {
len = strlen(buffer);
if(write_fn(data, buffer, len) != len)
return 1;
};
break;
case 'N': /* Display the sequential entry number */
sprintf(buffer, "%*lu", idlen, (unsigned long) node->id);
len = strlen(buffer);
if(write_fn(data, buffer, len) != len)
return 1;
break;
case 'G':
sprintf(buffer, "%*u", grplen, (unsigned) node->group);
len = strlen(buffer);
if(write_fn(data, buffer, len) != len)
return 1;
break;
case 'H': /* Display the history line */
for(seg=node->line->head; seg; seg=seg->next) {
len = seg->next ? GLH_SEG_SIZE : strlen(seg->s);
if(write_fn(data, seg->s, len) != len)
return 1;
};
break;
case '%': /* A literal % symbol */
if(write_fn(data, "%", 1) != 1)
return 1;
break;
};
/*
* Skip the directive.
*/
if(*fptr)
fptr++;
};
};
};
};
return 0;
}
/*.......................................................................
* Change the size of the history buffer.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* bufsize size_t The number of bytes in the history buffer, or 0
* to delete the buffer completely.
* Output:
* return int 0 - OK.
* 1 - Insufficient memory (the previous buffer
* will have been retained). No error message
* will be displayed.
*/
int _glh_resize_history(GlHistory *glh, size_t bufsize)
{
int nbuff; /* The number of segments in the new buffer */
int i;
/*
* Check the arguments.
*/
if(!glh) {
errno = EINVAL;
return 1;
};
/*
* How many buffer segments does the requested buffer size correspond
* to?
*/
nbuff = (bufsize+GLH_SEG_SIZE-1) / GLH_SEG_SIZE;
/*
* Has a different size than the current size been requested?
*/
if(glh->nbuff != nbuff) {
/*
* Cancel any ongoing search.
*/
(void) _glh_cancel_search(glh);
/*
* Create a wholly new buffer?
*/
if(glh->nbuff == 0 && nbuff>0) {
glh->buffer = (GlhLineSeg *) malloc(sizeof(GlhLineSeg) * nbuff);
if(!glh->buffer)
return 1;
glh->nbuff = nbuff;
glh->nfree = glh->nbuff;
glh->nbusy = 0;
glh->nline = 0;
/*
* Link the currently unused nodes of the buffer into a list.
*/
glh->unused = glh->buffer;
for(i=0; inbuff-1; i++) {
GlhLineSeg *seg = glh->unused + i;
seg->next = seg + 1;
};
glh->unused[i].next = NULL;
/*
* Delete an existing buffer?
*/
} else if(nbuff == 0) {
_glh_clear_history(glh, 1);
free(glh->buffer);
glh->buffer = NULL;
glh->unused = NULL;
glh->nbuff = 0;
glh->nfree = 0;
glh->nbusy = 0;
glh->nline = 0;
/*
* Change from one finite buffer size to another?
*/
} else {
GlhLineSeg *buffer; /* The resized buffer */
int nbusy; /* The number of used line segments in the new buffer */
/*
* Starting from the oldest line in the buffer, discard lines until
* the buffer contains at most 'nbuff' used line segments.
*/
while(glh->list.head && glh->nbusy > nbuff)
_glh_discard_line(glh, glh->list.head);
/*
* Attempt to allocate a new buffer.
*/
buffer = (GlhLineSeg *) malloc(nbuff * sizeof(GlhLineSeg));
if(!buffer) {
errno = ENOMEM;
return 1;
};
/*
* Copy the used segments of the old buffer to the start of the new buffer.
*/
nbusy = 0;
for(i=0; ihash.bucket + i;
GlhHashNode *hnode;
for(hnode=b->lines; hnode; hnode=hnode->next) {
GlhLineSeg *seg = hnode->head;
hnode->head = buffer + nbusy;
for( ; seg; seg=seg->next) {
buffer[nbusy] = *seg;
buffer[nbusy].next = seg->next ? &buffer[nbusy+1] : NULL;
nbusy++;
};
};
};
/*
* Make a list of the new buffer's unused segments.
*/
for(i=nbusy; ibuffer);
/*
* Install the new buffer.
*/
glh->buffer = buffer;
glh->nbuff = nbuff;
glh->nbusy = nbusy;
glh->nfree = nbuff - nbusy;
glh->unused = glh->nfree > 0 ? (buffer + nbusy) : NULL;
};
};
return 0;
}
/*.......................................................................
* Set an upper limit to the number of lines that can be recorded in the
* history list, or remove a previously specified limit.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* max_lines int The maximum number of lines to allow, or -1 to
* cancel a previous limit and allow as many lines
* as will fit in the current history buffer size.
*/
void _glh_limit_history(GlHistory *glh, int max_lines)
{
if(!glh)
return;
/*
* Apply a new limit?
*/
if(max_lines >= 0 && max_lines != glh->max_lines) {
/*
* Count successively older lines until we reach the start of the
* list, or until we have seen max_lines lines (at which point 'node'
* will be line number max_lines+1).
*/
int nline = 0;
GlhLineNode *node;
for(node=glh->list.tail; node && ++nline <= max_lines; node=node->prev)
;
/*
* Discard any lines that exceed the limit.
*/
if(node) {
GlhLineNode *oldest = node->next; /* The oldest line to be kept */
/*
* Delete nodes from the head of the list until we reach the node that
* is to be kept.
*/
while(glh->list.head && glh->list.head != oldest)
_glh_discard_line(glh, glh->list.head);
};
};
/*
* Record the new limit.
*/
glh->max_lines = max_lines;
return;
}
/*.......................................................................
* Discard either all history, or the history associated with the current
* history group.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* all_groups int If true, clear all of the history. If false,
* clear only the stored lines associated with the
* currently selected history group.
*/
void _glh_clear_history(GlHistory *glh, int all_groups)
{
int i;
/*
* Check the arguments.
*/
if(!glh)
return;
/*
* Cancel any ongoing search.
*/
(void) _glh_cancel_search(glh);
/*
* Delete all history lines regardless of group?
*/
if(all_groups) {
/*
* Claer the time-ordered list of lines.
*/
_rst_FreeList(glh->list.node_mem);
glh->list.head = glh->list.tail = NULL;
glh->nline = 0;
glh->id_node = NULL;
/*
* Clear the hash table.
*/
for(i=0; ihash.bucket[i].lines = NULL;
_rst_FreeList(glh->hash.node_mem);
/*
* Move all line segment nodes back onto the list of unused segments.
*/
if(glh->buffer) {
glh->unused = glh->buffer;
for(i=0; inbuff-1; i++) {
GlhLineSeg *seg = glh->unused + i;
seg->next = seg + 1;
};
glh->unused[i].next = NULL;
glh->nfree = glh->nbuff;
glh->nbusy = 0;
} else {
glh->unused = NULL;
glh->nbusy = glh->nfree = 0;
};
/*
* Just delete lines of the current group?
*/
} else {
GlhLineNode *node; /* The line node being checked */
GlhLineNode *next; /* The line node that follows 'node' */
/*
* Search out and delete the line nodes of the current group.
*/
for(node=glh->list.head; node; node=next) {
/*
* Keep a record of the following node before we delete the current
* node.
*/
next = node->next;
/*
* Discard this node?
*/
if(node->group == glh->group)
_glh_discard_line(glh, node);
};
};
return;
}
/*.......................................................................
* Temporarily enable or disable the history list.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* enable int If true, turn on the history mechanism. If
* false, disable it.
*/
void _glh_toggle_history(GlHistory *glh, int enable)
{
if(glh)
glh->enable = enable;
}
/*.......................................................................
* Discard a given archived input line.
*
* Input:
* glh GlHistory * The history container object.
* node GlhLineNode * The line to be discarded, specified via its
* entry in the time-ordered list of historical
* input lines.
*/
static void _glh_discard_line(GlHistory *glh, GlhLineNode *node)
{
/*
* Remove the node from the linked list.
*/
if(node->prev)
node->prev->next = node->next;
else
glh->list.head = node->next;
if(node->next)
node->next->prev = node->prev;
else
glh->list.tail = node->prev;
/*
* If we are deleting the node that is marked as the start point of the
* last ID search, remove the cached starting point.
*/
if(node == glh->id_node)
glh->id_node = NULL;
/*
* If we are deleting the node that is marked as the start point of the
* next prefix search, cancel the search.
*/
if(node == glh->recall)
_glh_cancel_search(glh);
/*
* Delete our copy of the line.
*/
node->line = _glh_discard_copy(glh, node->line);
/*
* Return the node to the freelist.
*/
(void) _del_FreeListNode(glh->list.node_mem, node);
/*
* Record the removal of a line from the list.
*/
glh->nline--;
return;
}
/*.......................................................................
* Lookup the details of a given history line, given its id.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* id GlLineID The sequential number of the line.
* Input/Output:
* line const char ** A pointer to a copy of the history line will be
* assigned to *line. Beware that this pointer may
* be invalidated by the next call to any public
* history function.
* group unsigned * The group membership of the line will be assigned
* to *group.
* timestamp time_t * The timestamp of the line will be assigned to
* *timestamp.
* Output:
* return int 0 - The requested line wasn't found.
* 1 - The line was found.
*/
int _glh_lookup_history(GlHistory *glh, GlhLineID id, const char **line,
unsigned *group, time_t *timestamp)
{
GlhLineNode *node; /* The located line location node */
/*
* Check the arguments.
*/
if(!glh)
return 0;
/*
* Search for the line that has the specified ID.
*/
node = _glh_find_id(glh, id);
/*
* Not found?
*/
if(!node)
return 0;
/*
* Has the history line been requested?
*/
if(line) {
/*
* If necessary, reallocate the lookup buffer to accomodate the size of
* a copy of the located line.
*/
if(node->line->len + 1 > glh->lbuf_dim) {
int lbuf_dim = node->line->len + 1;
char *lbuf = realloc(glh->lbuf, lbuf_dim);
if(!lbuf) {
errno = ENOMEM;
return 0;
};
glh->lbuf_dim = lbuf_dim;
glh->lbuf = lbuf;
};
/*
* Copy the history line into the lookup buffer.
*/
_glh_return_line(node->line, glh->lbuf, glh->lbuf_dim);
/*
* Assign the lookup buffer as the returned line pointer.
*/
*line = glh->lbuf;
};
/*
* Does the caller want to know the group of the line?
*/
if(group)
*group = node->group;
/*
* Does the caller want to know the timestamp of the line?
*/
if(timestamp)
*timestamp = node->timestamp;
return 1;
}
/*.......................................................................
* Lookup a node in the history list by its ID.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* id GlhLineID The ID of the line to be returned.
* Output:
* return GlhLIneNode * The located node, or NULL if not found.
*/
static GlhLineNode *_glh_find_id(GlHistory *glh, GlhLineID id)
{
GlhLineNode *node; /* The node being checked */
/*
* Is history enabled?
*/
if(!glh->enable || !glh->list.head)
return NULL;
/*
* If possible, start at the end point of the last ID search.
* Otherwise start from the head of the list.
*/
node = glh->id_node;
if(!node)
node = glh->list.head;
/*
* Search forwards from 'node'?
*/
if(node->id < id) {
while(node && node->id != id)
node = node->next;
glh->id_node = node ? node : glh->list.tail;
/*
* Search backwards from 'node'?
*/
} else {
while(node && node->id != id)
node = node->prev;
glh->id_node = node ? node : glh->list.head;
};
/*
* Return the located node (this will be NULL if the ID wasn't found).
*/
return node;
}
/*.......................................................................
* Query the state of the history list. Note that any of the input/output
* pointers can be specified as NULL.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* Input/Output:
* enabled int * If history is enabled, *enabled will be
* set to 1. Otherwise it will be assigned 0.
* group unsigned * The current history group ID will be assigned
* to *group.
* max_lines int * The currently requested limit on the number
* of history lines in the list, or -1 if
* unlimited.
*/
void _glh_state_of_history(GlHistory *glh, int *enabled, unsigned *group,
int *max_lines)
{
if(glh) {
if(enabled)
*enabled = glh->enable;
if(group)
*group = glh->group;
if(max_lines)
*max_lines = glh->max_lines;
};
}
/*.......................................................................
* Get the range of lines in the history buffer.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* Input/Output:
* oldest unsigned long * The sequential entry number of the oldest
* line in the history list will be assigned
* to *oldest, unless there are no lines, in
* which case 0 will be assigned.
* newest unsigned long * The sequential entry number of the newest
* line in the history list will be assigned
* to *newest, unless there are no lines, in
* which case 0 will be assigned.
* nlines int * The number of lines currently in the history
* list.
*/
void _glh_range_of_history(GlHistory *glh, unsigned long *oldest,
unsigned long *newest, int *nlines)
{
if(glh) {
if(oldest)
*oldest = glh->list.head ? glh->list.head->id : 0;
if(newest)
*newest = glh->list.tail ? glh->list.tail->id : 0;
if(nlines)
*nlines = glh->nline;
};
}
/*.......................................................................
* Return the size of the history buffer and the amount of the
* buffer that is currently in use.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* Input/Output:
* buff_size size_t * The size of the history buffer (bytes).
* buff_used size_t * The amount of the history buffer that
* is currently occupied (bytes).
*/
void _glh_size_of_history(GlHistory *glh, size_t *buff_size, size_t *buff_used)
{
if(glh) {
if(buff_size)
*buff_size = (glh->nbusy + glh->nfree) * GLH_SEG_SIZE;
/*
* Determine the amount of buffer space that is currently occupied.
*/
if(buff_used)
*buff_used = glh->nbusy * GLH_SEG_SIZE;
};
}
/*.......................................................................
* Return extra information (ie. in addition to that provided by errno)
* about the last error to occur in any of the public functions of this
* module.
*
* Input:
* glh GlHistory * The container of the history list.
* Output:
* return const char * A pointer to the internal buffer in which
* the error message is temporarily stored.
*/
const char *_glh_last_error(GlHistory *glh)
{
return glh ? _err_get_msg(glh->err) : "NULL GlHistory argument";
}
/*.......................................................................
* Unless already stored, store a copy of the line in the history buffer,
* then return a reference-counted hash-node pointer to this copy.
*
* Input:
* glh GlHistory * The history maintenance buffer.
* line const char * The history line to be recorded.
* n size_t The length of the string, excluding any '\0'
* terminator.
* Output:
* return GlhHashNode * The hash-node containing the stored line, or
* NULL on error.
*/
static GlhHashNode *_glh_acquire_copy(GlHistory *glh, const char *line,
size_t n)
{
GlhHashBucket *bucket; /* The hash-table bucket of the line */
GlhHashNode *hnode; /* The hash-table node of the line */
int i;
/*
* In which bucket should the line be recorded?
*/
bucket = glh_find_bucket(glh, line, n);
/*
* Is the line already recorded there?
*/
hnode = glh_find_hash_node(bucket, line, n);
/*
* If the line isn't recorded in the buffer yet, make room for it.
*/
if(!hnode) {
GlhLineSeg *seg; /* A line segment */
int offset; /* An offset into line[] */
/*
* How many string segments will be needed to record the new line,
* including space for a '\0' terminator?
*/
int nseg = ((n+1) + GLH_SEG_SIZE-1) / GLH_SEG_SIZE;
/*
* Discard the oldest history lines in the buffer until at least
* 'nseg' segments have been freed up, or until we run out of buffer
* space.
*/
while(glh->nfree < nseg && glh->nbusy > 0)
_glh_discard_line(glh, glh->list.head);
/*
* If the buffer is smaller than the new line, don't attempt to truncate
* it to fit. Simply don't archive it.
*/
if(glh->nfree < nseg)
return NULL;
/*
* Record the line in the first 'nseg' segments of the list of unused segments.
*/
offset = 0;
for(i=0,seg=glh->unused; inext, offset+=GLH_SEG_SIZE)
memcpy(seg->s, line + offset, GLH_SEG_SIZE);
memcpy(seg->s, line + offset, n-offset);
seg->s[n-offset] = '\0';
/*
* Create a new hash-node for the line.
*/
hnode = (GlhHashNode *) _new_FreeListNode(glh->hash.node_mem);
if(!hnode)
return NULL;
/*
* Move the copy of the line from the list of unused segments to
* the hash node.
*/
hnode->head = glh->unused;
glh->unused = seg->next;
seg->next = NULL;
glh->nbusy += nseg;
glh->nfree -= nseg;
/*
* Prepend the new hash node to the list within the associated bucket.
*/
hnode->next = bucket->lines;
bucket->lines = hnode;
/*
* Initialize the rest of the members of the hash node.
*/
hnode->len = n;
hnode->reported = 0;
hnode->used = 0;
hnode->bucket = bucket;
};
/*
* Increment the reference count of the line.
*/
hnode->used++;
return hnode;
}
/*.......................................................................
* Decrement the reference count of the history line of a given hash-node,
* and if the count reaches zero, delete both the hash-node and the
* buffered copy of the line.
*
* Input:
* glh GlHistory * The history container object.
* hnode GlhHashNode * The node to be removed.
* Output:
* return GlhHashNode * The deleted hash-node (ie. NULL).
*/
static GlhHashNode *_glh_discard_copy(GlHistory *glh, GlhHashNode *hnode)
{
if(hnode) {
GlhHashBucket *bucket = hnode->bucket;
/*
* If decrementing the reference count of the hash-node doesn't reduce
* the reference count to zero, then the line is still in use in another
* object, so don't delete it yet. Return NULL to indicate that the caller's
* access to the hash-node copy has been deleted.
*/
if(--hnode->used >= 1)
return NULL;
/*
* Remove the hash-node from the list in its parent bucket.
*/
if(bucket->lines == hnode) {
bucket->lines = hnode->next;
} else {
GlhHashNode *prev; /* The node which precedes hnode in the bucket */
for(prev=bucket->lines; prev && prev->next != hnode; prev=prev->next)
;
if(prev)
prev->next = hnode->next;
};
hnode->next = NULL;
/*
* Return the line segments of the hash-node to the list of unused segments.
*/
if(hnode->head) {
GlhLineSeg *tail; /* The last node in the list of line segments */
int nseg; /* The number of segments being discarded */
/*
* Get the last node of the list of line segments referenced in the hash-node,
* while counting the number of line segments used.
*/
for(nseg=1,tail=hnode->head; tail->next; nseg++,tail=tail->next)
;
/*
* Prepend the list of line segments used by the hash node to the
* list of unused line segments.
*/
tail->next = glh->unused;
glh->unused = hnode->head;
glh->nbusy -= nseg;
glh->nfree += nseg;
};
/*
* Return the container of the hash-node to the freelist.
*/
hnode = (GlhHashNode *) _del_FreeListNode(glh->hash.node_mem, hnode);
};
return NULL;
}
/*.......................................................................
* Private function to locate the hash bucket associated with a given
* history line.
*
* This uses a hash-function described in the dragon-book
* ("Compilers - Principles, Techniques and Tools", by Aho, Sethi and
* Ullman; pub. Adison Wesley) page 435.
*
* Input:
* glh GlHistory * The history container object.
* line const char * The historical line to look up.
* n size_t The length of the line in line[], excluding
* any '\0' terminator.
* Output:
* return GlhHashBucket * The located hash-bucket.
*/
static GlhHashBucket *glh_find_bucket(GlHistory *glh, const char *line,
size_t n)
{
unsigned long h = 0L;
int i;
for(i=0; ihash.bucket + (h % GLH_HASH_SIZE);
}
/*.......................................................................
* Find a given history line within a given hash-table bucket.
*
* Input:
* bucket GlhHashBucket * The hash-table bucket in which to search.
* line const char * The historical line to lookup.
* n size_t The length of the line in line[], excluding
* any '\0' terminator.
* Output:
* return GlhHashNode * The hash-table entry of the line, or NULL
* if not found.
*/
static GlhHashNode *glh_find_hash_node(GlhHashBucket *bucket, const char *line,
size_t n)
{
GlhHashNode *node; /* A node in the list of lines in the bucket */
/*
* Compare each of the lines in the list of lines, against 'line'.
*/
for(node=bucket->lines; node; node=node->next) {
if(_glh_is_line(node, line, n))
return node;
};
return NULL;
}
/*.......................................................................
* Return non-zero if a given string is equal to a given segmented line
* node.
*
* Input:
* hash GlhHashNode * The hash-table entry of the line.
* line const char * The string to be compared to the segmented
* line.
* n size_t The length of the line in line[], excluding
* any '\0' terminator.
* Output:
* return int 0 - The lines differ.
* 1 - The lines are the same.
*/
static int _glh_is_line(GlhHashNode *hash, const char *line, size_t n)
{
GlhLineSeg *seg; /* A node in the list of line segments */
int i;
/*
* Do the two lines have the same length?
*/
if(n != hash->len)
return 0;
/*
* Compare the characters of the segmented and unsegmented versions
* of the line.
*/
for(seg=hash->head; n>0 && seg; seg=seg->next) {
const char *s = seg->s;
for(i=0; n>0 && ilen > line->len)
return 0;
/*
* Compare the line to the prefix.
*/
while(pstr.c != '\0' && pstr.c == lstr.c) {
glh_step_stream(&lstr);
glh_step_stream(&pstr);
};
/*
* Did we reach the end of the prefix string before finding
* any differences?
*/
return pstr.c == '\0';
}
/*.......................................................................
* Copy a given history line into a specified output string.
*
* Input:
* hash GlhHashNode The hash-table entry of the history line to
* be copied.
* line char * A copy of the history line.
* dim size_t The allocated dimension of the line buffer.
*/
static void _glh_return_line(GlhHashNode *hash, char *line, size_t dim)
{
GlhLineSeg *seg; /* A node in the list of line segments */
int i;
for(seg=hash->head; dim>0 && seg; seg=seg->next) {
const char *s = seg->s;
for(i=0; dim>0 && irecall && glh->recall == glh->list.tail &&
!_glh_is_line(glh->recall->line, line, strlen(line))) {
_glh_cancel_search(glh);
};
/*
* If this is the first line recall of a new recall session, save the
* current line for potential recall later, and mark it as the last
* line recalled.
*/
if(!glh->recall) {
if(_glh_add_history(glh, line, 1))
return 1;
glh->recall = glh->list.tail;
/*
* The above call to _glh_add_history() will have incremented the line
* sequence number, after adding the line. Since we only want this to
* to be incremented for permanently entered lines, decrement it again.
*/
glh->seq--;
};
return 0;
}
/*.......................................................................
* Return non-zero if a history search session is currently in progress.
*
* Input:
* glh GlHistory * The input-line history maintenance object.
* Output:
* return int 0 - No search is currently in progress.
* 1 - A search is in progress.
*/
int _glh_search_active(GlHistory *glh)
{
return glh && glh->recall;
}
/*.......................................................................
* Initialize a character iterator object to point to the start of a
* given history line. The first character of the line will be placed
* in str->c, and subsequent characters can be placed there by calling
* glh_strep_stream().
*
* Input:
* str GlhLineStream * The iterator object to be initialized.
* line GlhHashNode * The history line to be iterated over (a
* NULL value here, is interpretted as an
* empty string by glh_step_stream()).
*/
static void glh_init_stream(GlhLineStream *str, GlhHashNode *line)
{
str->seg = line ? line->head : NULL;
str->posn = 0;
str->c = str->seg ? str->seg->s[0] : '\0';
}
/*.......................................................................
* Copy the next unread character in the line being iterated, in str->c.
* Once the end of the history line has been reached, all futher calls
* set str->c to '\0'.
*
* Input:
* str GlhLineStream * The history-line iterator to read from.
*/
static void glh_step_stream(GlhLineStream *str)
{
/*
* Get the character from the current iterator position within the line.
*/
str->c = str->seg ? str->seg->s[str->posn] : '\0';
/*
* Unless we have reached the end of the string, move the iterator
* to the position of the next character in the line.
*/
if(str->c != '\0' && ++str->posn >= GLH_SEG_SIZE) {
str->posn = 0;
str->seg = str->seg->next;
};
}
/*.......................................................................
* Return non-zero if the specified search prefix contains any glob
* wildcard characters.
*
* Input:
* prefix GlhHashNode * The search prefix.
* Output:
* return int 0 - The prefix doesn't contain any globbing
* characters.
* 1 - The prefix contains at least one
* globbing character.
*/
static int glh_contains_glob(GlhHashNode *prefix)
{
GlhLineStream pstr; /* The stream that is used to traverse 'prefix' */
/*
* Wrap a stream iterator around the prefix, so that we can traverse it
* without worrying about line-segmentation.
*/
glh_init_stream(&pstr, prefix);
/*
* Search for unescaped wildcard characters.
*/
while(pstr.c != '\0') {
switch(pstr.c) {
case '\\': /* Skip escaped characters */
glh_step_stream(&pstr);
break;
case '*': case '?': case '[': /* A wildcard character? */
return 1;
break;
};
glh_step_stream(&pstr);
};
/*
* No wildcard characters were found.
*/
return 0;
}
/*.......................................................................
* Return non-zero if the history line matches a search prefix containing
* a glob pattern.
*
* Input:
* lstr GlhLineStream * The iterator stream being used to traverse
* the history line that is being matched.
* pstr GlhLineStream * The iterator stream being used to traverse
* the pattern.
* Output:
* return int 0 - Doesn't match.
* 1 - The line matches the pattern.
*/
static int glh_line_matches_glob(GlhLineStream *lstr, GlhLineStream *pstr)
{
/*
* Match each character of the pattern until we reach the end of the
* pattern.
*/
while(pstr->c != '\0') {
/*
* Handle the next character of the pattern.
*/
switch(pstr->c) {
/*
* A match zero-or-more characters wildcard operator.
*/
case '*':
/*
* Skip the '*' character in the pattern.
*/
glh_step_stream(pstr);
/*
* If the pattern ends with the '*' wildcard, then the
* rest of the line matches this.
*/
if(pstr->c == '\0')
return 1;
/*
* Using the wildcard to match successively longer sections of
* the remaining characters of the line, attempt to match
* the tail of the line against the tail of the pattern.
*/
while(lstr->c) {
GlhLineStream old_lstr = *lstr;
GlhLineStream old_pstr = *pstr;
if(glh_line_matches_glob(lstr, pstr))
return 1;
/*
* Restore the line and pattern iterators for a new try.
*/
*lstr = old_lstr;
*pstr = old_pstr;
/*
* Prepare to try again, one character further into the line.
*/
glh_step_stream(lstr);
};
return 0; /* The pattern following the '*' didn't match */
break;
/*
* A match-one-character wildcard operator.
*/
case '?':
/*
* If there is a character to be matched, skip it and advance the
* pattern pointer.
*/
if(lstr->c) {
glh_step_stream(lstr);
glh_step_stream(pstr);
/*
* If we hit the end of the line, there is no character
* matching the operator, so the pattern doesn't match.
*/
} else {
return 0;
};
break;
/*
* A character range operator, with the character ranges enclosed
* in matching square brackets.
*/
case '[':
glh_step_stream(pstr); /* Skip the '[' character */
if(!lstr->c || !glh_matches_range(lstr->c, pstr))
return 0;
glh_step_stream(lstr); /* Skip the character that matched */
break;
/*
* A backslash in the pattern prevents the following character as
* being seen as a special character.
*/
case '\\':
glh_step_stream(pstr); /* Skip the backslash */
/* Note fallthrough to default */
/*
* A normal character to be matched explicitly.
*/
default:
if(lstr->c == pstr->c) {
glh_step_stream(lstr);
glh_step_stream(pstr);
} else {
return 0;
};
break;
};
};
/*
* To get here, pattern must have been exhausted. The line only
* matches the pattern if the line as also been exhausted.
*/
return pstr->c == '\0' && lstr->c == '\0';
}
/*.......................................................................
* Match a character range expression terminated by an unescaped close
* square bracket.
*
* Input:
* c char The character to be matched with the range
* pattern.
* pstr GlhLineStream * The iterator stream being used to traverse
* the pattern.
* Output:
* return int 0 - Doesn't match.
* 1 - The character matched.
*/
static int glh_matches_range(char c, GlhLineStream *pstr)
{
int invert = 0; /* True to invert the sense of the match */
int matched = 0; /* True if the character matched the pattern */
char lastc = '\0'; /* The previous character in the pattern */
/*
* If the first character is a caret, the sense of the match is
* inverted and only if the character isn't one of those in the
* range, do we say that it matches.
*/
if(pstr->c == '^') {
glh_step_stream(pstr);
invert = 1;
};
/*
* The hyphen is only a special character when it follows the first
* character of the range (not including the caret).
*/
if(pstr->c == '-') {
glh_step_stream(pstr);
if(c == '-')
matched = 1;
/*
* Skip other leading '-' characters since they make no sense.
*/
while(pstr->c == '-')
glh_step_stream(pstr);
};
/*
* The hyphen is only a special character when it follows the first
* character of the range (not including the caret or a hyphen).
*/
if(pstr->c == ']') {
glh_step_stream(pstr);
if(c == ']')
matched = 1;
};
/*
* Having dealt with the characters that have special meanings at
* the beginning of a character range expression, see if the
* character matches any of the remaining characters of the range,
* up until a terminating ']' character is seen.
*/
while(!matched && pstr->c && pstr->c != ']') {
/*
* Is this a range of characters signaled by the two end characters
* separated by a hyphen?
*/
if(pstr->c == '-') {
glh_step_stream(pstr); /* Skip the hyphen */
if(pstr->c != ']') {
if(c >= lastc && c <= pstr->c)
matched = 1;
};
/*
* A normal character to be compared directly.
*/
} else if(pstr->c == c) {
matched = 1;
};
/*
* Record and skip the character that we just processed.
*/
lastc = pstr->c;
if(pstr->c != ']')
glh_step_stream(pstr);
};
/*
* Find the terminating ']'.
*/
while(pstr->c && pstr->c != ']')
glh_step_stream(pstr);
/*
* Did we find a terminating ']'?
*/
if(pstr->c == ']') {
/*
* Skip the terminating ']'.
*/
glh_step_stream(pstr);
/*
* If the pattern started with a caret, invert the sense of the match.
*/
if(invert)
matched = !matched;
/*
* If the pattern didn't end with a ']', then it doesn't match,
* regardless of the value of the required sense of the match.
*/
} else {
matched = 0;
};
return matched;
}
yuma123_2.14/libtecla/cplfile.h 0000664 0001750 0001750 00000010607 14770023131 016475 0 ustar vladimir vladimir #ifndef cplfile_h
#define cplfile_h
/*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
typedef struct CompleteFile CompleteFile;
/*
* Create a file-completion resource object.
*/
CompleteFile *_new_CompleteFile(void);
/*
* Delete a file-completion resource object.
*/
CompleteFile *_del_CompleteFile(CompleteFile *cf);
/*.......................................................................
* Complete the string between path[0] and path[len-1] as a pathname,
* leaving the last component uncompleted if it is potentially ambiguous,
* and returning an array of possible completions. Note that the returned
* container belongs to the 'cf' object and its contents will change on
* subsequent calls to this function.
*
* Input:
* cpl WordCompletion * The object in which to record the completions.
* cf CompleteFile * The filename-completion resource object.
* line const char * The string containing the incomplete filename.
* word_start int The index of the first character in line[]
* of the incomplete filename.
* word_end int The index of the character in line[] that
* follows the last character of the incomplete
* filename.
* escaped int If true, backslashes in path[] are
* interpreted as escaping the characters
* that follow them, and any spaces, tabs,
* backslashes, or wildcard characters in the
* returned suffixes will be similarly be escaped.
* If false, backslashes will be interpreted as
* literal parts of the file name, and no
* backslashes will be added to the returned
* suffixes.
* check_fn CplCheckFn * If not zero, this argument specifies a
* function to call to ask whether a given
* file should be included in the list
* of completions.
* check_data void * Anonymous data to be passed to check_fn().
* Output:
* return int 0 - OK.
* 1 - Error. A description of the error can be
* acquired by calling cf_last_error(cf).
*/
int _cf_complete_file(WordCompletion *cpl, CompleteFile *cf,
const char *line, int word_start, int word_end,
int escaped, CplCheckFn *check_fn, void *check_data);
/*.......................................................................
* Return a description of the error that occurred on the last call to
* cf_complete_file().
*
* Input:
* cf CompleteFile * The path-completion resource object.
* Output:
* return char * The description of the last error.
*/
const char *_cf_last_error(CompleteFile *cf);
#endif
yuma123_2.14/libtecla/freelist.h 0000664 0001750 0001750 00000006201 14770023131 016667 0 ustar vladimir vladimir #ifndef freelist_h
#define freelist_h
/*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
/*
* This module provides a memory allocation scheme that helps to
* prevent memory fragmentation by allocating large blocks of
* fixed sized objects and forming them into a free-list for
* subsequent allocations. The free-list is expanded as needed.
*/
typedef struct FreeList FreeList;
/*
* Allocate a new free-list from blocks of 'blocking_factor' objects of size
* node_size. The node_size argument should be determined by applying
* the sizeof() operator to the object type that you intend to allocate from
* the freelist.
*/
FreeList *_new_FreeList(size_t node_size, unsigned blocking_factor);
/*
* If it is known that none of the nodes currently allocated from
* a freelist are still in use, the following function can be called
* to return all nodes to the freelist without the overhead of
* having to call del_FreeListNode() for every allocated node. The
* nodes of the freelist can then be reused by future callers to
* new_FreeListNode().
*/
void _rst_FreeList(FreeList *fl);
/*
* Delete a free-list.
*/
FreeList *_del_FreeList(FreeList *fl, int force);
/*
* Determine the number of nodes that are currently in use.
*/
long _busy_FreeListNodes(FreeList *fl);
/*
* Query the number of allocated nodes in the freelist which are
* currently unused.
*/
long _idle_FreeListNodes(FreeList *fl);
/*
* Allocate a new object from a free-list.
*/
void *_new_FreeListNode(FreeList *fl);
/*
* Return an object to the free-list that it was allocated from.
*/
void *_del_FreeListNode(FreeList *fl, void *object);
#endif
yuma123_2.14/libtecla/chrqueue.c 0000664 0001750 0001750 00000033271 14770023131 016675 0 ustar vladimir vladimir /*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
#include
#include
#include
#include
#include "ioutil.h"
#include "chrqueue.h"
#include "freelist.h"
#include "errmsg.h"
/*
* Set the number of bytes allocated to each node of the list of
* character buffers. This facility is designed principally as
* an expandible I/O output buffer, so use the stdio buffer size
* where available.
*/
#ifdef BUFSIZ
#define GL_CQ_SIZE BUFSIZ
#else
#define GL_CQ_SIZE 512
#endif
/*
* The queue is contained in a list of fixed sized buffers. New nodes
* are appended to this list as needed to accomodate newly added bytes.
* Old nodes at the head of the list are removed as they are emptied.
*/
typedef struct CqCharBuff CqCharBuff;
struct CqCharBuff {
CqCharBuff *next; /* The next node in the list of buffers */
char bytes[GL_CQ_SIZE]; /* The fixed size buffer of this node */
};
/*
* Define the structure that is used to contain a list of character
* buffers.
*/
struct GlCharQueue {
ErrMsg *err; /* A buffer in which to record error messages */
FreeList *bufmem; /* A free-list of CqCharBuff structures */
struct {
CqCharBuff *head; /* The head of the list of output buffers */
CqCharBuff *tail; /* The tail of the list of output buffers */
} buffers;
int nflush; /* The total number of characters that have been */
/* flushed from the start of the queue since */
/* _glq_empty_queue() was last called. */
int ntotal; /* The total number of characters that have been */
/* appended to the queue since _glq_empty_queue() */
/* was last called. */
};
/*.......................................................................
* Create a new GlCharQueue object.
*
* Output:
* return GlCharQueue * The new object, or NULL on error.
*/
GlCharQueue *_new_GlCharQueue(void)
{
GlCharQueue *cq; /* The object to be returned */
/*
* Allocate the container.
*/
cq = malloc(sizeof(GlCharQueue));
if(!cq) {
errno = ENOMEM;
return NULL;
};
/*
* Before attempting any operation that might fail, initialize the
* container at least up to the point at which it can safely be passed
* to del_GlCharQueue().
*/
cq->err = NULL;
cq->bufmem = NULL;
cq->buffers.head = NULL;
cq->buffers.tail = NULL;
cq->nflush = cq->ntotal = 0;
/*
* Allocate a place to record error messages.
*/
cq->err = _new_ErrMsg();
if(!cq->err)
return _del_GlCharQueue(cq);
/*
* Allocate the freelist of CqCharBuff structures.
*/
cq->bufmem = _new_FreeList(sizeof(CqCharBuff), 1);
if(!cq->bufmem)
return _del_GlCharQueue(cq);
return cq;
}
/*.......................................................................
* Delete a GlCharQueue object.
*
* Input:
* cq GlCharQueue * The object to be deleted.
* Output:
* return GlCharQueue * The deleted object (always NULL).
*/
GlCharQueue *_del_GlCharQueue(GlCharQueue *cq)
{
if(cq) {
cq->err = _del_ErrMsg(cq->err);
cq->bufmem = _del_FreeList(cq->bufmem, 1);
free(cq);
};
return NULL;
}
/*.......................................................................
* Append an array of n characters to a character queue.
*
* Input:
* cq GlCharQueue * The queue to append to.
* chars const char * The array of n characters to be appended.
* n int The number of characters in chars[].
* write_fn GL_WRITE_FN * The function to call to output characters,
* or 0 to simply discard the contents of the
* queue. This will be called whenever the
* buffer becomes full. If it fails to release
* any space, the buffer will be extended.
* data void * Anonymous data to pass to write_fn().
* Output:
* return int The number of characters successfully
* appended. This will only be < n on error.
*/
int _glq_append_chars(GlCharQueue *cq, const char *chars, int n,
GlWriteFn *write_fn, void *data)
{
int ndone = 0; /* The number of characters appended so far */
/*
* Check the arguments.
*/
if(!cq || !chars) {
errno = EINVAL;
return 0;
};
/*
* The appended characters may have to be split between multiple
* buffers, so loop for each buffer.
*/
while(ndone < n) {
int ntodo; /* The number of characters remaining to be appended */
int nleft; /* The amount of space remaining in cq->buffers.tail */
int nnew; /* The number of characters to append to cq->buffers.tail */
/*
* Compute the offset at which the next character should be written
* into the tail buffer segment.
*/
int boff = cq->ntotal % GL_CQ_SIZE;
/*
* Since we don't allocate a new buffer until we have at least one
* character to write into it, if boff is 0 at this point, it means
* that we hit the end of the tail buffer segment on the last append,
* so we need to allocate a new one.
*
* If allocating this new node will require a call to malloc(), as
* opposed to using a currently unused node in the freelist, first try
* flushing the current contents of the buffer to the terminal. When
* write_fn() uses blocking I/O, this stops the buffer size ever getting
* bigger than a single buffer node. When it is non-blocking, it helps
* to keep the amount of memory, but it isn't gauranteed to do so.
*/
if(boff == 0 && _idle_FreeListNodes(cq->bufmem) == 0) {
switch(_glq_flush_queue(cq, write_fn, data)) {
case GLQ_FLUSH_DONE:
break;
case GLQ_FLUSH_AGAIN:
errno = 0; /* Don't confuse the caller */
break;
default:
return ndone; /* Error */
};
boff = cq->ntotal % GL_CQ_SIZE;
};
/*
* Since we don't allocate a new buffer until we have at least one
* character to write into it, if boff is 0 at this point, it means
* that we hit the end of the tail buffer segment on the last append,
* so we need to allocate a new one.
*/
if(boff == 0) {
/*
* Allocate the new node.
*/
CqCharBuff *node = (CqCharBuff *) _new_FreeListNode(cq->bufmem);
if(!node) {
_err_record_msg(cq->err, "Insufficient memory to buffer output.",
END_ERR_MSG);
return ndone;
};
/*
* Initialize the node.
*/
node->next = NULL;
/*
* Append the new node to the tail of the list.
*/
if(cq->buffers.tail)
cq->buffers.tail->next = node;
else
cq->buffers.head = node;
cq->buffers.tail = node;
};
/*
* How much room is there for new characters in the current tail node?
*/
nleft = GL_CQ_SIZE - boff;
/*
* How many characters remain to be appended?
*/
ntodo = n - ndone;
/*
* How many characters should we append to the current tail node?
*/
nnew = nleft < ntodo ? nleft : ntodo;
/*
* Append the latest prefix of nnew characters.
*/
memcpy(cq->buffers.tail->bytes + boff, chars + ndone, nnew);
cq->ntotal += nnew;
ndone += nnew;
};
/*
* Return the count of the number of characters successfully appended.
*/
return ndone;
}
/*.......................................................................
* Discard the contents of a queue of characters.
*
* Input:
* cq GlCharQueue * The queue to clear.
*/
void _glq_empty_queue(GlCharQueue *cq)
{
if(cq) {
/*
* Return all list nodes to their respective free-lists.
*/
_rst_FreeList(cq->bufmem);
/*
* Mark the lists as empty.
*/
cq->buffers.head = cq->buffers.tail = NULL;
cq->nflush = cq->ntotal = 0;
};
}
/*.......................................................................
* Return a count of the number of characters currently in the queue.
*
* Input:
* cq GlCharQueue * The queue of interest.
* Output:
* return int The number of characters in the queue.
*/
int _glq_char_count(GlCharQueue *cq)
{
return (cq && cq->buffers.head) ? (cq->ntotal - cq->nflush) : 0;
}
/*.......................................................................
* Write as many characters as possible from the start of a character
* queue via a given output callback function, removing those written
* from the queue.
*
* Input:
* cq GlCharQueue * The queue to write characters from.
* write_fn GL_WRITE_FN * The function to call to output characters,
* or 0 to simply discard the contents of the
* queue.
* data void * Anonymous data to pass to write_fn().
* Output:
* return GlFlushState The status of the flush operation:
* GLQ_FLUSH_DONE - The flush operation
* completed successfully.
* GLQ_FLUSH_AGAIN - The flush operation
* couldn't be completed
* on this call. Call this
* function again when the
* output channel can accept
* further output.
* GLQ_FLUSH_ERROR Unrecoverable error.
*/
GlqFlushState _glq_flush_queue(GlCharQueue *cq, GlWriteFn *write_fn,
void *data)
{
/*
* Check the arguments.
*/
if(!cq) {
errno = EINVAL;
return GLQ_FLUSH_ERROR;
};
/*
* If possible keep writing until all of the chained buffers have been
* emptied and removed from the list.
*/
while(cq->buffers.head) {
/*
* Are we looking at the only node in the list?
*/
int is_tail = cq->buffers.head == cq->buffers.tail;
/*
* How many characters more than an exact multiple of the buffer-segment
* size have been added to the buffer so far?
*/
int nmodulo = cq->ntotal % GL_CQ_SIZE;
/*
* How many characters of the buffer segment at the head of the list
* have been used? Note that this includes any characters that have
* already been flushed. Also note that if nmodulo==0, this means that
* the tail buffer segment is full. The reason for this is that we
* don't allocate new tail buffer segments until there is at least one
* character to be added to them.
*/
int nhead = (!is_tail || nmodulo == 0) ? GL_CQ_SIZE : nmodulo;
/*
* How many characters remain to be flushed from the buffer
* at the head of the list?
*/
int nbuff = nhead - (cq->nflush % GL_CQ_SIZE);
/*
* Attempt to write this number.
*/
int nnew = write_fn(data, cq->buffers.head->bytes +
cq->nflush % GL_CQ_SIZE, nbuff);
/*
* Was anything written?
*/
if(nnew > 0) {
/*
* Increment the count of the number of characters that have
* been flushed from the head of the queue.
*/
cq->nflush += nnew;
/*
* If we succeded in writing all of the contents of the current
* buffer segment, remove it from the queue.
*/
if(nnew == nbuff) {
/*
* If we just emptied the last node left in the list, then the queue is
* now empty and should be reset.
*/
if(is_tail) {
_glq_empty_queue(cq);
} else {
/*
* Get the node to be removed from the head of the list.
*/
CqCharBuff *node = cq->buffers.head;
/*
* Make the node that follows it the new head of the queue.
*/
cq->buffers.head = node->next;
/*
* Return it to the freelist.
*/
node = (CqCharBuff *) _del_FreeListNode(cq->bufmem, node);
};
};
/*
* If the write blocked, request that this function be called again
* when space to write next becomes available.
*/
} else if(nnew==0) {
return GLQ_FLUSH_AGAIN;
/*
* I/O error.
*/
} else {
_err_record_msg(cq->err, "Error writing to terminal", END_ERR_MSG);
return GLQ_FLUSH_ERROR;
};
};
/*
* To get here the queue must now be empty.
*/
return GLQ_FLUSH_DONE;
}
/*.......................................................................
* Return extra information (ie. in addition to that provided by errno)
* about the last error to occur in any of the public functions of this
* module.
*
* Input:
* cq GlCharQueue * The container of the history list.
* Output:
* return const char * A pointer to the internal buffer in which
* the error message is temporarily stored.
*/
const char *_glq_last_error(GlCharQueue *cq)
{
return cq ? _err_get_msg(cq->err) : "NULL GlCharQueue argument";
}
yuma123_2.14/libtecla/pathutil.c 0000664 0001750 0001750 00000036330 14770023131 016705 0 ustar vladimir vladimir /*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
/*
* If file-system access is to be excluded, this module has no function,
* so all of its code should be excluded.
*/
#ifndef WITHOUT_FILE_SYSTEM
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "pathutil.h"
/*.......................................................................
* Create a new PathName object.
*
* Output:
* return PathName * The new object, or NULL on error.
*/
PathName *_new_PathName(void)
{
PathName *path; /* The object to be returned */
/*
* Allocate the container.
*/
path = (PathName *) malloc(sizeof(PathName));
if(!path) {
errno = ENOMEM;
return NULL;
};
/*
* Before attempting any operation that might fail, initialize the
* container at least up to the point at which it can safely be passed
* to _del_PathName().
*/
path->name = NULL;
path->dim = 0;
/*
* Figure out the maximum length of an expanded pathname.
*/
path->dim = _pu_pathname_dim();
if(path->dim == 0)
return _del_PathName(path);
/*
* Allocate the pathname buffer.
*/
path->name = (char *)malloc(path->dim * sizeof(char));
if(!path->name) {
errno = ENOMEM;
return _del_PathName(path);
};
return path;
}
/*.......................................................................
* Delete a PathName object.
*
* Input:
* path PathName * The object to be deleted.
* Output:
* return PathName * The deleted object (always NULL).
*/
PathName *_del_PathName(PathName *path)
{
if(path) {
if(path->name)
free(path->name);
free(path);
};
return NULL;
}
/*.......................................................................
* Return the pathname to a zero-length string.
*
* Input:
* path PathName * The pathname container.
* Output:
* return char * The cleared pathname buffer, or NULL on error.
*/
char *_pn_clear_path(PathName *path)
{
/*
* Check the arguments.
*/
if(!path) {
errno = EINVAL;
return NULL;
};
path->name[0] = '\0';
return path->name;
}
/*.......................................................................
* Append a string to a pathname, increasing the size of the pathname
* buffer if needed.
*
* Input:
* path PathName * The pathname container.
* string const char * The string to be appended to the pathname.
* Note that regardless of the slen argument,
* this should be a '\0' terminated string.
* slen int The maximum number of characters to append
* from string[], or -1 to append the whole
* string.
* remove_escapes int If true, remove the backslashes that escape
* spaces, tabs, backslashes etc..
* Output:
* return char * The pathname string path->name[], which may
* have been reallocated, or NULL if there was
* insufficient memory to extend the pathname.
*/
char *_pn_append_to_path(PathName *path, const char *string, int slen,
int remove_escapes)
{
int pathlen; /* The length of the pathname */
int i;
/*
* Check the arguments.
*/
if(!path || !string) {
errno = EINVAL;
return NULL;
};
/*
* Get the current length of the pathname.
*/
pathlen = strlen(path->name);
/*
* How many characters should be appended?
*/
if(slen < 0 || slen > strlen(string))
slen = strlen(string);
/*
* Resize the pathname if needed.
*/
if(!_pn_resize_path(path, pathlen + slen))
return NULL;
/*
* Append the string to the output pathname, removing any escape
* characters found therein.
*/
if(remove_escapes) {
int is_escape = 0;
for(i=0; iname[pathlen++] = string[i];
};
/*
* Terminate the string.
*/
path->name[pathlen] = '\0';
} else {
/*
* Append the string directly to the pathname.
*/
memcpy(path->name + pathlen, string, slen);
path->name[pathlen + slen] = '\0';
};
return path->name;
}
/*.......................................................................
* Prepend a string to a pathname, increasing the size of the pathname
* buffer if needed.
*
* Input:
* path PathName * The pathname container.
* string const char * The string to be prepended to the pathname.
* Note that regardless of the slen argument,
* this should be a '\0' terminated string.
* slen int The maximum number of characters to prepend
* from string[], or -1 to append the whole
* string.
* remove_escapes int If true, remove the backslashes that escape
* spaces, tabs, backslashes etc..
* Output:
* return char * The pathname string path->name[], which may
* have been reallocated, or NULL if there was
* insufficient memory to extend the pathname.
*/
char *_pn_prepend_to_path(PathName *path, const char *string, int slen,
int remove_escapes)
{
int pathlen; /* The length of the pathname */
int shift; /* The number of characters to shift the suffix by */
int i,j;
/*
* Check the arguments.
*/
if(!path || !string) {
errno = EINVAL;
return NULL;
};
/*
* Get the current length of the pathname.
*/
pathlen = strlen(path->name);
/*
* How many characters should be appended?
*/
if(slen < 0 || slen > strlen(string))
slen = strlen(string);
/*
* Work out how far we need to shift the original path string to make
* way for the new prefix. When removing escape characters, we need
* final length of the new prefix, after unescaped backslashes have
* been removed.
*/
if(remove_escapes) {
int is_escape = 0;
for(shift=0,i=0; iname + shift, path->name, pathlen+1);
/*
* Copy the new prefix into the vacated space at the beginning of the
* output pathname, removing any escape characters if needed.
*/
if(remove_escapes) {
int is_escape = 0;
for(i=j=0; iname[j++] = string[i];
};
} else {
memcpy(path->name, string, slen);
};
return path->name;
}
/*.......................................................................
* If needed reallocate a given pathname buffer to allow a string of
* a given length to be stored in it.
*
* Input:
* path PathName * The pathname container object.
* length size_t The required length of the pathname buffer,
* not including the terminating '\0'.
* Output:
* return char * The pathname buffer, or NULL if there was
* insufficient memory.
*/
char *_pn_resize_path(PathName *path, size_t length)
{
/*
* Check the arguments.
*/
if(!path) {
errno = EINVAL;
return NULL;
};
/*
* If the pathname buffer isn't large enough to accomodate a string
* of the specified length, attempt to reallocate it with the new
* size, plus space for a terminating '\0'. Also add a bit of
* head room to prevent too many reallocations if the initial length
* turned out to be very optimistic.
*/
if(length + 1 > path->dim) {
size_t dim = length + 1 + PN_PATHNAME_INC;
char *name = (char *) realloc(path->name, dim);
if(!name)
return NULL;
path->name = name;
path->dim = dim;
};
return path->name;
}
/*.......................................................................
* Estimate the largest amount of space needed to store a pathname.
*
* Output:
* return size_t The number of bytes needed, including space for the
* terminating '\0'.
*/
size_t _pu_pathname_dim(void)
{
int maxlen; /* The return value excluding space for the '\0' */
/*
* If the POSIX PATH_MAX macro is defined in limits.h, use it.
*/
#ifdef PATH_MAX
maxlen = PATH_MAX;
/*
* If we have pathconf, use it.
*/
#elif defined(_PC_PATH_MAX)
errno = 0;
maxlen = pathconf(FS_ROOT_DIR, _PC_PATH_MAX);
if(maxlen <= 0 || errno)
maxlen = MAX_PATHLEN_FALLBACK;
/*
* None of the above approaches worked, so substitute our fallback
* guess.
*/
#else
maxlen = MAX_PATHLEN_FALLBACK;
#endif
/*
* Return the amount of space needed to accomodate a pathname plus
* a terminating '\0'.
*/
return maxlen + 1;
}
/*.......................................................................
* Return non-zero if the specified path name refers to a directory.
*
* Input:
* pathname const char * The path to test.
* Output:
* return int 0 - Not a directory.
* 1 - pathname[] refers to a directory.
*/
int _pu_path_is_dir(const char *pathname)
{
struct stat statbuf; /* The file-statistics return buffer */
/*
* Look up the file attributes.
*/
if(stat(pathname, &statbuf) < 0)
return 0;
/*
* Is the file a directory?
*/
return S_ISDIR(statbuf.st_mode) != 0;
}
/*.......................................................................
* Return non-zero if the specified path name refers to a regular file.
*
* Input:
* pathname const char * The path to test.
* Output:
* return int 0 - Not a regular file.
* 1 - pathname[] refers to a regular file.
*/
int _pu_path_is_file(const char *pathname)
{
struct stat statbuf; /* The file-statistics return buffer */
/*
* Look up the file attributes.
*/
if(stat(pathname, &statbuf) < 0)
return 0;
/*
* Is the file a regular file?
*/
return S_ISREG(statbuf.st_mode) != 0;
}
/*.......................................................................
* Return non-zero if the specified path name refers to an executable.
*
* Input:
* pathname const char * The path to test.
* Output:
* return int 0 - Not an executable file.
* 1 - pathname[] refers to an executable file.
*/
int _pu_path_is_exe(const char *pathname)
{
struct stat statbuf; /* The file-statistics return buffer */
/*
* Look up the file attributes.
*/
if(stat(pathname, &statbuf) < 0)
return 0;
/*
* Is the file a regular file which is executable by the current user.
*/
return S_ISREG(statbuf.st_mode) != 0 &&
(statbuf.st_mode & (S_IXOTH | S_IXGRP | S_IXUSR)) &&
access(pathname, X_OK) == 0;
}
/*.......................................................................
* Search backwards for the potential start of a filename. This
* looks backwards from the specified index in a given string,
* stopping at the first unescaped space or the start of the line.
*
* Input:
* string const char * The string to search backwards in.
* back_from int The index of the first character in string[]
* that follows the pathname.
* Output:
* return char * The pointer to the first character of
* the potential pathname, or NULL on error.
*/
char *_pu_start_of_path(const char *string, int back_from)
{
int i, j;
/*
* Check the arguments.
*/
if(!string || back_from < 0) {
errno = EINVAL;
return NULL;
};
/*
* Search backwards from the specified index.
*/
for(i=back_from-1; i>=0; i--) {
int c = string[i];
/*
* Stop on unescaped spaces.
*/
if(isspace((int)(unsigned char)c)) {
/*
* The space can't be escaped if we are at the start of the line.
*/
if(i==0)
break;
/*
* Find the extent of the escape characters which precedes the space.
*/
for(j=i-1; j>=0 && string[j]=='\\'; j--)
;
/*
* If there isn't an odd number of escape characters before the space,
* then the space isn't escaped.
*/
if((i - 1 - j) % 2 == 0)
break;
};
};
return (char *)string + i + 1;
}
/*.......................................................................
* Find the length of a potential filename starting from a given
* point. This looks forwards from the specified index in a given string,
* stopping at the first unescaped space or the end of the line.
*
* Input:
* string const char * The string to search backwards in.
* start_from int The index of the first character of the pathname
* in string[].
* Output:
* return char * The pointer to the character that follows
* the potential pathname, or NULL on error.
*/
char *_pu_end_of_path(const char *string, int start_from)
{
int c; /* The character being examined */
int escaped = 0; /* True when the next character is escaped */
int i;
/*
* Check the arguments.
*/
if(!string || start_from < 0) {
errno = EINVAL;
return NULL;
};
/*
* Search forwards from the specified index.
*/
for(i=start_from; (c=string[i]) != '\0'; i++) {
if(escaped) {
escaped = 0;
} else if(isspace(c)) {
break;
} else if(c == '\\') {
escaped = 1;
};
};
return (char *)string + i;
}
/*.......................................................................
* Return non-zero if the specified path name refers to an existing file.
*
* Input:
* pathname const char * The path to test.
* Output:
* return int 0 - The file doesn't exist.
* 1 - The file does exist.
*/
int _pu_file_exists(const char *pathname)
{
struct stat statbuf;
return stat(pathname, &statbuf) == 0;
}
#endif /* ifndef WITHOUT_FILE_SYSTEM */
yuma123_2.14/libtecla/stringrp.c 0000664 0001750 0001750 00000021130 14770023131 016713 0 ustar vladimir vladimir /*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
#include
#include
#include
#include
#include "freelist.h"
#include "stringrp.h"
/*
* StringSegment objects store lots of small strings in larger
* character arrays. Since the total length of all of the strings can't
* be known in advance, an extensible list of large character arrays,
* called string-segments are used.
*/
typedef struct StringSegment StringSegment;
struct StringSegment {
StringSegment *next; /* A pointer to the next segment in the list */
char *block; /* An array of characters to be shared between strings */
int unused; /* The amount of unused space at the end of block[] */
};
/*
* StringGroup is typedef'd in stringrp.h.
*/
struct StringGroup {
FreeList *node_mem; /* The StringSegment free-list */
int block_size; /* The dimension of each character array block */
StringSegment *head; /* The list of character arrays */
};
/*
* Specify how many StringSegment's to allocate at a time.
*/
#define STR_SEG_BLK 20
/*.......................................................................
* Create a new StringGroup object.
*
* Input:
* segment_size int The length of each of the large character
* arrays in which multiple strings will be
* stored. This sets the length of longest
* string that can be stored, and for efficiency
* should be at least 10 times as large as
* the average string that will be stored.
* Output:
* return StringGroup * The new object, or NULL on error.
*/
StringGroup *_new_StringGroup(int segment_size)
{
StringGroup *sg; /* The object to be returned */
/*
* Check the arguments.
*/
if(segment_size < 1) {
errno = EINVAL;
return NULL;
};
/*
* Allocate the container.
*/
sg = (StringGroup *) malloc(sizeof(StringGroup));
if(!sg) {
errno = ENOMEM;
return NULL;
};
/*
* Before attempting any operation that might fail, initialize the
* container at least up to the point at which it can safely be passed
* to _del_StringGroup().
*/
sg->node_mem = NULL;
sg->head = NULL;
sg->block_size = segment_size;
/*
* Allocate the free list that is used to allocate list nodes.
*/
sg->node_mem = _new_FreeList(sizeof(StringSegment), STR_SEG_BLK);
if(!sg->node_mem)
return _del_StringGroup(sg);
return sg;
}
/*.......................................................................
* Delete a StringGroup object.
*
* Input:
* sg StringGroup * The object to be deleted.
* Output:
* return StringGroup * The deleted object (always NULL).
*/
StringGroup *_del_StringGroup(StringGroup *sg)
{
if(sg) {
StringSegment *node;
/*
* Delete the character arrays.
*/
for(node=sg->head; node; node=node->next) {
if(node->block)
free(node->block);
node->block = NULL;
};
/*
* Delete the list nodes that contained the string segments.
*/
sg->node_mem = _del_FreeList(sg->node_mem, 1);
sg->head = NULL; /* Already deleted by deleting sg->node_mem */
/*
* Delete the container.
*/
free(sg);
};
return NULL;
}
/*.......................................................................
* Make a copy of a string in the specified string group, and return
* a pointer to the copy.
*
* Input:
* sg StringGroup * The group to store the string in.
* string const char * The string to be recorded.
* remove_escapes int If true, omit backslashes which escape
* other characters when making the copy.
* Output:
* return char * The pointer to the copy of the string,
* or NULL if there was insufficient memory.
*/
char *_sg_store_string(StringGroup *sg, const char *string, int remove_escapes)
{
char *copy; /* The recorded copy of string[] */
/*
* Check the arguments.
*/
if(!sg || !string)
return NULL;
/*
* Get memory for the string.
*/
copy = _sg_alloc_string(sg, strlen(string));
if(copy) {
/*
* If needed, remove backslash escapes while copying the input string
* into the cache string.
*/
if(remove_escapes) {
int escaped = 0; /* True if the next character should be */
/* escaped. */
const char *src = string; /* A pointer into the input string */
char *dst = copy; /* A pointer into the cached copy of the */
/* string. */
while(*src) {
if(!escaped && *src == '\\') {
escaped = 1;
src++;
} else {
escaped = 0;
*dst++ = *src++;
};
};
*dst = '\0';
/*
* If escapes have already been removed, copy the input string directly
* into the cache.
*/
} else {
strcpy(copy, string);
};
};
/*
* Return a pointer to the copy of the string (or NULL if the allocation
* failed).
*/
return copy;
}
/*.......................................................................
* Allocate memory for a string of a given length.
*
* Input:
* sg StringGroup * The group to store the string in.
* length int The required length of the string.
* Output:
* return char * The pointer to the copy of the string,
* or NULL if there was insufficient memory.
*/
char *_sg_alloc_string(StringGroup *sg, int length)
{
StringSegment *node; /* A node of the list of string segments */
char *copy; /* The allocated string */
/*
* If the string is longer than block_size, then we can't record it.
*/
if(length > sg->block_size || length < 0)
return NULL;
/*
* See if there is room to record the string in one of the existing
* string segments. Do this by advancing the node pointer until we find
* a node with length+1 bytes unused, or we get to the end of the list.
*/
for(node=sg->head; node && node->unused <= length; node=node->next)
;
/*
* If there wasn't room, allocate a new string segment.
*/
if(!node) {
node = (StringSegment *) _new_FreeListNode(sg->node_mem);
if(!node)
return NULL;
/*
* Initialize the segment.
*/
node->next = NULL;
node->block = NULL;
node->unused = sg->block_size;
/*
* Attempt to allocate the string segment character array.
*/
node->block = (char *) malloc(sg->block_size);
if(!node->block)
return NULL;
/*
* Prepend the node to the list.
*/
node->next = sg->head;
sg->head = node;
};
/*
* Get memory for the string.
*/
copy = node->block + sg->block_size - node->unused;
node->unused -= length + 1;
/*
* Return a pointer to the string memory.
*/
return copy;
}
/*.......................................................................
* Delete all of the strings that are currently stored by a specified
* StringGroup object.
*
* Input:
* sg StringGroup * The group of strings to clear.
*/
void _clr_StringGroup(StringGroup *sg)
{
StringSegment *node; /* A node in the list of string segments */
/*
* Mark all of the string segments as unoccupied.
*/
for(node=sg->head; node; node=node->next)
node->unused = sg->block_size;
return;
}
yuma123_2.14/libtecla/stringrp.h 0000664 0001750 0001750 00000006736 14770023131 016737 0 ustar vladimir vladimir #ifndef stringrp_h
#define stringrp_h
/*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
/*
* StringGroup objects provide memory for modules that need to
* allocate lots of small strings without needing to free any of them
* individually, but rather is happy to free them all at the same
* time. Taking advantage of these properties, StringGroup objects
* avoid the heap fragmentation that tends to occur when lots of small
* strings are allocated directly from the heap and later free'd. They
* do this by allocating a list of large character arrays in each of
* which multiple strings are stored. Thus instead of allocating lots
* of small strings, a few large character arrays are allocated. When
* the strings are free'd on mass, this list of character arrays is
* maintained, ready for subsequent use in recording another set of
* strings.
*/
typedef struct StringGroup StringGroup;
/*
* The following constructor allocates a string-allocation object.
* The segment_size argument specifies how long each string segment
* array should be. This should be at least 10 times the length of
* the average string to be recorded in the string group, and
* sets the length of the longest string that can be stored.
*/
StringGroup *_new_StringGroup(int segment_size);
/*
* Delete all of the strings that are currently stored by a specified
* StringGroup object.
*/
void _clr_StringGroup(StringGroup *sg);
/*
* Make a copy of the specified string, returning a pointer to
* the copy, or NULL if there was insufficient memory. If the
* remove_escapes argument is non-zero, backslashes that escape
* other characters will be removed.
*/
char *_sg_store_string(StringGroup *sg, const char *string, int remove_escapes);
/*
* Allocate memory for a string of a given length.
*/
char *_sg_alloc_string(StringGroup *sg, int length);
/*
* Delete a StringGroup object (and all of the strings that it
* contains).
*/
StringGroup *_del_StringGroup(StringGroup *sg);
#endif
yuma123_2.14/libtecla/demo2.c 0000664 0001750 0001750 00000033060 14770023131 016056 0 ustar vladimir vladimir /*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include "libtecla.h"
/*
* If the library is being built with file-system access excluded, this
* demo program won't have anything to demonstrate.
*/
#ifdef WITHOUT_FILE_SYSTEM
int main(int argc, char *argv[])
{
fprintf(stderr, "\n"
" This program normally demonstrates tecla's path-lookup\n"
" facility. However libtecla has been installed with\n"
" file-system facilities explicitly excluded, so there is\n"
" nothing to demonstrate.\n\n");
return 1;
}
#else
/*
* Encapsulate the resources needed by this demo.
*/
typedef struct {
GetLine *gl; /* The line editor */
PathCache *pc; /* A cache of executables in the user's path */
PcaPathConf *ppc; /* The configuration argument of pca_path_completions() */
} DemoRes;
/*
* The following functions allocate and free instances of the above
* structure.
*/
static DemoRes *new_DemoRes(void);
static DemoRes *del_DemoRes(DemoRes *res);
/*
* Search backwards for the start of a pathname.
*/
static char *start_of_path(const char *string, int back_from);
/*
* Find the array indexes of the first character of the first
* space-delimited word in the specified string, and of the character
* that follows it.
*/
static int get_word_limits(const char *string, int *wa, int *wb);
/*
* This is the demonstration completion callback function (defined below).
*/
static CPL_MATCH_FN(demo_cpl_fn);
/* The function which displays the introductory text of the demo */
static void show_demo_introduction(GetLine *gl);
/*.......................................................................
* This demo takes no arguments. It reads lines of input until the
* word 'exit' is entered, or C-d is pressed. It replaces the default
* tab-completion callback with one which when invoked at the start of
* a line, looks up completions of commands in the user's execution
* path, and when invoked in other parts of the line, reverts to
* normal filename completion. Whenever a new line is entered, it
* extracts the first word on the line, looks it up in the user's
* execution path to see if it corresponds to a known executable file,
* and if so, displays the full pathname of the file, along with the
* remaining arguments.
*/
int main(int argc, char *argv[])
{
char *line; /* A line of input */
DemoRes *res; /* The resources of the demo */
int wa,wb; /* The delimiting indexes of a word in line[] */
int major,minor,micro; /* The version number of the library */
/*
* Allocate the resources needed by this demo.
*/
res = new_DemoRes();
if(!res)
return 1;
/*
* If the user has the LC_CTYPE or LC_ALL environment variables set,
* enable display of characters corresponding to the specified locale.
*/
(void) setlocale(LC_CTYPE, "");
/*
* Lookup and display the version number of the library.
*/
libtecla_version(&major, &minor, µ);
printf("\n Welcome to the path-search demo of libtecla version %d.%d.%d\n",
major, minor, micro);
/*
* Display some introductory text, left-justifying it within the current
* width of the terminal and enclosing it in a box of asterixes.
*/
show_demo_introduction(res->gl);
/*
* Read lines of input from the user and print them to stdout.
*/
do {
/*
* Get a new line from the user.
*/
line = gl_get_line(res->gl, "$ ", NULL, 0);
if(!line)
break;
/*
* Work out the extent of the first word in the input line, and
* try to identify this as a command in the path, displaying the
* full pathname of the match if found.
*/
if(get_word_limits(line, &wa, &wb) == 0) {
char *cmd = pca_lookup_file(res->pc, line + wa, wb-wa, 0);
if(cmd) {
printf("Command=%s\n", cmd);
printf("Arguments=%s", line+wb);
} else {
printf("Command not found\n");
};
};
/*
* If the user types "exit", quit the program.
*/
if(strcmp(line, "exit\n")==0)
break;
} while(1);
/*
* Clean up.
*/
res = del_DemoRes(res);
return 0;
}
/*.......................................................................
* This completion callback searches for completions of executables in
* the user's path when invoked on a word at the start of the path, and
* performs normal filename completion elsewhere.
*/
static CPL_MATCH_FN(demo_cpl_fn)
{
/*
* Get the resource object that was passed to gl_customize_completion().
*/
DemoRes *res = (DemoRes *) data;
/*
* Find the start of the filename prefix to be completed, searching
* backwards for the first unescaped space, or the start of the line.
*/
char *start = start_of_path(line, word_end);
/*
* Skip spaces preceding the start of the prefix.
*/
while(start > line && isspace((int)(unsigned char) start[-1]))
start--;
/*
* If the filename prefix is at the start of the line, attempt
* to complete the filename as a command in the path. Otherwise
* perform normal filename completion.
*/
return (start == line) ?
pca_path_completions(cpl, res->ppc, line, word_end) :
cpl_file_completions(cpl, NULL, line, word_end);
}
/*.......................................................................
* Search backwards for the potential start of a filename. This
* looks backwards from the specified index in a given string,
* stopping at the first unescaped space or the start of the line.
*
* Input:
* string const char * The string to search backwards in.
* back_from int The index of the first character in string[]
* that follows the pathname.
* Output:
* return char * The pointer to the first character of
* the potential pathname, or NULL on error.
*/
static char *start_of_path(const char *string, int back_from)
{
int i, j;
/*
* Search backwards from the specified index.
*/
for(i=back_from-1; i>=0; i--) {
int c = string[i];
/*
* Stop on unescaped spaces.
*/
if(isspace((int)(unsigned char)c)) {
/*
* The space can't be escaped if we are at the start of the line.
*/
if(i==0)
break;
/*
* Find the extent of the escape characters which precedes the space.
*/
for(j=i-1; j>=0 && string[j]=='\\'; j--)
;
/*
* If there isn't an odd number of escape characters before the space,
* then the space isn't escaped.
*/
if((i - 1 - j) % 2 == 0)
break;
};
};
return (char *)string + i + 1;
}
/*.......................................................................
* Create a new DemoRes object containing the resources needed by the
* demo.
*
* Output:
* return DemoRes * The new object, or NULL on error.
*/
static DemoRes *new_DemoRes(void)
{
DemoRes *res; /* The object to be returned */
/*
* Allocate the container.
*/
res = (DemoRes *)malloc(sizeof(DemoRes));
if(!res) {
fprintf(stderr, "new_DemoRes: Insufficient memory.\n");
return NULL;
};
/*
* Before attempting any operation that might fail, initialize the
* container at least up to the point at which it can safely be passed
* to del_DemoRes().
*/
res->gl = NULL;
res->pc = NULL;
res->ppc = NULL;
/*
* Create the line editor, specifying a max line length of 500 bytes,
* and 10000 bytes to allocate to storage of historical input lines.
*/
res->gl = new_GetLine(500, 10000);
if(!res->gl)
return del_DemoRes(res);
/*
* Enable text attribute formatting directives in prompt strings.
*/
gl_prompt_style(res->gl, GL_FORMAT_PROMPT);
/*
* Allocate a cache of the executable files found in the user's path.
*/
res->pc = new_PathCache();
if(!res->pc)
return del_DemoRes(res);
/*
* Populate the cache with the contents of the user's path.
*/
if(pca_scan_path(res->pc, getenv("PATH")))
return del_DemoRes(res);
/*
* Arrange for susequent calls to pca_lookup_file() and pca_path_completions()
* to only report files that are executable by the user.
*/
pca_set_check_fn(res->pc, cpl_check_exe, NULL);
/*
* Allocate a configuration object for use with pca_path_completions().
*/
res->ppc = new_PcaPathConf(res->pc);
if(!res->ppc)
return del_DemoRes(res);
/*
* Replace the builtin filename completion callback with one which
* searches for completions of executables in the user's path when
* invoked on a word at the start of the path, and completes files
* elsewhere.
*/
if(gl_customize_completion(res->gl, res, demo_cpl_fn))
return del_DemoRes(res);
return res;
}
/*.......................................................................
* Delete a DemoRes object.
*
* Input:
* res DemoRes * The object to be deleted.
* Output:
* return DemoRes * The deleted object (always NULL).
*/
static DemoRes *del_DemoRes(DemoRes *res)
{
if(res) {
res->gl = del_GetLine(res->gl);
res->pc = del_PathCache(res->pc);
res->ppc = del_PcaPathConf(res->ppc);
free(res);
};
return NULL;
}
/*.......................................................................
* Return the limits of the word at the start of a given string, ignoring
* leading white-space, and interpretting the first unescaped space, tab or
* the end of the line, as the end of the word.
*
* Input:
* string const char * The string to tokenize.
* Input/Output:
* wa,wb int * The indexes of the first character of the word,
* and the character which follows the last
* character of the word, will be assigned to
* *wa and *wb, respectively.
* Output:
* return int 0 - A word was found.
* 1 - No word was found before the end of the
* string.
*/
static int get_word_limits(const char *string, int *wa, int *wb)
{
int escaped = 0; /* True if the next character is escaped */
/*
* Skip leading white-space.
*/
for(*wa=0; isspace((int)(unsigned char)string[*wa]); (*wa)++)
;
/*
* Find the first unescaped space, stopping early if the end of the
* string is reached.
*/
for(*wb = *wa; ; (*wb)++) {
int c = string[*wb];
if(c=='\\')
escaped = !escaped;
else if((!escaped && isspace((int)(unsigned char)c)) || c=='\0')
break;
};
return *wa == *wb;
}
/*.......................................................................
* Display introductory text to the user, formatted according to the
* current terminal width and enclosed in a box of asterixes.
*
* Input:
* gl GetLine * The resource object of gl_get_line().
*/
static void show_demo_introduction(GetLine *gl)
{
int start; /* The column in which gl_display_text() left the cursor */
int i;
/*
* Break the indtroductory text into an array of strings, so as to
* avoid overflowing any compiler string limits.
*/
const char *doc[] = {
"This program demonstrates the use of the pca_lookup_file() function ",
"for finding executables in the UNIX PATH. It also demonstrates ",
"tab completion of the names of executables found in the path. For ",
"example, if you type:\n\n ta\n\nthen hit the tab key, you will be ",
"presented with a list of executables such as tar and tail whose names ",
"start with the string \"ta\". If you decide to add an \"r\" to select ",
"the tar command, then you type return, the full pathname of the tar ",
"program will be printed.\n\nThe file demo2.c contains the code ",
"of this program, and is fully commented to enable its use as ",
"a working example of how to use the facilities documented in the ",
"pca_lookup_file man page.\n"};
/*
* Form the top line of the documentation box by filling the area of
* the line between a " *" prefix and a "* " suffix with asterixes.
*/
printf("\n");
gl_display_text(gl, 0, " *", "* ", '*', 80, 0, "\n");
/*
* Justify the documentation text within margins of asterixes.
*/
for(start=0,i=0; i= 0; i++)
start = gl_display_text(gl, 0, " * ", " * ", ' ', 80, start,doc[i]);
/*
* Draw the bottom line of the documentation box.
*/
gl_display_text(gl, 0, " *", "* ", '*', 80, 0, "\n");
printf("\n");
}
#endif /* ifndef WITHOUT_FILE_SYSTEM */
yuma123_2.14/libtecla/configure.in 0000664 0001750 0001750 00000053632 14770023131 017224 0 ustar vladimir vladimir dnl This is the input file which autoconf uses to construct a
dnl "configure" script for the tecla library. It is a bourne shell
dnl script which autoconf pre-processes with the m4 preprocessor to
dnl expand autoconf-defined m4 macros such as AC_INIT(). The
dnl following line just initializes autoconf. Autoconf interprets the
dnl single argument as the name of an arbitrary file, which it uses to
dnl ensure that it is being run correctly from the directory which
dnl contains the libtecla source code.
AC_INIT(getline.c)
dnl Here we set the major version number of the tecla library.
dnl Incrementing this number implies that a change has been made to
dnl the library's public interface, which makes it binary incompatible
dnl with programs that were linked with previous shared versions of
dnl the tecla library. Incompatible changes of this type should be
dnl avoided at all costs, so it is hoped that the major version number
dnl won't ever have to change. The major version number must be a
dnl small integer number, preferably a single numeric digit.
AC_SUBST(MAJOR_VER)
MAJOR_VER="1"
dnl Set the minor version number of the tecla library. This number
dnl should be incremented by one whenever additional functionality,
dnl such as new functions or modules, are added to the library. The
dnl idea is that a program that was linked with a shared library of
dnl the same major version number, but a lower minor version number,
dnl will continue to function when the run-time loader links it
dnl against the updated version. The minor version number must be a
dnl small integer number, which should be reset to 0 whenever the
dnl major version number is incremented.
AC_SUBST(MINOR_VER)
MINOR_VER="6"
dnl Set the micro version number of the tecla library. This is
dnl incremented whenever modifications to the library are made which
dnl make no changes to the public interface, but which fix bugs and/or
dnl improve the behind-the-scenes implementation. The micro version
dnl number should be reset to 0 whenever the minor version number is
dnl incremented. The micro version number must be a small integer
dnl number.
AC_SUBST(MICRO_VER)
MICRO_VER="1"
dnl The AC_PROG_CC line looks for a C compiler, and if gcc is chosen,
dnl sets the $GCC shell variable to "yes". Make sure that CFLAGS is
dnl set to something first, to prevent AC_PROG_CC from substituting -g
dnl for the optimization level.
CFLAGS="$CFLAGS"
AC_PROG_CC
dnl Apparently not all implementations of the 'make' command define
dnl the MAKE variable. The following directive creates a variable
dnl called SET_MAKE which when expanded in a makefile is either empty
dnl if the local 'make' command was found to define the MAKE variable,
dnl or contains an assignment which will give the MAKE variable the
dnl value 'make'.
AC_PROG_MAKE_SET
dnl The following directive causes autoconf to see if symbolic links
dnl are supported on the current filesystem. If so, it sets the
dnl variable LN_S to "ln -s". Otherwise it sets LN_S to just "ln".
dnl This allows us to create symbolic links where possible, but falls
dnl back to creating hard links where symbolic links aren't available.
AC_PROG_LN_S
dnl The following macro searches for the best implementation of awk
dnl on the host system, and records it in the AWK shell variable.
AC_PROG_AWK
dnl If ranlib is needed on the target system, the RANLIB make variable
dnl is set to ranlib. Otherwise it is set to :, which is the do-nothing
dnl command of the bourne shell.
dnl Note that we do not use AC_PROG_RANLIB because (at least in
dnl autoconf 2.53) this does not check for cross-compilation.
AC_CHECK_TOOL(RANLIB, ranlib)
dnl Set LD as appropriate, especially when cross-compiling
AC_CHECK_TOOL(LD, ld)
dnl The following directive tells autoconf to figure out the target
dnl system type and assign a canonical name for this to the $target
dnl shell variable. This is used below in the target-specific case
dnl statement.
AC_CANONICAL_SYSTEM
dnl In early versions of Solaris, some libraries are in /usr/ccs/lib,
dnl where gcc doesn't look. The tests below for the curses library
dnl would thus fail without this directory being added to the search
dnl path. We thus add it here before the tests. Note that in the
dnl following, since [ and ] are m4 quotes, and m4 will remove the
dnl outermost quotes when it processes this file, we have to double
dnl them up here to get [0-6] to appear in the output configure
dnl script.
case $target_os in
solaris2.[[0-6]]|solaris2.[[0-6]].*)
LIBS="$LIBS -L/usr/ccs/lib"
;;
esac
dnl Recent versions of gcc place /usr/local/include at the head of the
dnl system include-file search path. This causes problems when include
dnl files that have the same name as standard system include files are
dnl placed in this directory by third-party packages. To avoid this,
dnl move /usr/local/include to the end of the search path.
if test "$GCC"_ = "yes"_; then
touch foo.c
fix=`$CC -E -Wp,-v foo.c 2>&1 | $AWK '
/^#include <...> search starts here:/ {in_list=1;ndir=0}
/ *\// && in_list {path[[ndir++]] = $1}
/^End of search list/ {in_list=0}
END {
if(path[[0]] ~ /\/usr\/local\/include/) {
for(dir=1; dir])], [AC_CHECK_HEADERS(ncurses/curses.h, [AC_CHECK_HEADERS(ncurses/term.h,[],[],[#include ])])])
dnl The following variable lists the targets that will be created if
dnl the user runs make without any arguments. Initially we assume
dnl that we can create both the normal and the reentrant versions
dnl of the library.
AC_SUBST(TARGETS)
TARGETS="normal reentrant"
dnl Check for reentrant functions by attempting to compile and link a
dnl temporary program which calls them, being sure to include the
dnl appropriate headers and define _POSIX_C_SOURCE, just in case any
dnl of the functions are defined as macros. In the following,
dnl AC_CACHE_CHECK outputs the message "checking for reentrant
dnl functions". If this check has been done before, it assigns the
dnl cached yes/no value to tecla_cv_reentrant. Otherwise it uses
dnl AC_TRY_LINK() to attempt to compile and link the specified dummy
dnl program, and sets tecla_cv_reentrant to yes or no, depending on
dnl whether this succeeds. Finally it caches the value of
dnl tecla_cv_reentrant in the file config.cache, and writes "yes" or
dnl "no" to the terminal.
AC_CACHE_CHECK(for reentrant functions, tecla_cv_reentrant, [
KEPT_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -D_POSIX_C_SOURCE=199506L"
AC_TRY_LINK([
#include
#include
#include
#include
#include
], [
(void) readdir_r(NULL, NULL, NULL);
(void) getpwuid_r(geteuid(), NULL, NULL, 0, NULL);
(void) getpwnam_r(NULL, NULL, NULL, 0, NULL);
], tecla_cv_reentrant=yes, tecla_cv_reentrant=no)
CFLAGS="$KEPT_CFLAGS"
])
dnl If the necessary reentrant functions weren't found to be
dnl available, default to only compiling the non-reentrant version of
dnl the library.
if test $tecla_cv_reentrant = no; then
TARGETS="normal"
fi
dnl If sys/select.h exists, arrange for the HAVE_SYS_SELECT_H C-macro to
dnl be defined when compiling the library.
AC_CHECK_HEADER(sys/select.h, AC_DEFINE(HAVE_SYS_SELECT_H))
dnl Check for the select system call with the normal arguments,
dnl by attempting to compile and link a temporary program which
dnl calls it, being sure to include the appropriate headers.
dnl In the following, AC_CACHE_CHECK outputs the message
dnl "checking for select system call". If this check has been done
dnl before, it assigns the cached yes/no value to tecla_cv_select.
dnl Otherwise it uses AC_TRY_LINK() to attempt to compile and link
dnl the specified dummy program, and sets tecla_cv_select to yes
dnl or no, depending on whether this succeeds. Finally it caches
dnl the value of tecla_cv_select in the file config.cache, and
dnl writes "yes" or "no" to the terminal.
AC_CACHE_CHECK(for select system call, tecla_cv_select, [
AC_TRY_LINK([
#include
#include
#include
#ifdef HAVE_SYS_SELECT_H
#include
#endif
], [
fd_set fds;
int nready;
FD_ZERO(&fds);
FD_SET(1, &fds);
nready = select(2, &fds, &fds, &fds, NULL);
], tecla_cv_select=yes, tecla_cv_select=no)
])
dnl If the select function was available, arrange for HAVE_SELECT to
dnl be defined by CFLAGS.
if test $tecla_cv_select = yes; then
AC_DEFINE(HAVE_SELECT)
fi
dnl Check if this system supports the system V pseudo terminal interface.
AC_CACHE_CHECK(for SysV pseudo-terminals, tecla_cv_sysv_pty, [
AC_TRY_LINK([
#include
#include
#include
], [
char *name = ptsname(0);
int i1 = grantpt(0);
int i2 = unlockpt(0);
int i3 = ioctl(0, I_PUSH, "ptem");
return 0;
], tecla_cv_sysv_pty=yes, tecla_cv_sysv_pty=no)
])
dnl If the system-V pseudo-terminal interface is available, arrange
dnl for HAVE_SYSV_PTY to be defined by CFLAGS.
if test $tecla_cv_sysv_pty = yes; then
AC_DEFINE(HAVE_SYSV_PTY)
fi
dnl The following variable contains the extension to append to
dnl "libtecla" and "libtecla_r" when creating shared libraries on the
dnl target platform. This is system dependent and is ignored if
dnl LINK_SHARED remains an empty string. On most platforms that
dnl support shared libaries, this will be .so.$MAJOR_VER, where
dnl MAJOR_VER is the major version number described above, which on
dnl some systems, tells the run-time loader if the program being
dnl loaded is binary compatible with a given version of the library
dnl (see the discussion of MAJOR_VER near the top of this file).
dnl The following empty default can be overriden on a system by system
dnl basis later in this file.
AC_SUBST(SHARED_EXT)
SHARED_EXT=""
dnl When a shared library is installed with the extension $SHARED_EXT,
dnl you can optionally produce other copies of this library with
dnl different extensions. This is done using symbolic or hard links,
dnl depending on what is available on the current filesystem, and the
dnl extensions to use for these links are listed in the following
dnl variable, separated by spaces. The following empty default can be
dnl overriden on a system by system basis later in this file.
AC_SUBST(SHARED_ALT)
SHARED_ALT=""
dnl The following variable lists extra compilation flags needed to
dnl create object files that can be included in shared libraries.
dnl Normally one would include a flag to tell the C compiler to
dnl compile position-independent code. This option commonly includes
dnl the acronym 'pic'.
AC_SUBST(SHARED_CFLAGS)
SHARED_CFLAGS=""
dnl On systems that support shared libraries, the following variable
dnl provides the command needed to make a shared library. In this
dnl variable, $$@ will be replaced with the name of the shared
dnl library, $$(LIB_OBJECTS) will be replaced with a space separated
dnl list of the object files that are to be included in the library,
dnl and libtecla$$(SUFFIX) will be the name of the library being
dnl built, minus the system-specific extension (eg. libtecla or
dnl libtecla_r). If LINK_SHARED is left as an empty string, shared
dnl library creation will not attempted. If your system supports
dnl shared library creation, you should override the default value of
dnl this variable in the target-specific case statement later in this
dnl file.
AC_SUBST(LINK_SHARED)
LINK_SHARED=""
dnl When compiling the reentrant version of the library, the following
dnl compiler flags are presented to the compiler, in addition to those
dnl that are used when compiling the non-reentrant version of the
dnl library. The PREFER_REENTRANT macro is an internal libtecla macro
dnl whose presence reports when the reentrant version of the library
dnl is being compiled. This allows the code to determine when to
dnl disable features that can't portably be implemented reentrantly,
dnl such as username completion. The existence of the _POSIX_C_SOURCE
dnl macro can't be reliably used for this purpose, since some systems
dnl define it by default for all code.
AC_SUBST(DEFS_R)
DEFS_R="-D_POSIX_C_SOURCE=199506L -DPREFER_REENTRANT"
dnl For man pages relating to library features, the following two
dnl variables determine in which sub-directory of the top-level man
dnl directory the man pages should go, and what file-name extensions
dnl these files should have. On systems where the following defaults
dnl are not valid, the default values should be overriden in the
dnl target-specific case statement later in this file.
AC_SUBST(LIBR_MANDIR)
AC_SUBST(LIBR_MANEXT)
LIBR_MANDIR="man3"
LIBR_MANEXT="3"
dnl For man pages relating to library functions, the following two
dnl variables serve the same purpose as the previously described
dnl LIBR_MANDIR and LIBR_MANEXT variables.
AC_SUBST(FUNC_MANDIR)
AC_SUBST(FUNC_MANEXT)
FUNC_MANDIR="man3"
FUNC_MANEXT="3"
dnl For man pages relating to programs, the following two variables
dnl serve the same purpose as the previously described LIBR_MANDIR
dnl and LIBR_MANEXT variables.
AC_SUBST(PROG_MANDIR)
AC_SUBST(PROG_MANEXT)
PROG_MANDIR="man1"
PROG_MANEXT="1"
dnl For man pages on miscellaneous topics, the following two variables
dnl serve the same purpose as the previously described LIBR_MANDIR
dnl and LIBR_MANEXT variables.
AC_SUBST(MISC_MANDIR)
AC_SUBST(MISC_MANEXT)
MISC_MANDIR="man7"
MISC_MANEXT="7"
dnl For man pages relating to configuration files, the following two
dnl variables serve the same purpose as the previously described
dnl LIBR_MANDIR and LIBR_MANEXT variables.
AC_SUBST(FILE_MANDIR)
AC_SUBST(FILE_MANEXT)
FILE_MANDIR="man5"
FILE_MANEXT="5"
dnl If the application doesn't want the user to have access to the
dnl filesystem, it can remove all action functions that list, read or
dnl write files, by including the configuration argument
dnl --without-file-actions.
AC_ARG_WITH(file-actions, AC_HELP_STRING([--with-file-actions], [Should users of gl_get_line() have access to the filesystem (default=yes)]),
AC_DEFINE(HIDE_FILE_SYSTEM), )
dnl If the target system either has no file-system, or file-system access
dnl isn't needed, libtecla can be made smaller by excluding all file and
dnl directory access code. This is done by adding the configuration
dnl argument --without-file-system.
AC_ARG_WITH(file-system, AC_HELP_STRING([--with-file-system], [Does the target have a filesystem (default=yes)]),
AC_DEFINE(WITHOUT_FILE_SYSTEM), )
dnl The following bourne shell case statement is where system
dnl dependencies can be added. In particular, if your system supports
dnl shared library creation, the following switch is the place to
dnl configure it. To do so you will first need to find out what target
dnl type was just assigned by the AC_CANONICAL_SYSTEM macro executed
dnl previously. The target type of your current system can be
dnl determined by cd'ing to the top level directory of the tecla
dnl distribution, and typing the command "sh config.guess". This will
dnl report what autoconf thinks the system type is. Note that this
dnl will be very specific, so if you know that the configuration
dnl parameters that you are about to provide apply to different
dnl versions of the current system type, you can express this in the
dnl case statement by using a wild-card in place of the version
dnl number, or by using an | alternation to list one or more version
dnl names. Beware that autoconf uses [] as quote characters, so if you
dnl want to use a regexp character range like [a-z], you should write
dnl this as [[a-z]].
case $target in
*solaris*)
AC_DEFINE(__EXTENSIONS__)
SHARED_EXT=".so.${MAJOR_VER}"
SHARED_ALT=".so"
LINK_SHARED="$LD"' -G -M $$(srcdir)/libtecla.map -o $$@ -h $$(@F) -z defs -i $$(LIB_OBJECTS) $$(LIBS) -lc'
SHARED_CFLAGS="-Kpic"
case $CC in
*/cc|cc) SHARED_CFLAGS="$SHARED_CFLAGS -xstrconst" ;;
esac
case $target_cpu in
sparc) SHARED_CFLAGS="$SHARED_CFLAGS -xregs=no%appl"
esac
case $target_os in
solaris2.[[89]]*|solaris2.1[[0-9]]*)
LIBR_MANEXT=3lib
FUNC_MANEXT=3tecla
LIBR_MANDIR=man$LIBR_MANEXT
FUNC_MANDIR=man$FUNC_MANEXT
esac
MISC_MANDIR="man5"
MISC_MANEXT="5"
FILE_MANDIR="man4"
FILE_MANEXT="4"
;;
*linux*)
SHARED_EXT=".so.${MAJOR_VER}.${MINOR_VER}.${MICRO_VER}"
SHARED_ALT=".so .so.${MAJOR_VER}"
dnl See if the installed version of Gnu ld accepts version scripts.
AC_CACHE_CHECK([for --version-script in GNU ld], tecla_cv_gnu_ld_script, [
if (echo 'void dummy(void) {return;}' > dummy.c; $CC -c -fpic dummy.c; \
$LD -o dummy.so dummy.o -shared --version-script=$srcdir/libtecla.map) 1>&2 2>/dev/null; then
tecla_cv_gnu_ld_script=yes
else
tecla_cv_gnu_ld_script=no
fi
rm -f dummy.c dummy.o dummy.so
])
if test $tecla_cv_gnu_ld_script = yes; then
VERSION_OPT='--version-script=$$(srcdir)/libtecla.map'
else
VERSION_OPT=''
fi
LINK_SHARED="$LD"' -o $$@ -soname libtecla$$(SUFFIX).so.'${MAJOR_VER}' -shared '$VERSION_OPT' $$(LIB_OBJECTS) $$(LIBS) -lc'
SHARED_CFLAGS="-fpic"
dnl Reenable the inclusion of symbols which get undefined when POSIX_C_SOURCE
dnl is specified.
CFLAGS="-D_SVID_SOURCE -D_BSD_SOURCE $CFLAGS"
;;
*hpux*)
SHARED_EXT=".${MAJOR_VER}"
SHARED_ALT=".sl"
LINK_SHARED="$LD"' -b +h $$(@F) +k +vshlibunsats -o $$@ -c libtecla.map.opt $$(LIB_OBJECTS) $$(LIBS) -lc'
SHARED_CFLAGS="+z"
MISC_MANEXT=5
FILE_MANEXT=4
MISC_MANDIR=man$MISC_MANEXT
FILE_MANDIR=man$FILE_MANEXT
;;
*darwin*)
SHARED_EXT=".${MAJOR_VER}.${MINOR_VER}.${MICRO_VER}.dylib"
SHARED_ALT=".dylib .${MAJOR_VER}.dylib"
LINK_SHARED='$(CC) -o $$@ -dynamiclib -flat_namespace -undefined suppress -compatibility_version '${MAJOR_VER}.${MINOR_VER}' -current_version '${MAJOR_VER}.${MINOR_VER}.${MICRO_VER}' -install_name '${libdir}'/$$@ $$(LIB_OBJECTS)'
SHARED_CFLAGS=""
;;
*dec-osf*)
AC_DEFINE(_OSF_SOURCE)
;;
*freebsd*)
SHARED_EXT=".so.${MAJOR_VER}"
SHARED_ALT=".so"
VERSION_OPT='--version-script=$$(srcdir)/libtecla.map'
LINK_SHARED='ld -o $$@ -soname libtecla$$(SUFFIX).so.'${MAJOR_VER}' -shared '$VERSION_OPT' $$(LIB_OBJECTS) $$(LIBS) -lc'
SHARED_CFLAGS="-fpic"
;;
mips-sgi-irix*)
DEFS_R="$DEFS_R -D_XOPEN_SOURCE=500"
if test "$RANLIB"_ = "_"; then
RANLIB=":"
fi
;;
esac
dnl The following statement checks to see if the GNU C compiler has
dnl been chosen instead of the normal compiler of the host operating
dnl system. If it has, and shared library creation has been
dnl configured, it replaces the shared-library-specific C compilation
dnl flags with those supported by gcc. Also append the gcc run-time
dnl library to the shared library link line.
if test "$GCC"_ = "yes"_ && test "$LINK_SHARED"_ != "_" ; then
SHARED_CFLAGS="-fpic"
case $target in
sparc-*-solaris*)
SHARED_CFLAGS="$SHARED_CFLAGS -mno-app-regs"
;;
*darwin*)
SHARED_CFLAGS=""
;;
esac
LINK_SHARED="$LINK_SHARED `gcc -print-libgcc-file-name`"
fi
dnl The following variable will list which types of libraries,
dnl "static", and possibly "shared", are to be created and installed.
AC_SUBST(TARGET_LIBS)
dnl If shared library creation has been configured, add shared
dnl libraries to the list of libraries to be built.
if test "$LINK_SHARED"_ != "_"; then
TARGET_LIBS="static shared"
else
TARGET_LIBS="static"
LINK_SHARED="@:"
fi
dnl Set the shell variable and Makefile variable, MAKE_MAN_PAGES, to
dnl "yes" if man pages are desired. By default they are, but if the
dnl user specifies --with-man-pages=no or --without-man-pages, then
dnl they won't be preprocessed by the configure script or installed
dnl by the Makefile.
AC_SUBST(MAKE_MAN_PAGES)
AC_ARG_WITH(man-pages, AC_HELP_STRING([--with-man-pages], [Are man pages desired (default=yes)]),
MAKE_MAN_PAGES="$withval", MAKE_MAN_PAGES="yes")
dnl Create the list of files to be generated by the configure script.
OUTPUT_FILES="Makefile"
rm -rf man/man*
if test "$MAKE_MAN_PAGES"_ = "yes"_; then
for area in libr func misc prog file; do
for page in man/$area/*.in; do
OUTPUT_FILES="$OUTPUT_FILES `echo $page | sed 's/\.in$//'`"
done
done
fi
dnl The following directive must always be the last line of any
dnl autoconf script. It causes autoconf to create the configure
dnl script, which for each argument of AC_OUTPUT, will look for a
dnl filename formed by appending ".in" to the argument, preprocess
dnl that file, replacing @VAR@ directives with the corresponding value
dnl of the specified shell variable VAR, as set above in this file,
dnl and write the resulting output to the filename given in the
dnl argument. Note that only shell variables that were exported above
dnl with the AC_SUBST() directive will be substituted in @VAR@
dnl directives (some macros like AC_PROG_CC also call AC_SUBST for you
dnl for the variables that they output).
AC_OUTPUT($OUTPUT_FILES)
yuma123_2.14/libtecla/INSTALL 0000664 0001750 0001750 00000023534 14770023131 015742 0 ustar vladimir vladimir To compile and optionally install the library, it is first necessary
to create a makefile for your system, by typing:
./configure
The Makefile that this generates is designed to install the files of
the library in subdirectories of /usr/local/. If you would prefer to
install them under a different directory, you can type:
./configure --prefix /wherever
Where you would replace /wherever with your chosen directory. Other
command-line options are available, and can be listed by typing:
./configure --help
Having run the configure script, you are then ready to make the
library. To do this, just type:
make
What 'make' does depends on whether the configure script knows about
your system. If the configure script doesn't know anything specific
about your system, it will arrange for 'make' to produce the static
tecla library, called libtecla.a, and if possible, the reentrant
version of this called libtecla_r.a. If it does know about your
system, it will also create shared libraries if possible. If you are
on a system that isn't known, and you would like shared libraries to
be compiled, please read the file called PORTING to see how this can
be achieved.
To install the library, its include file and it manual pages, type:
make install
Note that this will also compile the library if you haven't already
done so.
Having compiled the library, if you wish, you can test it by running
the demo programs. After building the library, you should find two
programs, called demo and demo2, in the current directory.
The first of the demos programs reads input lines from the user, and
writes what was typed back to the screen. While typing a line of
input, you can experiment with line editing, tab completion, history
recall etc.. For details about these line editing features, see the
man page gl_get_line(3). If you haven't installed this yet, you can
see it anyway by typing:
nroff -man man3/gl_get_line.3 | more
The second demo program, called demo2, demonstrates command-completion
with the UNIX PATH. If you type in a partial command name, and press
TAB, the command name will be completed if possible, and possible
completions will be listed if it is ambiguous. When you then enter the
line, the demo program then prints out the full pathname of the
command that you typed. If you type anything after the command name,
filename completion with the tab key reverts to its default behavior
of completing filenames in the current directory.
COMPILING IN A DIFFERENT DIRECTORY
----------------------------------
If you unpack the distribution in a directory which is visible from
multiple hosts which have different architectures, you have the option
of compiling the library for the different architectures in different
directories. You might for example create a sub-directory for each
architecture, under the top level directory of the distribution. You
would then log in to a host of one of these architectures, cd to the
sub-directory that you created for it, and type:
../configure
The configure script then creates a makefile in the current directory
which is designed to build the library, object files, demos etc for
the architecture of the current host, in the current directory, using
the original source code in ../. You then repeat this procedure on
hosts of other architectures.
The compilation directories don't have to be sub-directories of the
top level directory of the distribution. That was just described as an
example. They can be anywhere you like.
Every rule in the makefiles that are generated by the configure
script, cites the paths of the target and source files explicitly, so
this procedure should work on any system, without the need for vpath
makefile support.
EMBEDDING IN OTHER PACKAGE DISTRIBUTIONS
----------------------------------------
If you distribute the library with another package, which has its own
heirarchy and configuration procedures, the following installation
options may be of interest to you. At first glance, the use of a GNU
configure script by the tecla library, may appear to reduce your
options for controlling what gets made, and where it gets installed,
but this isn't the case, because many of the parameters configured by
the configure script are assigned to makefile variables which can be
overriden when you run make.
Configure script options:
If the users of your package won't benefit from having access to the
tecla man pages, you can shorten the length of time taken to run the
configure script by telling this script not to preprocess the man
pages. This is done as follows.
./configure --without-man-pages
Note that this option also causes the makefile man-page installation
targets to do nothing.
Similarly, if you don't want your users to have access to the
filesystem while they are editing input lines using gl_get_line(),
then use the following configuration argument.
./configure --without-file-actions
This will completely remove the "expand-filename", "read-from-file",
"read-init-files", and "list-glob" action functions. It will also
arrange that the default behavior of actions such as "complete-word"
and "list-or-eof" be changed to show no completions, instead of the
normal default of showing filename completions.
If you are using a system that doesn't have a file-system, such as an
embedded system, then libtecla can be built with all code that
accesses the filesystem removed. This will make the library a bit
smaller, and potentially avoid running into problems of missing system
functions related to file-system access. This is done with the
following configuration option.
./configure --without-file-system
Beware that this not only prevents the user from accessing the
filesystem while editing an input line in gl_get_line(), but also
removes all public file-related functions, such as the pathname
expansion module. When using gl_get_line() in this configuration,
the functions that load and save history from and to files, are
stubs that report an error if called upon to read files. The
gl_configure_getline() function can still be called upon to
configure gl_get_line() via its app_string argument, but passing it
a filename in either the app_file or user_file arguments will result
in an error being reported.
Now lets say that you have your own configuration script in the parent
directory of the libtecla top-level directory, and that you don't want
tecla's man pages to be generated. In your configuration script, you
would first need to have a line similar to the following:
(cd libtecla; ./configure --without-man-pages)
Now, from your makefile or whatever script you use to build your
application, you would need to make the tecla library. Assuming that
your makefile or build script is in the parent directory of the
libtecla distribution, then the following line tells make to just
build the non-reentrant, static version of the tecla library, and then
to install it and the tecla include file in sub-directories called lib
and include in your current directory.
(cd libtecla; make LIBDIR=../lib INCDIR=../include TARGETS=normal TARGET_LIBS="static" install_lib install_inc)
In this statement the LIBDIR=../lib component means that on installing
the library, the make command should place the library in the
directory libtecla/../lib. Similarly INCDIR tells make where to place
the include files. The install_lib and install_inc targets tell make
to install the libraries and the include file. Because the install_man
and install_bin targets have been omitted in this example, the man
pages and programs aren't installed. If you were to include these
additional targets then you could use the MANDIR and BINDIR variables,
respectively to control where they were installed.
The TARGETS variable is used to specify which of the normal and
reentrant versions of the library are compiled. This can contain one
or both of the words "normal" and "reentrant". If you don't specify
this when you invoke make, the default value generated by the
configure script will be used. Depending on whether reentrant POSIX
functions are available for compilation of the reentrant version, this
will be either "normal" or "normal reentrant".
The TARGET_LIBS variable is used to specify which of the static and
shared libraries are to be built. This can contain one or both of the
words "static" and "shared". If you don't specify this when you invoke
make, the default value generated by the configure script will be
used. Depending on whether the configure script knows how to create
shared libraries on the target system, this will be either "static" or
"static shared". Beware that shared libraries aren't supported on many
systems, so requiring "shared" will limit which systems you can
compile your package on. Also note that unless your package installs
the tecla library in a directory which all users of your program will
have access to, you should only compile the static version.
Instructions for adding shared-library creation rules for new systems
are included in the PORTING file.
The OPT variable can be used to change the default optimization from
the default of "-O" to something else.
The DEMOS variable controls whether the demo programs are built.
Normally this has the value "demos", which tells the makefile to build
the demo programs. Setting it to an empty string stops the demos from
being built.
The PROGRAMS variable is used to specify which programs are to be
built and subsequently installed. All available programs are built by
default. Currently there is only one such program, selected by
specifying the word "enhance". This program uses tecla-enhanced
pseudo-terminals to layer command line editing on top of third party
programs.
The PROGRAMS_R variable serves the same purpose as the PROGRAMS
variable, except that programs listed here are linked with the
reentrant version of the library, and should be specified with a _r
suffix. Currently this variable is empty by default.
Martin Shepherd (mcs@astro.caltech.edu)
yuma123_2.14/libtecla/expand.h 0000664 0001750 0001750 00000003727 14770023131 016343 0 ustar vladimir vladimir #ifndef expand_h
#define expand_h
/*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
/*
* This header is not for use by external applicatons. It contains
* internal immplementation features of the libtecla library, which
* may change incompatibly between releases.
*/
/*
* Print a list of expansions via a callback function.
*/
int _ef_output_expansions(FileExpansion *result, GlWriteFn *write_fn,
void *data, int term_width);
#endif
yuma123_2.14/libtecla/errmsg.h 0000664 0001750 0001750 00000005624 14770023131 016361 0 ustar vladimir vladimir #ifndef errmsg_h
#define errmsg_h
/*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
/*
* Set the longest expected length of an error message (excluding its
* '\0' terminator. Since any message over a nominal terminal width of
* 80 characters is going to look a mess, it makes no sense to support
* huge lengths. Note that many uses of strings declared with this
* macro assume that it will be at least 81, so don't reduce it below
* this limit.
*/
#define ERR_MSG_LEN 128
/*
* Provide an opaque typedef to the error-message object.
*/
typedef struct ErrMsg ErrMsg;
/*
* The following token is used to terminate the argument lists of calls
* to _err_record_msg().
*/
#define END_ERR_MSG ((const char *)0)
/*
* Allocate a new error-message buffer.
*/
ErrMsg *_new_ErrMsg(void);
/*
* Delete an error message buffer.
*/
ErrMsg *_del_ErrMsg(ErrMsg *err);
/*
* Concatenate a list of string arguments into the specified buffer, buff[],
* which has an allocated size of buffdim characters.
* The last argument must be END_ERR_MSG to terminate the argument list.
*/
void _err_record_msg(ErrMsg *err, ...);
/*
* Replace the current error message with an empty string.
*/
void _err_clear_msg(ErrMsg *err);
/*
* Return a pointer to the error message buffer. This is
* a '\0' terminated character array containing ERR_MSG_LEN+1
* elements.
*/
char *_err_get_msg(ErrMsg *err);
#endif
yuma123_2.14/libtecla/keytab.c 0000664 0001750 0001750 00000073641 14770023131 016340 0 ustar vladimir vladimir /*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
#include
#include
#include
#include
#include
#include "keytab.h"
#include "strngmem.h"
#include "getline.h"
#include "errmsg.h"
#include "hash.h"
/*
* When allocating or reallocating the key-binding table, how
* many entries should be added?
*/
#define KT_TABLE_INC 100
/*
* Define the size of the hash table that is used to associate action
* names with action functions. This should be a prime number.
*/
#define KT_HASH_SIZE 113
/*
* Define a binary-symbol-table object.
*/
struct KeyTab {
ErrMsg *err; /* Information about the last error */
int size; /* The allocated dimension of table[] */
int nkey; /* The current number of members in the table */
KeySym *table; /* The table of lexically sorted key sequences */
HashTable *actions; /* The hash table of actions */
StringMem *smem; /* Memory for allocating strings */
};
static int _kt_extend_table(KeyTab *kt);
static int _kt_parse_keybinding_string(const char *keyseq,
char *binary, int *nc);
static int _kt_compare_strings(const char *s1, int n1, const char *s2, int n2);
static void _kt_assign_action(KeySym *sym, KtBinder binder, KtKeyFn *keyfn,
void *data);
static char _kt_backslash_escape(const char *string, const char **endp);
static int _kt_is_emacs_meta(const char *string);
static int _kt_is_emacs_ctrl(const char *string);
static KtKeyMatch _kt_locate_keybinding(KeyTab *kt, const char *binary_keyseq,
int nc, int *first, int *last);
/*.......................................................................
* Create a new key-binding symbol table.
*
* Output:
* return KeyTab * The new object, or NULL on error.
*/
KeyTab *_new_KeyTab(void)
{
KeyTab *kt; /* The object to be returned */
/*
* Allocate the container.
*/
kt = (KeyTab *) malloc(sizeof(KeyTab));
if(!kt) {
errno = ENOMEM;
return NULL;
};
/*
* Before attempting any operation that might fail, initialize the
* container at least up to the point at which it can safely be passed
* to del_KeyTab().
*/
kt->err = NULL;
kt->size = KT_TABLE_INC;
kt->nkey = 0;
kt->table = NULL;
kt->actions = NULL;
kt->smem = NULL;
/*
* Allocate a place to record error messages.
*/
kt->err = _new_ErrMsg();
if(!kt->err)
return _del_KeyTab(kt);
/*
* Allocate the table.
*/
kt->table = (KeySym *) malloc(sizeof(kt->table[0]) * kt->size);
if(!kt->table) {
errno = ENOMEM;
return _del_KeyTab(kt);
};
/*
* Allocate a hash table of actions.
*/
kt->actions = _new_HashTable(NULL, KT_HASH_SIZE, IGNORE_CASE, NULL, 0);
if(!kt->actions)
return _del_KeyTab(kt);
/*
* Allocate a string allocation object. This allows allocation of
* small strings without fragmenting the heap.
*/
kt->smem = _new_StringMem(KT_TABLE_INC);
if(!kt->smem)
return _del_KeyTab(kt);
return kt;
}
/*.......................................................................
* Delete a KeyTab object.
*
* Input:
* kt KeyTab * The object to be deleted.
* Output:
* return KeyTab * The deleted object (always NULL).
*/
KeyTab *_del_KeyTab(KeyTab *kt)
{
if(kt) {
if(kt->table)
free(kt->table);
kt->actions = _del_HashTable(kt->actions);
kt->smem = _del_StringMem(kt->smem, 1);
kt->err = _del_ErrMsg(kt->err);
free(kt);
};
return NULL;
}
/*.......................................................................
* Increase the size of the table to accomodate more keys.
*
* Input:
* kt KeyTab * The table to be extended.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int _kt_extend_table(KeyTab *kt)
{
/*
* Attempt to increase the size of the table.
*/
KeySym *newtab = (KeySym *) realloc(kt->table, sizeof(kt->table[0]) *
(kt->size + KT_TABLE_INC));
/*
* Failed?
*/
if(!newtab) {
_err_record_msg(kt->err, "Can't extend keybinding table", END_ERR_MSG);
errno = ENOMEM;
return 1;
};
/*
* Install the resized table.
*/
kt->table = newtab;
kt->size += KT_TABLE_INC;
return 0;
}
/*.......................................................................
* Add, update or remove a keybinding to the table.
*
* Input:
* kt KeyTab * The table to add the binding to.
* binder KtBinder The source of the binding.
* keyseq const char * The key-sequence to bind.
* action char * The action to associate with the key sequence, or
* NULL to remove the action associated with the
* key sequence.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
int _kt_set_keybinding(KeyTab *kt, KtBinder binder, const char *keyseq,
const char *action)
{
KtKeyFn *keyfn; /* The action function */
void *data; /* The callback data of the action function */
/*
* Check arguments.
*/
if(kt==NULL || !keyseq) {
errno = EINVAL;
if(kt)
_err_record_msg(kt->err, "NULL argument(s)", END_ERR_MSG);
return 1;
};
/*
* Lookup the function that implements the specified action.
*/
if(!action) {
keyfn = 0;
data = NULL;
} else {
Symbol *sym = _find_HashSymbol(kt->actions, action);
if(!sym) {
_err_record_msg(kt->err, "Unknown key-binding action: ", action,
END_ERR_MSG);
errno = EINVAL;
return 1;
};
keyfn = (KtKeyFn *) sym->fn;
data = sym->data;
};
/*
* Record the action in the table.
*/
return _kt_set_keyfn(kt, binder, keyseq, keyfn, data);
}
/*.......................................................................
* Add, update or remove a keybinding to the table, specifying an action
* function directly.
*
* Input:
* kt KeyTab * The table to add the binding to.
* binder KtBinder The source of the binding.
* keyseq char * The key-sequence to bind.
* keyfn KtKeyFn * The action function, or NULL to remove any existing
* action function.
* data void * A pointer to anonymous data to be passed to keyfn
* whenever it is called.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
int _kt_set_keyfn(KeyTab *kt, KtBinder binder, const char *keyseq,
KtKeyFn *keyfn, void *data)
{
const char *kptr; /* A pointer into keyseq[] */
char *binary; /* The binary version of keyseq[] */
int nc; /* The number of characters in binary[] */
int first,last; /* The first and last entries in the table which */
/* minimally match. */
int size; /* The size to allocate for the binary string */
int i;
/*
* Check arguments.
*/
if(kt==NULL || !keyseq) {
errno = EINVAL;
if(kt)
_err_record_msg(kt->err, "NULL argument(s)", END_ERR_MSG);
return 1;
};
/*
* Work out a pessimistic estimate of how much space will be needed
* for the binary copy of the string, noting that binary meta characters
* embedded in the input string get split into two characters.
*/
for(size=0,kptr = keyseq; *kptr; kptr++)
size += IS_META_CHAR(*kptr) ? 2 : 1;
/*
* Allocate a string that has the length of keyseq[].
*/
binary = _new_StringMemString(kt->smem, size + 1);
if(!binary) {
errno = ENOMEM;
_err_record_msg(kt->err, "Insufficient memory to record key sequence",
END_ERR_MSG);
return 1;
};
/*
* Convert control and octal character specifications to binary characters.
*/
if(_kt_parse_keybinding_string(keyseq, binary, &nc)) {
binary = _del_StringMemString(kt->smem, binary);
return 1;
};
/*
* Lookup the position in the table at which to insert the binding.
*/
switch(_kt_locate_keybinding(kt, binary, nc, &first, &last)) {
/*
* If an exact match for the key-sequence is already in the table,
* simply replace its binding function (or delete the entry if
* the new binding is 0).
*/
case KT_EXACT_MATCH:
if(keyfn) {
_kt_assign_action(kt->table + first, binder, keyfn, data);
} else {
_del_StringMemString(kt->smem, kt->table[first].keyseq);
memmove(kt->table + first, kt->table + first + 1,
(kt->nkey - first - 1) * sizeof(kt->table[0]));
kt->nkey--;
};
binary = _del_StringMemString(kt->smem, binary);
break;
/*
* If an ambiguous match has been found and we are installing a
* callback, then our new key-sequence would hide all of the ambiguous
* matches, so we shouldn't allow it.
*/
case KT_AMBIG_MATCH:
if(keyfn) {
_err_record_msg(kt->err, "Can't bind \"", keyseq,
"\", because it is a prefix of another binding",
END_ERR_MSG);
binary = _del_StringMemString(kt->smem, binary);
errno = EPERM;
return 1;
};
break;
/*
* If the entry doesn't exist, create it.
*/
case KT_NO_MATCH:
/*
* Add a new binding?
*/
if(keyfn) {
KeySym *sym;
/*
* We will need a new entry, extend the table if needed.
*/
if(kt->nkey + 1 > kt->size) {
if(_kt_extend_table(kt)) {
binary = _del_StringMemString(kt->smem, binary);
return 1;
};
};
/*
* Make space to insert the new key-sequence before 'last'.
*/
if(last < kt->nkey) {
memmove(kt->table + last + 1, kt->table + last,
(kt->nkey - last) * sizeof(kt->table[0]));
};
/*
* Insert the new binding in the vacated position.
*/
sym = kt->table + last;
sym->keyseq = binary;
sym->nc = nc;
for(i=0; iactions + i;
action->fn = 0;
action->data = NULL;
};
sym->binder = -1;
_kt_assign_action(sym, binder, keyfn, data);
kt->nkey++;
};
break;
case KT_BAD_MATCH:
binary = _del_StringMemString(kt->smem, binary);
return 1;
break;
};
return 0;
}
/*.......................................................................
* Perform a min-match lookup of a key-binding.
*
* Input:
* kt KeyTab * The keybinding table to lookup in.
* binary_keyseq char * The binary key-sequence to lookup.
* nc int the number of characters in keyseq[].
* Input/Output:
* first,last int * If there is an ambiguous or exact match, the indexes
* of the first and last symbols that minimally match
* will be assigned to *first and *last respectively.
* If there is no match, then first and last will
* bracket the location where the symbol should be
* inserted.
* Output:
* return KtKeyMatch One of the following enumerators:
* KT_EXACT_MATCH - An exact match was found.
* KT_AMBIG_MATCH - An ambiguous match was found.
* KT_NO_MATCH - No match was found.
* KT_BAD_MATCH - An error occurred while searching.
*/
static KtKeyMatch _kt_locate_keybinding(KeyTab *kt, const char *binary_keyseq,
int nc, int *first, int *last)
{
int mid; /* The index at which to bisect the table */
int bot; /* The lowest index of the table not searched yet */
int top; /* The highest index of the table not searched yet */
int test; /* The return value of strcmp() */
/*
* Perform a binary search for the key-sequence.
*/
bot = 0;
top = kt->nkey - 1;
while(top >= bot) {
mid = (top + bot)/2;
test = _kt_compare_strings(kt->table[mid].keyseq, kt->table[mid].nc,
binary_keyseq, nc);
if(test > 0)
top = mid - 1;
else if(test < 0)
bot = mid + 1;
else {
*first = *last = mid;
return KT_EXACT_MATCH;
};
};
/*
* An exact match wasn't found, but top is the index just below the
* index where a match would be found, and bot is the index just above
* where the match ought to be found.
*/
*first = top;
*last = bot;
/*
* See if any ambiguous matches exist, and if so make *first and *last
* refer to the first and last matches.
*/
if(*last < kt->nkey && kt->table[*last].nc > nc &&
_kt_compare_strings(kt->table[*last].keyseq, nc, binary_keyseq, nc)==0) {
*first = *last;
while(*last+1 < kt->nkey && kt->table[*last+1].nc > nc &&
_kt_compare_strings(kt->table[*last+1].keyseq, nc, binary_keyseq, nc)==0)
(*last)++;
return KT_AMBIG_MATCH;
};
/*
* No match.
*/
return KT_NO_MATCH;
}
/*.......................................................................
* Lookup the sub-array of key-bindings who's key-sequences minimally
* match a given key-sequence.
*
* Input:
* kt KeyTab * The keybinding table to lookup in.
* binary_keyseq char * The binary key-sequence to lookup.
* nc int the number of characters in keyseq[].
* Input/Output:
* matches KeySym ** The array of minimally matching symbols
* can be found in (*matches)[0..nmatch-1], unless
* no match was found, in which case *matches will
* be set to NULL.
* nmatch int The number of ambiguously matching symbols. This
* will be 0 if there is no match, 1 for an exact
* match, and a number greater than 1 for an ambiguous
* match.
* Output:
* return KtKeyMatch One of the following enumerators:
* KT_EXACT_MATCH - An exact match was found.
* KT_AMBIG_MATCH - An ambiguous match was found.
* KT_NO_MATCH - No match was found.
* KT_BAD_MATCH - An error occurred while searching.
*/
KtKeyMatch _kt_lookup_keybinding(KeyTab *kt, const char *binary_keyseq,
int nc, KeySym **matches, int *nmatch)
{
KtKeyMatch status; /* The return status */
int first,last; /* The indexes of the first and last matching entry */
/* in the symbol table. */
/*
* Check the arguments.
*/
if(!kt || !binary_keyseq || !matches || !nmatch || nc < 0) {
errno = EINVAL;
if(kt)
_err_record_msg(kt->err, "NULL argument(s)", END_ERR_MSG);
return KT_BAD_MATCH;
};
/*
* Lookup the indexes of the binding-table entries that bracket the
* target key-sequence.
*/
status = _kt_locate_keybinding(kt, binary_keyseq, nc, &first, &last);
/*
* Translate the indexes into the corresponding subarray of matching
* table entries.
*/
switch(status) {
case KT_EXACT_MATCH:
case KT_AMBIG_MATCH:
*matches = kt->table + first;
*nmatch = last - first + 1;
break;
default:
*matches = NULL;
*nmatch = 0;
break;
};
return status;
}
/*.......................................................................
* Convert a keybinding string into a uniq binary representation.
*
* Control characters can be given directly in their binary form,
* expressed as either ^ or C-, followed by the character, expressed in
* octal, like \129 or via C-style backslash escapes, with the addition
* of '\E' to denote the escape key. Similarly, meta characters can be
* given directly in binary or expressed as M- followed by the character.
* Meta characters are recorded as two characters in the binary output
* string, the first being the escape key, and the second being the key
* that was modified by the meta key. This means that binding to
* \EA or ^[A or M-A are all equivalent.
*
* Input:
* keyseq char * The key sequence being added.
* Input/Output:
* binary char * The binary version of the key sequence will be
* assigned to binary[], which must have at least
* as many characters as keyseq[] plus the number
* of embedded binary meta characters.
* nc int * The number of characters assigned to binary[]
* will be recorded in *nc.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int _kt_parse_keybinding_string(const char *keyseq, char *binary,
int *nc)
{
const char *iptr = keyseq; /* Pointer into keyseq[] */
char *optr = binary; /* Pointer into binary[] */
char c; /* An intermediate character */
/*
* Parse the input characters until they are exhausted or the
* output string becomes full.
*/
while(*iptr) {
/*
* Check for special characters.
*/
switch(*iptr) {
case '^': /* A control character specification */
/*
* Convert the caret expression into the corresponding control
* character unless no character follows the caret, in which case
* record a literal caret.
*/
if(iptr[1]) {
/*
* Get the next, possibly escaped, character.
*/
if(iptr[1] == '\\') {
c = _kt_backslash_escape(iptr+2, &iptr);
} else {
c = iptr[1];
iptr += 2;
};
/*
* Convert the character to a control character.
*/
*optr++ = MAKE_CTRL(c);
} else {
*optr++ = *iptr++;
};
break;
/*
* A backslash-escaped character?
*/
case '\\':
/*
* Convert the escape sequence to a binary character.
*/
*optr++ = _kt_backslash_escape(iptr+1, &iptr);
break;
/*
* Possibly an emacs-style meta character?
*/
case 'M':
if(_kt_is_emacs_meta(iptr)) {
*optr++ = GL_ESC_CHAR;
iptr += 2;
} else {
*optr++ = *iptr++;
};
break;
/*
* Possibly an emacs-style control character specification?
*/
case 'C':
if(_kt_is_emacs_ctrl(iptr)) {
*optr++ = MAKE_CTRL(iptr[2]);
iptr += 3;
} else {
*optr++ = *iptr++;
};
break;
default:
/*
* Convert embedded meta characters into an escape character followed
* by the meta-unmodified character.
*/
if(IS_META_CHAR(*iptr)) {
*optr++ = GL_ESC_CHAR;
*optr++ = META_TO_CHAR(*iptr);
iptr++;
/*
* To allow keysequences that start with printable characters to
* be distinguished from the cursor-key keywords, prepend a backslash
* to the former. This same operation is performed in gl_interpret_char()
* before looking up a keysequence that starts with a printable character.
*/
} else if(iptr==keyseq && !IS_CTRL_CHAR(*iptr) &&
strcmp(keyseq, "up") != 0 && strcmp(keyseq, "down") != 0 &&
strcmp(keyseq, "left") != 0 && strcmp(keyseq, "right") != 0) {
*optr++ = '\\';
*optr++ = *iptr++;
} else {
*optr++ = *iptr++;
};
};
};
/*
* How many characters were placed in the output array?
*/
*nc = optr - binary;
return 0;
}
/*.......................................................................
* Add, remove or modify an action.
*
* Input:
* kt KeyTab * The key-binding table.
* action char * The name of the action.
* fn KtKeyFn * The function that implements the action, or NULL
* to remove an existing action.
* data void * A pointer to arbitrary callback data to pass to the
* action function whenever it is called.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
int _kt_set_action(KeyTab *kt, const char *action, KtKeyFn *fn, void *data)
{
Symbol *sym; /* The symbol table entry of the action */
/*
* Check the arguments.
*/
if(!kt || !action) {
errno = EINVAL;
if(kt)
_err_record_msg(kt->err, "NULL argument(s)", END_ERR_MSG);
return 1;
};
/*
* If no function was provided, delete an existing action.
*/
if(!fn) {
sym = _del_HashSymbol(kt->actions, action);
return 0;
};
/*
* If the action already exists, replace its action function.
*/
sym = _find_HashSymbol(kt->actions, action);
if(sym) {
sym->fn = (void (*)(void))fn;
sym->data = data;
return 0;
};
/*
* Add a new action.
*/
if(!_new_HashSymbol(kt->actions, action, 0, (void (*)(void))fn, data, 0)) {
_err_record_msg(kt->err, "Insufficient memory to record key-binding action",
END_ERR_MSG);
return 1;
};
return 0;
}
/*.......................................................................
* Compare two strings of specified length which may contain embedded
* ascii NUL's.
*
* Input:
* s1 char * The first of the strings to be compared.
* n1 int The length of the string in s1.
* s2 char * The second of the strings to be compared.
* n2 int The length of the string in s2.
* Output:
* return int < 0 if(s1 < s2)
* 0 if(s1 == s2)
* > 0 if(s1 > s2)
*/
static int _kt_compare_strings(const char *s1, int n1, const char *s2, int n2)
{
int i;
/*
* Find the first character where the two strings differ.
*/
for(i=0; i= KTB_NBIND)
return;
/*
* Record the action according to its source.
*/
action = sym->actions + binder;
action->fn = keyfn;
action->data = data;
/*
* Find the highest priority binding source that has supplied an
* action. Note that the actions[] array is ordered in order of
* descreasing priority, so the first entry that contains a function
* is the one to use.
*/
for(i=0; iactions[i].fn; i++)
;
/*
* Record the index of this action for use during lookups.
*/
sym->binder = i < KTB_NBIND ? i : -1;
return;
}
/*.......................................................................
* Remove all key bindings that came from a specified source.
*
* Input:
* kt KeyTab * The table of key bindings.
* binder KtBinder The source of the bindings to be cleared.
*/
void _kt_clear_bindings(KeyTab *kt, KtBinder binder)
{
int oldkey; /* The index of a key in the original binding table */
int newkey; /* The index of a key in the updated binding table */
/*
* If there is no table, then no bindings exist to be deleted.
*/
if(!kt)
return;
/*
* Clear bindings of the given source.
*/
for(oldkey=0; oldkeynkey; oldkey++)
_kt_assign_action(kt->table + oldkey, binder, 0, NULL);
/*
* Delete entries that now don't have a binding from any source.
*/
newkey = 0;
for(oldkey=0; oldkeynkey; oldkey++) {
KeySym *sym = kt->table + oldkey;
if(sym->binder < 0) {
_del_StringMemString(kt->smem, sym->keyseq);
} else {
if(oldkey != newkey)
kt->table[newkey] = *sym;
newkey++;
};
};
/*
* Record the number of keys that were kept.
*/
kt->nkey = newkey;
return;
}
/*.......................................................................
* Translate a backslash escape sequence to a binary character.
*
* Input:
* string const char * The characters that follow the backslash.
* Input/Output:
* endp const char ** If endp!=NULL, on return *endp will be made to
* point to the character in string[] which follows
* the escape sequence.
* Output:
* return char The binary character.
*/
static char _kt_backslash_escape(const char *string, const char **endp)
{
char c; /* The output character */
/*
* Is the backslash followed by one or more octal digits?
*/
switch(*string) {
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
c = strtol(string, (char **)&string, 8);
break;
case 'a':
c = '\a';
string++;
break;
case 'b':
c = '\b';
string++;
break;
case 'e': case 'E': /* Escape */
c = GL_ESC_CHAR;
string++;
break;
case 'f':
c = '\f';
string++;
break;
case 'n':
c = '\n';
string++;
break;
case 'r':
c = '\r';
string++;
break;
case 't':
c = '\t';
string++;
break;
case 'v':
c = '\v';
string++;
break;
case '\0':
c = '\\';
break;
default:
c = *string++;
break;
};
/*
* Report the character which follows the escape sequence.
*/
if(endp)
*endp = string;
return c;
}
/*.......................................................................
* Return non-zero if the next two characters are M- and a third character
* follows. Otherwise return 0.
*
* Input:
* string const char * The sub-string to scan.
* Output:
* return int 1 - The next two characters are M- and these
* are followed by at least one character.
* 0 - The next two characters aren't M- or no
* character follows a M- pair.
*/
static int _kt_is_emacs_meta(const char *string)
{
return *string++ == 'M' && *string++ == '-' && *string;
}
/*.......................................................................
* Return non-zero if the next two characters are C- and a third character
* follows. Otherwise return 0.
*
* Input:
* string const char * The sub-string to scan.
* Output:
* return int 1 - The next two characters are C- and these
* are followed by at least one character.
* 0 - The next two characters aren't C- or no
* character follows a C- pair.
*/
static int _kt_is_emacs_ctrl(const char *string)
{
return *string++ == 'C' && *string++ == '-' && *string;
}
/*.......................................................................
* Merge an array of bindings with existing bindings.
*
* Input:
* kt KeyTab * The table of key bindings.
* binder KtBinder The source of the bindings.
* bindings const KtKeyBinding * The array of bindings.
* n int The number of bindings in bindings[].
* Output:
* return int 0 - OK.
* 1 - Error.
*/
int _kt_add_bindings(KeyTab *kt, KtBinder binder, const KtKeyBinding *bindings,
unsigned n)
{
int i;
/*
* Check the arguments.
*/
if(!kt || !bindings) {
errno = EINVAL;
if(kt)
_err_record_msg(kt->err, "NULL argument(s)", END_ERR_MSG);
return 1;
};
/*
* Install the array of bindings.
*/
for(i=0; ierr, "NULL argument(s)", END_ERR_MSG);
return 1;
};
/*
* Lookup the symbol table entry of the action.
*/
sym = _find_HashSymbol(kt->actions, action);
if(!sym)
return 1;
/*
* Return the function and ccallback data associated with the action.
*/
if(fn)
*fn = (KtKeyFn *) sym->fn;
if(data)
*data = sym->data;
return 0;
}
/*.......................................................................
* Return extra information (ie. in addition to that provided by errno)
* about the last error to occur in any of the public functions of this
* module.
*
* Input:
* kt KeyTab * The table of key bindings.
* Output:
* return const char * A pointer to the internal buffer in which
* the error message is temporarily stored.
*/
const char *_kt_last_error(KeyTab *kt)
{
return kt ? _err_get_msg(kt->err) : "NULL KeyTab argument";
}
yuma123_2.14/libtecla/libtecla.map 0000664 0001750 0001750 00000010112 14770023131 017153 0 ustar vladimir vladimir # This mapfile (or version script) lists the public symbols that are
# publically exported by each version of the tecla library. This file
# has the format required by the Sun and Linux linkers, and also acts
# as a template from which map files for other systems can be derived
# with awk or sed.
#
# Under Solaris and Linux, this map file is used by ld during shared
# library creation. It has two purposes:
#
# 1. It specifies which symbols in the library are to be made visible
# to applications. This has the dual benefits of reducing namespace
# polution, and of preventing applications from using private
# internal library functions that might change or disappear in
# future releases.
#
# 2. The information listed in this file is recorded in the shared
# library, such that when an application is linked against it, the
# linker can record a dependency in the application which says
# which is the earliest library version which included all of the
# symbols that the application needs. This means that if the
# application is copied to another system that has an earlier
# version of the library, the linker can quickly determine whether
# the earlier version contains all of the symbols that it needs.
#
# Under Linux, mapfiles can also be used to allow multiple
# incompatible versions of a given function to exist in a library,
# thus supporting applications that were compiled against different
# incompatible versions of the library. Since this feature (and the
# inclusion of .symver directives) isn't supported by Solaris, it
# can't be included in this file. Non backwards compatibility in the
# ABI must instead be handled in the more traditional way, by
# incrementing the major version number.
#
# When a new minor release is made, a new tecla_1.x specification
# should be added which inherits the symbols of the previous release
# and lists newly added functions. For example, below you will find
# the following clause:
#
# tecla_1.3 {
# global:
# ef_list_expansions;
# } tecla_1.2;
#
# This says that ef_list_expansions is the name of a public function
# that was added in the 1.3 release, and that the symbols defined in
# the previous tecla_1.2 clause have been inherited by tecla_1.3.
#
# For more details see the following URL:
#
# http://www.usenix.org/publications/library/proceedings/als2000/browndavid.html
#-------------------------------------------------------------------------------
tecla_1.2 {
global:
cfc_file_start;
cfc_literal_escapes;
cfc_set_check_fn;
cpl_add_completion;
cpl_check_exe;
cpl_complete_word;
cpl_file_completions;
cpl_init_FileArgs;
cpl_last_error;
cpl_list_completions;
cpl_record_error;
del_CplFileConf;
del_ExpandFile;
del_GetLine;
del_PathCache;
del_PcaPathConf;
del_WordCompletion;
ef_expand_file;
ef_last_error;
gl_change_terminal;
gl_customize_completion;
gl_get_line;
new_CplFileConf;
new_ExpandFile;
new_GetLine;
new_PathCache;
new_PcaPathConf;
new_WordCompletion;
pca_last_error;
pca_lookup_file;
pca_path_completions;
pca_scan_path;
pca_set_check_fn;
ppc_file_start;
ppc_literal_escapes;
local:
*;
};
tecla_1.3 {
global:
ef_list_expansions;
} tecla_1.2;
tecla_1.4 {
global:
gl_configure_getline;
gl_save_history;
gl_load_history;
gl_group_history;
gl_show_history;
gl_resize_history;
gl_limit_history;
gl_clear_history;
gl_toggle_history;
gl_watch_fd;
libtecla_version;
gl_terminal_size;
gl_state_of_history;
gl_range_of_history;
gl_size_of_history;
gl_lookup_history;
gl_echo_mode;
gl_replace_prompt;
gl_prompt_style;
gl_ignore_signal;
gl_trap_signal;
gl_last_signal;
} tecla_1.3;
tecla_l.5 {
global:
gl_inactivity_timeout;
gl_completion_action;
gl_register_action;
gl_display_text;
gl_error_message;
gl_return_status;
gl_set_term_size;
gl_list_signals;
gl_catch_blocked;
gl_io_mode;
gl_raw_io;
gl_normal_io;
gl_tty_signals;
gl_abandon_line;
gl_handle_signal;
gl_pending_io;
gl_bind_keyseq;
cpl_recall_matches;
gl_erase_terminal;
} tecla_1.4;
tecla_1.6 {
global:
gl_append_history;
gl_automatic_history;
gl_query_char;
gl_read_char;
} tecla_l.5;
yuma123_2.14/libtecla/strngmem.c 0000664 0001750 0001750 00000015252 14770023131 016707 0 ustar vladimir vladimir /*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
#include
#include
#include
#include "strngmem.h"
#include "freelist.h"
struct StringMem {
unsigned long nmalloc; /* The number of strings allocated with malloc */
FreeList *fl; /* The free-list */
};
/*.......................................................................
* Create a string free-list container and the first block of its free-list.
*
* Input:
* blocking_factor int The blocking_factor argument specifies how
* many strings of length SM_STRLEN
* bytes (see stringmem.h) are allocated in each
* free-list block.
* For example if blocking_factor=64 and
* SM_STRLEN=16, then each new
* free-list block will take 1K of memory.
* Output:
* return StringMem * The new free-list container, or NULL on
* error.
*/
StringMem *_new_StringMem(unsigned blocking_factor)
{
StringMem *sm; /* The container to be returned. */
/*
* Check arguments.
*/
if(blocking_factor < 1) {
errno = EINVAL;
return NULL;
};
/*
* Allocate the container.
*/
sm = (StringMem *) malloc(sizeof(StringMem));
if(!sm) {
errno = ENOMEM;
return NULL;
};
/*
* Before attempting any operation that might fail, initialize
* the container at least up to the point at which it can safely
* be passed to _del_StringMem().
*/
sm->nmalloc = 0;
sm->fl = NULL;
/*
* Allocate the free-list.
*/
sm->fl = _new_FreeList(SM_STRLEN, blocking_factor);
if(!sm->fl)
return _del_StringMem(sm, 1);
/*
* Return the free-list container.
*/
return sm;
}
/*.......................................................................
* Delete a string free-list.
*
* Input:
* sm StringMem * The string free-list to be deleted, or NULL.
* force int If force==0 then _del_StringMem() will complain
* and refuse to delete the free-list if any
* of nodes have not been returned to the free-list.
* If force!=0 then _del_StringMem() will not check
* whether any nodes are still in use and will
* always delete the list.
* Output:
* return StringMem * Always NULL (even if the list couldn't be
* deleted).
*/
StringMem *_del_StringMem(StringMem *sm, int force)
{
if(sm) {
/*
* Check whether any strings have not been returned to the free-list.
*/
if(!force && (sm->nmalloc > 0 || _busy_FreeListNodes(sm->fl) > 0)) {
errno = EBUSY;
return NULL;
};
/*
* Delete the free-list.
*/
sm->fl = _del_FreeList(sm->fl, force);
/*
* Delete the container.
*/
free(sm);
};
return NULL;
}
/*.......................................................................
* Allocate an array of 'length' chars.
*
* Input:
* sm StringMem * The string free-list to allocate from.
* length size_t The length of the new string (including '\0').
* Output:
* return char * The new string or NULL on error.
*/
char *_new_StringMemString(StringMem *sm, size_t length)
{
char *string; /* The string to be returned */
int was_malloc; /* True if malloc was used to allocate the string */
/*
* Check arguments.
*/
if(!sm)
return NULL;
if(length < 1)
length = 1;
/*
* Allocate the new node from the free list if possible.
*/
if(length < SM_STRLEN) {
string = (char *)_new_FreeListNode(sm->fl);
if(!string)
return NULL;
was_malloc = 0;
} else {
string = (char *) malloc(length+1); /* Leave room for the flag byte */
if(!string)
return NULL;
/*
* Count malloc allocations.
*/
was_malloc = 1;
sm->nmalloc++;
};
/*
* Use the first byte of the string to record whether the string was
* allocated with malloc or from the free-list. Then return the rest
* of the string for use by the user.
*/
string[0] = (char) was_malloc;
return string + 1;
}
/*.......................................................................
* Free a string that was previously returned by _new_StringMemString().
*
* Input:
* sm StringMem * The free-list from which the string was originally
* allocated.
* s char * The string to be returned to the free-list, or NULL.
* Output:
* return char * Always NULL.
*/
char *_del_StringMemString(StringMem *sm, char *s)
{
int was_malloc; /* True if the string originally came from malloc() */
/*
* Is there anything to be deleted?
*/
if(s && sm) {
/*
* Retrieve the true string pointer. This is one less than the one
* returned by _new_StringMemString() because the first byte of the
* allocated memory is reserved by _new_StringMemString as a flag byte
* to say whether the memory was allocated from the free-list or directly
* from malloc().
*/
s--;
/*
* Get the origination flag.
*/
was_malloc = s[0];
if(was_malloc) {
free(s);
s = NULL;
sm->nmalloc--;
} else {
s = (char *) _del_FreeListNode(sm->fl, s);
};
};
return NULL;
}
yuma123_2.14/libtecla/Makefile.am 0000664 0001750 0001750 00000003412 14770023131 016736 0 ustar vladimir vladimir noinst_LTLIBRARIES = libtecla.la
noinst_HEADERS= \
$(top_srcdir)/libtecla/chrqueue.h \
$(top_srcdir)/libtecla/cplfile.h \
$(top_srcdir)/libtecla/cplmatch.h \
$(top_srcdir)/libtecla/direader.h \
$(top_srcdir)/libtecla/errmsg.h \
$(top_srcdir)/libtecla/expand.h \
$(top_srcdir)/libtecla/freelist.h \
$(top_srcdir)/libtecla/getline.h \
$(top_srcdir)/libtecla/hash.h \
$(top_srcdir)/libtecla/history.h \
$(top_srcdir)/libtecla/homedir.h \
$(top_srcdir)/libtecla/ioutil.h \
$(top_srcdir)/libtecla/keytab.h \
$(top_srcdir)/libtecla/libtecla.h \
$(top_srcdir)/libtecla/pathutil.h \
$(top_srcdir)/libtecla/stringrp.h \
$(top_srcdir)/libtecla/strngmem.h
libtecla_la_SOURCES = \
$(top_srcdir)/libtecla/chrqueue.c \
$(top_srcdir)/libtecla/cplfile.c \
$(top_srcdir)/libtecla/cplmatch.c \
$(top_srcdir)/libtecla/direader.c \
$(top_srcdir)/libtecla/enhance.c \
$(top_srcdir)/libtecla/errmsg.c \
$(top_srcdir)/libtecla/expand.c \
$(top_srcdir)/libtecla/freelist.c \
$(top_srcdir)/libtecla/getline.c \
$(top_srcdir)/libtecla/hash.c \
$(top_srcdir)/libtecla/history.c \
$(top_srcdir)/libtecla/homedir.c \
$(top_srcdir)/libtecla/ioutil.c \
$(top_srcdir)/libtecla/keytab.c \
$(top_srcdir)/libtecla/pathutil.c \
$(top_srcdir)/libtecla/pcache.c \
$(top_srcdir)/libtecla/stringrp.c \
$(top_srcdir)/libtecla/strngmem.c \
$(top_srcdir)/libtecla/version.c
libtecla_la_CPPFLAGS = -I$(top_srcdir)/netconf/src/agt -I$(top_srcdir)/netconf/src/mgr -I$(top_srcdir)/libtecla -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=1 -DUSE_TERMINFO=1 -DHAVE_CURSES_H=1 -DHAVE_TERM_H=1 -DHAVE_SYS_SELECT_H=1 -DHAVE_SELECT=1 -DHAVE_SYSV_PTY=1 -D_SVID_SOURCE -D_BSD_SOURCE
libtecla_la_LDFLAGS = -static
yuma123_2.14/libtecla/RELEASE.NOTES 0000664 0001750 0001750 00000070203 14770023131 016576 0 ustar vladimir vladimir This file lists major changes which accompany each new release.
Version 1.6.1:
This is primarily a minor bug-fix release.
One added feature is the ability to call gl_normal_io() from
callbacks registered by gl_watch_fd() and
gl_inactivity_timeout(). This allows these callbacks to cleanly
suspend line editing before either reading from the terminal, or
writing to the terminal; and then subsequently causes the input line
to be automatically redisplayed, and line-editing to be resumed by
gl_get_line(), as soon as the callback returns.
Another minor change is that if the terminal type specified in the
TERM environment variable is set to "dumb", gl_get_line() now treats
the terminal as though it were a non-interactive stream, rather than
treating it as a VT100-compatible terminal. This means that it
doesn't either prompt for input, or perform any command-line
editing, even when it really is interacting with a terminal. This is
aimed at the rare situation where a third-pary program that connects
to libtecla through an embedded pseudo-terminal, needs to be forced
to behave as though it weren't talking to a terminal, in order that
it be useable in non-interactive scripts.
Note that in the previous release, the optional configuration
function, gl_tty_signals(), was incorrectly swapping the suspend and
terminal signal handlers before installing them.
A configuration problem that prevented select() from being used
under MacOS X, has been fixed.
Although not documented in the man page, it was meant to be possible
to take the input line that one call to gl_get_line() returned, and
ask the next call to gl_get_line() to present it back to the user
for re-editing, simply by passing the pointer returned by one call
to gl_get_line() as the start_line argument of the next call to
gl_get_line(). This feature unfortunately stopped working in 1.6.0,
so this release restores it, and officially documents it in the man
page documentation of gl_get_line().
In the previous version of the library, calling gl_terminal_size()
on a system without SIGWINCH support, would crash the
application. This has been fixed.
Libtecla now apparently compiles cleanly under IRIX.
Version 1.6.0:
This release is primarily a bug-fix release. However there are also
four new functions, so the minor version number has been
incremented to reflect this.
Two of the new functions are gl_automatic_history() and
gl_append_history(). The former of these functions allows the
application to tell gl_get_line() not to automatically archive
entered lines in the history list. The second of these functions
allows the application to explicitly append a line to the history
list. Thus together, these two functions allow the calling
application to take over control of what is placed in the history
list.
The third new function is gl_query_char(), which prompts the user
for a single character reply, which the user can then type without
having to hit return to enter it. Unless echoing is disabled, the
character that is entered is then displayed after the prompt,
and a newline is started.
Finally, the 4th new function is gl_read_char(), which also reads
a single character from the user, but doesn't prompt the user, write
anything to the terminal, or disturb any partially entered input
line. It is thus safe to call this function not only from between
calls to gl_get_line(), but also from application callback
functions, even if gl_normal_io() hasn't been called.
When using the history-search-backwards or history-search-forwards
actions, if the search prefix that the user typed, contains any of
the *,? or [ globbing characters, it is now treated as a glob
pattern to be matched against historical lines, instead of a simple
prefix.
I have added a --without-file-system option to the configure
script. This is intended for use in embedded systems that either
don't have filesystems, or where the file-system code in libtecla is
seen as unwanted bloat. See the INSTALL document for details.
Similarly, I also added a --without-file-actions option to the
configure script. This allows the application author/installer to
prevent users of gl_get_line() from accessing the filesystem with
the builtin actions of gl_get_line(). It does this by removing a
number of action functions, such as expand-filename, and list-glob,
and by changing the default behavior of other actions, such as
complete-word and list-or-eof, to show no completions.
Now to the bugs that have been fixed. Version 1.5.0 had a lot of big
internal changes, so there are a number of bugs that needed to be
fixed. There was a bug which caused a crash if gl_load_history()
was called multiple times. There was another bug which caused a
prompt not to be displayed on the next line after switching from
reading input from a file to reading from the terminal. Also, in
tecla configuration files, backslash escaped characters within
key-binding key-sequences weren't being escaped. Thus ^\\ got
interpretted as a control-\ followed by a \ character instead of as
a control-\. There was a bug in the history recall mechanism which
caused the search prefix to be forgotten in certain complicated
usage scenarios. There was a minor memory leak in the
gl_configure_getline() function. Finally, if gl_get_line() was
aborted by a signal, or any other abnormal event, the value of errno
which originally indicated what had happened, got zeroed by the
code that restored the terminal to a usable state. Thus the
application couldn't figure out what had caused the error, apart
from by looking at gl_return_status(). All of these bugs have been
fixed.
In the Makefile, there were a number of places where install-sh was
invoked without a path prefix. This has now been remedied.
A fully functional workaround for a bug in Solaris' terminal I/O
code has also been implemented. This bug, which only manifested
itself in libtecla's uncommonly used non-blocking server I/O mode,
caused characters entered while in normal I/O mode, between calls to
gl_get_line() to be invisible to the next call to gl_get_line(),
until the user typed at least one more key after raw terminal mode
was restored.
The Gnu autoconf config.guess and config.sub scripts have been
updated to their latest versions. Apparently the old versions that I
was previously using were too old to know about certain BSD ports.
Version 1.5.0:
This release includes several major new features for those using
gl_get_line(), shared library support in Darwin, better cross
compilation support, and various minor bug fixes.
The biggest new feature is the option of a non-blocking I/O mode, in
which gl_get_line() can safely be called from an application's
external event-loop to incrementally read input lines from the user.
This feature is documented in the gl_io_mode(3) man page.
In addition, there is now support for the definition of additional
word-completion action functions, which can then be bound to
different keys. See the documentation of the gl_completion_action()
function in the gl_get_line(3) man page.
Externally defined action functions can also be defined, although
presently they don't have write access to the input line, so they
are restricted to operations that display information text to the
terminal, or modify the environment of the calling application in
some way. See the documentation of the gl_register_action() function
in the gl_get_line(3) man page.
Some of the non-blocking I/O support functions can also be used for
improved signal handling in the normal blocking mode. In particular,
the gl_list_signals() and gl_catch_blocked() functions make it
easier to write reliable signal handling around gl_get_line(). The
new "RELIABLE SIGNAL HANDLING" section of the gl_get_line(3) man
page is intended as an introduction to this subject.
Programs can now clear the terminal between calls to gl_get_line(),
by calling the new gl_erase_terminal() function.
The gl_display_text() function, now used in the demos to display
introductory banners, is provided for formatting text according to
the width of the terminal.
It is now possible to install inactivity timeout callbacks in
gl_get_line(), using the new gl_inactivity_timeout() function.
The new gl_set_term_size() function allows the application to
explicitly set the terminal size, for cases, such as when one is
using a terminal at the end of a serial lineq, where the terminal
driver doesn't send the process a SIGWINCH when the terminal size
changes.
The new gl_bind_keyseq() function provides a convenient
alternative to gl_configure_getline(), for binding or unbinding
one key-sequence at a time.
gl_get_line()s signal handling, file-descriptor event-handling,
inactivity-timeout handling and server-mode non-blocking I/O
features now not only work when input is coming from a terminal, but
now also work when input is coming from non-interactive streams,
such as files and pipes.
The history implementation has been re-written to make it more
efficient and easier to modify. The biggest user-level change is
that when recalling history lines using a search prefix, the same
line is no longer returned more than once in a row. Previously this
duplicate elimination only worked when one was recalling a line
without specifying a search prefix, and this was naively performed
by preventing neighboring duplicates from existing in the history
list, rather than by skipping duplicates at search time.
In previous versions of the library, when gl_get_line() and its
associated public functions detected invalid arguments, or couldn't
allocate memory, etc, error messages were written to stderr. This
isn't appropriate for library functions, so instead of writing such
messages to stderr, these messages are now recorded in buffers
within the affected GetLine object. The latest error message can
then subsequently be queried by calling gl_error_message(). The use
of errno has also been expanded, and a new function called
gl_return_status() has been provided to expand on the cause of the
last return from gl_get_line().
User level usage and configuration information has now been split
out of the gl_get_line(3) man page into a separate tecla(7) man
page. The enhance(3) man page has also been renamed to enhance(1).
When expanding "~/", gl_get_line() now checks for, and returns the
value of the HOME environment variable, if it exists, in preference
to looking up the directory of the current user in the password
file.
When the terminal was resized to a narrower width, previous versions
of gl_get_line() would redraw the line higher up the terminal. This
bug has been fixed. A bug in history recall has also been fixed, in
which an error message was being generated if one attempted to
recall a line while the cursor was at the end of the longest
possible input line. A more serious bug, in which callbacks
registered by gl_watch_fd() weren't being called for write-events,
has also been fixed. Finally, a few minor fixes have been made to
improve support under QNX and Mac OS X.
Beware that in this release, much of the underlying code has
undergone some radical re-work, so although backwards compatibility
of all documented features has been preserved, there may be some
lingering bugs that could break existing programs. So, if you plan
to use this version in production code, please test it as far as
possible within your application before releasing it to your
clients, and as always, please report any unexpected behavior.
Version 1.4.1:
This is a maintenance release. It includes minor changes to support
Mac OS X (Darwin), the QNX real-time operating system, and Cygwin
under Windows. It also fixes an oversight that was preventing the
tab key from inserting tab characters when users unbound the
complete-word action from it.
Version 1.4.0:
The contents of the history list can now be saved and restored with
the new gl_save_history() and gl_load_history() functions.
Event handlers can now be registered to watch for and respond to I/O
on arbitrary file descriptors while gl_get_line() is waiting for
terminal input from the user. See the gl_get_line(3) man page
for details on gl_watch_fd().
As an optional alternative to getting configuration information only
from ~/.teclarc, the new gl_configure_getline() function allows
configuration commands to be taken from any of, a string, a
specified application-specific file, and/or a specified
user-specific file. See the gl_get_line(3) man page for details.
The version number of the library can now be queried using the
libtecla_version() function. See the libtecla(3) man page.
The new gl_group_history() function allows applications to group
different types of input line in the history buffer, and arrange for
only members of the appropriate group to be recalled on a given call
to gl_get_line(). See the gl_get_line(3) man page.
The new gl_show_history() function displays the current history list
to a given stdio output stream. See the gl_get_line(3) man page.
new_GetLine() now allows you to specify a history buffer size of
zero, thus requesting that no history buffer be allocated. You can
subsequently resize or delete the history buffer at any time, by
calling gl_resize_history(), limit the number of lines that are
allowed in the buffer by calling gl_limit_history(), clear either
all history lines from the history list, or just the history lines
that are associated with the current history group, by calling
gl_clear_history, and toggle the history mechanism on and off by
calling gl_toggle_history().
The new gl_terminal_size() function can be used to query the
current terminal size. It can also be used to supply a default
terminal size on systems where no mechanism is available for
looking up the size.
The contents and configuration of the history list can now be
obtained by the calling application, by calling the new
gl_lookup_history(), gl_state_of_history(), gl_range_of_history()
and gl_size_of_history() functions. See the gl_get_line(3) man page.
Echoing of the input line as it is typed, can now be turned on and
off via the new gl_echo_mode() function. While echoing is disabled,
newly entered input lines are omitted from the history list. See
the gl_get_line(3) man page.
While the default remains to display the prompt string literally,
the new gl_prompt_style() function can be used to enable text
attribute formatting directives in prompt strings, such as
underlining, bold font, and highlighting directives.
Signal handling in gl_get_line() is now customizable. The default
signal handling behavior remains essentially the same, except that
the SIGTSTP, SIGTTIN and SIGTTOU are now forwarded to the
corresponding signal handler of the calling program, instead of
causing a SIGSTOP to be sent to the application. It is now possible
to remove signals from the list that are trapped by gl_get_line(),
as well as add new signals to this list. The signal and terminal
environments in which the signal handler of the calling program is
invoked, and what gl_get_line() does after the signal handler
returns, is now customizable on a per signal basis. You can now also
query the last signal that was caught by gl_get_line(). This is
useful when gl_get_line() aborts with errno=EINTR, and you need to
know which signal caused it to abort.
Key-sequences bound to action functions can now start with printable
characters. Previously only keysequences starting with control or
meta characters were permitted.
gl_get_line() is now 8-bit clean. If the calling program has
correctly called setlocale(LC_CTYPE,""), then the user can select an
alternate locale by setting the standard LC_CTYPE, LC_ALL, or LANG
environment variables, and international characters can then be
entered directly, either by using a non-US keyboard, or by using a
compose key on a standard US keyboard. Note that in locales in which
meta characters become printable, meta characters no longer match
M-c bindings, which then have to be entered using their escape-c
equivalents. Fortunately most modern terminal emulators either
output the escape-c version by default when the meta key is used, or
can be configured to do so (see the gl_get_line(3) man page), so in
most cases you can continue to use the meta key.
Completion callback functions can now tell gl_get_line() to return
the input line immediately after a successful tab completion, simply
by setting the last character of the optional continuation suffix to
a newline character (ie. in the call to cpl_add_completion()).
It is now safe to create and use multiple GetLine objects, albeit
still only from a single thread. In conjunction with the new
gl_configure_getline() function, this optionally allows multiple
GetLine objects with different bindings to be used to implement
different input modes.
The edit-mode configuration command now accepts the argument,
none. This tells gl_get_line() to revert to using just the native
line editing facilities provided by the terminal driver. This could
be used if the termcap or terminfo entry of the host terminal were
badly corrupted.
Application callback functions invoked by gl_get_line() can now
change the displayed prompt using the gl_replace_prompt() function.
Their is now an optional program distributed with the library. This
is a beta release of a program which adds tecla command-line editing
to virtually any third party application without the application
needing to be linked to the library. See the enhance(3) man page for
further details. Although built and installed by default, the
INSTALL document explains how to prevent this.
The INSTALL document now explains how you can stop the demo programs
from being built and installed.
NetBSD/termcap fixes. Mike MacFaden reported two problems that he
saw when compiling libtecla under NetBSD. Both cases were related to
the use of termcap. Most systems use terminfo, so this problem has
gone unnoticed until now, and won't have affected the grand majority
of users. The configure script had a bug which prevented the check
for CPP working properly, and getline.c wouldn't compile due to an
undeclared variable when USE_TERMCAP was defined. Both problems have
now been fixed. Note that if you successfully compiled version
1.3.3, this problem didn't affect you.
An unfortunate and undocumented binding of the key-sequence M-O was
shadowing the arrow-key bindings on systems that use ^[OA etc. I
have removed this binding (the documented lower case M-o binding
remains bound). Under the KDE konsole terminal this was causing the
arrow keys to do something other than expected.
There was a bug in the history list code which could result in
strange entries appearing at the start of the history list once
enough history lines had been added to the list to cause the
circular history buffer to wrap. This is now fixed.
Version 1.3.3:
Signal handling has been re-written, and documentation of its
behaviour has been added to the gl_get_line(3) man page. In addition
to eliminating race conditions, and appropriately setting errno for
those signals that abort gl_get_line(), many more signals are now
intercepted, making it less likely that the terminal will be left in
raw mode by a signal that isn't trapped by gl_get_line().
A bug was also fixed that was leaving the terminal in raw mode if
the editing mode was changed interactively between vi and emacs.
This was only noticeable when running programs from old shells that
don't reset terminal modes.
Version 1.3.2:
Tim Eliseo contributed a number of improvements to vi mode,
including a fuller set of vi key-bindings, implementation of the vi
constraint that the cursor can't backup past the point at which
input mode was entered, and restoration of overwritten characters
when backspacing in overwrite mode. There are also now new bindings
to allow users to toggle between vi and emacs modes interactively.
The terminal bell is now used in some circumstances, such as when an
unrecognized key sequence is entered. This can be turned off by the
new nobeep option in the tecla configuration file.
Unrelated to the above, a problem under Linux which prevented ^Q
from being used to resume terminal output after the user had pressed
^S, has been fixed.
Version 1.3.1:
In vi mode a bug was preventing the history-search-backward and
history-search-forward actions from doing anything when invoked on
empty lines. On empty lines they now act like up-history and
down-history respectively, as in emacs mode.
When creating shared libraries under Linux, the -soname directive
was being used incorrectly. The result is that Linux binaries linked
with the 1.2.3, 1.2.4 and 1.3.0 versions of the tecla shared
libraries, will refuse to see other versions of the shared library
until relinked with version 1.3.1 or higher.
The configure script can now handle the fact that under Solaris-2.6
and earlier, the only curses library is a static one that hides in
/usr/ccs/lib. Under Linux it now also caters for old versions of GNU
ld which don't accept version scripts.
The demos are now linked against the shared version of the library
if possible. Previously they were always linked with the static
version.
Version 1.3.0:
The major change in this release is the addition of an optional vi
command-line editing mode in gl_get_line(), along with lots of new
action functions to support its bindings. To enable this, first
create a ~/.teclarc file if you don't already have one, then add the
following line to it.
edit-mode vi
The default vi bindings, which are designed to mimic those of the vi
editor as closely as possible, are described in the gl_get_line(3)
man page.
A new convenience function called ef_list_expansions() has been
added for listing filename expansions. See the ef_list_expansions(3)
man page for details. This is used in a new list-glob binding, bound
to ^Xg in emacs mode, and ^G in vi input mode.
A bug has been fixed in the key-binding table expansion code. This
bug would have caused problems to anybody who defined more than
about 18 personalized key-bindings in their ~/.teclarc file.
Version 1.2.4:
Buffered I/O is now used for writing to terminals, and where
supported, cursor motion is done with move-n-positions terminfo
capabilities instead of doing lots of move-1-position requests. This
greatly improves how the library feels over slow links.
You can now optionally compile different architectures in different
directories, without having to make multiple copies of the
distribution. This is documented in the INSTALL file.
The ksh ~+ directive is now supported.
Thanks to Markus Gyger for the above improvements.
Documentation has been added to the INSTALL file describing features
designed to facilitate configuration and installation of the library
as part of larger packages. These features are intended to remove
the need to modify the tecla distribution's configuration and build
procedures when embedding the libtecla distribution in other package
distributions.
A previous fix to stop the cursor from warping when the last
character of the input line was in the last column of the terminal,
was only being used for the first terminal line of the input line.
It is now used for all subsequent lines as well, as originally
intended.
Version 1.2.3:
The installation procedure has been better automated with the
addition of an autoconf configure script. This means that installers
can now compile and install the library by typing:
./configure
make
make install
On all systems this makes at least the normal static version of the
tecla library. It also makes the reentrant version if reentrant
POSIX functions are detected. Under Solaris, Linux and HP-UX the
configuration script arranges for shared libraries to be compiled in
addition to the static libraries. It is hoped that installers will
return information about how to compile shared libraries on other
systems, for inclusion in future releases, and to this end, a new
PORTING guide has been provided.
The versioning number scheme has been changed. This release would
have been 1.2c, but instead will be refered to as 1.2.3. The
versioning scheme, based on conventions used by Sun Microsystems, is
described in configure.in.
The library was also tested under HP-UX, and this revealed two
serious bugs, both of which have now been fixed.
The first bug prevented the library from writing control codes to
terminals on big-endian machines, with the exception of those
running under Solaris. This was due to an int variable being used
where a char was needed.
The second bug had the symptom that on systems that don't use the
newline character as the control code for moving the cursor down a
line, a newline wasn't started when the user hit enter.
Version 1.2b:
Two more minor bug fixes:
Many terminals don't wrap the cursor to the next line when a
character is written to the rightmost terminal column. Instead, they
delay starting a new line until one more character is written, at
which point they move the cursor two positions. gl_get_line()
wasn't aware of this, so cursor repositionings just after writing
the last character of a column, caused it to erroneously go up a
line. This has now been remedied, using a method that should work
regardless of whether a terminal exhibits this behavior or not.
Some systems dynamically record the current terminal dimensions in
environment variables called LINES and COLUMNS. On such systems,
during the initial terminal setup, these values should override the
static values read from the terminal information databases, and now
do. Previously they were only used if the dimensions returned by
terminfo/termcap looked bogus.
Version 1.2a:
This minor release fixes the following two bugs:
The initial terminal size and subsequent changes thereto, weren't
being noticed by gl_get_line(). This was because the test for the
existence of TIOCWINSZ was erroneously placed before the inclusion
of termios.h. One of the results was that on input lines that
spanned more than one terminal line, the cursor occasionally jumped
unexpectedly to the previous terminal line.
On entering a line that wrapped over multiple terminal lines,
gl_get_line() simply output a carriage-return line-feed at the point
at which the user pressed return. Thus if one typed in such a line,
then moved back onto one of the earlier terminal lines before
hitting return, the cursor was left on a line containing part of the
line that had just been entered. This didn't do any harm, but it
looked a mess.
Version 1.2:
A new facility for looking up and completing filenames in UNIX-style
paths has now been added (eg. you can search for, or complete
commands using the UNIX PATH environment variable). See the
pca_lookup_file(3) man page.
The already existing filename completion callback can now be made
selective in what types of files it lists. See the
cpl_complete_word(3) man page.
Due to its potential to break applications when changed, the use of
the publically defined CplFileArgs structure to configure the
cpl_file_completions() callback is now deprecated. The definition
of this structure has been frozen, and its documentation has been
removed from the man pages. It will remain supported, but if you
have used it, you are recommended to switch to the new method, which
involves a new opaque configuration object, allocated via a provided
constructor function, configured via accessor functions, and
eventually deleted with a provided destructor function. The
cpl_file_completions() callback distinguishes which structure type
it has been sent by virtue of a code placed at the start of the new
structure by the constructor. It is assumed that no existing
applications set the boolean 'escaped' member of the CplFileArgs
structure to 4568. The new method is documented in the
cpl_complete_word(3) man page.
Version 1.1j
This was the initial public release on freshmeat.org.
yuma123_2.14/libtecla/ioutil.h 0000664 0001750 0001750 00000006327 14770023131 016370 0 ustar vladimir vladimir #ifndef ioutil_h
#define ioutil_h
/*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
/*.......................................................................
* Callback functions of the following type can be registered to write
* to a terminal, when the default blocking writes to a local terminal
* aren't appropriate. In particular, if you don't want gl_get_line()
* to block, then this function should return before writing the
* specified number of characters if doing otherwise would involve
* waiting.
*
* Input:
* data void * The anonymous data pointer that was registered with
* this callback function.
* s const char * The string to be written. Beware that this string
* may not have a terminating '\0' character.
* n int The length of the prefix of s[] to attempt to
* write.
* Output:
* return int The number of characters written from s[]. This
* should normally be a number in the range 0 to n.
* To signal that an I/O error occurred, return -1.
*/
#define GL_WRITE_FN(fn) int (fn)(void *data, const char *s, int n)
typedef GL_WRITE_FN(GlWriteFn);
/*
* The following output callback function requires a (FILE *) callback
* data argument, and writes to this stream using the fwrite stdio
* function.
*/
GL_WRITE_FN(_io_write_stdio);
/*
* Left justify text within the bounds of the terminal adding optional
* indentation, prefixes and suffixes to each line if requested.
*/
int _io_display_text(GlWriteFn *write_fn, void *data, int indentation,
const char *prefix, const char *suffix, int fill_char,
int term_width, int start, const char *string);
#endif
yuma123_2.14/libtecla/Makefile.rules 0000664 0001750 0001750 00000013314 14770023131 017475 0 ustar vladimir vladimir default: $(OBJDIR) $(TARGETS) $(DEMOS) $(PROGRAMS)
#-----------------------------------------------------------------------
# You shouldn't need to change anything in this file.
#-----------------------------------------------------------------------
# Create the directory in which the object files will be created.
$(OBJDIR):
mkdir $(OBJDIR)
# Construct the compilation command.
COMPILE = $(CC) -c $(CFLAGS) -o $@
LIB_OBJECTS = $(OBJDIR)/getline.o $(OBJDIR)/keytab.o $(OBJDIR)/freelist.o \
$(OBJDIR)/strngmem.o $(OBJDIR)/hash.o $(OBJDIR)/history.o \
$(OBJDIR)/direader.o $(OBJDIR)/homedir.o $(OBJDIR)/pathutil.o \
$(OBJDIR)/expand.o $(OBJDIR)/stringrp.o $(OBJDIR)/cplfile.o \
$(OBJDIR)/cplmatch.o $(OBJDIR)/pcache.o $(OBJDIR)/version.o \
$(OBJDIR)/chrqueue.o $(OBJDIR)/ioutil.o $(OBJDIR)/errmsg.o
# List the available demonstration programs.
DEMO_PROGS = demo$(SUFFIX) demo2$(SUFFIX) demo3$(SUFFIX)
# List all of the programs that this makefile can build.
PROGS = $(DEMO_PROGS) enhance$(SUFFIX)
static: libtecla$(SUFFIX).a
libtecla$(SUFFIX).a: $(LIB_OBJECTS)
ar -ru $@ $(LIB_OBJECTS); \
$(RANLIB) $@; \
rm -f $(PROGS)
shared: libtecla$(SUFFIX)$(SHARED_EXT)
libtecla$(SUFFIX)$(SHARED_EXT): $(LIB_OBJECTS) $(srcdir)/libtecla.map \
libtecla.map.opt
$(LINK_SHARED)
@endings="$(SHARED_ALT)" ; \
for alt in $$endings ; do \
lnk="libtecla$(SUFFIX)$$alt"; \
echo "rm -f $$lnk; $(LN_S) $@ $$lnk"; \
rm -f $$lnk; $(LN_S) $@ $$lnk; \
done; \
rm -f $(PROGS)
libtecla.map.opt: $(srcdir)/libtecla.map
sed -n 's/^[ ]*\([_a-zA-Z0-9]*\)[ ]*;.*/+e \1/p' $? >$@
demos: $(DEMO_PROGS)
demo$(SUFFIX): $(OBJDIR)/demo.o
LD_RUN_PATH="$(LIBDIR):$$LD_RUN_PATH:`pwd`" $(CC) $(CFLAGS) -o $@ \
$(OBJDIR)/demo.o -L. -ltecla$(SUFFIX) $(LIBS)
demo2$(SUFFIX): $(OBJDIR)/demo2.o
LD_RUN_PATH="$(LIBDIR):$$LD_RUN_PATH:`pwd`" $(CC) $(CFLAGS) -o $@ \
$(OBJDIR)/demo2.o -L. -ltecla$(SUFFIX) $(LIBS)
demo3$(SUFFIX): $(OBJDIR)/demo3.o
LD_RUN_PATH="$(LIBDIR):$$LD_RUN_PATH:`pwd`" $(CC) $(CFLAGS) -o $@ \
$(OBJDIR)/demo3.o -L. -ltecla$(SUFFIX) $(LIBS)
enhance$(SUFFIX): $(OBJDIR)/enhance.o
LD_RUN_PATH="$(LIBDIR):$$LD_RUN_PATH:`pwd`" $(CC) $(CFLAGS) -o $@ \
$(OBJDIR)/enhance.o -L. -ltecla$(SUFFIX) $(LIBS)
#-----------------------------------------------------------------------
# Object file dependencies.
#-----------------------------------------------------------------------
$(OBJDIR)/getline.o: $(srcdir)/getline.c $(srcdir)/pathutil.h \
$(srcdir)/libtecla.h $(OBJDIR)/keytab.h $(srcdir)/history.h \
$(srcdir)/freelist.h $(srcdir)/stringrp.h $(srcdir)/getline.h \
$(srcdir)/ioutil.h $(srcdir)/chrqueue.h $(srcdir)/cplmatch.h \
$(srcdir)/expand.h $(srcdir)/errmsg.h
$(COMPILE) $(srcdir)/getline.c
$(OBJDIR)/keytab.o: $(srcdir)/keytab.c $(OBJDIR)/keytab.h \
$(srcdir)/strngmem.h $(srcdir)/getline.h $(srcdir)/errmsg.h \
$(srcdir)/hash.h
$(COMPILE) $(srcdir)/keytab.c
$(OBJDIR)/strngmem.o: $(srcdir)/strngmem.c $(srcdir)/strngmem.h \
$(srcdir)/freelist.h
$(COMPILE) $(srcdir)/strngmem.c
$(OBJDIR)/freelist.o: $(srcdir)/freelist.c $(srcdir)/freelist.h
$(COMPILE) $(srcdir)/freelist.c
$(OBJDIR)/hash.o: $(srcdir)/hash.c $(srcdir)/hash.h $(srcdir)/strngmem.h \
$(srcdir)/freelist.h
$(COMPILE) $(srcdir)/hash.c
$(OBJDIR)/history.o: $(srcdir)/history.c $(srcdir)/ioutil.h \
$(srcdir)/history.h $(srcdir)/freelist.h $(srcdir)/errmsg.h
$(COMPILE) $(srcdir)/history.c
$(OBJDIR)/expand.o: $(srcdir)/expand.c $(srcdir)/freelist.h \
$(srcdir)/direader.h $(srcdir)/pathutil.h $(srcdir)/homedir.h \
$(srcdir)/stringrp.h $(srcdir)/libtecla.h $(srcdir)/ioutil.h \
$(srcdir)/expand.h $(srcdir)/errmsg.h
$(COMPILE) $(srcdir)/expand.c
$(OBJDIR)/direader.o: $(srcdir)/direader.c $(srcdir)/direader.h \
$(srcdir)/errmsg.h
$(COMPILE) $(srcdir)/direader.c
$(OBJDIR)/homedir.o: $(srcdir)/homedir.c $(srcdir)/pathutil.h \
$(srcdir)/homedir.h $(srcdir)/errmsg.h
$(COMPILE) $(srcdir)/homedir.c
$(OBJDIR)/pathutil.o: $(srcdir)/pathutil.c $(srcdir)/pathutil.h
$(COMPILE) $(srcdir)/pathutil.c
$(OBJDIR)/stringrp.o: $(srcdir)/stringrp.c $(srcdir)/freelist.h \
$(srcdir)/stringrp.h
$(COMPILE) $(srcdir)/stringrp.c
$(OBJDIR)/cplfile.o: $(srcdir)/cplfile.c $(srcdir)/libtecla.h \
$(srcdir)/direader.h $(srcdir)/homedir.h $(srcdir)/pathutil.h \
$(srcdir)/cplfile.h $(srcdir)/errmsg.h
$(COMPILE) $(srcdir)/cplfile.c
$(OBJDIR)/cplmatch.o: $(srcdir)/cplmatch.c $(srcdir)/libtecla.h \
$(srcdir)/ioutil.h $(srcdir)/stringrp.h $(srcdir)/pathutil.h \
$(srcdir)/cplfile.h $(srcdir)/cplmatch.h $(srcdir)/errmsg.h
$(COMPILE) $(srcdir)/cplmatch.c
$(OBJDIR)/pcache.o: $(srcdir)/pcache.c $(srcdir)/libtecla.h \
$(srcdir)/pathutil.h $(srcdir)/homedir.h $(srcdir)/freelist.h \
$(srcdir)/direader.h $(srcdir)/stringrp.h $(errmsg.h)
$(COMPILE) $(srcdir)/pcache.c
$(OBJDIR)/demo.o: $(srcdir)/demo.c $(srcdir)/libtecla.h
$(COMPILE) $(srcdir)/demo.c
$(OBJDIR)/demo2.o: $(srcdir)/demo2.c $(srcdir)/libtecla.h
$(COMPILE) $(srcdir)/demo2.c
$(OBJDIR)/demo3.o: $(srcdir)/demo3.c $(srcdir)/libtecla.h
$(COMPILE) $(srcdir)/demo3.c
$(OBJDIR)/version.o: $(srcdir)/version.c $(srcdir)/libtecla.h
$(COMPILE) $(srcdir)/version.c
$(OBJDIR)/enhance.o: $(srcdir)/enhance.c $(srcdir)/libtecla.h
$(COMPILE) $(srcdir)/enhance.c
$(OBJDIR)/chrqueue.o: $(srcdir)/chrqueue.c $(srcdir)/ioutil.h \
$(srcdir)/chrqueue.h $(srcdir)/freelist.h $(srcdir)/errmsg.h
$(COMPILE) $(srcdir)/chrqueue.c
$(OBJDIR)/ioutil.o: $(srcdir)/ioutil.c $(srcdir)/ioutil.h
$(COMPILE) $(srcdir)/ioutil.c
$(OBJDIR)/errmsg.o: $(srcdir)/errmsg.c $(srcdir)/errmsg.h
$(COMPILE) $(srcdir)/errmsg.c
#-----------------------------------------------------------------------
# Include file dependencies.
#-----------------------------------------------------------------------
$(OBJDIR)/keytab.h: $(srcdir)/keytab.h $(srcdir)/libtecla.h
cp $(srcdir)/keytab.h $@
yuma123_2.14/libtecla/freelist.c 0000664 0001750 0001750 00000027523 14770023131 016674 0 ustar vladimir vladimir /*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
#include
#include
#include
#include "freelist.h"
typedef struct FreeListBlock FreeListBlock;
struct FreeListBlock {
FreeListBlock *next; /* The next block in the list */
char *nodes; /* The array of free-list nodes */
};
struct FreeList {
size_t node_size; /* The size of a free-list node */
unsigned blocking_factor; /* The number of nodes per block */
long nbusy; /* The number of nodes that are in use */
long ntotal; /* The total number of nodes in the free list */
FreeListBlock *block; /* The head of the list of free-list blocks */
void *free_list; /* The free-list of nodes */
};
static FreeListBlock *_new_FreeListBlock(FreeList *fl);
static FreeListBlock *_del_FreeListBlock(FreeListBlock *fl);
static void _thread_FreeListBlock(FreeList *fl, FreeListBlock *block);
/*.......................................................................
* Allocate a new free-list from blocks of 'blocking_factor' objects of size
* node_size.
*
* Input:
* node_size size_t The size of the free-list nodes to be returned
* by _new_FreeListNode(). Use sizeof() to
* determine this.
* blocking_factor unsigned The number of objects of size 'object_size'
* to allocate per block.
* Output:
* return FreeList * The new freelist, or NULL on error.
*/
FreeList *_new_FreeList(size_t node_size, unsigned blocking_factor)
{
FreeList *fl; /* The new free-list container */
/*
* When a free-list node is on the free-list, it is used as a (void *)
* link field. Roundup node_size to a mulitple of the size of a void
* pointer. This, plus the fact that the array of nodes is obtained via
* malloc, which returns memory suitably aligned for any object, will
* ensure that the first sizeof(void *) bytes of each node will be
* suitably aligned to use as a (void *) link pointer.
*/
node_size = sizeof(void *) *
((node_size + sizeof(void *) - 1) / sizeof(void *));
/*
* Enfore a minimum block size.
*/
if(blocking_factor < 1)
blocking_factor = 1;
/*
* Allocate the container of the free list.
*/
fl = (FreeList *) malloc(sizeof(FreeList));
if(!fl) {
errno = ENOMEM;
return NULL;
};
/*
* Before attempting any operation that might fail, initialize the
* container at least up to the point at which it can safely be passed
* to _del_FreeList().
*/
fl->node_size = node_size;
fl->blocking_factor = blocking_factor;
fl->nbusy = 0;
fl->ntotal = 0;
fl->block = NULL;
fl->free_list = NULL;
/*
* Allocate the first block of memory.
*/
fl->block = _new_FreeListBlock(fl);
if(!fl->block) {
errno = ENOMEM;
return _del_FreeList(fl, 1);
};
/*
* Add the new list of nodes to the free-list.
*/
fl->free_list = fl->block->nodes;
/*
* Return the free-list for use.
*/
return fl;
}
/*.......................................................................
* Re-thread a freelist to reclaim all allocated nodes.
* This function should not be called unless if it is known that none
* of the currently allocated nodes are still being used.
*
* Input:
* fl FreeList * The free-list to be reset, or NULL.
*/
void _rst_FreeList(FreeList *fl)
{
if(fl) {
FreeListBlock *block;
/*
* Re-thread the nodes of each block into individual free-lists.
*/
for(block=fl->block; block; block=block->next)
_thread_FreeListBlock(fl, block);
/*
* Link all of the block freelists into one large freelist.
*/
fl->free_list = NULL;
for(block=fl->block; block; block=block->next) {
/*
* Locate the last node of the current block.
*/
char *last_node = block->nodes + fl->node_size *
(fl->blocking_factor - 1);
/*
* Make the link-field of the last node point to the first
* node of the current freelist, then make the first node of the
* new block the start of the freelist.
*/
*(void **)last_node = fl->free_list;
fl->free_list = block->nodes;
};
/*
* All allocated nodes have now been returned to the freelist.
*/
fl->nbusy = 0;
};
}
/*.......................................................................
* Delete a free-list.
*
* Input:
* fl FreeList * The free-list to be deleted, or NULL.
* force int If force==0 then _del_FreeList() will complain
* and refuse to delete the free-list if any
* of nodes have not been returned to the free-list.
* If force!=0 then _del_FreeList() will not check
* whether any nodes are still in use and will
* always delete the list.
* Output:
* return FreeList * Always NULL (even if the list couldn't be
* deleted).
*/
FreeList *_del_FreeList(FreeList *fl, int force)
{
if(fl) {
/*
* Check whether any nodes are in use.
*/
if(!force && _busy_FreeListNodes(fl) != 0) {
errno = EBUSY;
return NULL;
};
/*
* Delete the list blocks.
*/
{
FreeListBlock *next = fl->block;
while(next) {
FreeListBlock *block = next;
next = block->next;
block = _del_FreeListBlock(block);
};
};
fl->block = NULL;
fl->free_list = NULL;
/*
* Discard the container.
*/
free(fl);
};
return NULL;
}
/*.......................................................................
* Allocate a new object from a free-list.
*
* Input:
* fl FreeList * The free-list to return an object from.
* Output:
* return void * A new object of the size that was specified via
* the node_size argument of _new_FreeList() when
* the free-list was created, or NULL if there
* is insufficient memory, or 'fl' is NULL.
*/
void *_new_FreeListNode(FreeList *fl)
{
void *node; /* The node to be returned */
/*
* Check arguments.
*/
if(!fl)
return NULL;
/*
* If the free-list has been exhausted extend it by allocating
* another block of nodes.
*/
if(!fl->free_list) {
FreeListBlock *block = _new_FreeListBlock(fl);
if(!block)
return NULL;
/*
* Prepend the new block to the list of free-list blocks.
*/
block->next = fl->block;
fl->block = block;
/*
* Add the new list of nodes to the free-list.
*/
fl->free_list = fl->block->nodes;
};
/*
* Remove and return a node from the front of the free list.
*/
node = fl->free_list;
fl->free_list = *(void **)node;
/*
* Record the loss of a node from the free-list.
*/
fl->nbusy++;
/*
* Return the node.
*/
return node;
}
/*.......................................................................
* Return an object to the free-list that it was allocated from.
*
* Input:
* fl FreeList * The free-list from which the object was taken.
* object void * The node to be returned.
* Output:
* return void * Always NULL.
*/
void *_del_FreeListNode(FreeList *fl, void *object)
{
/*
* Check arguments.
*/
if(!fl)
return NULL;
/*
* Return the node to the head of the free list.
*/
if(object) {
*(void **)object = fl->free_list;
fl->free_list = object;
/*
* Record the return of the node to the free-list.
*/
fl->nbusy--;
};
return NULL;
}
/*.......................................................................
* Return a count of the number of nodes that are currently allocated.
*
* Input:
* fl FreeList * The list to count wrt, or NULL.
* Output:
* return long The number of nodes (or 0 if fl==NULL).
*/
long _busy_FreeListNodes(FreeList *fl)
{
return fl ? fl->nbusy : 0;
}
/*.......................................................................
* Query the number of allocated nodes in the freelist which are
* currently unused.
*
* Input:
* fl FreeList * The list to count wrt, or NULL.
* Output:
* return long The number of unused nodes (or 0 if fl==NULL).
*/
long _idle_FreeListNodes(FreeList *fl)
{
return fl ? (fl->ntotal - fl->nbusy) : 0;
}
/*.......................................................................
* Allocate a new list of free-list nodes. On return the nodes will
* be linked together as a list starting with the node at the lowest
* address and ending with a NULL next pointer.
*
* Input:
* fl FreeList * The free-list to allocate the list for.
* Output:
* return FreeListBlock * The new linked block of free-list nodes,
* or NULL on error.
*/
static FreeListBlock *_new_FreeListBlock(FreeList *fl)
{
FreeListBlock *block; /* The new block to be returned */
/*
* Allocate the container.
*/
block = (FreeListBlock *) malloc(sizeof(FreeListBlock));
if(!block)
return NULL;
/*
* Before attempting any operation that might fail, initialize the
* container at least up to the point at which it can safely be passed
* to _del_FreeListBlock().
*/
block->next = NULL;
block->nodes = NULL;
/*
* Allocate the block of nodes.
*/
block->nodes = (char *) malloc(fl->node_size * fl->blocking_factor);
if(!block->nodes)
return _del_FreeListBlock(block);
/*
* Initialize the block as a linked list of FreeListNode's.
*/
_thread_FreeListBlock(fl, block);
/*
* Update the record of the number of nodes in the freelist.
*/
fl->ntotal += fl->blocking_factor;
return block;
}
/*.......................................................................
* Link each node of a freelist block to the node that follows it.
*
* Input:
* fl FreeList * The freelist that contains the block.
* block FreeListBlock * The block to be threaded.
*/
static void _thread_FreeListBlock(FreeList *fl, FreeListBlock *block)
{
char *mem = block->nodes;
int i;
for(i=0; iblocking_factor - 1; i++, mem += fl->node_size)
*(void **)mem = mem + fl->node_size; /* Link to the next node */
*(void **)mem = NULL; /* Terminate the list */
}
/*.......................................................................
* Delete a free-list block.
*
* Input:
* fl FreeListBlock * The block to be deleted, or NULL.
* Output:
* return FreeListBlock * Always NULL.
*/
static FreeListBlock *_del_FreeListBlock(FreeListBlock *fl)
{
if(fl) {
fl->next = NULL;
if(fl->nodes)
free(fl->nodes);
fl->nodes = NULL;
free(fl);
};
return NULL;
}
yuma123_2.14/libtecla/ioutil.c 0000664 0001750 0001750 00000030260 14770023131 016354 0 ustar vladimir vladimir /*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
#include
#include
#include
#include
#include
#include "ioutil.h"
static int _io_pad_line(GlWriteFn *write_fn, void *data, int c, int n);
/*.......................................................................
* Display a left-justified string over multiple terminal lines,
* taking account of the specified width of the terminal. Optional
* indentation and an option prefix string can be specified to be
* displayed at the start of each new terminal line used, and if
* needed, a single paragraph can be broken across multiple calls.
* Note that literal newlines in the input string can be used to force
* a newline at any point, and that in order to allow individual
* paragraphs to be written using multiple calls to this function,
* unless an explicit newline character is specified at the end of the
* string, a newline will not be started at the end of the last word
* in the string. Note that when a new line is started between two
* words that are separated by spaces, those spaces are not output,
* whereas when a new line is started because a newline character was
* found in the string, only the spaces before the newline character
* are discarded.
*
* Input:
* write_fn GlWriteFn * The callback function to use to write the
* output.
* data void * A pointer to arbitrary data to be passed to
* write_fn() whenever it is called.
* fp FILE * The stdio stream to write to.
* indentation int The number of fill characters to use to
* indent the start of each new terminal line.
* prefix const char * An optional prefix string to write after the
* indentation margin at the start of each new
* terminal line. You can specify NULL if no
* prefix is required.
* suffix const char * An optional suffix string to draw at the end
* of the terminal line. The line will be padded
* where necessary to ensure that the suffix ends
* in the last column of the terminal line. If
* no suffix is desired, specify NULL.
* fill_char int The padding character to use when indenting
* and filling up to the suffix.
* term_width int The width of the terminal being written to.
* start int The number of characters already written to
* the start of the current terminal line. This
* is primarily used to allow individual
* paragraphs to be written over multiple calls
* to this function, but can also be used to
* allow you to start the first line of a
* paragraph with a different prefix or
* indentation than those specified above.
* string const char * The string to be written.
* Output:
* return int On error -1 is returned. Otherwise the
* return value is the terminal column index at
* which the cursor was left after writing the
* final word in the string. Successful return
* values can thus be passed verbatim to the
* 'start' arguments of subsequent calls to
* _io_display_text() to allow the printing of a
* paragraph to be broken across multiple calls
* to _io_display_text().
*/
int _io_display_text(GlWriteFn *write_fn, void *data, int indentation,
const char *prefix, const char *suffix, int fill_char,
int term_width, int start, const char *string)
{
int ndone; /* The number of characters written from string[] */
int nnew; /* The number of characters to be displayed next */
int was_space; /* True if the previous character was a space or tab */
int last = start; /* The column number of the last character written */
int prefix_len; /* The length of the optional line prefix string */
int suffix_len; /* The length of the optional line prefix string */
int margin_width; /* The total number of columns used by the indentation */
/* margin and the prefix string. */
int i;
/*
* Check the arguments?
*/
if(!string || !write_fn) {
errno = EINVAL;
return -1;
};
/*
* Enforce sensible values on the arguments.
*/
if(term_width < 0)
term_width = 0;
if(indentation > term_width)
indentation = term_width;
else if(indentation < 0)
indentation = 0;
if(start > term_width)
start = term_width;
else if(start < 0)
start = 0;
/*
* Get the length of the prefix string.
*/
prefix_len = prefix ? strlen(prefix) : 0;
/*
* Get the length of the suffix string.
*/
suffix_len = suffix ? strlen(suffix) : 0;
/*
* How many characters are devoted to indenting and prefixing each line?
*/
margin_width = indentation + prefix_len;
/*
* Write as many terminal lines as are needed to display the whole string.
*/
for(ndone=0; string[ndone]; start=0) {
last = start;
/*
* Write spaces from the current position in the terminal line to the
* width of the requested indentation margin.
*/
if(indentation > 0 && last < indentation) {
if(_io_pad_line(write_fn, data, fill_char, indentation - last))
return -1;
last = indentation;
};
/*
* If a prefix string has been specified, display it unless we have
* passed where it should end in the terminal output line.
*/
if(prefix_len > 0 && last < margin_width) {
int pstart = last - indentation;
int plen = prefix_len - pstart;
if(write_fn(data, prefix+pstart, plen) != plen)
return -1;
last = margin_width;
};
/*
* Locate the end of the last complete word in the string before
* (term_width - start) characters have been seen. To handle the case
* where a single word is wider than the available space after the
* indentation and prefix margins, always make sure that at least one
* word is printed after the margin, regardless of whether it won't
* fit on the line. The two exceptions to this rule are if an embedded
* newline is found in the string or the end of the string is reached
* before any word has been seen.
*/
nnew = 0;
was_space = 0;
for(i=ndone; string[i] && (last+i-ndone < term_width - suffix_len ||
(nnew==0 && last==margin_width)); i++) {
if(string[i] == '\n') {
if(!was_space)
nnew = i-ndone;
break;
} else if(isspace((int) string[i])) {
if(!was_space) {
nnew = i-ndone+1;
was_space = 1;
};
} else {
was_space = 0;
};
};
/*
* Does the end of the string delimit the last word that will fit on the
* output line?
*/
if(nnew==0 && string[i] == '\0')
nnew = i-ndone;
/*
* Write the new line.
*/
if(write_fn(data, string+ndone, nnew) != nnew)
return -1;
ndone += nnew;
last += nnew;
/*
* Start a newline unless we have reached the end of the input string.
* In the latter case, in order to give the caller the chance to
* concatenate multiple calls to _io_display_text(), omit the newline,
* leaving it up to the caller to write this.
*/
if(string[ndone] != '\0') {
/*
* If a suffix has been provided, pad out the end of the line with spaces
* such that the suffix will end in the right-most terminal column.
*/
if(suffix_len > 0) {
int npad = term_width - suffix_len - last;
if(npad > 0 && _io_pad_line(write_fn, data, fill_char, npad))
return -1;
last += npad;
if(write_fn(data, suffix, suffix_len) != suffix_len)
return -1;
last += suffix_len;
};
/*
* Start a new line.
*/
if(write_fn(data, "\n", 1) != 1)
return -1;
/*
* Skip any spaces and tabs that follow the last word that was written.
*/
while(string[ndone] && isspace((int)string[ndone]) &&
string[ndone] != '\n')
ndone++;
/*
* If the terminating character was a literal newline character,
* skip it in the input string, since we just wrote it.
*/
if(string[ndone] == '\n')
ndone++;
last = 0;
};
};
/*
* Return the column number of the last character printed.
*/
return last;
}
/*.......................................................................
* Write a given number of spaces to the specified stdio output string.
*
* Input:
* write_fn GlWriteFn * The callback function to use to write the
* output.
* data void * A pointer to arbitrary data to be passed to
* write_fn() whenever it is called.
* c int The padding character.
* n int The number of spaces to be written.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int _io_pad_line(GlWriteFn *write_fn, void *data, int c, int n)
{
enum {FILL_SIZE=20};
char fill[FILL_SIZE+1];
/*
* Fill the buffer with the specified padding character.
*/
memset(fill, c, FILL_SIZE);
fill[FILL_SIZE] = '\0';
/*
* Write the spaces using the above literal string of spaces as
* many times as needed to output the requested number of spaces.
*/
while(n > 0) {
int nnew = n <= FILL_SIZE ? n : FILL_SIZE;
if(write_fn(data, fill, nnew) != nnew)
return 1;
n -= nnew;
};
return 0;
}
/*.......................................................................
* The following is an output callback function which uses fwrite()
* to write to the stdio stream specified via its callback data argument.
*
* Input:
* data void * The stdio stream to write to, specified via a
* (FILE *) pointer cast to (void *).
* s const char * The string to be written.
* n int The length of the prefix of s[] to attempt to
* write.
* Output:
* return int The number of characters written from s[]. This
* should normally be a number in the range 0 to n.
* To signal that an I/O error occurred, return -1.
*/
GL_WRITE_FN(_io_write_stdio)
{
int ndone; /* The total number of characters written */
int nnew; /* The number of characters written in the latest write */
/*
* The callback data is the stdio stream to write to.
*/
FILE *fp = (FILE *) data;
/*
* Because of signals we may need to do more than one write to output
* the whole string.
*/
for(ndone=0; ndone
#include
#include
#include
#include
#include "hash.h"
#include "strngmem.h"
#include "freelist.h"
/*
* The following container object contains free-lists to be used
* for allocation of HashTable containers and nodes.
*/
struct HashMemory {
FreeList *hash_memory; /* HashTable free-list */
FreeList *node_memory; /* HashNode free-list */
StringMem *string_memory; /* Memory used to allocate hash strings */
};
/*
* Define a hash symbol-table entry.
* See symbol.h for the definition of the Symbol container type.
*/
typedef struct HashNode HashNode;
struct HashNode {
Symbol symbol; /* The symbol stored in the hash-entry */
HashNode *next; /* The next hash-table entry in a bucket list */
};
/*
* Each hash-table bucket contains a linked list of entries that
* hash to the same bucket.
*/
typedef struct {
HashNode *head; /* The head of the bucket hash-node list */
int count; /* The number of entries in the list */
} HashBucket;
/*
* A hash-table consists of 'size' hash buckets.
* Note that the HashTable typedef for this struct is contained in hash.h.
*/
struct HashTable {
HashMemory *mem; /* HashTable free-list */
int internal_mem; /* True if 'mem' was allocated by _new_HashTable() */
int case_sensitive; /* True if case is significant in lookup keys */
int size; /* The number of hash buckets */
HashBucket *bucket; /* An array of 'size' hash buckets */
int (*keycmp)(const char *, const char *); /* Key comparison function */
void *app_data; /* Application-provided data */
HASH_DEL_FN(*del_fn); /* Application-provided 'app_data' destructor */
};
static HashNode *_del_HashNode(HashTable *hash, HashNode *node);
static HashNode *_new_HashNode(HashTable *hash, const char *name, int code,
void (*fn)(void), void *data, SYM_DEL_FN(*del_fn));
static HashNode *_find_HashNode(HashTable *hash, HashBucket *bucket,
const char *name, HashNode **prev);
static HashBucket *_find_HashBucket(HashTable *hash, const char *name);
static int _ht_lower_strcmp(const char *node_key, const char *look_key);
static int _ht_strcmp(const char *node_key, const char *look_key);
/*.......................................................................
* Allocate a free-list for use in allocating hash tables and their nodes.
*
* Input:
* list_count int The number of HashTable containers per free-list
* block.
* node_count int The number of HashTable nodes per free-list block.
* Output:
* return HashMemory * The new free-list for use in allocating hash tables
* and their nodes.
*/
HashMemory *_new_HashMemory(int hash_count, int node_count)
{
HashMemory *mem;
/*
* Allocate the free-list container.
*/
mem = (HashMemory *) malloc(sizeof(HashMemory));
if(!mem) {
errno = ENOMEM;
return NULL;
};
/*
* Initialize the container at least up to the point at which it can
* safely be passed to _del_HashMemory().
*/
mem->hash_memory = NULL;
mem->node_memory = NULL;
mem->string_memory = NULL;
/*
* Allocate the two free-lists.
*/
mem->hash_memory = _new_FreeList(sizeof(HashTable), hash_count);
if(!mem->hash_memory)
return _del_HashMemory(mem, 1);
mem->node_memory = _new_FreeList(sizeof(HashNode), node_count);
if(!mem->node_memory)
return _del_HashMemory(mem, 1);
mem->string_memory = _new_StringMem(64);
if(!mem->string_memory)
return _del_HashMemory(mem, 1);
/*
* Return the free-list container.
*/
return mem;
}
/*.......................................................................
* Delete a HashTable free-list. An error will be displayed if the list is
* still in use and the deletion will be aborted.
*
* Input:
* mem HashMemory * The free-list container to be deleted.
* force int If force==0 then _del_HashMemory() will complain
* and refuse to delete the free-list if any
* of nodes have not been returned to the free-list.
* If force!=0 then _del_HashMemory() will not check
* whether any nodes are still in use and will
* always delete the list.
* Output:
* return HashMemory * Always NULL (even if the memory could not be
* deleted).
*/
HashMemory *_del_HashMemory(HashMemory *mem, int force)
{
if(mem) {
if(!force && (_busy_FreeListNodes(mem->hash_memory) > 0 ||
_busy_FreeListNodes(mem->node_memory) > 0)) {
errno = EBUSY;
return NULL;
};
mem->hash_memory = _del_FreeList(mem->hash_memory, force);
mem->node_memory = _del_FreeList(mem->node_memory, force);
mem->string_memory = _del_StringMem(mem->string_memory, force);
free(mem);
};
return NULL;
}
/*.......................................................................
* Create a new hash table.
*
* Input:
* mem HashMemory * An optional free-list for use in allocating
* HashTable containers and nodes. See explanation
* in hash.h. If you are going to allocate more
* than one hash table, then it will be more
* efficient to allocate a single free-list for
* all of them than to force each hash table
* to allocate its own private free-list.
* size int The size of the hash table. Best performance
* will be acheived if this is a prime number.
* hcase HashCase Specify how symbol case is considered when
* looking up symbols, from:
* IGNORE_CASE - Upper and lower case versions
* of a letter are treated as
* being identical.
* HONOUR_CASE - Upper and lower case versions
* of a letter are treated as
* being distinct.
* characters in a lookup name is significant.
* app_data void * Optional application data to be registered
* to the table. This is presented to user
* provided SYM_DEL_FN() symbol destructors along
* with the symbol data.
* del_fn() HASH_DEL_FN(*) If you want app_data to be free'd when the
* hash-table is destroyed, register a suitable
* destructor function here.
* Output:
* return HashTable * The new hash table, or NULL on error.
*/
HashTable *_new_HashTable(HashMemory *mem, int size, HashCase hcase,
void *app_data, HASH_DEL_FN(*del_fn))
{
HashTable *hash; /* The table to be returned */
int allocate_mem = !mem; /* True if mem should be internally allocated */
int i;
/*
* Check arguments.
*/
if(size <= 0) {
errno = EINVAL;
return NULL;
};
/*
* Allocate an internal free-list?
*/
if(allocate_mem) {
mem = _new_HashMemory(1, 100);
if(!mem)
return NULL;
};
/*
* Allocate the container.
*/
hash = (HashTable *) _new_FreeListNode(mem->hash_memory);
if(!hash) {
errno = ENOMEM;
if(allocate_mem)
mem = _del_HashMemory(mem, 1);
return NULL;
};
/*
* Before attempting any operation that might fail, initialize
* the container at least up to the point at which it can safely
* be passed to _del_HashTable().
*/
hash->mem = mem;
hash->internal_mem = allocate_mem;
hash->case_sensitive = hcase==HONOUR_CASE;
hash->size = size;
hash->bucket = NULL;
hash->keycmp = hash->case_sensitive ? _ht_strcmp : _ht_lower_strcmp;
hash->app_data = app_data;
hash->del_fn = del_fn;
/*
* Allocate the array of 'size' hash buckets.
*/
hash->bucket = (HashBucket *) malloc(sizeof(HashBucket) * size);
if(!hash->bucket) {
errno = ENOMEM;
return _del_HashTable(hash);
};
/*
* Initialize the bucket array.
*/
for(i=0; ibucket + i;
b->head = NULL;
b->count = 0;
};
/*
* The table is ready for use - albeit currently empty.
*/
return hash;
}
/*.......................................................................
* Delete a hash-table.
*
* Input:
* hash HashTable * The hash table to be deleted.
* Output:
* return HashTable * The deleted hash table (always NULL).
*/
HashTable *_del_HashTable(HashTable *hash)
{
if(hash) {
/*
* Clear and delete the bucket array.
*/
if(hash->bucket) {
_clear_HashTable(hash);
free(hash->bucket);
hash->bucket = NULL;
};
/*
* Delete application data.
*/
if(hash->del_fn)
hash->del_fn(hash->app_data);
/*
* If the hash table was allocated from an internal free-list, delete
* it and the hash table by deleting the free-list. Otherwise just
* return the hash-table to the external free-list.
*/
if(hash->internal_mem)
_del_HashMemory(hash->mem, 1);
else
hash = (HashTable *) _del_FreeListNode(hash->mem->hash_memory, hash);
};
return NULL;
}
/*.......................................................................
* Create and install a new entry in a hash table. If an entry with the
* same name already exists, replace its contents with the new data.
*
* Input:
* hash HashTable * The hash table to insert the symbol into.
* name const char * The name to tag the entry with.
* code int An application-specific code to be stored in
* the entry.
* fn void (*)(void) An application-specific function to be stored
* in the entry.
* data void * An application-specific pointer to data to be
* associated with the entry, or NULL if not
* relevant.
* del_fn SYM_DEL_FN(*) An optional destructor function. When the
* symbol is deleted this function will be called
* with the 'code' and 'data' arguments given
* above. Any application data that was registered
* to the table via the app_data argument of
* _new_HashTable() will also be passed.
* Output:
* return HashNode * The new entry, or NULL if there was insufficient
* memory or the arguments were invalid.
*/
Symbol *_new_HashSymbol(HashTable *hash, const char *name, int code,
void (*fn)(void), void *data, SYM_DEL_FN(*del_fn))
{
HashBucket *bucket; /* The hash-bucket associated with the name */
HashNode *node; /* The new node */
/*
* Check arguments.
*/
if(!hash || !name) {
errno = EINVAL;
return NULL;
};
/*
* Get the hash bucket of the specified name.
*/
bucket = _find_HashBucket(hash, name);
/*
* See if a node with the same name already exists.
*/
node = _find_HashNode(hash, bucket, name, NULL);
/*
* If found, delete its contents by calling the user-supplied
* destructor function, if provided.
*/
if(node) {
if(node->symbol.data && node->symbol.del_fn) {
node->symbol.data = node->symbol.del_fn(hash->app_data, node->symbol.code,
node->symbol.data);
};
/*
* Allocate a new node if necessary.
*/
} else {
node = _new_HashNode(hash, name, code, fn, data, del_fn);
if(!node)
return NULL;
};
/*
* Install the node at the head of the hash-bucket list.
*/
node->next = bucket->head;
bucket->head = node;
bucket->count++;
return &node->symbol;
}
/*.......................................................................
* Remove and delete a given hash-table entry.
*
* Input:
* hash HashTable * The hash table to find the symbol in.
* name const char * The name of the entry.
* Output:
* return HashNode * The deleted hash node (always NULL).
*/
Symbol *_del_HashSymbol(HashTable *hash, const char *name)
{
if(hash && name) {
HashBucket *bucket = _find_HashBucket(hash, name);
HashNode *prev; /* The node preceding the located node */
HashNode *node = _find_HashNode(hash, bucket, name, &prev);
/*
* Node found?
*/
if(node) {
/*
* Remove the node from the bucket list.
*/
if(prev) {
prev->next = node->next;
} else {
bucket->head = node->next;
};
/*
* Record the loss of a node.
*/
bucket->count--;
/*
* Delete the node.
*/
(void) _del_HashNode(hash, node);
};
};
return NULL;
}
/*.......................................................................
* Look up a symbol in the hash table.
*
* Input:
* hash HashTable * The table to look up the string in.
* name const char * The name of the symbol to look up.
* Output:
* return Symbol * The located hash-table symbol, or NULL if not
* found.
*/
Symbol *_find_HashSymbol(HashTable *hash, const char *name)
{
HashBucket *bucket; /* The hash-table bucket associated with name[] */
HashNode *node; /* The hash-table node of the requested symbol */
/*
* Check arguments.
*/
if(!hash)
return NULL;
/*
* Nothing to lookup?
*/
if(!name)
return NULL;
/*
* Hash the name to a hash-table bucket.
*/
bucket = _find_HashBucket(hash, name);
/*
* Find the bucket entry that exactly matches the name.
*/
node = _find_HashNode(hash, bucket, name, NULL);
if(!node)
return NULL;
return &node->symbol;
}
/*.......................................................................
* Private function used to allocate a hash-table node.
* The caller is responsible for checking that the specified symbol
* is unique and for installing the returned entry in the table.
*
* Input:
* hash HashTable * The table to allocate the node for.
* name const char * The name of the new entry.
* code int A user-supplied context code.
* fn void (*)(void) A user-supplied function pointer.
* data void * A user-supplied data pointer.
* del_fn SYM_DEL_FN(*) An optional 'data' destructor function.
* Output:
* return HashNode * The new node, or NULL on error.
*/
static HashNode *_new_HashNode(HashTable *hash, const char *name, int code,
void (*fn)(void), void *data, SYM_DEL_FN(*del_fn))
{
HashNode *node; /* The new node */
/*
* Allocate the new node from the free list.
*/
node = (HashNode *) _new_FreeListNode(hash->mem->node_memory);
if(!node)
return NULL;
/*
* Before attempting any operation that might fail, initialize the
* contents of 'node' at least up to the point at which it can be
* safely passed to _del_HashNode().
*/
node->symbol.name = NULL;
node->symbol.code = code;
node->symbol.fn = fn;
node->symbol.data = data;
node->symbol.del_fn = del_fn;
node->next = NULL;
/*
* Allocate a copy of 'name'.
*/
node->symbol.name = _new_StringMemString(hash->mem->string_memory,
strlen(name) + 1);
if(!node->symbol.name)
return _del_HashNode(hash, node);
/*
* If character-case is insignificant in the current table, convert the
* name to lower case while copying it.
*/
if(hash->case_sensitive) {
strcpy(node->symbol.name, name);
} else {
const char *src = name;
char *dst = node->symbol.name;
for( ; *src; src++,dst++)
*dst = tolower(*src);
*dst = '\0';
};
return node;
}
/*.......................................................................
* Private function used to delete a hash-table node.
* The node must have been removed from its list before calling this
* function.
*
* Input:
* hash HashTable * The table for which the node was originally
* allocated.
* node HashNode * The node to be deleted.
* Output:
* return HashNode * The deleted node (always NULL).
*/
static HashNode *_del_HashNode(HashTable *hash, HashNode *node)
{
if(node) {
node->symbol.name = _del_StringMemString(hash->mem->string_memory,
node->symbol.name);
/*
* Call the user-supplied data-destructor if provided.
*/
if(node->symbol.data && node->symbol.del_fn)
node->symbol.data = node->symbol.del_fn(hash->app_data,
node->symbol.code,
node->symbol.data);
/*
* Return the node to the free-list.
*/
node->next = NULL;
node = (HashNode *) _del_FreeListNode(hash->mem->node_memory, node);
};
return NULL;
}
/*.......................................................................
* Private function to locate the hash bucket associated with a given
* name.
*
* This uses a hash-function described in the dragon-book
* ("Compilers - Principles, Techniques and Tools", by Aho, Sethi and
* Ullman; pub. Adison Wesley) page 435.
*
* Input:
* hash HashTable * The table to look up the string in.
* name const char * The name of the symbol to look up.
* Output:
* return HashBucket * The located hash-bucket.
*/
static HashBucket *_find_HashBucket(HashTable *hash, const char *name)
{
unsigned const char *kp;
unsigned long h = 0L;
if(hash->case_sensitive) {
for(kp=(unsigned const char *) name; *kp; kp++)
h = 65599UL * h + *kp; /* 65599 is a prime close to 2^16 */
} else {
for(kp=(unsigned const char *) name; *kp; kp++)
h = 65599UL * h + tolower((int)*kp); /* 65599 is a prime close to 2^16 */
};
return hash->bucket + (h % hash->size);
}
/*.......................................................................
* Search for a given name in the entries of a given bucket.
*
* Input:
* hash HashTable * The hash-table being searched.
* bucket HashBucket * The bucket to search (use _find_HashBucket()).
* name const char * The name to search for.
* Output:
* prev HashNode ** If prev!=NULL then the pointer to the node
* preceding the located node in the list will
* be recorded in *prev. This will be NULL either
* if the name is not found or the located node is
* at the head of the list of entries.
* return HashNode * The located hash-table node, or NULL if not
* found.
*/
static HashNode *_find_HashNode(HashTable *hash, HashBucket *bucket,
const char *name, HashNode **prev)
{
HashNode *last; /* The previously searched node */
HashNode *node; /* The node that is being searched */
/*
* Search the list for a node containing the specified name.
*/
for(last=NULL, node=bucket->head;
node && hash->keycmp(node->symbol.name, name)!=0;
last = node, node=node->next)
;
if(prev)
*prev = node ? last : NULL;
return node;
}
/*.......................................................................
* When hash->case_sensitive is zero this function is called
* in place of strcmp(). In such cases the hash-table names are stored
* as lower-case versions of the original strings so this function
* performs the comparison against lower-case copies of the characters
* of the string being compared.
*
* Input:
* node_key const char * The lower-case hash-node key being compared
* against.
* look_key const char * The lookup key.
* Output:
* return int <0 if node_key < look_key.
* 0 if node_key == look_key.
* >0 if node_key > look_key.
*/
static int _ht_lower_strcmp(const char *node_key, const char *look_key)
{
int cn; /* The latest character from node_key[] */
int cl; /* The latest character from look_key[] */
do {
cn = *node_key++;
cl = *look_key++;
} while(cn && cn==tolower(cl));
return cn - tolower(cl);
}
/*.......................................................................
* This is a wrapper around strcmp for comparing hash-keys in a case
* sensitive manner. The reason for having this wrapper, instead of using
* strcmp() directly, is to make some C++ compilers happy. The problem
* is that when the library is compiled with a C++ compiler, the
* declaration of the comparison function is a C++ declaration, whereas
* strcmp() is a pure C function and thus although it appears to have the
* same declaration, the compiler disagrees.
*
* Input:
* node_key char * The lower-case hash-node key being compared against.
* look_key char * The lookup key.
* Output:
* return int <0 if node_key < look_key.
* 0 if node_key == look_key.
* >0 if node_key > look_key.
*/
static int _ht_strcmp(const char *node_key, const char *look_key)
{
return strcmp(node_key, look_key);
}
/*.......................................................................
* Empty a hash-table by deleting all of its entries.
*
* Input:
* hash HashTable * The hash table to clear.
* Output:
* return int 0 - OK.
* 1 - Invalid arguments.
*/
int _clear_HashTable(HashTable *hash)
{
int i;
/*
* Check the arguments.
*/
if(!hash)
return 1;
/*
* Clear the contents of the bucket array.
*/
for(i=0; isize; i++) {
HashBucket *bucket = hash->bucket + i;
/*
* Delete the list of active hash nodes from the bucket.
*/
HashNode *node = bucket->head;
while(node) {
HashNode *next = node->next;
(void) _del_HashNode(hash, node);
node = next;
};
/*
* Mark the bucket as empty.
*/
bucket->head = NULL;
bucket->count = 0;
};
return 0;
}
/*.......................................................................
* Execute a given function on each entry of a hash table, returning
* before completion if the the specified function returns non-zero.
*
* Input:
* hash HashTable * The table to traverse.
* scan_fn HASH_SCAN_FN(*) The function to call.
* context void * Optional caller-specific context data
* to be passed to scan_fn().
* Output:
* return int 0 - OK.
* 1 - Either the arguments were invalid, or
* scan_fn() returned non-zero at some
* point.
*/
int _scan_HashTable(HashTable *hash, HASH_SCAN_FN(*scan_fn), void *context)
{
int i;
/*
* Check the arguments.
*/
if(!hash || !scan_fn)
return 1;
/*
* Iterate through the buckets of the table.
*/
for(i=0; isize; i++) {
HashBucket *bucket = hash->bucket + i;
HashNode *node;
/*
* Iterate through the list of symbols that fall into bucket i,
* passing each one to the caller-specified function.
*/
for(node=bucket->head; node; node=node->next) {
if(scan_fn(&node->symbol, context))
return 1;
};
};
return 0;
}
yuma123_2.14/libtecla/cplmatch.c 0000664 0001750 0001750 00000112263 14770023131 016646 0 ustar vladimir vladimir /*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
/*
* Standard includes.
*/
#include
#include
#include
#include
/*
* Local includes.
*/
#include "libtecla.h"
#include "ioutil.h"
#include "stringrp.h"
#include "pathutil.h"
#include "cplfile.h"
#include "cplmatch.h"
#include "errmsg.h"
/*
* Specify the number of strings to allocate when the string free-list
* is exhausted. This also sets the number of elements to expand the
* matches[] array by whenever it is found to be too small.
*/
#define STR_BLK_FACT 100
/*
* Set the default number of spaces place between columns when listing
* a set of completions.
*/
#define CPL_COL_SEP 2
/*
* Completion matches are recorded in containers of the following
* type.
*/
struct WordCompletion {
ErrMsg *err; /* The error reporting buffer */
StringGroup *sg; /* Memory for a group of strings */
int matches_dim; /* The allocated size of result.matches[] */
CplMatches result; /* Completions to be returned to the caller */
#ifndef WITHOUT_FILE_SYSTEM
CompleteFile *cf; /* The resources used for filename completion */
#endif
};
static void cpl_sort_matches(WordCompletion *cpl);
static void cpl_zap_duplicates(WordCompletion *cpl);
static void cpl_clear_completions(WordCompletion *cpl);
static int cpl_cmp_matches(const void *v1, const void *v2);
static int cpl_cmp_suffixes(const void *v1, const void *v2);
/*
* The new_CplFileConf() constructor sets the integer first member of
* the returned object to the following magic number. On seeing this,
* cpl_file_completions() knows when it is passed a valid CplFileConf
* object.
*/
#define CFC_ID_CODE 4568
#ifndef WITHOUT_FILE_SYSTEM
/*
* A pointer to a structure of the following type can be passed to
* the builtin file-completion callback function to modify its behavior.
*/
struct CplFileConf {
int id; /* new_CplFileConf() sets this to CFC_ID_CODE */
int escaped; /* If none-zero, backslashes in the input line are */
/* interpreted as escaping special characters and */
/* spaces, and any special characters and spaces in */
/* the listed completions will also be escaped with */
/* added backslashes. This is the default behaviour. */
/* If zero, backslashes are interpreted as being */
/* literal parts of the filename, and none are added */
/* to the completion suffixes. */
int file_start; /* The index in the input line of the first character */
/* of the filename. If you specify -1 here, */
/* cpl_file_completions() identifies the */
/* the start of the filename by looking backwards for */
/* an unescaped space, or the beginning of the line. */
CplCheckFn *chk_fn; /* If not zero, this argument specifies a */
/* function to call to ask whether a given */
/* file should be included in the list */
/* of completions. */
void *chk_data; /* Anonymous data to be passed to check_fn(). */
};
static void cpl_init_FileConf(CplFileConf *cfc);
/*
* When file-system access is being excluded, define a dummy structure
* to satisfy the typedef in libtecla.h.
*/
#else
struct CplFileConf {int dummy;};
#endif
/*
* Encapsulate the formatting information needed to layout a
* multi-column listing of completions.
*/
typedef struct {
int term_width; /* The width of the terminal (characters) */
int column_width; /* The number of characters within in each column. */
int ncol; /* The number of columns needed */
int nline; /* The number of lines needed */
} CplListFormat;
/*
* Given the current terminal width, and a list of completions, determine
* how to best use the terminal width to display a multi-column listing
* of completions.
*/
static void cpl_plan_listing(CplMatches *result, int term_width,
CplListFormat *fmt);
/*
* Display a given line of a multi-column list of completions.
*/
static int cpl_format_line(CplMatches *result, CplListFormat *fmt, int lnum,
GlWriteFn *write_fn, void *data);
/*.......................................................................
* Create a new string-completion object.
*
* Output:
* return WordCompletion * The new object, or NULL on error.
*/
WordCompletion *new_WordCompletion(void)
{
WordCompletion *cpl; /* The object to be returned */
/*
* Allocate the container.
*/
cpl = (WordCompletion *) malloc(sizeof(WordCompletion));
if(!cpl) {
errno = ENOMEM;
return NULL;
};
/*
* Before attempting any operation that might fail, initialize the
* container at least up to the point at which it can safely be passed
* to del_WordCompletion().
*/
cpl->err = NULL;
cpl->sg = NULL;
cpl->matches_dim = 0;
cpl->result.suffix = NULL;
cpl->result.cont_suffix = NULL;
cpl->result.matches = NULL;
cpl->result.nmatch = 0;
#ifndef WITHOUT_FILE_SYSTEM
cpl->cf = NULL;
#endif
/*
* Allocate a place to record error messages.
*/
cpl->err = _new_ErrMsg();
if(!cpl->err)
return del_WordCompletion(cpl);
/*
* Allocate an object that allows a group of strings to be allocated
* efficiently by placing many of them in contiguous string segments.
*/
#ifdef WITHOUT_FILE_SYSTEM
cpl->sg = _new_StringGroup(MAX_PATHLEN_FALLBACK);
#else
cpl->sg = _new_StringGroup(_pu_pathname_dim());
#endif
if(!cpl->sg)
return del_WordCompletion(cpl);
/*
* Allocate an array for matching completions. This will be extended later
* if needed.
*/
cpl->matches_dim = STR_BLK_FACT;
cpl->result.matches = (CplMatch *) malloc(sizeof(cpl->result.matches[0]) *
cpl->matches_dim);
if(!cpl->result.matches) {
errno = ENOMEM;
return del_WordCompletion(cpl);
};
/*
* Allocate a filename-completion resource object.
*/
#ifndef WITHOUT_FILE_SYSTEM
cpl->cf = _new_CompleteFile();
if(!cpl->cf)
return del_WordCompletion(cpl);
#endif
return cpl;
}
/*.......................................................................
* Delete a string-completion object.
*
* Input:
* cpl WordCompletion * The object to be deleted.
* Output:
* return WordCompletion * The deleted object (always NULL).
*/
WordCompletion *del_WordCompletion(WordCompletion *cpl)
{
if(cpl) {
cpl->err = _del_ErrMsg(cpl->err);
cpl->sg = _del_StringGroup(cpl->sg);
if(cpl->result.matches) {
free(cpl->result.matches);
cpl->result.matches = NULL;
#ifndef WITHOUT_FILE_SYSTEM
cpl->cf = _del_CompleteFile(cpl->cf);
#endif
};
free(cpl);
};
return NULL;
}
/*.......................................................................
* This function is designed to be called by CplMatchFn callback
* functions. It adds one possible completion of the token that is being
* completed to an array of completions. If the completion needs any
* special quoting to be valid when displayed in the input line, this
* quoting must be included in the string.
*
* Input:
* cpl WordCompletion * The argument of the same name that was passed
* to the calling CplMatchFn callback function.
* line const char * The input line, as received by the callback
* function.
* word_start int The index within line[] of the start of the
* word that is being completed.
* word_end int The index within line[] of the character which
* follows the incomplete word, as received by the
* calling callback function.
* suffix const char * The appropriately quoted string that could
* be appended to the incomplete token to complete
* it. A copy of this string will be allocated
* internally.
* type_suffix const char * When listing multiple completions, gl_get_line()
* appends this string to the completion to indicate
* its type to the user. If not pertinent pass "".
* Otherwise pass a literal or static string.
* cont_suffix const char * If this turns out to be the only completion,
* gl_get_line() will append this string as
* a continuation. For example, the builtin
* file-completion callback registers a directory
* separator here for directory matches, and a
* space otherwise. If the match were a function
* name you might want to append an open
* parenthesis, etc.. If not relevant pass "".
* Otherwise pass a literal or static string.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
int cpl_add_completion(WordCompletion *cpl, const char *line,
int word_start, int word_end, const char *suffix,
const char *type_suffix, const char *cont_suffix)
{
CplMatch *match; /* The container of the new match */
char *string; /* A newly allocated copy of the completion string */
/*
* Check the arguments.
*/
if(!cpl)
return 1;
if(!suffix)
return 0;
if(!type_suffix)
type_suffix = "";
if(!cont_suffix)
cont_suffix = "";
/*
* Do we need to extend the array of matches[]?
*/
if(cpl->result.nmatch+1 > cpl->matches_dim) {
int needed = cpl->matches_dim + STR_BLK_FACT;
CplMatch *matches = (CplMatch *) realloc(cpl->result.matches,
sizeof(cpl->result.matches[0]) * needed);
if(!matches) {
_err_record_msg(cpl->err,
"Insufficient memory to extend array of matches.",
END_ERR_MSG);
return 1;
};
cpl->result.matches = matches;
cpl->matches_dim = needed;
};
/*
* Allocate memory to store the combined completion prefix and the
* new suffix.
*/
string = _sg_alloc_string(cpl->sg, word_end-word_start + strlen(suffix));
if(!string) {
_err_record_msg(cpl->err, "Insufficient memory to extend array of matches.",
END_ERR_MSG);
return 1;
};
/*
* Compose the string.
*/
strncpy(string, line + word_start, word_end - word_start);
strcpy(string + word_end - word_start, suffix);
/*
* Record the new match.
*/
match = cpl->result.matches + cpl->result.nmatch++;
match->completion = string;
match->suffix = string + word_end - word_start;
match->type_suffix = type_suffix;
/*
* Record the continuation suffix.
*/
cpl->result.cont_suffix = cont_suffix;
return 0;
}
/*.......................................................................
* Sort the array of matches.
*
* Input:
* cpl WordCompletion * The completion resource object.
*/
static void cpl_sort_matches(WordCompletion *cpl)
{
qsort(cpl->result.matches, cpl->result.nmatch,
sizeof(cpl->result.matches[0]), cpl_cmp_matches);
}
/*.......................................................................
* This is a qsort() comparison function used to sort matches.
*
* Input:
* v1, v2 void * Pointers to the two matches to be compared.
* Output:
* return int -1 -> v1 < v2.
* 0 -> v1 == v2
* 1 -> v1 > v2
*/
static int cpl_cmp_matches(const void *v1, const void *v2)
{
const CplMatch *m1 = (const CplMatch *) v1;
const CplMatch *m2 = (const CplMatch *) v2;
return strcmp(m1->completion, m2->completion);
}
/*.......................................................................
* Sort the array of matches in order of their suffixes.
*
* Input:
* cpl WordCompletion * The completion resource object.
*/
static void cpl_sort_suffixes(WordCompletion *cpl)
{
qsort(cpl->result.matches, cpl->result.nmatch,
sizeof(cpl->result.matches[0]), cpl_cmp_suffixes);
}
/*.......................................................................
* This is a qsort() comparison function used to sort matches in order of
* their suffixes.
*
* Input:
* v1, v2 void * Pointers to the two matches to be compared.
* Output:
* return int -1 -> v1 < v2.
* 0 -> v1 == v2
* 1 -> v1 > v2
*/
static int cpl_cmp_suffixes(const void *v1, const void *v2)
{
const CplMatch *m1 = (const CplMatch *) v1;
const CplMatch *m2 = (const CplMatch *) v2;
return strcmp(m1->suffix, m2->suffix);
}
/*.......................................................................
* Find the common prefix of all of the matching completion matches,
* and record a pointer to it in cpl->result.suffix. Note that this has
* the side effect of sorting the matches into suffix order.
*
* Input:
* cpl WordCompletion * The completion resource object.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int cpl_common_suffix(WordCompletion *cpl)
{
CplMatches *result; /* The result container */
const char *first, *last; /* The first and last matching suffixes */
int length; /* The length of the common suffix */
/*
* Get the container of the array of matching files.
*/
result = &cpl->result;
/*
* No matching completions?
*/
if(result->nmatch < 1)
return 0;
/*
* Sort th matches into suffix order.
*/
cpl_sort_suffixes(cpl);
/*
* Given that the array of matches is sorted, the first and last
* suffixes are those that differ most in their prefixes, so the common
* prefix of these strings is the longest common prefix of all of the
* suffixes.
*/
first = result->matches[0].suffix;
last = result->matches[result->nmatch - 1].suffix;
/*
* Find the point at which the first and last matching strings
* first difffer.
*/
while(*first && *first == *last) {
first++;
last++;
};
/*
* How long is the common suffix?
*/
length = first - result->matches[0].suffix;
/*
* Allocate memory to record the common suffix.
*/
result->suffix = _sg_alloc_string(cpl->sg, length);
if(!result->suffix) {
_err_record_msg(cpl->err,
"Insufficient memory to record common completion suffix.",
END_ERR_MSG);
return 1;
};
/*
* Record the common suffix.
*/
strncpy(result->suffix, result->matches[0].suffix, length);
result->suffix[length] = '\0';
return 0;
}
/*.......................................................................
* Discard the contents of the array of possible completion matches.
*
* Input:
* cpl WordCompletion * The word-completion resource object.
*/
static void cpl_clear_completions(WordCompletion *cpl)
{
/*
* Discard all of the strings.
*/
_clr_StringGroup(cpl->sg);
/*
* Record the fact that the array is now empty.
*/
cpl->result.nmatch = 0;
cpl->result.suffix = NULL;
cpl->result.cont_suffix = "";
/*
* Also clear the error message.
*/
_err_clear_msg(cpl->err);
return;
}
/*.......................................................................
* Given an input line and the point at which it completion is to be
* attempted, return an array of possible completions.
*
* Input:
* cpl WordCompletion * The completion resource object.
* line char * The current input line.
* word_end int The index of the character in line[] which
* follows the end of the token that is being
* completed.
* data void * Anonymous 'data' to be passed to match_fn().
* match_fn CplMatchFn * The function that will identify the prefix
* to be completed from the input line, and
* record completion matches.
* Output:
* return CplMatches * The container of the array of possible
* completions. The returned pointer refers
* to a container owned by the parent WordCompletion
* object, and its contents thus potentially
* change on every call to cpl_matches().
* On error, NULL is returned, and a description
* of the error can be acquired by calling
* cpl_last_error(cpl).
*/
CplMatches *cpl_complete_word(WordCompletion *cpl, const char *line,
int word_end, void *data,
CplMatchFn *match_fn)
{
int line_len; /* The total length of the input line */
/*
* How long is the input line?
*/
line_len = strlen(line);
/*
* Check the arguments.
*/
if(!cpl || !line || !match_fn || word_end < 0 || word_end > line_len) {
if(cpl) {
_err_record_msg(cpl->err, "cpl_complete_word: Invalid arguments.",
END_ERR_MSG);
};
return NULL;
};
/*
* Clear the return container.
*/
cpl_clear_completions(cpl);
/*
* Have the matching function record possible completion matches in
* cpl->result.matches.
*/
if(match_fn(cpl, data, line, word_end)) {
if(_err_get_msg(cpl->err)[0] == '\0')
_err_record_msg(cpl->err, "Error completing word.", END_ERR_MSG);
return NULL;
};
/*
* Record a copy of the common initial part of all of the prefixes
* in cpl->result.common.
*/
if(cpl_common_suffix(cpl))
return NULL;
/*
* Sort the matches into lexicographic order.
*/
cpl_sort_matches(cpl);
/*
* Discard any duplicate matches.
*/
cpl_zap_duplicates(cpl);
/*
* If there is more than one match, discard the continuation suffix.
*/
if(cpl->result.nmatch > 1)
cpl->result.cont_suffix = "";
/*
* Return the array of matches.
*/
return &cpl->result;
}
/*.......................................................................
* Recall the return value of the last call to cpl_complete_word().
*
* Input:
* cpl WordCompletion * The completion resource object.
* Output:
* return CplMatches * The container of the array of possible
* completions, as returned by the last call to
* cpl_complete_word(). The returned pointer refers
* to a container owned by the parent WordCompletion
* object, and its contents thus potentially
* change on every call to cpl_complete_word().
* On error, either in the execution of this
* function, or in the last call to
* cpl_complete_word(), NULL is returned, and a
* description of the error can be acquired by
* calling cpl_last_error(cpl).
*/
CplMatches *cpl_recall_matches(WordCompletion *cpl)
{
return (!cpl || *_err_get_msg(cpl->err)!='\0') ? NULL : &cpl->result;
}
/*.......................................................................
* Print out an array of matching completions.
*
* Input:
* result CplMatches * The container of the sorted array of
* completions.
* fp FILE * The output stream to write to.
* term_width int The width of the terminal.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
int cpl_list_completions(CplMatches *result, FILE *fp, int term_width)
{
return _cpl_output_completions(result, _io_write_stdio, fp, term_width);
}
/*.......................................................................
* Print an array of matching completions via a callback function.
*
* Input:
* result CplMatches * The container of the sorted array of
* completions.
* write_fn GlWriteFn * The function to call to write the completions,
* or 0 to discard the output.
* data void * Anonymous data to pass to write_fn().
* term_width int The width of the terminal.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
int _cpl_output_completions(CplMatches *result, GlWriteFn *write_fn, void *data,
int term_width)
{
CplListFormat fmt; /* List formatting information */
int lnum; /* The sequential number of the line to print next */
/*
* Not enough space to list anything?
*/
if(term_width < 1)
return 0;
/*
* Do we have a callback to write via, and any completions to be listed?
*/
if(write_fn && result && result->nmatch>0) {
/*
* Work out how to arrange the listing into fixed sized columns.
*/
cpl_plan_listing(result, term_width, &fmt);
/*
* Print the listing via the specified callback.
*/
for(lnum=0; lnum < fmt.nline; lnum++) {
if(cpl_format_line(result, &fmt, lnum, write_fn, data))
return 1;
};
};
return 0;
}
/*.......................................................................
* Return a description of the string-completion error that occurred.
*
* Input:
* cpl WordCompletion * The string-completion resource object.
* Output:
* return const char * The description of the last error.
*/
const char *cpl_last_error(WordCompletion *cpl)
{
return cpl ? _err_get_msg(cpl->err) : "NULL WordCompletion argument";
}
/*.......................................................................
* When an error occurs while performing a completion, you registerf a
* terse description of the error by calling cpl_record_error(). This
* message will then be returned on the next call to cpl_last_error().
*
* Input:
* cpl WordCompletion * The string-completion resource object that was
* originally passed to the callback.
* errmsg const char * The description of the error.
*/
void cpl_record_error(WordCompletion *cpl, const char *errmsg)
{
if(cpl && errmsg)
_err_record_msg(cpl->err, errmsg, END_ERR_MSG);
}
/*.......................................................................
* This is the builtin completion callback function which performs file
* completion.
*
* Input:
* cpl WordCompletion * An opaque pointer to the object that will
* contain the matches. This should be filled
* via zero or more calls to cpl_add_completion().
* data void * Either NULL to request the default
* file-completion behavior, or a pointer to a
* CplFileConf structure, whose members specify
* a different behavior.
* line char * The current input line.
* word_end int The index of the character in line[] which
* follows the end of the token that is being
* completed.
* Output
* return int 0 - OK.
* 1 - Error.
*/
CPL_MATCH_FN(cpl_file_completions)
{
#ifdef WITHOUT_FILE_SYSTEM
return 0;
#else
const char *start_path; /* The pointer to the start of the pathname */
/* in line[]. */
CplFileConf *conf; /* The new-style configuration object. */
/*
* The following configuration object will be used if the caller didn't
* provide one.
*/
CplFileConf default_conf;
/*
* This function can be called externally, so check its arguments.
*/
if(!cpl)
return 1;
if(!line || word_end < 0) {
_err_record_msg(cpl->err, "cpl_file_completions: Invalid arguments.",
END_ERR_MSG);
return 1;
};
/*
* The 'data' argument is either a CplFileConf pointer, identifiable
* by having an integer id code as its first member, or the deprecated
* CplFileArgs pointer, or can be NULL to request the default
* configuration.
*/
if(data && *(int *)data == CFC_ID_CODE) {
conf = (CplFileConf *) data;
} else {
/*
* Select the defaults.
*/
conf = &default_conf;
cpl_init_FileConf(&default_conf);
/*
* If we have been passed an instance of the deprecated CplFileArgs
* structure, copy its configuration parameters over the defaults.
*/
if(data) {
CplFileArgs *args = (CplFileArgs *) data;
conf->escaped = args->escaped;
conf->file_start = args->file_start;
};
};
/*
* Get the start of the filename. If not specified by the caller
* identify it by searching backwards in the input line for an
* unescaped space or the start of the line.
*/
if(conf->file_start < 0) {
start_path = _pu_start_of_path(line, word_end);
if(!start_path) {
_err_record_msg(cpl->err, "Unable to find the start of the filename.",
END_ERR_MSG);
return 1;
};
} else {
start_path = line + conf->file_start;
};
/*
* Perform the completion.
*/
if(_cf_complete_file(cpl, cpl->cf, line, start_path - line, word_end,
conf->escaped, conf->chk_fn, conf->chk_data)) {
cpl_record_error(cpl, _cf_last_error(cpl->cf));
return 1;
};
return 0;
#endif
}
/*.......................................................................
* Initialize a CplFileArgs structure with default configuration
* parameters. Note that the CplFileArgs configuration type is
* deprecated. The opaque CplFileConf object should be used in future
* applications.
*
* Input:
* cfa CplFileArgs * The configuration object of the
* cpl_file_completions() callback.
*/
void cpl_init_FileArgs(CplFileArgs *cfa)
{
if(cfa) {
cfa->escaped = 1;
cfa->file_start = -1;
};
}
#ifndef WITHOUT_FILE_SYSTEM
/*.......................................................................
* Initialize a CplFileConf structure with default configuration
* parameters.
*
* Input:
* cfc CplFileConf * The configuration object of the
* cpl_file_completions() callback.
*/
static void cpl_init_FileConf(CplFileConf *cfc)
{
if(cfc) {
cfc->id = CFC_ID_CODE;
cfc->escaped = 1;
cfc->file_start = -1;
cfc->chk_fn = 0;
cfc->chk_data = NULL;
};
}
#endif
/*.......................................................................
* Create a new CplFileConf object and initialize it with defaults.
*
* Output:
* return CplFileConf * The new object, or NULL on error.
*/
CplFileConf *new_CplFileConf(void)
{
#ifdef WITHOUT_FILE_SYSTEM
errno = EINVAL;
return NULL;
#else
CplFileConf *cfc; /* The object to be returned */
/*
* Allocate the container.
*/
cfc = (CplFileConf *)malloc(sizeof(CplFileConf));
if(!cfc)
return NULL;
/*
* Before attempting any operation that might fail, initialize the
* container at least up to the point at which it can safely be passed
* to del_CplFileConf().
*/
cpl_init_FileConf(cfc);
return cfc;
#endif
}
/*.......................................................................
* Delete a CplFileConf object.
*
* Input:
* cfc CplFileConf * The object to be deleted.
* Output:
* return CplFileConf * The deleted object (always NULL).
*/
CplFileConf *del_CplFileConf(CplFileConf *cfc)
{
#ifndef WITHOUT_FILE_SYSTEM
if(cfc) {
/*
* Delete the container.
*/
free(cfc);
};
#endif
return NULL;
}
/*.......................................................................
* If backslashes in the filename should be treated as literal
* characters, call the following function with literal=1. Otherwise
* the default is to treat them as escape characters, used for escaping
* spaces etc..
*
* Input:
* cfc CplFileConf * The cpl_file_completions() configuration object
* to be configured.
* literal int Pass non-zero here to enable literal interpretation
* of backslashes. Pass 0 to turn off literal
* interpretation.
*/
void cfc_literal_escapes(CplFileConf *cfc, int literal)
{
#ifndef WITHOUT_FILE_SYSTEM
if(cfc)
cfc->escaped = !literal;
#endif
}
/*.......................................................................
* Call this function if you know where the index at which the
* filename prefix starts in the input line. Otherwise by default,
* or if you specify start_index to be -1, the filename is taken
* to start after the first unescaped space preceding the cursor,
* or the start of the line, which ever comes first.
*
* Input:
* cfc CplFileConf * The cpl_file_completions() configuration object
* to be configured.
* start_index int The index of the start of the filename in
* the input line, or -1 to select the default.
*/
void cfc_file_start(CplFileConf *cfc, int start_index)
{
#ifndef WITHOUT_FILE_SYSTEM
if(cfc)
cfc->file_start = start_index;
#endif
}
/*.......................................................................
* If you only want certain types of files to be included in the
* list of completions, you use the following function to specify a
* callback function which will be called to ask whether a given file
* should be included.
*
* Input:
* cfc CplFileConf * The cpl_file_completions() configuration object
* to be configured.
* chk_fn CplCheckFn * Zero to disable filtering, or a pointer to a
* function that returns 1 if a given file should
* be included in the list of completions.
* chk_data void * Anonymous data to be passed to chk_fn()
* every time that it is called.
*/
void cfc_set_check_fn(CplFileConf *cfc, CplCheckFn *chk_fn, void *chk_data)
{
#ifndef WITHOUT_FILE_SYSTEM
if(cfc) {
cfc->chk_fn = chk_fn;
cfc->chk_data = chk_data;
};
#endif
}
/*.......................................................................
* The following CplCheckFn callback returns non-zero if the specified
* filename is that of an executable.
*/
CPL_CHECK_FN(cpl_check_exe)
{
#ifdef WITHOUT_FILE_SYSTEM
return 0;
#else
return _pu_path_is_exe(pathname);
#endif
}
/*.......................................................................
* Remove duplicates from a sorted array of matches.
*
* Input:
* cpl WordCompletion * The completion resource object.
*/
static void cpl_zap_duplicates(WordCompletion *cpl)
{
CplMatch *matches; /* The array of matches */
int nmatch; /* The number of elements in matches[] */
const char *completion; /* The completion string of the last unique match */
const char *type_suffix; /* The type of the last unique match */
int src; /* The index of the match being considered */
int dst; /* The index at which to record the next */
/* unique match. */
/*
* Get the array of matches and the number of matches that it
* contains.
*/
matches = cpl->result.matches;
nmatch = cpl->result.nmatch;
/*
* No matches?
*/
if(nmatch < 1)
return;
/*
* Initialize the comparison strings with the first match.
*/
completion = matches[0].completion;
type_suffix = matches[0].type_suffix;
/*
* Go through the array of matches, copying each new unrecorded
* match at the head of the array, while discarding duplicates.
*/
for(src=dst=1; srccompletion) != 0 ||
strcmp(type_suffix, match->type_suffix) != 0) {
if(src != dst)
matches[dst] = *match;
dst++;
completion = match->completion;
type_suffix = match->type_suffix;
};
};
/*
* Record the number of unique matches that remain.
*/
cpl->result.nmatch = dst;
return;
}
/*.......................................................................
* Work out how to arrange a given array of completions into a listing
* of one or more fixed size columns.
*
* Input:
* result CplMatches * The set of completions to be listed.
* term_width int The width of the terminal. A lower limit of
* zero is quietly enforced.
* Input/Output:
* fmt CplListFormat * The formatting information will be assigned
* to the members of *fmt.
*/
static void cpl_plan_listing(CplMatches *result, int term_width,
CplListFormat *fmt)
{
int maxlen; /* The length of the longest matching string */
int i;
/*
* Ensure that term_width >= 0.
*/
if(term_width < 0)
term_width = 0;
/*
* Start by assuming the worst case, that either nothing will fit
* on the screen, or that there are no matches to be listed.
*/
fmt->term_width = term_width;
fmt->column_width = 0;
fmt->nline = fmt->ncol = 0;
/*
* Work out the maximum length of the matching strings.
*/
maxlen = 0;
for(i=0; inmatch; i++) {
CplMatch *match = result->matches + i;
int len = strlen(match->completion) + strlen(match->type_suffix);
if(len > maxlen)
maxlen = len;
};
/*
* Nothing to list?
*/
if(maxlen == 0)
return;
/*
* Split the available terminal width into columns of
* maxlen + CPL_COL_SEP characters.
*/
fmt->column_width = maxlen;
fmt->ncol = fmt->term_width / (fmt->column_width + CPL_COL_SEP);
/*
* If the column width is greater than the terminal width, zero columns
* will have been selected. Set a lower limit of one column. Leave it
* up to the caller how to deal with completions who's widths exceed
* the available terminal width.
*/
if(fmt->ncol < 1)
fmt->ncol = 1;
/*
* How many lines of output will be needed?
*/
fmt->nline = (result->nmatch + fmt->ncol - 1) / fmt->ncol;
return;
}
/*.......................................................................
* Render one line of a multi-column listing of completions, using a
* callback function to pass the output to an arbitrary destination.
*
* Input:
* result CplMatches * The container of the sorted array of
* completions.
* fmt CplListFormat * Formatting information.
* lnum int The index of the line to print, starting
* from 0, and incrementing until the return
* value indicates that there is nothing more
* to be printed.
* write_fn GlWriteFn * The function to call to write the line, or
* 0 to discard the output.
* data void * Anonymous data to pass to write_fn().
* Output:
* return int 0 - Line printed ok.
* 1 - Nothing to print.
*/
static int cpl_format_line(CplMatches *result, CplListFormat *fmt, int lnum,
GlWriteFn *write_fn, void *data)
{
int col; /* The index of the list column being output */
/*
* If the line index is out of bounds, there is nothing to be written.
*/
if(lnum < 0 || lnum >= fmt->nline)
return 1;
/*
* If no output function has been provided, return as though the
* line had been printed.
*/
if(!write_fn)
return 0;
/*
* Print the matches in 'ncol' columns, sorted in line order within each
* column.
*/
for(col=0; col < fmt->ncol; col++) {
int m = col*fmt->nline + lnum;
/*
* Is there another match to be written? Note that in general
* the last line of a listing will have fewer filled columns
* than the initial lines.
*/
if(m < result->nmatch) {
CplMatch *match = result->matches + m;
/*
* How long are the completion and type-suffix strings?
*/
int clen = strlen(match->completion);
int tlen = strlen(match->type_suffix);
/*
* Write the completion string.
*/
if(write_fn(data, match->completion, clen) != clen)
return 1;
/*
* Write the type suffix, if any.
*/
if(tlen > 0 && write_fn(data, match->type_suffix, tlen) != tlen)
return 1;
/*
* If another column follows the current one, pad to its start with spaces.
*/
if(col+1 < fmt->ncol) {
/*
* The following constant string of spaces is used to pad the output.
*/
static const char spaces[] = " ";
static const int nspace = sizeof(spaces) - 1;
/*
* Pad to the next column, using as few sub-strings of the spaces[]
* array as possible.
*/
int npad = fmt->column_width + CPL_COL_SEP - clen - tlen;
while(npad>0) {
int n = npad > nspace ? nspace : npad;
if(write_fn(data, spaces + nspace - n, n) != n)
return 1;
npad -= n;
};
};
};
};
/*
* Start a new line.
*/
{
char s[] = "\r\n";
int n = strlen(s);
if(write_fn(data, s, n) != n)
return 1;
};
return 0;
}
yuma123_2.14/libtecla/LICENSE.TERMS 0000664 0001750 0001750 00000002755 14770023131 016611 0 ustar vladimir vladimir Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, and/or sell copies of the Software, and to permit persons
to whom the Software is furnished to do so, provided that the above
copyright notice(s) and this permission notice appear in all copies of
the Software and that both the above copyright notice(s) and this
permission notice appear in supporting documentation.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
Except as contained in this notice, the name of a copyright holder
shall not be used in advertising or otherwise to promote the sale, use
or other dealings in this Software without prior written authorization
of the copyright holder.
yuma123_2.14/libtecla/pathutil.h 0000664 0001750 0001750 00000010563 14770023131 016712 0 ustar vladimir vladimir #ifndef pathutil_h
#define pathutil_h
/*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
/*
* The following object encapsulates a buffer designed to be used to
* store pathnames. The pathname member of the object is initially
* allocated with the size that _pu_pathname_dim() returns, and then
* if this turns out to be pessimistic, the pathname can be reallocated
* via calls to pb_append_to_path() and/or pb_resize_path().
*/
typedef struct {
char *name; /* The path buffer */
size_t dim; /* The current allocated size of buffer[] */
} PathName;
PathName *_new_PathName(void);
PathName *_del_PathName(PathName *path);
char *_pn_clear_path(PathName *path);
char *_pn_append_to_path(PathName *path, const char *string, int slen,
int remove_escapes);
char *_pn_prepend_to_path(PathName *path, const char *string, int slen,
int remove_escapes);
char *_pn_resize_path(PathName *path, size_t length);
/*
* Search backwards for the potential start of a filename. This
* looks backwards from the specified index in a given string,
* stopping at the first unescaped space or the start of the line.
*/
char *_pu_start_of_path(const char *string, int back_from);
/*
* Find the end of a potential filename, starting from a given index
* in the string. This looks forwards from the specified index in a
* given string, stopping at the first unescaped space or the end
* of the line.
*/
char *_pu_end_of_path(const char *string, int start_from);
/*
* Return an estimate of the the length of the longest pathname
* on the local system.
*/
size_t _pu_pathname_dim(void);
/*
* Return non-zero if the specified path name refers to a directory.
*/
int _pu_path_is_dir(const char *pathname);
/*
* Return non-zero if the specified path name refers to a regular file.
*/
int _pu_path_is_file(const char *pathname);
/*
* Return non-zero if the specified path name refers to an executable.
*/
int _pu_path_is_exe(const char *pathname);
/*
* Return non-zero if a file exists with the specified pathname.
*/
int _pu_file_exists(const char *pathname);
/*
* If neither the POSIX PATH_MAX macro nor the pathconf() function
* can be used to find out the maximum pathlength on the target
* system, the following fallback maximum length is used.
*/
#define MAX_PATHLEN_FALLBACK 1024
/*
* If the pathname buffer turns out to be too small, it will be extended
* in chunks of the following amount (plus whatever is needed at the time).
*/
#define PN_PATHNAME_INC 100
/*
* Define the special character-sequences of the filesystem.
*/
#define FS_ROOT_DIR "/" /* The root directory */
#define FS_ROOT_DIR_LEN (sizeof(FS_ROOT_DIR) - 1)
#define FS_PWD "." /* The current working directory */
#define FS_PWD_LEN (sizeof(FS_PWD_LEN) - 1)
#define FS_DIR_SEP "/" /* The directory separator string */
#define FS_DIR_SEP_LEN (sizeof(FS_DIR_SEP) - 1)
#endif
yuma123_2.14/libtecla/hash.h 0000664 0001750 0001750 00000013464 14770023131 016006 0 ustar vladimir vladimir #ifndef hash_h
#define hash_h
/*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
/*
* The following macro can be used to prototype or define a
* function that deletes the data of a symbol-table entry.
*
* Input:
* app_data void * The _new_HashTable() app_data argument.
* code int The Symbol::code argument.
* sym_data void * The Symbol::data argument to be deleted.
* Output:
* return void * The deleted data (always return NULL).
*/
#define SYM_DEL_FN(fn) void *(fn)(void *app_data, int code, void *sym_data)
/*
* The following macro can be used to prototype or define a
* function that deletes the application-data of a hash-table.
*
* Input:
* data void * The _new_HashTable() 'app_data' argument to be
* deleted.
* Output:
* return void * The deleted data (always return NULL).
*/
#define HASH_DEL_FN(fn) void *(fn)(void *app_data)
/*
* The following is a container for recording the context
* of a symbol in a manner that is independant of the particular
* symbol-table implementation. Each hash-table entry contains
* the following user supplied parameters:
*
* 1. An optional integral parameter 'code'. This is useful for
* enumerating a symbol or for describing what type of data
* or function is stored in the symbol.
*
* 2. An optional generic function pointer. This is useful for
* associating functions with names. The user is responsible
* for casting between the generic function type and the
* actual function type. The code field could be used to
* enumerate what type of function to cast to.
*
* 3. An optional generic pointer to a static or heap-allocated
* object. It is up to the user to cast this back to the
* appropriate object type. Again, the code field could be used
* to describe what type of object is stored there.
* If the object is dynamically allocated and should be discarded
* when the symbol is deleted from the symbol table, send a
* destructor function to have it deleted automatically.
*/
typedef struct {
char *name; /* The name of the symbol */
int code; /* Application supplied integral code */
void (*fn)(void); /* Application supplied generic function */
void *data; /* Application supplied context data */
SYM_DEL_FN(*del_fn); /* Data destructor function */
} Symbol;
/*
* HashNode's and HashTable's are small objects. Separately allocating
* many such objects would normally cause memory fragmentation. To
* counter this, HashMemory objects are used. These contain
* dedicated free-lists formed from large dynamically allocated arrays
* of objects. One HashMemory object can be shared between multiple hash
* tables (within a single thread).
*/
typedef struct HashMemory HashMemory;
/* Create a free-list for allocation of hash tables and their nodes */
HashMemory *_new_HashMemory(int hash_count, int node_count);
/* Delete a redundant free-list if not being used */
HashMemory *_del_HashMemory(HashMemory *mem, int force);
/*
* Declare an alias for the private HashTable structure defined in
* hash.c.
*/
typedef struct HashTable HashTable;
/*
* Enumerate case-sensitivity options.
*/
typedef enum {
IGNORE_CASE, /* Ignore case when looking up symbols */
HONOUR_CASE /* Honor case when looking up symbols */
} HashCase;
/* Create a new hash-table */
HashTable *_new_HashTable(HashMemory *mem, int size, HashCase hcase,
void *app_data, HASH_DEL_FN(*del_fn));
/* Delete a reference to a hash-table */
HashTable *_del_HashTable(HashTable *hash);
/* Add an entry to a hash table */
Symbol *_new_HashSymbol(HashTable *hash, const char *key, int code,
void (*fn)(void), void *data, SYM_DEL_FN(*del_fn));
/* Remove and delete all the entries in a given hash table */
int _clear_HashTable(HashTable *hash);
/* Remove and delete a given hash-table entry */
Symbol *_del_HashSymbol(HashTable *hash, const char *key);
/* Lookup a given hash-table entry */
Symbol *_find_HashSymbol(HashTable *hash, const char *key);
/* Execute a given function on each entry of a hash table, returning */
/* before completion if the specified function returns non-zero. */
#define HASH_SCAN_FN(fn) int (fn)(Symbol *sym, void *context)
int _scan_HashTable(HashTable *hash, HASH_SCAN_FN(*scan_fn), void *context);
#endif
yuma123_2.14/libtecla/cplfile.c 0000664 0001750 0001750 00000070267 14770023131 016500 0 ustar vladimir vladimir /*
* Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
*
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
* OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder
* shall not be used in advertising or otherwise to promote the sale, use
* or other dealings in this Software without prior written authorization
* of the copyright holder.
*/
/*
* If file-system access is to be excluded, this module has no function,
* so all of its code should be excluded.
*/
#ifndef WITHOUT_FILE_SYSTEM
/*
* Standard includes.
*/
#include
#include
#include
#include
#include
#include
/*
* Local includes.
*/
#include "libtecla.h"
#include "direader.h"
#include "homedir.h"
#include "pathutil.h"
#include "cplfile.h"
#include "errmsg.h"
/*
* Set the maximum length allowed for usernames.
* names.
*/
#define USR_LEN 100
/*
* Set the maximum length allowed for environment variable names.
*/
#define ENV_LEN 100
/*
* The resources needed to complete a filename are maintained in objects
* of the following type.
*/
struct CompleteFile {
ErrMsg *err; /* The error reporting buffer */
DirReader *dr; /* A directory reader */
HomeDir *home; /* A home directory expander */
PathName *path; /* The buffer in which to accumulate the path */
PathName *buff; /* A pathname work buffer */
char usrnam[USR_LEN+1]; /* The buffer used when reading the names of */
/* users. */
char envnam[ENV_LEN+1]; /* The buffer used when reading the names of */
/* environment variables. */
};
static int cf_expand_home_dir(CompleteFile *cf, const char *user);
static int cf_complete_username(CompleteFile *cf, WordCompletion *cpl,
const char *prefix, const char *line,
int word_start, int word_end, int escaped);
static HOME_DIR_FN(cf_homedir_callback);
static int cf_complete_entry(CompleteFile *cf, WordCompletion *cpl,
const char *line, int word_start, int word_end,
int escaped, CplCheckFn *check_fn,
void *check_data);
static char *cf_read_name(CompleteFile *cf, const char *type,
const char *string, int slen,
char *nambuf, int nammax);
static int cf_prepare_suffix(CompleteFile *cf, const char *suffix,
int add_escapes);
/*
* A stack based object of the following type is used to pass data to the
* cf_homedir_callback() function.
*/
typedef struct {
CompleteFile *cf; /* The file-completion resource object */
WordCompletion *cpl; /* The string-completion rsource object */
size_t prefix_len; /* The length of the prefix being completed */
const char *line; /* The line from which the prefix was extracted */
int word_start; /* The index in line[] of the start of the username */
int word_end; /* The index in line[] following the end of the prefix */
int escaped; /* If true, add escapes to the completion suffixes */
} CfHomeArgs;
/*.......................................................................
* Create a new file-completion object.
*
* Output:
* return CompleteFile * The new object, or NULL on error.
*/
CompleteFile *_new_CompleteFile(void)
{
CompleteFile *cf; /* The object to be returned */
/*
* Allocate the container.
*/
cf = (CompleteFile *) malloc(sizeof(CompleteFile));
if(!cf) {
errno = ENOMEM;
return NULL;
};
/*
* Before attempting any operation that might fail, initialize the
* container at least up to the point at which it can safely be passed
* to _del_CompleteFile().
*/
cf->err = NULL;
cf->dr = NULL;
cf->home = NULL;
cf->path = NULL;
cf->buff = NULL;
cf->usrnam[0] = '\0';
cf->envnam[0] = '\0';
/*
* Allocate a place to record error messages.
*/
cf->err = _new_ErrMsg();
if(!cf->err)
return _del_CompleteFile(cf);
/*
* Create the object that is used for reading directories.
*/
cf->dr = _new_DirReader();
if(!cf->dr)
return _del_CompleteFile(cf);
/*
* Create the object that is used to lookup home directories.
*/
cf->home = _new_HomeDir();
if(!cf->home)
return _del_CompleteFile(cf);
/*
* Create the buffer in which the completed pathname is accumulated.
*/
cf->path = _new_PathName();
if(!cf->path)
return _del_CompleteFile(cf);
/*
* Create a pathname work buffer.
*/
cf->buff = _new_PathName();
if(!cf->buff)
return _del_CompleteFile(cf);
return cf;
}
/*.......................................................................
* Delete a file-completion object.
*
* Input:
* cf CompleteFile * The object to be deleted.
* Output:
* return CompleteFile * The deleted object (always NULL).
*/
CompleteFile *_del_CompleteFile(CompleteFile *cf)
{
if(cf) {
cf->err = _del_ErrMsg(cf->err);
cf->dr = _del_DirReader(cf->dr);
cf->home = _del_HomeDir(cf->home);
cf->path = _del_PathName(cf->path);
cf->buff = _del_PathName(cf->buff);
free(cf);
};
return NULL;
}
/*.......................................................................
* Look up the possible completions of the incomplete filename that
* lies between specified indexes of a given command-line string.
*
* Input:
* cpl WordCompletion * The object in which to record the completions.
* cf CompleteFile * The filename-completion resource object.
* line const char * The string containing the incomplete filename.
* word_start int The index of the first character in line[]
* of the incomplete filename.
* word_end int The index of the character in line[] that
* follows the last character of the incomplete
* filename.
* escaped int If true, backslashes in line[] are
* interpreted as escaping the characters
* that follow them, and any spaces, tabs,
* backslashes, or wildcard characters in the
* returned suffixes will be similarly escaped.
* If false, backslashes will be interpreted as
* literal parts of the file name, and no
* backslashes will be added to the returned
* suffixes.
* check_fn CplCheckFn * If not zero, this argument specifies a
* function to call to ask whether a given
* file should be included in the list
* of completions.
* check_data void * Anonymous data to be passed to check_fn().
* Output:
* return int 0 - OK.
* 1 - Error. A description of the error can be
* acquired by calling _cf_last_error(cf).
*/
int _cf_complete_file(WordCompletion *cpl, CompleteFile *cf,
const char *line, int word_start, int word_end,
int escaped, CplCheckFn *check_fn, void *check_data)
{
const char *lptr; /* A pointer into line[] */
int nleft; /* The number of characters still to be processed */
/* in line[]. */
/*
* Check the arguments.
*/
if(!cpl || !cf || !line || word_end < word_start) {
if(cf) {
_err_record_msg(cf->err, "_cf_complete_file: Invalid arguments",
END_ERR_MSG);
};
return 1;
};
/*
* Clear the buffer in which the filename will be constructed.
*/
_pn_clear_path(cf->path);
/*
* How many characters are to be processed?
*/
nleft = word_end - word_start;
/*
* Get a pointer to the start of the incomplete filename.
*/
lptr = line + word_start;
/*
* If the first character is a tilde, then perform home-directory
* interpolation.
*/
if(nleft > 0 && *lptr == '~') {
int slen;
if(!cf_read_name(cf, "User", ++lptr, --nleft, cf->usrnam, USR_LEN))
return 1;
/*
* Advance over the username in the input line.
*/
slen = strlen(cf->usrnam);
lptr += slen;
nleft -= slen;
/*
* If we haven't hit the end of the input string then we have a complete
* username to translate to the corresponding home directory.
*/
if(nleft > 0) {
if(cf_expand_home_dir(cf, cf->usrnam))
return 1;
/*
* ~user and ~ are usually followed by a directory separator to
* separate them from the file contained in the home directory.
* If the home directory is the root directory, then we don't want
* to follow the home directory by a directory separator, so we should
* skip over it so that it doesn't get copied into the filename.
*/
if(strcmp(cf->path->name, FS_ROOT_DIR) == 0 &&
strncmp(lptr, FS_DIR_SEP, FS_DIR_SEP_LEN) == 0) {
lptr += FS_DIR_SEP_LEN;
nleft -= FS_DIR_SEP_LEN;
};
/*
* If we have reached the end of the input string, then the username
* may be incomplete, and we should attempt to complete it.
*/
} else {
/*
* Look up the possible completions of the username.
*/
return cf_complete_username(cf, cpl, cf->usrnam, line, word_start+1,
word_end, escaped);
};
};
/*
* Copy the rest of the path, stopping to expand $envvar expressions
* where encountered.
*/
while(nleft > 0) {
int seglen; /* The length of the next segment to be copied */
/*
* Find the length of the next segment to be copied, stopping if an
* unescaped '$' is seen, or the end of the path is reached.
*/
for(seglen=0; seglen < nleft; seglen++) {
int c = lptr[seglen];
if(escaped && c == '\\')
seglen++;
else if(c == '$')
break;
/*
* We will be completing the last component of the file name,
* so whenever a directory separator is seen, assume that it
* might be the start of the last component, and mark the character
* that follows it as the start of the name that is to be completed.
*/
if(nleft >= FS_DIR_SEP_LEN &&
strncmp(lptr + seglen, FS_DIR_SEP, FS_DIR_SEP_LEN)==0) {
word_start = (lptr + seglen) - line + FS_DIR_SEP_LEN;
};
};
/*
* We have reached either the end of the filename or the start of
* $environment_variable expression. Record the newly checked
* segment of the filename in the output filename, removing
* backslash-escapes where needed.
*/
if(_pn_append_to_path(cf->path, lptr, seglen, escaped) == NULL) {
_err_record_msg(cf->err, "Insufficient memory to complete filename",
END_ERR_MSG);
return 1;
};
lptr += seglen;
nleft -= seglen;
/*
* If the above loop finished before we hit the end of the filename,
* then this was because an unescaped $ was seen. In this case, interpolate
* the value of the environment variable that follows it into the output
* filename.
*/
if(nleft > 0) {
char *value; /* The value of the environment variable */
int vlen; /* The length of the value string */
int nlen; /* The length of the environment variable name */
/*
* Read the name of the environment variable.
*/
if(!cf_read_name(cf, "Environment", ++lptr, --nleft, cf->envnam, ENV_LEN))
return 1;
/*
* Advance over the environment variable name in the input line.
*/
nlen = strlen(cf->envnam);
lptr += nlen;
nleft -= nlen;
/*
* Get the value of the environment variable.
*/
value = getenv(cf->envnam);
if(!value) {
_err_record_msg(cf->err, "Unknown environment variable: ", cf->envnam,
END_ERR_MSG);
return 1;
};
vlen = strlen(value);
/*
* If we are at the start of the filename and the first character of the
* environment variable value is a '~', attempt home-directory
* interpolation.
*/
if(cf->path->name[0] == '\0' && value[0] == '~') {
if(!cf_read_name(cf, "User", value+1, vlen-1, cf->usrnam, USR_LEN) ||
cf_expand_home_dir(cf, cf->usrnam))
return 1;
/*
* If the home directory is the root directory, and the ~usrname expression
* was followed by a directory separator, prevent the directory separator
* from being appended to the root directory by skipping it in the
* input line.
*/
if(strcmp(cf->path->name, FS_ROOT_DIR) == 0 &&
strncmp(lptr, FS_DIR_SEP, FS_DIR_SEP_LEN) == 0) {
lptr += FS_DIR_SEP_LEN;
nleft -= FS_DIR_SEP_LEN;
};
} else {
/*
* Append the value of the environment variable to the output path.
*/
if(_pn_append_to_path(cf->path, value, strlen(value), escaped)==NULL) {
_err_record_msg(cf->err, "Insufficient memory to complete filename",
END_ERR_MSG);
return 1;
};
/*
* Prevent extra directory separators from being added.
*/
if(nleft >= FS_DIR_SEP_LEN &&
strcmp(cf->path->name, FS_ROOT_DIR) == 0 &&
strncmp(lptr, FS_DIR_SEP, FS_DIR_SEP_LEN) == 0) {
lptr += FS_DIR_SEP_LEN;
nleft -= FS_DIR_SEP_LEN;
} else if(vlen > FS_DIR_SEP_LEN &&
strcmp(value + vlen - FS_DIR_SEP_LEN, FS_DIR_SEP)==0) {
cf->path->name[vlen-FS_DIR_SEP_LEN] = '\0';
};
};
/*
* If adding the environment variable didn't form a valid directory,
* we can't complete the line, since there is no way to separate append
* a partial filename to an environment variable reference without
* that appended part of the name being seen later as part of the
* environment variable name. Thus if the currently constructed path
* isn't a directory, quite now with no completions having been
* registered.
*/
if(!_pu_path_is_dir(cf->path->name))
return 0;
/*
* For the reasons given above, if we have reached the end of the filename
* with the expansion of an environment variable, the only allowed
* completion involves the addition of a directory separator.
*/
if(nleft == 0) {
if(cpl_add_completion(cpl, line, lptr-line, word_end, FS_DIR_SEP,
"", "")) {
_err_record_msg(cf->err, cpl_last_error(cpl), END_ERR_MSG);
return 1;
};
return 0;
};
};
};
/*
* Complete the filename if possible.
*/
return cf_complete_entry(cf, cpl, line, word_start, word_end, escaped,
check_fn, check_data);
}
/*.......................................................................
* Return a description of the last path-completion error that occurred.
*
* Input:
* cf CompleteFile * The path-completion resource object.
* Output:
* return const char * The description of the last error.
*/
const char *_cf_last_error(CompleteFile *cf)
{
return cf ? _err_get_msg(cf->err) : "NULL CompleteFile argument";
}
/*.......................................................................
* Lookup the home directory of the specified user, or the current user
* if no name is specified, appending it to output pathname.
*
* Input:
* cf CompleteFile * The pathname completion resource object.
* user const char * The username to lookup, or "" to lookup the
* current user.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int cf_expand_home_dir(CompleteFile *cf, const char *user)
{
/*
* Attempt to lookup the home directory.
*/
const char *home_dir = _hd_lookup_home_dir(cf->home, user);
/*
* Failed?
*/
if(!home_dir) {
_err_record_msg(cf->err, _hd_last_home_dir_error(cf->home), END_ERR_MSG);
return 1;
};
/*
* Append the home directory to the pathname string.
*/
if(_pn_append_to_path(cf->path, home_dir, -1, 0) == NULL) {
_err_record_msg(cf->err, "Insufficient memory for home directory expansion",
END_ERR_MSG);
return 1;
};
return 0;
}
/*.......................................................................
* Lookup and report all completions of a given username prefix.
*
* Input:
* cf CompleteFile * The filename-completion resource object.
* cpl WordCompletion * The object in which to record the completions.
* prefix const char * The prefix of the usernames to lookup.
* line const char * The command-line in which the username appears.
* word_start int The index within line[] of the start of the
* username that is being completed.
* word_end int The index within line[] of the character which
* follows the incomplete username.
* escaped int True if the completions need to have special
* characters escaped.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int cf_complete_username(CompleteFile *cf, WordCompletion *cpl,
const char *prefix, const char *line,
int word_start, int word_end, int escaped)
{
/*
* Set up a container of anonymous arguments to be sent to the
* username-lookup iterator.
*/
CfHomeArgs args;
args.cf = cf;
args.cpl = cpl;
args.prefix_len = strlen(prefix);
args.line = line;
args.word_start = word_start;
args.word_end = word_end;
args.escaped = escaped;
/*
* Iterate through the list of users, recording those which start
* with the specified prefix.
*/
if(_hd_scan_user_home_dirs(cf->home, prefix, &args, cf_homedir_callback)) {
_err_record_msg(cf->err, _hd_last_home_dir_error(cf->home), END_ERR_MSG);
return 1;
};
return 0;
}
/*.......................................................................
* The user/home-directory scanner callback function (see homedir.h)
* used by cf_complete_username().
*/
static HOME_DIR_FN(cf_homedir_callback)
{
/*
* Get the file-completion resources from the anonymous data argument.
*/
CfHomeArgs *args = (CfHomeArgs *) data;
WordCompletion *cpl = args->cpl;
CompleteFile *cf = args->cf;
/*
* Copy the username into the pathname work buffer, adding backslash
* escapes where needed.
*/
if(cf_prepare_suffix(cf, usrnam+args->prefix_len, args->escaped)) {
strncpy(errmsg, _err_get_msg(cf->err), maxerr);
errmsg[maxerr] = '\0';
return 1;
};
/*
* Report the completion suffix that was copied above.
*/
if(cpl_add_completion(cpl, args->line, args->word_start, args->word_end,
cf->buff->name, FS_DIR_SEP, FS_DIR_SEP)) {
strncpy(errmsg, cpl_last_error(cpl), maxerr);
errmsg[maxerr] = '\0';
return 1;
};
return 0;
}
/*.......................................................................
* Report possible completions of the filename in cf->path->name[].
*
* Input:
* cf CompleteFile * The file-completion resource object.
* cpl WordCompletion * The object in which to record the completions.
* line const char * The input line, as received by the callback
* function.
* word_start int The index within line[] of the start of the
* last component of the filename that is being
* completed.
* word_end int The index within line[] of the character which
* follows the incomplete filename.
* escaped int If true, escape special characters in the
* completion suffixes.
* check_fn CplCheckFn * If not zero, this argument specifies a
* function to call to ask whether a given
* file should be included in the list
* of completions.
* check_data void * Anonymous data to be passed to check_fn().
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int cf_complete_entry(CompleteFile *cf, WordCompletion *cpl,
const char *line, int word_start, int word_end,
int escaped, CplCheckFn *check_fn,
void *check_data)
{
const char *dirpath; /* The name of the parent directory */
int start; /* The index of the start of the last filename */
/* component in the transcribed filename. */
const char *prefix; /* The filename prefix to be completed */
int prefix_len; /* The length of the filename prefix */
const char *file_name; /* The lastest filename being compared */
int waserr = 0; /* True after errors */
int terminated=0; /* True if the directory part had to be terminated */
/*
* Get the pathname string and its current length.
*/
char *pathname = cf->path->name;
int pathlen = strlen(pathname);
/*
* Locate the start of the final component of the pathname.
*/
for(start=pathlen - 1; start >= 0 &&
strncmp(pathname + start, FS_DIR_SEP, FS_DIR_SEP_LEN) != 0; start--)
;
/*
* Is the parent directory the root directory?
*/
if(start==0 ||
(start < 0 && strncmp(pathname, FS_ROOT_DIR, FS_ROOT_DIR_LEN) == 0)) {
dirpath = FS_ROOT_DIR;
start += FS_ROOT_DIR_LEN;
/*
* If we found a directory separator then the part which precedes the
* last component is the name of the directory to be opened.
*/
} else if(start > 0) {
/*
* The _dr_open_dir() function requires the directory name to be '\0'
* terminated, so temporarily do this by overwriting the first character
* of the directory separator.
*/
pathname[start] = '\0';
dirpath = pathname;
terminated = 1;
/*
* We reached the start of the pathname before finding a directory
* separator, so arrange to open the current working directory.
*/
} else {
start = 0;
dirpath = FS_PWD;
};
/*
* Attempt to open the directory.
*/
if(_dr_open_dir(cf->dr, dirpath, NULL)) {
_err_record_msg(cf->err, "Can't open directory: ", dirpath, END_ERR_MSG);
return 1;
};
/*
* If removed above, restore the directory separator and skip over it
* to the start of the filename.
*/
if(terminated) {
memcpy(pathname + start, FS_DIR_SEP, FS_DIR_SEP_LEN);
start += FS_DIR_SEP_LEN;
};
/*
* Get the filename prefix and its length.
*/
prefix = pathname + start;
prefix_len = strlen(prefix);
/*
* Traverse the directory, looking for files who's prefixes match the
* last component of the pathname.
*/
while((file_name = _dr_next_file(cf->dr)) != NULL && !waserr) {
int name_len = strlen(file_name);
/*
* Is the latest filename a possible completion of the filename prefix?
*/
if(name_len >= prefix_len && strncmp(prefix, file_name, prefix_len)==0) {
/*
* When listing all files in a directory, don't list files that start
* with '.'. This is how hidden files are denoted in UNIX.
*/
if(prefix_len > 0 || file_name[0] != '.') {
/*
* Copy the completion suffix into the work pathname cf->buff->name,
* adding backslash escapes if needed.
*/
if(cf_prepare_suffix(cf, file_name + prefix_len, escaped)) {
waserr = 1;
} else {
/*
* We want directories to be displayed with directory suffixes,
* and other fully completed filenames to be followed by spaces.
* To check the type of the file, append the current suffix
* to the path being completed, check the filetype, then restore
* the path to its original form.
*/
const char *cont_suffix = ""; /* The suffix to add if fully */
/* completed. */
const char *type_suffix = ""; /* The suffix to add when listing */
if(_pn_append_to_path(cf->path, file_name + prefix_len,
-1, escaped) == NULL) {
_err_record_msg(cf->err,
"Insufficient memory to complete filename.",
END_ERR_MSG);
return 1;
};
/*
* Specify suffixes according to the file type.
*/
if(_pu_path_is_dir(cf->path->name)) {
cont_suffix = FS_DIR_SEP;
type_suffix = FS_DIR_SEP;
} else if(!check_fn || check_fn(check_data, cf->path->name)) {
cont_suffix = " ";
} else {
cf->path->name[pathlen] = '\0';
continue;
};
/*
* Remove the temporarily added suffix.
*/
cf->path->name[pathlen] = '\0';
/*
* Record the latest completion.
*/
if(cpl_add_completion(cpl, line, word_start, word_end, cf->buff->name,
type_suffix, cont_suffix))
waserr = 1;
};
};
};
};
/*
* Close the directory.
*/
_dr_close_dir(cf->dr);
return waserr;
}
/*.......................................................................
* Read a username or environment variable name, stopping when a directory
* separator is seen, when the end of the string is reached, or the
* output buffer overflows.
*
* Input:
* cf CompleteFile * The file-completion resource object.
* type char * The capitalized name of the type of name being read.
* string char * The string who's prefix contains the name.
* slen int The number of characters in string[].
* nambuf char * The output name buffer.
* nammax int The longest string that will fit in nambuf[], excluding
* the '\0' terminator.
* Output:
* return char * A pointer to nambuf on success. On error NULL is
* returned and a description of the error is recorded
* in cf->err.
*/
static char *cf_read_name(CompleteFile *cf, const char *type,
const char *string, int slen,
char *nambuf, int nammax)
{
int namlen; /* The number of characters in nambuf[] */
const char *sptr; /* A pointer into string[] */
/*
* Work out the max number of characters that should be copied.
*/
int nmax = nammax < slen ? nammax : slen;
/*
* Get the environment variable name that follows the dollar.
*/
for(sptr=string,namlen=0;
namlen < nmax && (slen-namlen < FS_DIR_SEP_LEN ||
strncmp(sptr, FS_DIR_SEP, FS_DIR_SEP_LEN) != 0);
namlen++) {
nambuf[namlen] = *sptr++;
};
/*
* Did the name overflow the buffer?
*/
if(namlen >= nammax) {
_err_record_msg(cf->err, type, " name too long", END_ERR_MSG);
return NULL;
};
/*
* Terminate the string.
*/
nambuf[namlen] = '\0';
return nambuf;
}
/*.......................................................................
* Using the work buffer cf->buff, make a suitably escaped copy of a
* given completion suffix, ready to be passed to cpl_add_completion().
*
* Input:
* cf CompleteFile * The file-completion resource object.
* suffix char * The suffix to be copied.
* add_escapes int If true, escape special characters.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int cf_prepare_suffix(CompleteFile *cf, const char *suffix,
int add_escapes)
{
const char *sptr; /* A pointer into suffix[] */
int nbsl; /* The number of backslashes to add to the suffix */
int i;
/*
* How long is the suffix?
*/
int suffix_len = strlen(suffix);
/*
* Clear the work buffer.
*/
_pn_clear_path(cf->buff);
/*
* Count the number of backslashes that will have to be added to
* escape spaces, tabs, backslashes and wildcard characters.
*/
nbsl = 0;
if(add_escapes) {
for(sptr = suffix; *sptr; sptr++) {
switch(*sptr) {
case ' ': case '\t': case '\\': case '*': case '?': case '[':
nbsl++;
break;
};
};
};
/*
* Arrange for the output path buffer to have sufficient room for the
* both the suffix and any backslashes that have to be inserted.
*/
if(_pn_resize_path(cf->buff, suffix_len + nbsl) == NULL) {
_err_record_msg(cf->err, "Insufficient memory to complete filename",
END_ERR_MSG);
return 1;
};
/*
* If the suffix doesn't need any escapes, copy it directly into the
* work buffer.
*/
if(nbsl==0) {
strcpy(cf->buff->name, suffix);
} else {
/*
* Make a copy with special characters escaped?
*/
if(nbsl > 0) {
const char *src = suffix;
char *dst = cf->buff->name;
for(i=0; i
#include
#include
#include
#include
#include
#include
#include
/*
* UNIX headers.
*/
#include
#ifdef HAVE_SELECT
#ifdef HAVE_SYS_SELECT_H
#include
#endif
#include
#include
#endif
/*
* Handle the different sources of terminal control string and size
* information. Note that if no terminal information database is available,
* ANSI VT100 control sequences are used.
*/
#if defined(USE_TERMINFO) || defined(USE_TERMCAP)
/*
* Include curses.h or ncurses/curses.h depending on which is available.
*/
#ifdef HAVE_CURSES_H
#include
#elif defined(HAVE_NCURSES_CURSES_H)
#include
#endif
/*
* Include term.h where available.
*/
#if defined(HAVE_TERM_H)
#include
#elif defined(HAVE_NCURSES_TERM_H)
#include
#endif
/*
* When using termcap, include termcap.h on systems that have it.
* Otherwise assume that all prototypes are provided by curses.h.
*/
#if defined(USE_TERMCAP) && defined(HAVE_TERMCAP_H)
#include
#endif
/*
* Under Solaris default Curses the output function that tputs takes is
* declared to have a char argument. On all other systems and on Solaris
* X/Open Curses (Issue 4, Version 2) it expects an int argument (using
* c89 or options -I /usr/xpg4/include -L /usr/xpg4/lib -R /usr/xpg4/lib
* selects XPG4v2 Curses on Solaris 2.6 and later).
*
* Similarly, under Mac OS X, the return value of the tputs output
* function is declared as void, whereas it is declared as int on
* other systems.
*/
#if defined __sun && defined __SVR4 && !defined _XOPEN_CURSES
typedef int TputsRetType;
typedef char TputsArgType; /* int tputs(char c, FILE *fp) */
#define TPUTS_RETURNS_VALUE 1
#elif defined(__APPLE__) && defined(__MACH__)
typedef void TputsRetType;
typedef int TputsArgType; /* void tputs(int c, FILE *fp) */
#define TPUTS_RETURNS_VALUE 0
#else
typedef int TputsRetType;
typedef int TputsArgType; /* int tputs(int c, FILE *fp) */
#define TPUTS_RETURNS_VALUE 1
#endif
/*
* Use the above specifications to prototype our tputs callback function.
*/
static TputsRetType gl_tputs_putchar(TputsArgType c);
#endif /* defined(USE_TERMINFO) || defined(USE_TERMCAP) */
/*
* If the library is being compiled without filesystem access facilities,
* ensure that none of the action functions that normally do access the
* filesystem are bound by default, and that it they do get bound, that
* they don't do anything.
*/
#if WITHOUT_FILE_SYSTEM
#define HIDE_FILE_SYSTEM
#endif
/*
* POSIX headers.
*/
#include
#include
#include
/*
* Provide typedefs for standard POSIX structures.
*/
typedef struct sigaction SigAction;
typedef struct termios Termios;
/*
* Which flag is used to select non-blocking I/O with fcntl()?
*/
#undef NON_BLOCKING_FLAG
#if defined(O_NONBLOCK)
#define NON_BLOCKING_FLAG (O_NONBLOCK)
#elif defined(O_NDELAY)
#define NON_BLOCKING_FLAG (O_NDELAY)
#endif
/*
* What value should we give errno if I/O blocks when it shouldn't.
*/
#undef BLOCKED_ERRNO
#if defined(EAGAIN)
#define BLOCKED_ERRNO (EAGAIN)
#elif defined(EWOULDBLOCK)
#define BLOCKED_ERRNO (EWOULDBLOCK)
#elif defined(EIO)
#define BLOCKED_ERRNO (EIO)
#else
#define BLOCKED_ERRNO 0
#endif
/*
* Local headers.
*/
#ifndef WITHOUT_FILE_SYSTEM
#include "pathutil.h"
#endif
#include "libtecla.h"
#include "keytab.h"
#include "getline.h"
#include "ioutil.h"
#include "history.h"
#include "freelist.h"
#include "stringrp.h"
#include "chrqueue.h"
#include "cplmatch.h"
#ifndef WITHOUT_FILE_SYSTEM
#include "expand.h"
#endif
#include "errmsg.h"
/*
* Enumerate the available editing styles.
*/
typedef enum {
GL_EMACS_MODE, /* Emacs style editing */
GL_VI_MODE, /* Vi style editing */
GL_NO_EDITOR /* Fall back to the basic OS-provided editing */
} GlEditor;
/*
* Set the largest key-sequence that can be handled.
*/
#define GL_KEY_MAX 64
/*
* In vi mode, the following datatype is used to implement the
* undo command. It records a copy of the input line from before
* the command-mode action which edited the input line.
*/
typedef struct {
char *line; /* A historical copy of the input line */
int buff_curpos; /* The historical location of the cursor in */
/* line[] when the line was modified. */
int ntotal; /* The number of characters in line[] */
int saved; /* True once a line has been saved after the */
/* last call to gl_interpret_char(). */
} ViUndo;
/*
* In vi mode, the following datatype is used to record information
* needed by the vi-repeat-change command.
*/
typedef struct {
KtAction action; /* The last action function that made a */
/* change to the line. */
int count; /* The repeat count that was passed to the */
/* above command. */
int input_curpos; /* Whenever vi command mode is entered, the */
/* the position at which it was first left */
/* is recorded here. */
int command_curpos; /* Whenever vi command mode is entered, the */
/* the location of the cursor is recorded */
/* here. */
char input_char; /* Commands that call gl_read_terminal() */
/* record the character here, so that it can */
/* used on repeating the function. */
int saved; /* True if a function has been saved since the */
/* last call to gl_interpret_char(). */
int active; /* True while a function is being repeated. */
} ViRepeat;
/*
* The following datatype is used to encapsulate information specific
* to vi mode.
*/
typedef struct {
ViUndo undo; /* Information needed to implement the vi */
/* undo command. */
ViRepeat repeat; /* Information needed to implement the vi */
/* repeat command. */
int command; /* True in vi command-mode */
int find_forward; /* True if the last character search was in the */
/* forward direction. */
int find_onto; /* True if the last character search left the */
/* on top of the located character, as opposed */
/* to just before or after it. */
char find_char; /* The last character sought, or '\0' if no */
/* searches have been performed yet. */
} ViMode;
#ifdef HAVE_SELECT
/*
* Define a type for recording a file-descriptor callback and its associated
* data.
*/
typedef struct {
GlFdEventFn *fn; /* The callback function */
void *data; /* Anonymous data to pass to the callback function */
} GlFdHandler;
/*
* A list of nodes of the following type is used to record file-activity
* event handlers, but only on systems that have the select() system call.
*/
typedef struct GlFdNode GlFdNode;
struct GlFdNode {
GlFdNode *next; /* The next in the list of nodes */
int fd; /* The file descriptor being watched */
GlFdHandler rd; /* The callback to call when fd is readable */
GlFdHandler wr; /* The callback to call when fd is writable */
GlFdHandler ur; /* The callback to call when fd has urgent data */
};
/*
* Set the number of the above structures to allocate every time that
* the freelist of GlFdNode's becomes exhausted.
*/
#define GLFD_FREELIST_BLOCKING 10
static int gl_call_fd_handler(GetLine *gl, GlFdHandler *gfh, int fd,
GlFdEvent event);
static int gl_call_timeout_handler(GetLine *gl);
#endif
/*
* Each signal that gl_get_line() traps is described by a list node
* of the following type.
*/
typedef struct GlSignalNode GlSignalNode;
struct GlSignalNode {
GlSignalNode *next; /* The next signal in the list */
int signo; /* The number of the signal */
sigset_t proc_mask; /* A process mask which only includes signo */
SigAction original; /* The signal disposition of the calling program */
/* for this signal. */
unsigned flags; /* A bitwise union of GlSignalFlags enumerators */
GlAfterSignal after; /* What to do after the signal has been handled */
int errno_value; /* What to set errno to */
};
/*
* Set the number of the above structures to allocate every time that
* the freelist of GlSignalNode's becomes exhausted.
*/
#define GLS_FREELIST_BLOCKING 30
/*
* Completion handlers and their callback data are recorded in
* nodes of the following type.
*/
typedef struct GlCplCallback GlCplCallback;
struct GlCplCallback {
CplMatchFn *fn; /* The completion callback function */
void *data; /* Arbitrary callback data */
};
/*
* The following function is used as the default completion handler when
* the filesystem is to be hidden. It simply reports no completions.
*/
#ifdef HIDE_FILE_SYSTEM
static CPL_MATCH_FN(gl_no_completions);
#endif
/*
* Specify how many GlCplCallback nodes are added to the GlCplCallback freelist
* whenever it becomes exhausted.
*/
#define GL_CPL_FREELIST_BLOCKING 10
/*
* External action functions and their callback data are recorded in
* nodes of the following type.
*/
typedef struct GlExternalAction GlExternalAction;
struct GlExternalAction {
GlActionFn *fn; /* The function which implements the action */
void *data; /* Arbitrary callback data */
};
/*
* Specify how many GlExternalAction nodes are added to the
* GlExternalAction freelist whenever it becomes exhausted.
*/
#define GL_EXT_ACT_FREELIST_BLOCKING 10
/*
* Define the contents of the GetLine object.
* Note that the typedef for this object can be found in libtecla.h.
*/
struct GetLine {
ErrMsg *err; /* The error-reporting buffer */
GlHistory *glh; /* The line-history buffer */
WordCompletion *cpl; /* String completion resource object */
GlCplCallback cplfn; /* The completion callback */
#ifndef WITHOUT_FILE_SYSTEM
ExpandFile *ef; /* ~user/, $envvar and wildcard expansion */
/* resource object. */
#endif
StringGroup *capmem; /* Memory for recording terminal capability */
/* strings. */
GlCharQueue *cq; /* The terminal output character queue */
int input_fd; /* The file descriptor to read on */
int output_fd; /* The file descriptor to write to */
FILE *input_fp; /* A stream wrapper around input_fd */
FILE *output_fp; /* A stream wrapper around output_fd */
FILE *file_fp; /* When input is being temporarily taken from */
/* a file, this is its file-pointer. Otherwise */
/* it is NULL. */
char *term; /* The terminal type specified on the last call */
/* to gl_change_terminal(). */
int is_term; /* True if stdin is a terminal */
GlWriteFn *flush_fn; /* The function to call to write to the terminal */
GlIOMode io_mode; /* The I/O mode established by gl_io_mode() */
int raw_mode; /* True while the terminal is in raw mode */
GlPendingIO pending_io; /* The type of I/O that is currently pending */
GlReturnStatus rtn_status; /* The reason why gl_get_line() returned */
int rtn_errno; /* THe value of errno associated with rtn_status */
size_t linelen; /* The max number of characters per line */
char *line; /* A line-input buffer of allocated size */
/* linelen+2. The extra 2 characters are */
/* reserved for "\n\0". */
char *cutbuf; /* A cut-buffer of the same size as line[] */
char *prompt; /* The current prompt string */
int prompt_len; /* The length of the prompt string */
int prompt_changed; /* True after a callback changes the prompt */
int prompt_style; /* How the prompt string is displayed */
FreeList *cpl_mem; /* Memory for GlCplCallback objects */
FreeList *ext_act_mem; /* Memory for GlExternalAction objects */
FreeList *sig_mem; /* Memory for nodes of the signal list */
GlSignalNode *sigs; /* The head of the list of signals */
int signals_masked; /* True between calls to gl_mask_signals() and */
/* gl_unmask_signals() */
int signals_overriden; /* True between calls to gl_override_signals() */
/* and gl_restore_signals() */
sigset_t all_signal_set; /* The set of all signals that we are trapping */
sigset_t old_signal_set; /* The set of blocked signals on entry to */
/* gl_get_line(). */
sigset_t use_signal_set; /* The subset of all_signal_set to unblock */
/* while waiting for key-strokes */
Termios oldattr; /* Saved terminal attributes. */
KeyTab *bindings; /* A table of key-bindings */
int ntotal; /* The number of characters in gl->line[] */
int buff_curpos; /* The cursor position within gl->line[] */
int term_curpos; /* The cursor position on the terminal */
int term_len; /* The number of terminal characters used to */
/* display the current input line. */
int buff_mark; /* A marker location in the buffer */
int insert_curpos; /* The cursor position at start of insert */
int insert; /* True in insert mode */
int number; /* If >= 0, a numeric argument is being read */
int endline; /* True to tell gl_get_input_line() to return */
/* the current contents of gl->line[] */
int displayed; /* True if an input line is currently displayed */
int redisplay; /* If true, the input line will be redrawn */
/* either after the current action function */
/* returns, or when gl_get_input_line() */
/* is next called. */
int postpone; /* _gl_normal_io() sets this flag, to */
/* postpone any redisplays until */
/* is next called, to resume line editing. */
char keybuf[GL_KEY_MAX+1]; /* A buffer of currently unprocessed key presses */
int nbuf; /* The number of characters in keybuf[] */
int nread; /* The number of characters read from keybuf[] */
KtAction current_action; /* The action function that is being invoked */
int current_count; /* The repeat count passed to */
/* current_acction.fn() */
GlhLineID preload_id; /* When not zero, this should be the ID of a */
/* line in the history buffer for potential */
/* recall. */
int preload_history; /* If true, preload the above history line when */
/* gl_get_input_line() is next called. */
long keyseq_count; /* The number of key sequences entered by the */
/* the user since new_GetLine() was called. */
long last_search; /* The value of keyseq_count during the last */
/* history search operation. */
GlEditor editor; /* The style of editing, (eg. vi or emacs) */
int silence_bell; /* True if gl_ring_bell() should do nothing. */
int automatic_history; /* True to automatically archive entered lines */
/* in the history list. */
ViMode vi; /* Parameters used when editing in vi mode */
const char *left; /* The string that moves the cursor 1 character */
/* left. */
const char *right; /* The string that moves the cursor 1 character */
/* right. */
const char *up; /* The string that moves the cursor 1 character */
/* up. */
const char *down; /* The string that moves the cursor 1 character */
/* down. */
const char *home; /* The string that moves the cursor home */
const char *bol; /* Move cursor to beginning of line */
const char *clear_eol; /* The string that clears from the cursor to */
/* the end of the line. */
const char *clear_eod; /* The string that clears from the cursor to */
/* the end of the display. */
const char *u_arrow; /* The string returned by the up-arrow key */
const char *d_arrow; /* The string returned by the down-arrow key */
const char *l_arrow; /* The string returned by the left-arrow key */
const char *r_arrow; /* The string returned by the right-arrow key */
const char *sound_bell; /* The string needed to ring the terminal bell */
const char *bold; /* Switch to the bold font */
const char *underline; /* Underline subsequent characters */
const char *standout; /* Turn on standout mode */
const char *dim; /* Switch to a dim font */
const char *reverse; /* Turn on reverse video */
const char *blink; /* Switch to a blinking font */
const char *text_attr_off; /* Turn off all text attributes */
int nline; /* The height of the terminal in lines */
int ncolumn; /* The width of the terminal in columns */
#ifdef USE_TERMCAP
char *tgetent_buf; /* The buffer that is used by tgetent() to */
/* store a terminal description. */
char *tgetstr_buf; /* The buffer that is used by tgetstr() to */
/* store terminal capabilities. */
#endif
#ifdef USE_TERMINFO
const char *left_n; /* The parameter string that moves the cursor */
/* n characters left. */
const char *right_n; /* The parameter string that moves the cursor */
/* n characters right. */
#endif
char *app_file; /* The pathname of the application-specific */
/* .teclarc configuration file, or NULL. */
char *user_file; /* The pathname of the user-specific */
/* .teclarc configuration file, or NULL. */
int configured; /* True as soon as any teclarc configuration */
/* file has been read. */
int echo; /* True to display the line as it is being */
/* entered. If 0, only the prompt will be */
/* displayed, and the line will not be */
/* archived in the history list. */
int last_signal; /* The last signal that was caught by */
/* the last call to gl_get_line(), or -1 */
/* if no signal has been caught yet. */
#ifdef HAVE_SELECT
FreeList *fd_node_mem; /* A freelist of GlFdNode structures */
GlFdNode *fd_nodes; /* The list of fd event descriptions */
fd_set rfds; /* The set of fds to watch for readability */
fd_set wfds; /* The set of fds to watch for writability */
fd_set ufds; /* The set of fds to watch for urgent data */
int max_fd; /* The maximum file-descriptor being watched */
struct { /* Inactivity timeout related data */
struct timeval dt; /* The inactivity timeout when timer.fn() */
/* isn't 0 */
GlTimeoutFn *fn; /* The application callback to call when */
/* the inactivity timer expires, or 0 if */
/* timeouts are not required. */
void *data; /* Application provided data to be passed to */
/* timer.fn(). */
} timer;
#endif
};
/*
* Define the max amount of space needed to store a termcap terminal
* description. Unfortunately this has to be done by guesswork, so
* there is the potential for buffer overflows if we guess too small.
* Fortunately termcap has been replaced by terminfo on most
* platforms, and with terminfo this isn't an issue. The value that I
* am using here is the conventional value, as recommended by certain
* web references.
*/
#ifdef USE_TERMCAP
#define TERMCAP_BUF_SIZE 2048
#endif
/*
* Set the size of the string segments used to store terminal capability
* strings.
*/
#define CAPMEM_SEGMENT_SIZE 512
/*
* If no terminal size information is available, substitute the
* following vt100 default sizes.
*/
#define GL_DEF_NLINE 24
#define GL_DEF_NCOLUMN 80
/*
* Enumerate the attributes needed to classify different types of
* signals. These attributes reflect the standard default
* characteristics of these signals (according to Richard Steven's
* Advanced Programming in the UNIX Environment). Note that these values
* are all powers of 2, so that they can be combined in a bitwise union.
*/
typedef enum {
GLSA_TERM=1, /* A signal that terminates processes */
GLSA_SUSP=2, /* A signal that suspends processes */
GLSA_CONT=4, /* A signal that is sent when suspended processes resume */
GLSA_IGN=8, /* A signal that is ignored */
GLSA_CORE=16, /* A signal that generates a core dump */
GLSA_HARD=32, /* A signal generated by a hardware exception */
GLSA_SIZE=64 /* A signal indicating terminal size changes */
} GlSigAttr;
/*
* List the signals that we need to catch. In general these are
* those that by default terminate or suspend the process, since
* in such cases we need to restore terminal settings.
*/
static const struct GlDefSignal {
int signo; /* The number of the signal */
unsigned flags; /* A bitwise union of GlSignalFlags enumerators */
GlAfterSignal after; /* What to do after the signal has been delivered */
int attr; /* The default attributes of this signal, expressed */
/* as a bitwise union of GlSigAttr enumerators */
int errno_value; /* What to set errno to */
} gl_signal_list[] = {
{SIGABRT, GLS_SUSPEND_INPUT, GLS_ABORT, GLSA_TERM|GLSA_CORE, EINTR},
{SIGALRM, GLS_RESTORE_ENV, GLS_CONTINUE, GLSA_TERM, 0},
{SIGCONT, GLS_RESTORE_ENV, GLS_CONTINUE, GLSA_CONT|GLSA_IGN, 0},
#if defined(SIGHUP)
#ifdef ENOTTY
{SIGHUP, GLS_SUSPEND_INPUT, GLS_ABORT, GLSA_TERM, ENOTTY},
#else
{SIGHUP, GLS_SUSPEND_INPUT, GLS_ABORT, GLSA_TERM, EINTR},
#endif
#endif
{SIGINT, GLS_SUSPEND_INPUT, GLS_ABORT, GLSA_TERM, EINTR},
#if defined(SIGPIPE)
#ifdef EPIPE
{SIGPIPE, GLS_SUSPEND_INPUT, GLS_ABORT, GLSA_TERM, EPIPE},
#else
{SIGPIPE, GLS_SUSPEND_INPUT, GLS_ABORT, GLSA_TERM, EINTR},
#endif
#endif
#ifdef SIGPOLL
{SIGPOLL, GLS_SUSPEND_INPUT, GLS_ABORT, GLSA_TERM, EINTR},
#endif
#ifdef SIGPWR
{SIGPWR, GLS_RESTORE_ENV, GLS_CONTINUE, GLSA_IGN, 0},
#endif
#ifdef SIGQUIT
{SIGQUIT, GLS_SUSPEND_INPUT, GLS_ABORT, GLSA_TERM|GLSA_CORE, EINTR},
#endif
{SIGTERM, GLS_SUSPEND_INPUT, GLS_ABORT, GLSA_TERM, EINTR},
#ifdef SIGTSTP
{SIGTSTP, GLS_SUSPEND_INPUT, GLS_CONTINUE, GLSA_SUSP, 0},
#endif
#ifdef SIGTTIN
{SIGTTIN, GLS_SUSPEND_INPUT, GLS_CONTINUE, GLSA_SUSP, 0},
#endif
#ifdef SIGTTOU
{SIGTTOU, GLS_SUSPEND_INPUT, GLS_CONTINUE, GLSA_SUSP, 0},
#endif
#ifdef SIGUSR1
{SIGUSR1, GLS_RESTORE_ENV, GLS_CONTINUE, GLSA_TERM, 0},
#endif
#ifdef SIGUSR2
{SIGUSR2, GLS_RESTORE_ENV, GLS_CONTINUE, GLSA_TERM, 0},
#endif
#ifdef SIGVTALRM
{SIGVTALRM, GLS_RESTORE_ENV, GLS_CONTINUE, GLSA_TERM, 0},
#endif
#ifdef SIGWINCH
{SIGWINCH, GLS_RESTORE_ENV, GLS_CONTINUE, GLSA_SIZE|GLSA_IGN, 0},
#endif
#ifdef SIGXCPU
{SIGXCPU, GLS_RESTORE_ENV, GLS_CONTINUE, GLSA_TERM|GLSA_CORE, 0},
#endif
#ifdef SIGXFSZ
{SIGXFSZ, GLS_RESTORE_ENV, GLS_CONTINUE, GLSA_TERM|GLSA_CORE, 0},
#endif
};
/*
* Define file-scope variables for use in signal handlers.
*/
static volatile sig_atomic_t gl_pending_signal = -1;
static sigjmp_buf gl_setjmp_buffer;
static void gl_signal_handler(int signo);
static int gl_check_caught_signal(GetLine *gl);
/*
* Respond to an externally caught process suspension or
* termination signal.
*/
static void gl_suspend_process(int signo, GetLine *gl, int ngl);
/* Return the default attributes of a given signal */
static int gl_classify_signal(int signo);
/*
* Unfortunately both terminfo and termcap require one to use the tputs()
* function to output terminal control characters, and this function
* doesn't allow one to specify a file stream. As a result, the following
* file-scope variable is used to pass the current output file stream.
* This is bad, but there doesn't seem to be any alternative.
*/
static GetLine *tputs_gl = NULL;
/*
* Define a tab to be a string of 8 spaces.
*/
#define TAB_WIDTH 8
/*
* Lookup the current size of the terminal.
*/
static void gl_query_size(GetLine *gl, int *ncolumn, int *nline);
/*
* Getline calls this to temporarily override certain signal handlers
* of the calling program.
*/
static int gl_override_signal_handlers(GetLine *gl);
/*
* Getline calls this to restore the signal handlers of the calling
* program.
*/
static int gl_restore_signal_handlers(GetLine *gl);
/*
* Temporarily block the delivery of all signals that gl_get_line()
* is currently configured to trap.
*/
static int gl_mask_signals(GetLine *gl, sigset_t *oldset);
/*
* Restore the process signal mask that was overriden by a previous
* call to gl_mask_signals().
*/
static int gl_unmask_signals(GetLine *gl, sigset_t *oldset);
/*
* Unblock the signals that gl_get_line() has been configured to catch.
*/
static int gl_catch_signals(GetLine *gl);
/*
* Return the set of all trappable signals.
*/
static void gl_list_trappable_signals(sigset_t *signals);
/*
* Put the terminal into raw input mode, after saving the original
* terminal attributes in gl->oldattr.
*/
static int gl_raw_terminal_mode(GetLine *gl);
/*
* Restore the terminal attributes from gl->oldattr.
*/
static int gl_restore_terminal_attributes(GetLine *gl);
/*
* Switch to non-blocking I/O if possible.
*/
static int gl_nonblocking_io(GetLine *gl, int fd);
/*
* Switch to blocking I/O if possible.
*/
static int gl_blocking_io(GetLine *gl, int fd);
/*
* Read a line from the user in raw mode.
*/
static int gl_get_input_line(GetLine *gl, const char *prompt,
const char *start_line, int start_pos);
/*
* Query the user for a single character.
*/
static int gl_get_query_char(GetLine *gl, const char *prompt, int defchar);
/*
* Read input from a non-interactive input stream.
*/
static int gl_read_stream_line(GetLine *gl);
/*
* Read a single character from a non-interactive input stream.
*/
static int gl_read_stream_char(GetLine *gl);
/*
* Prepare to edit a new line.
*/
static int gl_present_line(GetLine *gl, const char *prompt,
const char *start_line, int start_pos);
/*
* Reset all line-editing parameters for a new input line.
*/
static void gl_reset_editor(GetLine *gl);
/*
* Handle the receipt of the potential start of a new key-sequence from
* the user.
*/
static int gl_interpret_char(GetLine *gl, char c);
/*
* Bind a single control or meta character to an action.
*/
static int gl_bind_control_char(GetLine *gl, KtBinder binder,
char c, const char *action);
/*
* Set up terminal-specific key bindings.
*/
static int gl_bind_terminal_keys(GetLine *gl);
/*
* Lookup terminal control string and size information.
*/
static int gl_control_strings(GetLine *gl, const char *term);
/*
* Wrappers around the terminfo and termcap functions that lookup
* strings in the terminal information databases.
*/
#ifdef USE_TERMINFO
static const char *gl_tigetstr(GetLine *gl, const char *name);
#elif defined(USE_TERMCAP)
static const char *gl_tgetstr(GetLine *gl, const char *name, char **bufptr);
#endif
/*
* Output a binary string directly to the terminal.
*/
static int gl_print_raw_string(GetLine *gl, int buffered,
const char *string, int n);
/*
* Print an informational message, starting and finishing on new lines.
* After the list of strings to be printed, the last argument MUST be
* GL_END_INFO.
*/
static int gl_print_info(GetLine *gl, ...);
#define GL_END_INFO ((const char *)0)
/*
* Start a newline and place the cursor at its start.
*/
static int gl_start_newline(GetLine *gl, int buffered);
/*
* Output a terminal control sequence.
*/
static int gl_print_control_sequence(GetLine *gl, int nline,
const char *string);
/*
* Output a character or string to the terminal after converting tabs
* to spaces and control characters to a caret followed by the modified
* character.
*/
static int gl_print_char(GetLine *gl, char c, char pad);
static int gl_print_string(GetLine *gl, const char *string, char pad);
/*
* Delete nc characters starting from the one under the cursor.
* Optionally copy the deleted characters to the cut buffer.
*/
static int gl_delete_chars(GetLine *gl, int nc, int cut);
/*
* Add a character to the line buffer at the current cursor position,
* inserting or overwriting according the current mode.
*/
static int gl_add_char_to_line(GetLine *gl, char c);
/*
* Insert/append a string to the line buffer and terminal at the current
* cursor position.
*/
static int gl_add_string_to_line(GetLine *gl, const char *s);
/*
* Record a new character in the input-line buffer.
*/
static int gl_buffer_char(GetLine *gl, char c, int bufpos);
/*
* Record a string in the input-line buffer.
*/
static int gl_buffer_string(GetLine *gl, const char *s, int n, int bufpos);
/*
* Make way to insert a string in the input-line buffer.
*/
static int gl_make_gap_in_buffer(GetLine *gl, int start, int n);
/*
* Remove characters from the input-line buffer, and move any characters
* that followed them to the start of the vacated space.
*/
static void gl_remove_from_buffer(GetLine *gl, int start, int n);
/*
* Terminate the input-line buffer after a specified number of characters.
*/
static int gl_truncate_buffer(GetLine *gl, int n);
/*
* Delete the displayed part of the input line that follows the current
* terminal cursor position.
*/
static int gl_truncate_display(GetLine *gl);
/*
* Accomodate changes to the contents of the input line buffer
* that weren't made by the above gl_*buffer functions.
*/
static void gl_update_buffer(GetLine *gl);
/*
* Read a single character from the terminal.
*/
static int gl_read_terminal(GetLine *gl, int keep, char *c);
/*
* Discard processed characters from the key-press lookahead buffer.
*/
static void gl_discard_chars(GetLine *gl, int nused);
/*
* Move the terminal cursor n positions to the left or right.
*/
static int gl_terminal_move_cursor(GetLine *gl, int n);
/*
* Move the terminal cursor to a given position.
*/
static int gl_set_term_curpos(GetLine *gl, int term_curpos);
/*
* Set the position of the cursor both in the line input buffer and on the
* terminal.
*/
static int gl_place_cursor(GetLine *gl, int buff_curpos);
/*
* How many characters are needed to write a number as an octal string?
*/
static int gl_octal_width(unsigned num);
/*
* Return the number of spaces needed to display a tab character at
* a given location of the terminal.
*/
static int gl_displayed_tab_width(GetLine *gl, int term_curpos);
/*
* Return the number of terminal characters needed to display a
* given raw character.
*/
static int gl_displayed_char_width(GetLine *gl, char c, int term_curpos);
/*
* Return the number of terminal characters needed to display a
* given substring.
*/
static int gl_displayed_string_width(GetLine *gl, const char *string, int nc,
int term_curpos);
/*
* Return non-zero if 'c' is to be considered part of a word.
*/
static int gl_is_word_char(int c);
/*
* Read a tecla configuration file.
*/
static int _gl_read_config_file(GetLine *gl, const char *filename, KtBinder who);
/*
* Read a tecla configuration string.
*/
static int _gl_read_config_string(GetLine *gl, const char *buffer, KtBinder who);
/*
* Define the callback function used by _gl_parse_config_line() to
* read the next character of a configuration stream.
*/
#define GLC_GETC_FN(fn) int (fn)(void *stream)
typedef GLC_GETC_FN(GlcGetcFn);
static GLC_GETC_FN(glc_file_getc); /* Read from a file */
static GLC_GETC_FN(glc_buff_getc); /* Read from a string */
/*
* Parse a single configuration command line.
*/
static int _gl_parse_config_line(GetLine *gl, void *stream, GlcGetcFn *getc_fn,
const char *origin, KtBinder who, int *lineno);
static int gl_report_config_error(GetLine *gl, const char *origin, int lineno,
const char *errmsg);
/*
* Bind the actual arrow key bindings to match those of the symbolic
* arrow-key bindings.
*/
static int _gl_bind_arrow_keys(GetLine *gl);
/*
* Copy the binding of the specified symbolic arrow-key binding to
* the terminal specific, and default arrow-key key-sequences.
*/
static int _gl_rebind_arrow_key(GetLine *gl, const char *name,
const char *term_seq,
const char *def_seq1,
const char *def_seq2);
/*
* After the gl_read_from_file() action has been used to tell gl_get_line()
* to temporarily read input from a file, gl_revert_input() arranges
* for input to be reverted to the input stream last registered with
* gl_change_terminal().
*/
static void gl_revert_input(GetLine *gl);
/*
* Flush unwritten characters to the terminal.
*/
static int gl_flush_output(GetLine *gl);
/*
* The callback through which all terminal output is routed.
* This simply appends characters to a queue buffer, which is
* subsequently flushed to the output channel by gl_flush_output().
*/
static GL_WRITE_FN(gl_write_fn);
/*
* The callback function which the output character queue object
* calls to transfer characters to the output channel.
*/
static GL_WRITE_FN(gl_flush_terminal);
/*
* Enumerate the possible return statuses of gl_read_input().
*/
typedef enum {
GL_READ_OK, /* A character was read successfully */
GL_READ_ERROR, /* A read-error occurred */
GL_READ_BLOCKED, /* The read would have blocked the caller */
GL_READ_EOF /* The end of the current input file was reached */
} GlReadStatus;
static GlReadStatus gl_read_input(GetLine *gl, char *c);
/*
* Private functions of gl_read_input().
*/
static int gl_event_handler(GetLine *gl, int fd);
static GlReadStatus gl_read_unmasked(GetLine *gl, int fd, char *c);
/*
* A private function of gl_tty_signals().
*/
static int gl_set_tty_signal(int signo, void (*handler)(int));
/*
* Change the editor style being emulated.
*/
static int gl_change_editor(GetLine *gl, GlEditor editor);
/*
* Searching in a given direction, return the index of a given (or
* read) character in the input line, or the character that precedes
* it in the specified search direction. Return -1 if not found.
*/
static int gl_find_char(GetLine *gl, int count, int forward, int onto, char c);
/*
* Return the buffer index of the nth word ending after the cursor.
*/
static int gl_nth_word_end_forward(GetLine *gl, int n);
/*
* Return the buffer index of the nth word start after the cursor.
*/
static int gl_nth_word_start_forward(GetLine *gl, int n);
/*
* Return the buffer index of the nth word start before the cursor.
*/
static int gl_nth_word_start_backward(GetLine *gl, int n);
/*
* When called when vi command mode is enabled, this function saves the
* current line and cursor position for potential restoration later
* by the vi undo command.
*/
static void gl_save_for_undo(GetLine *gl);
/*
* If in vi mode, switch to vi command mode.
*/
static void gl_vi_command_mode(GetLine *gl);
/*
* In vi mode this is used to delete up to or onto a given or read
* character in the input line. Also switch to insert mode if requested
* after the deletion.
*/
static int gl_delete_find(GetLine *gl, int count, char c, int forward,
int onto, int change);
/*
* Copy the characters between the cursor and the count'th instance of
* a specified (or read) character in the input line, into the cut buffer.
*/
static int gl_copy_find(GetLine *gl, int count, char c, int forward, int onto);
/*
* Return the line index of the parenthesis that either matches the one under
* the cursor, or not over a parenthesis character, the index of the next
* close parenthesis. Return -1 if not found.
*/
static int gl_index_of_matching_paren(GetLine *gl);
/*
* Replace a malloc'd string (or NULL), with another malloc'd copy of
* a string (or NULL).
*/
static int gl_record_string(char **sptr, const char *string);
/*
* Enumerate text display attributes as powers of two, suitable for
* use in a bit-mask.
*/
typedef enum {
GL_TXT_STANDOUT=1, /* Display text highlighted */
GL_TXT_UNDERLINE=2, /* Display text underlined */
GL_TXT_REVERSE=4, /* Display text with reverse video */
GL_TXT_BLINK=8, /* Display blinking text */
GL_TXT_DIM=16, /* Display text in a dim font */
GL_TXT_BOLD=32 /* Display text using a bold font */
} GlTextAttr;
/*
* Display the prompt regardless of the current visibility mode.
*/
static int gl_display_prompt(GetLine *gl);
/*
* Return the number of characters used by the prompt on the terminal.
*/
static int gl_displayed_prompt_width(GetLine *gl);
/*
* Prepare to return the current input line to the caller of gl_get_line().
*/
static int gl_line_ended(GetLine *gl, int newline_char);
/*
* Arrange for the input line to be redisplayed when the current contents
* of the output queue have been flushed.
*/
static void gl_queue_redisplay(GetLine *gl);
/*
* Erase the displayed representation of the input line, without
* touching the buffered copy.
*/
static int gl_erase_line(GetLine *gl);
/*
* This function is called whenever the input line has been erased.
*/
static void gl_line_erased(GetLine *gl);
/*
* Arrange for the current input line to be discarded.
*/
void _gl_abandon_line(GetLine *gl);
/*
* The following are private internally callable versions of pertinent
* public functions. Unlike their public wrapper functions, they don't
* block signals while running, and assume that their arguments are valid.
* They are designed to be called from places where signals are already
* blocked, and where simple sanity checks have already been applied to
* their arguments.
*/
static char *_gl_get_line(GetLine *gl, const char *prompt,
const char *start_line, int start_pos);
static int _gl_query_char(GetLine *gl, const char *prompt, char defchar);
static int _gl_read_char(GetLine *gl);
static int _gl_update_size(GetLine *gl);
/*
* Redraw the current input line to account for a change in the terminal
* size. Also install the new size in gl.
*/
static int gl_handle_tty_resize(GetLine *gl, int ncolumn, int nline);
static int _gl_change_terminal(GetLine *gl, FILE *input_fp, FILE *output_fp,
const char *term);
static int _gl_configure_getline(GetLine *gl, const char *app_string,
const char *app_file, const char *user_file);
static int _gl_save_history(GetLine *gl, const char *filename,
const char *comment, int max_lines);
static int _gl_load_history(GetLine *gl, const char *filename,
const char *comment);
static int _gl_watch_fd(GetLine *gl, int fd, GlFdEvent event,
GlFdEventFn *callback, void *data);
static void _gl_terminal_size(GetLine *gl, int def_ncolumn, int def_nline,
GlTerminalSize *size);
static void _gl_replace_prompt(GetLine *gl, const char *prompt);
static int _gl_trap_signal(GetLine *gl, int signo, unsigned flags,
GlAfterSignal after, int errno_value);
static int _gl_raw_io(GetLine *gl, int redisplay);
static int _gl_normal_io(GetLine *gl);
static int _gl_completion_action(GetLine *gl, void *data, CplMatchFn *match_fn,
int list_only, const char *name,
const char *keyseq);
static int _gl_register_action(GetLine *gl, void *data, GlActionFn *fn,
const char *name, const char *keyseq);
static int _gl_io_mode(GetLine *gl, GlIOMode mode);
static int _gl_set_term_size(GetLine *gl, int ncolumn, int nline);
static int _gl_append_history(GetLine *gl, const char *line);
/*
* Reset the completion status and associated errno value in
* gl->rtn_status and gl->rtn_errno.
*/
static void gl_clear_status(GetLine *gl);
/*
* Record a completion status, unless a previous abnormal completion
* status has already been recorded for the current call.
*/
static void gl_record_status(GetLine *gl, GlReturnStatus rtn_status,
int rtn_errno);
/*
* Set the maximum length of a line in a user's tecla configuration
* file (not counting comments).
*/
#define GL_CONF_BUFLEN 100
/*
* Set the maximum number of arguments supported by individual commands
* in tecla configuration files.
*/
#define GL_CONF_MAXARG 10
/*
* Prototype the available action functions.
*/
static KT_KEY_FN(gl_user_interrupt);
static KT_KEY_FN(gl_abort);
static KT_KEY_FN(gl_suspend);
static KT_KEY_FN(gl_stop_output);
static KT_KEY_FN(gl_start_output);
static KT_KEY_FN(gl_literal_next);
static KT_KEY_FN(gl_cursor_left);
static KT_KEY_FN(gl_cursor_right);
static KT_KEY_FN(gl_insert_mode);
static KT_KEY_FN(gl_beginning_of_line);
static KT_KEY_FN(gl_end_of_line);
static KT_KEY_FN(gl_delete_line);
static KT_KEY_FN(gl_kill_line);
static KT_KEY_FN(gl_forward_word);
static KT_KEY_FN(gl_backward_word);
static KT_KEY_FN(gl_forward_delete_char);
static KT_KEY_FN(gl_backward_delete_char);
static KT_KEY_FN(gl_forward_delete_word);
static KT_KEY_FN(gl_backward_delete_word);
static KT_KEY_FN(gl_delete_refind);
static KT_KEY_FN(gl_delete_invert_refind);
static KT_KEY_FN(gl_delete_to_column);
static KT_KEY_FN(gl_delete_to_parenthesis);
static KT_KEY_FN(gl_forward_delete_find);
static KT_KEY_FN(gl_backward_delete_find);
static KT_KEY_FN(gl_forward_delete_to);
static KT_KEY_FN(gl_backward_delete_to);
static KT_KEY_FN(gl_upcase_word);
static KT_KEY_FN(gl_downcase_word);
static KT_KEY_FN(gl_capitalize_word);
static KT_KEY_FN(gl_redisplay);
static KT_KEY_FN(gl_clear_screen);
static KT_KEY_FN(gl_transpose_chars);
static KT_KEY_FN(gl_set_mark);
static KT_KEY_FN(gl_exchange_point_and_mark);
static KT_KEY_FN(gl_kill_region);
static KT_KEY_FN(gl_copy_region_as_kill);
static KT_KEY_FN(gl_yank);
static KT_KEY_FN(gl_up_history);
static KT_KEY_FN(gl_down_history);
static KT_KEY_FN(gl_history_search_backward);
static KT_KEY_FN(gl_history_re_search_backward);
static KT_KEY_FN(gl_history_search_forward);
static KT_KEY_FN(gl_history_re_search_forward);
static KT_KEY_FN(gl_complete_word);
#ifndef HIDE_FILE_SYSTEM
static KT_KEY_FN(gl_expand_filename);
static KT_KEY_FN(gl_read_from_file);
static KT_KEY_FN(gl_read_init_files);
static KT_KEY_FN(gl_list_glob);
#endif
static KT_KEY_FN(gl_del_char_or_list_or_eof);
static KT_KEY_FN(gl_list_or_eof);
static KT_KEY_FN(gl_beginning_of_history);
static KT_KEY_FN(gl_end_of_history);
static KT_KEY_FN(gl_digit_argument);
static KT_KEY_FN(gl_newline);
static KT_KEY_FN(gl_repeat_history);
static KT_KEY_FN(gl_vi_insert);
static KT_KEY_FN(gl_vi_overwrite);
static KT_KEY_FN(gl_change_case);
static KT_KEY_FN(gl_vi_insert_at_bol);
static KT_KEY_FN(gl_vi_append_at_eol);
static KT_KEY_FN(gl_vi_append);
static KT_KEY_FN(gl_backward_kill_line);
static KT_KEY_FN(gl_goto_column);
static KT_KEY_FN(gl_forward_to_word);
static KT_KEY_FN(gl_vi_replace_char);
static KT_KEY_FN(gl_vi_change_rest_of_line);
static KT_KEY_FN(gl_vi_change_line);
static KT_KEY_FN(gl_vi_change_to_bol);
static KT_KEY_FN(gl_vi_change_refind);
static KT_KEY_FN(gl_vi_change_invert_refind);
static KT_KEY_FN(gl_vi_change_to_column);
static KT_KEY_FN(gl_vi_change_to_parenthesis);
static KT_KEY_FN(gl_vi_forward_change_word);
static KT_KEY_FN(gl_vi_backward_change_word);
static KT_KEY_FN(gl_vi_forward_change_find);
static KT_KEY_FN(gl_vi_backward_change_find);
static KT_KEY_FN(gl_vi_forward_change_to);
static KT_KEY_FN(gl_vi_backward_change_to);
static KT_KEY_FN(gl_vi_forward_change_char);
static KT_KEY_FN(gl_vi_backward_change_char);
static KT_KEY_FN(gl_forward_copy_char);
static KT_KEY_FN(gl_backward_copy_char);
static KT_KEY_FN(gl_forward_find_char);
static KT_KEY_FN(gl_backward_find_char);
static KT_KEY_FN(gl_forward_to_char);
static KT_KEY_FN(gl_backward_to_char);
static KT_KEY_FN(gl_repeat_find_char);
static KT_KEY_FN(gl_invert_refind_char);
static KT_KEY_FN(gl_append_yank);
static KT_KEY_FN(gl_backward_copy_word);
static KT_KEY_FN(gl_forward_copy_word);
static KT_KEY_FN(gl_copy_to_bol);
static KT_KEY_FN(gl_copy_refind);
static KT_KEY_FN(gl_copy_invert_refind);
static KT_KEY_FN(gl_copy_to_column);
static KT_KEY_FN(gl_copy_to_parenthesis);
static KT_KEY_FN(gl_copy_rest_of_line);
static KT_KEY_FN(gl_copy_line);
static KT_KEY_FN(gl_backward_copy_find);
static KT_KEY_FN(gl_forward_copy_find);
static KT_KEY_FN(gl_backward_copy_to);
static KT_KEY_FN(gl_forward_copy_to);
static KT_KEY_FN(gl_vi_undo);
static KT_KEY_FN(gl_emacs_editing_mode);
static KT_KEY_FN(gl_vi_editing_mode);
static KT_KEY_FN(gl_ring_bell);
static KT_KEY_FN(gl_vi_repeat_change);
static KT_KEY_FN(gl_find_parenthesis);
static KT_KEY_FN(gl_list_history);
static KT_KEY_FN(gl_list_completions);
static KT_KEY_FN(gl_run_external_action);
/*
* Name the available action functions.
*/
static const struct {const char *name; KT_KEY_FN(*fn);} gl_actions[] = {
{"user-interrupt", gl_user_interrupt},
{"abort", gl_abort},
{"suspend", gl_suspend},
{"stop-output", gl_stop_output},
{"start-output", gl_start_output},
{"literal-next", gl_literal_next},
{"cursor-right", gl_cursor_right},
{"cursor-left", gl_cursor_left},
{"insert-mode", gl_insert_mode},
{"beginning-of-line", gl_beginning_of_line},
{"end-of-line", gl_end_of_line},
{"delete-line", gl_delete_line},
{"kill-line", gl_kill_line},
{"forward-word", gl_forward_word},
{"backward-word", gl_backward_word},
{"forward-delete-char", gl_forward_delete_char},
{"backward-delete-char", gl_backward_delete_char},
{"forward-delete-word", gl_forward_delete_word},
{"backward-delete-word", gl_backward_delete_word},
{"delete-refind", gl_delete_refind},
{"delete-invert-refind", gl_delete_invert_refind},
{"delete-to-column", gl_delete_to_column},
{"delete-to-parenthesis", gl_delete_to_parenthesis},
{"forward-delete-find", gl_forward_delete_find},
{"backward-delete-find", gl_backward_delete_find},
{"forward-delete-to", gl_forward_delete_to},
{"backward-delete-to", gl_backward_delete_to},
{"upcase-word", gl_upcase_word},
{"downcase-word", gl_downcase_word},
{"capitalize-word", gl_capitalize_word},
{"redisplay", gl_redisplay},
{"clear-screen", gl_clear_screen},
{"transpose-chars", gl_transpose_chars},
{"set-mark", gl_set_mark},
{"exchange-point-and-mark", gl_exchange_point_and_mark},
{"kill-region", gl_kill_region},
{"copy-region-as-kill", gl_copy_region_as_kill},
{"yank", gl_yank},
{"up-history", gl_up_history},
{"down-history", gl_down_history},
{"history-search-backward", gl_history_search_backward},
{"history-re-search-backward", gl_history_re_search_backward},
{"history-search-forward", gl_history_search_forward},
{"history-re-search-forward", gl_history_re_search_forward},
{"complete-word", gl_complete_word},
#ifndef HIDE_FILE_SYSTEM
{"expand-filename", gl_expand_filename},
{"read-from-file", gl_read_from_file},
{"read-init-files", gl_read_init_files},
{"list-glob", gl_list_glob},
#endif
{"del-char-or-list-or-eof", gl_del_char_or_list_or_eof},
{"beginning-of-history", gl_beginning_of_history},
{"end-of-history", gl_end_of_history},
{"digit-argument", gl_digit_argument},
{"newline", gl_newline},
{"repeat-history", gl_repeat_history},
{"vi-insert", gl_vi_insert},
{"vi-overwrite", gl_vi_overwrite},
{"vi-insert-at-bol", gl_vi_insert_at_bol},
{"vi-append-at-eol", gl_vi_append_at_eol},
{"vi-append", gl_vi_append},
{"change-case", gl_change_case},
{"backward-kill-line", gl_backward_kill_line},
{"goto-column", gl_goto_column},
{"forward-to-word", gl_forward_to_word},
{"vi-replace-char", gl_vi_replace_char},
{"vi-change-rest-of-line", gl_vi_change_rest_of_line},
{"vi-change-line", gl_vi_change_line},
{"vi-change-to-bol", gl_vi_change_to_bol},
{"vi-change-refind", gl_vi_change_refind},
{"vi-change-invert-refind", gl_vi_change_invert_refind},
{"vi-change-to-column", gl_vi_change_to_column},
{"vi-change-to-parenthesis", gl_vi_change_to_parenthesis},
{"forward-copy-char", gl_forward_copy_char},
{"backward-copy-char", gl_backward_copy_char},
{"forward-find-char", gl_forward_find_char},
{"backward-find-char", gl_backward_find_char},
{"forward-to-char", gl_forward_to_char},
{"backward-to-char", gl_backward_to_char},
{"repeat-find-char", gl_repeat_find_char},
{"invert-refind-char", gl_invert_refind_char},
{"append-yank", gl_append_yank},
{"backward-copy-word", gl_backward_copy_word},
{"forward-copy-word", gl_forward_copy_word},
{"copy-to-bol", gl_copy_to_bol},
{"copy-refind", gl_copy_refind},
{"copy-invert-refind", gl_copy_invert_refind},
{"copy-to-column", gl_copy_to_column},
{"copy-to-parenthesis", gl_copy_to_parenthesis},
{"copy-rest-of-line", gl_copy_rest_of_line},
{"copy-line", gl_copy_line},
{"backward-copy-find", gl_backward_copy_find},
{"forward-copy-find", gl_forward_copy_find},
{"backward-copy-to", gl_backward_copy_to},
{"forward-copy-to", gl_forward_copy_to},
{"list-or-eof", gl_list_or_eof},
{"vi-undo", gl_vi_undo},
{"vi-backward-change-word", gl_vi_backward_change_word},
{"vi-forward-change-word", gl_vi_forward_change_word},
{"vi-backward-change-find", gl_vi_backward_change_find},
{"vi-forward-change-find", gl_vi_forward_change_find},
{"vi-backward-change-to", gl_vi_backward_change_to},
{"vi-forward-change-to", gl_vi_forward_change_to},
{"vi-backward-change-char", gl_vi_backward_change_char},
{"vi-forward-change-char", gl_vi_forward_change_char},
{"emacs-mode", gl_emacs_editing_mode},
{"vi-mode", gl_vi_editing_mode},
{"ring-bell", gl_ring_bell},
{"vi-repeat-change", gl_vi_repeat_change},
{"find-parenthesis", gl_find_parenthesis},
{"list-history", gl_list_history},
};
/*
* Define the default key-bindings in emacs mode.
*/
static const KtKeyBinding gl_emacs_bindings[] = {
{"right", "cursor-right"},
{"^F", "cursor-right"},
{"left", "cursor-left"},
{"^B", "cursor-left"},
{"M-i", "insert-mode"},
{"M-I", "insert-mode"},
{"^A", "beginning-of-line"},
{"^E", "end-of-line"},
{"^U", "delete-line"},
{"^K", "kill-line"},
{"M-f", "forward-word"},
{"M-F", "forward-word"},
{"M-b", "backward-word"},
{"M-B", "backward-word"},
{"^D", "del-char-or-list-or-eof"},
{"^H", "backward-delete-char"},
{"^?", "backward-delete-char"},
{"M-d", "forward-delete-word"},
{"M-D", "forward-delete-word"},
{"M-^H", "backward-delete-word"},
{"M-^?", "backward-delete-word"},
{"M-u", "upcase-word"},
{"M-U", "upcase-word"},
{"M-l", "downcase-word"},
{"M-L", "downcase-word"},
{"M-c", "capitalize-word"},
{"M-C", "capitalize-word"},
{"^R", "redisplay"},
{"^L", "clear-screen"},
{"^T", "transpose-chars"},
{"^@", "set-mark"},
{"^X^X", "exchange-point-and-mark"},
{"^W", "kill-region"},
{"M-w", "copy-region-as-kill"},
{"M-W", "copy-region-as-kill"},
{"^Y", "yank"},
{"^P", "up-history"},
{"up", "up-history"},
{"^N", "down-history"},
{"down", "down-history"},
{"M-p", "history-search-backward"},
{"M-P", "history-search-backward"},
{"M-n", "history-search-forward"},
{"M-N", "history-search-forward"},
{"\t", "complete-word"},
#ifndef HIDE_FILE_SYSTEM
{"^X*", "expand-filename"},
{"^X^F", "read-from-file"},
{"^X^R", "read-init-files"},
{"^Xg", "list-glob"},
{"^XG", "list-glob"},
#endif
{"^Xh", "list-history"},
{"^XH", "list-history"},
{"M-<", "beginning-of-history"},
{"M->", "end-of-history"},
{"M-0", "digit-argument"},
{"M-1", "digit-argument"},
{"M-2", "digit-argument"},
{"M-3", "digit-argument"},
{"M-4", "digit-argument"},
{"M-5", "digit-argument"},
{"M-6", "digit-argument"},
{"M-7", "digit-argument"},
{"M-8", "digit-argument"},
{"M-9", "digit-argument"},
{"\r", "newline"},
{"\n", "newline"},
{"M-o", "repeat-history"},
{"M-C-v", "vi-mode"},
};
/*
* Define the default key-bindings in vi mode. Note that in vi-mode
* meta-key bindings are command-mode bindings. For example M-i first
* switches to command mode if not already in that mode, then moves
* the cursor one position right, as in vi.
*/
static const KtKeyBinding gl_vi_bindings[] = {
{"^D", "list-or-eof"},
#ifndef HIDE_FILE_SYSTEM
{"^G", "list-glob"},
#endif
{"^H", "backward-delete-char"},
{"\t", "complete-word"},
{"\r", "newline"},
{"\n", "newline"},
{"^L", "clear-screen"},
{"^N", "down-history"},
{"^P", "up-history"},
{"^R", "redisplay"},
{"^U", "backward-kill-line"},
{"^W", "backward-delete-word"},
#ifndef HIDE_FILE_SYSTEM
{"^X^F", "read-from-file"},
{"^X^R", "read-init-files"},
{"^X*", "expand-filename"},
#endif
{"^?", "backward-delete-char"},
{"M- ", "cursor-right"},
{"M-$", "end-of-line"},
#ifndef HIDE_FILE_SYSTEM
{"M-*", "expand-filename"},
#endif
{"M-+", "down-history"},
{"M--", "up-history"},
{"M-<", "beginning-of-history"},
{"M->", "end-of-history"},
{"M-^", "beginning-of-line"},
{"M-;", "repeat-find-char"},
{"M-,", "invert-refind-char"},
{"M-|", "goto-column"},
{"M-~", "change-case"},
{"M-.", "vi-repeat-change"},
{"M-%", "find-parenthesis"},
{"M-0", "digit-argument"},
{"M-1", "digit-argument"},
{"M-2", "digit-argument"},
{"M-3", "digit-argument"},
{"M-4", "digit-argument"},
{"M-5", "digit-argument"},
{"M-6", "digit-argument"},
{"M-7", "digit-argument"},
{"M-8", "digit-argument"},
{"M-9", "digit-argument"},
{"M-a", "vi-append"},
{"M-A", "vi-append-at-eol"},
{"M-b", "backward-word"},
{"M-B", "backward-word"},
{"M-C", "vi-change-rest-of-line"},
{"M-cb", "vi-backward-change-word"},
{"M-cB", "vi-backward-change-word"},
{"M-cc", "vi-change-line"},
{"M-ce", "vi-forward-change-word"},
{"M-cE", "vi-forward-change-word"},
{"M-cw", "vi-forward-change-word"},
{"M-cW", "vi-forward-change-word"},
{"M-cF", "vi-backward-change-find"},
{"M-cf", "vi-forward-change-find"},
{"M-cT", "vi-backward-change-to"},
{"M-ct", "vi-forward-change-to"},
{"M-c;", "vi-change-refind"},
{"M-c,", "vi-change-invert-refind"},
{"M-ch", "vi-backward-change-char"},
{"M-c^H", "vi-backward-change-char"},
{"M-c^?", "vi-backward-change-char"},
{"M-cl", "vi-forward-change-char"},
{"M-c ", "vi-forward-change-char"},
{"M-c^", "vi-change-to-bol"},
{"M-c0", "vi-change-to-bol"},
{"M-c$", "vi-change-rest-of-line"},
{"M-c|", "vi-change-to-column"},
{"M-c%", "vi-change-to-parenthesis"},
{"M-dh", "backward-delete-char"},
{"M-d^H", "backward-delete-char"},
{"M-d^?", "backward-delete-char"},
{"M-dl", "forward-delete-char"},
{"M-d ", "forward-delete-char"},
{"M-dd", "delete-line"},
{"M-db", "backward-delete-word"},
{"M-dB", "backward-delete-word"},
{"M-de", "forward-delete-word"},
{"M-dE", "forward-delete-word"},
{"M-dw", "forward-delete-word"},
{"M-dW", "forward-delete-word"},
{"M-dF", "backward-delete-find"},
{"M-df", "forward-delete-find"},
{"M-dT", "backward-delete-to"},
{"M-dt", "forward-delete-to"},
{"M-d;", "delete-refind"},
{"M-d,", "delete-invert-refind"},
{"M-d^", "backward-kill-line"},
{"M-d0", "backward-kill-line"},
{"M-d$", "kill-line"},
{"M-D", "kill-line"},
{"M-d|", "delete-to-column"},
{"M-d%", "delete-to-parenthesis"},
{"M-e", "forward-word"},
{"M-E", "forward-word"},
{"M-f", "forward-find-char"},
{"M-F", "backward-find-char"},
{"M--", "up-history"},
{"M-h", "cursor-left"},
{"M-H", "beginning-of-history"},
{"M-i", "vi-insert"},
{"M-I", "vi-insert-at-bol"},
{"M-j", "down-history"},
{"M-J", "history-search-forward"},
{"M-k", "up-history"},
{"M-K", "history-search-backward"},
{"M-l", "cursor-right"},
{"M-L", "end-of-history"},
{"M-n", "history-re-search-forward"},
{"M-N", "history-re-search-backward"},
{"M-p", "append-yank"},
{"M-P", "yank"},
{"M-r", "vi-replace-char"},
{"M-R", "vi-overwrite"},
{"M-s", "vi-forward-change-char"},
{"M-S", "vi-change-line"},
{"M-t", "forward-to-char"},
{"M-T", "backward-to-char"},
{"M-u", "vi-undo"},
{"M-w", "forward-to-word"},
{"M-W", "forward-to-word"},
{"M-x", "forward-delete-char"},
{"M-X", "backward-delete-char"},
{"M-yh", "backward-copy-char"},
{"M-y^H", "backward-copy-char"},
{"M-y^?", "backward-copy-char"},
{"M-yl", "forward-copy-char"},
{"M-y ", "forward-copy-char"},
{"M-ye", "forward-copy-word"},
{"M-yE", "forward-copy-word"},
{"M-yw", "forward-copy-word"},
{"M-yW", "forward-copy-word"},
{"M-yb", "backward-copy-word"},
{"M-yB", "backward-copy-word"},
{"M-yf", "forward-copy-find"},
{"M-yF", "backward-copy-find"},
{"M-yt", "forward-copy-to"},
{"M-yT", "backward-copy-to"},
{"M-y;", "copy-refind"},
{"M-y,", "copy-invert-refind"},
{"M-y^", "copy-to-bol"},
{"M-y0", "copy-to-bol"},
{"M-y$", "copy-rest-of-line"},
{"M-yy", "copy-line"},
{"M-Y", "copy-line"},
{"M-y|", "copy-to-column"},
{"M-y%", "copy-to-parenthesis"},
{"M-^E", "emacs-mode"},
{"M-^H", "cursor-left"},
{"M-^?", "cursor-left"},
{"M-^L", "clear-screen"},
{"M-^N", "down-history"},
{"M-^P", "up-history"},
{"M-^R", "redisplay"},
{"M-^D", "list-or-eof"},
{"M-\r", "newline"},
{"M-\t", "complete-word"},
{"M-\n", "newline"},
#ifndef HIDE_FILE_SYSTEM
{"M-^X^R", "read-init-files"},
#endif
{"M-^Xh", "list-history"},
{"M-^XH", "list-history"},
{"down", "down-history"},
{"up", "up-history"},
{"left", "cursor-left"},
{"right", "cursor-right"},
};
/*.......................................................................
* Create a new GetLine object.
*
* Input:
* linelen size_t The maximum line length to allow for.
* histlen size_t The number of bytes to allocate for recording
* a circular buffer of history lines.
* Output:
* return GetLine * The new object, or NULL on error.
*/
GetLine *new_GetLine(size_t linelen, size_t histlen)
{
GetLine *gl; /* The object to be returned */
int i;
/*
* Check the arguments.
*/
if(linelen < 10) {
errno = ENOMEM;
return NULL;
};
/*
* Allocate the container.
*/
gl = (GetLine *) malloc(sizeof(GetLine));
if(!gl) {
errno = ENOMEM;
return NULL;
};
/*
* Before attempting any operation that might fail, initialize the
* container at least up to the point at which it can safely be passed
* to del_GetLine().
*/
gl->err = NULL;
gl->glh = NULL;
gl->cpl = NULL;
#ifndef HIDE_FILE_SYSTEM
gl->cplfn.fn = cpl_file_completions;
#else
gl->cplfn.fn = gl_no_completions;
#endif
gl->cplfn.data = NULL;
#ifndef WITHOUT_FILE_SYSTEM
gl->ef = NULL;
#endif
gl->capmem = NULL;
gl->cq = NULL;
gl->input_fd = -1;
gl->output_fd = -1;
gl->input_fp = NULL;
gl->output_fp = NULL;
gl->file_fp = NULL;
gl->term = NULL;
gl->is_term = 0;
gl->flush_fn = gl_flush_terminal;
gl->io_mode = GL_NORMAL_MODE;
gl->raw_mode = 0;
gl->pending_io = GLP_WRITE; /* We will start by writing the prompt */
gl_clear_status(gl);
gl->linelen = linelen;
gl->line = NULL;
gl->cutbuf = NULL;
gl->prompt = NULL;
gl->prompt_len = 0;
gl->prompt_changed = 0;
gl->prompt_style = GL_LITERAL_PROMPT;
gl->cpl_mem = NULL;
gl->ext_act_mem = NULL;
gl->sig_mem = NULL;
gl->sigs = NULL;
gl->signals_masked = 0;
gl->signals_overriden = 0;
sigemptyset(&gl->all_signal_set);
sigemptyset(&gl->old_signal_set);
sigemptyset(&gl->use_signal_set);
gl->bindings = NULL;
gl->ntotal = 0;
gl->buff_curpos = 0;
gl->term_curpos = 0;
gl->term_len = 0;
gl->buff_mark = 0;
gl->insert_curpos = 0;
gl->insert = 1;
gl->number = -1;
gl->endline = 1;
gl->displayed = 0;
gl->redisplay = 0;
gl->postpone = 0;
gl->keybuf[0]='\0';
gl->nbuf = 0;
gl->nread = 0;
gl->current_action.fn = 0;
gl->current_action.data = NULL;
gl->current_count = 0;
gl->preload_id = 0;
gl->preload_history = 0;
gl->keyseq_count = 0;
gl->last_search = -1;
gl->editor = GL_EMACS_MODE;
gl->silence_bell = 0;
gl->automatic_history = 1;
gl->vi.undo.line = NULL;
gl->vi.undo.buff_curpos = 0;
gl->vi.undo.ntotal = 0;
gl->vi.undo.saved = 0;
gl->vi.repeat.action.fn = 0;
gl->vi.repeat.action.data = 0;
gl->vi.repeat.count = 0;
gl->vi.repeat.input_curpos = 0;
gl->vi.repeat.command_curpos = 0;
gl->vi.repeat.input_char = '\0';
gl->vi.repeat.saved = 0;
gl->vi.repeat.active = 0;
gl->vi.command = 0;
gl->vi.find_forward = 0;
gl->vi.find_onto = 0;
gl->vi.find_char = '\0';
gl->left = NULL;
gl->right = NULL;
gl->up = NULL;
gl->down = NULL;
gl->home = NULL;
gl->bol = 0;
gl->clear_eol = NULL;
gl->clear_eod = NULL;
gl->u_arrow = NULL;
gl->d_arrow = NULL;
gl->l_arrow = NULL;
gl->r_arrow = NULL;
gl->sound_bell = NULL;
gl->bold = NULL;
gl->underline = NULL;
gl->standout = NULL;
gl->dim = NULL;
gl->reverse = NULL;
gl->blink = NULL;
gl->text_attr_off = NULL;
gl->nline = 0;
gl->ncolumn = 0;
#ifdef USE_TERMINFO
gl->left_n = NULL;
gl->right_n = NULL;
#elif defined(USE_TERMCAP)
gl->tgetent_buf = NULL;
gl->tgetstr_buf = NULL;
#endif
gl->app_file = NULL;
gl->user_file = NULL;
gl->configured = 0;
gl->echo = 1;
gl->last_signal = -1;
#ifdef HAVE_SELECT
gl->fd_node_mem = NULL;
gl->fd_nodes = NULL;
FD_ZERO(&gl->rfds);
FD_ZERO(&gl->wfds);
FD_ZERO(&gl->ufds);
gl->max_fd = 0;
gl->timer.dt.tv_sec = 0;
gl->timer.dt.tv_usec = 0;
gl->timer.fn = 0;
gl->timer.data = NULL;
#endif
/*
* Allocate an error reporting buffer.
*/
gl->err = _new_ErrMsg();
if(!gl->err)
return del_GetLine(gl);
/*
* Allocate the history buffer.
*/
gl->glh = _new_GlHistory(histlen);
if(!gl->glh)
return del_GetLine(gl);
/*
* Allocate the resource object for file-completion.
*/
gl->cpl = new_WordCompletion();
if(!gl->cpl)
return del_GetLine(gl);
/*
* Allocate the resource object for file-completion.
*/
#ifndef WITHOUT_FILE_SYSTEM
gl->ef = new_ExpandFile();
if(!gl->ef)
return del_GetLine(gl);
#endif
/*
* Allocate a string-segment memory allocator for use in storing terminal
* capablity strings.
*/
gl->capmem = _new_StringGroup(CAPMEM_SEGMENT_SIZE);
if(!gl->capmem)
return del_GetLine(gl);
/*
* Allocate the character queue that is used to buffer terminal output.
*/
gl->cq = _new_GlCharQueue();
if(!gl->cq)
return del_GetLine(gl);
/*
* Allocate a line buffer, leaving 2 extra characters for the terminating
* '\n' and '\0' characters
*/
gl->line = (char *) malloc(linelen + 2);
if(!gl->line) {
errno = ENOMEM;
return del_GetLine(gl);
};
/*
* Start with an empty input line.
*/
gl_truncate_buffer(gl, 0);
/*
* Allocate a cut buffer.
*/
gl->cutbuf = (char *) malloc(linelen + 2);
if(!gl->cutbuf) {
errno = ENOMEM;
return del_GetLine(gl);
};
gl->cutbuf[0] = '\0';
/*
* Allocate an initial empty prompt.
*/
_gl_replace_prompt(gl, NULL);
if(!gl->prompt) {
errno = ENOMEM;
return del_GetLine(gl);
};
/*
* Allocate a vi undo buffer.
*/
gl->vi.undo.line = (char *) malloc(linelen + 2);
if(!gl->vi.undo.line) {
errno = ENOMEM;
return del_GetLine(gl);
};
gl->vi.undo.line[0] = '\0';
/*
* Allocate a freelist from which to allocate nodes for the list
* of completion functions.
*/
gl->cpl_mem = _new_FreeList(sizeof(GlCplCallback), GL_CPL_FREELIST_BLOCKING);
if(!gl->cpl_mem)
return del_GetLine(gl);
/*
* Allocate a freelist from which to allocate nodes for the list
* of external action functions.
*/
gl->ext_act_mem = _new_FreeList(sizeof(GlExternalAction),
GL_EXT_ACT_FREELIST_BLOCKING);
if(!gl->ext_act_mem)
return del_GetLine(gl);
/*
* Allocate a freelist from which to allocate nodes for the list
* of signals.
*/
gl->sig_mem = _new_FreeList(sizeof(GlSignalNode), GLS_FREELIST_BLOCKING);
if(!gl->sig_mem)
return del_GetLine(gl);
/*
* Install initial dispositions for the default list of signals that
* gl_get_line() traps.
*/
for(i=0; isigno, sig->flags, sig->after,
sig->errno_value))
return del_GetLine(gl);
};
/*
* Allocate an empty table of key bindings.
*/
gl->bindings = _new_KeyTab();
if(!gl->bindings)
return del_GetLine(gl);
/*
* Define the available actions that can be bound to key sequences.
*/
for(i=0; ibindings, gl_actions[i].name, gl_actions[i].fn, NULL))
return del_GetLine(gl);
};
/*
* Set up the default bindings.
*/
if(gl_change_editor(gl, gl->editor))
return del_GetLine(gl);
/*
* Allocate termcap buffers.
*/
#ifdef USE_TERMCAP
gl->tgetent_buf = (char *) malloc(TERMCAP_BUF_SIZE);
gl->tgetstr_buf = (char *) malloc(TERMCAP_BUF_SIZE);
if(!gl->tgetent_buf || !gl->tgetstr_buf) {
errno = ENOMEM;
return del_GetLine(gl);
};
#endif
/*
* Set up for I/O assuming stdin and stdout.
*/
if(_gl_change_terminal(gl, stdin, stdout, getenv("TERM")))
return del_GetLine(gl);
/*
* Create a freelist for use in allocating GlFdNode list nodes.
*/
#ifdef HAVE_SELECT
gl->fd_node_mem = _new_FreeList(sizeof(GlFdNode), GLFD_FREELIST_BLOCKING);
if(!gl->fd_node_mem)
return del_GetLine(gl);
#endif
/*
* We are done for now.
*/
return gl;
}
/*.......................................................................
* Delete a GetLine object.
*
* Input:
* gl GetLine * The object to be deleted.
* Output:
* return GetLine * The deleted object (always NULL).
*/
GetLine *del_GetLine(GetLine *gl)
{
if(gl) {
/*
* If the terminal is in raw server mode, reset it.
*/
_gl_normal_io(gl);
/*
* Deallocate all objects contained by gl.
*/
gl->err = _del_ErrMsg(gl->err);
gl->glh = _del_GlHistory(gl->glh);
gl->cpl = del_WordCompletion(gl->cpl);
#ifndef WITHOUT_FILE_SYSTEM
gl->ef = del_ExpandFile(gl->ef);
#endif
gl->capmem = _del_StringGroup(gl->capmem);
gl->cq = _del_GlCharQueue(gl->cq);
if(gl->file_fp)
fclose(gl->file_fp);
if(gl->term)
free(gl->term);
if(gl->line)
free(gl->line);
if(gl->cutbuf)
free(gl->cutbuf);
if(gl->prompt)
free(gl->prompt);
gl->cpl_mem = _del_FreeList(gl->cpl_mem, 1);
gl->ext_act_mem = _del_FreeList(gl->ext_act_mem, 1);
gl->sig_mem = _del_FreeList(gl->sig_mem, 1);
gl->sigs = NULL; /* Already freed by freeing sig_mem */
gl->bindings = _del_KeyTab(gl->bindings);
if(gl->vi.undo.line)
free(gl->vi.undo.line);
#ifdef USE_TERMCAP
if(gl->tgetent_buf)
free(gl->tgetent_buf);
if(gl->tgetstr_buf)
free(gl->tgetstr_buf);
#endif
if(gl->app_file)
free(gl->app_file);
if(gl->user_file)
free(gl->user_file);
#ifdef HAVE_SELECT
gl->fd_node_mem = _del_FreeList(gl->fd_node_mem, 1);
gl->fd_nodes = NULL; /* Already freed by freeing gl->fd_node_mem */
#endif
/*
* Delete the now empty container.
*/
free(gl);
};
return NULL;
}
/*.......................................................................
* Bind a control or meta character to an action.
*
* Input:
* gl GetLine * The resource object of this program.
* binder KtBinder The source of the binding.
* c char The control or meta character.
* If this is '\0', the call is ignored.
* action const char * The action name to bind the key to.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int gl_bind_control_char(GetLine *gl, KtBinder binder, char c,
const char *action)
{
char keyseq[2];
/*
* Quietly reject binding to the NUL control character, since this
* is an ambiguous prefix of all bindings.
*/
if(c == '\0')
return 0;
/*
* Making sure not to bind characters which aren't either control or
* meta characters.
*/
if(IS_CTRL_CHAR(c) || IS_META_CHAR(c)) {
keyseq[0] = c;
keyseq[1] = '\0';
} else {
return 0;
};
/*
* Install the binding.
*/
if(_kt_set_keybinding(gl->bindings, binder, keyseq, action)) {
_err_record_msg(gl->err, _kt_last_error(gl->bindings), END_ERR_MSG);
return 1;
};
return 0;
}
/*.......................................................................
* Read a line from the user.
*
* Input:
* gl GetLine * A resource object returned by new_GetLine().
* prompt char * The prompt to prefix the line with.
* start_line char * The initial contents of the input line, or NULL
* if it should start out empty.
* start_pos int If start_line isn't NULL, this specifies the
* index of the character over which the cursor
* should initially be positioned within the line.
* If you just want it to follow the last character
* of the line, send -1.
* Output:
* return char * An internal buffer containing the input line, or
* NULL at the end of input. If the line fitted in
* the buffer there will be a '\n' newline character
* before the terminating '\0'. If it was truncated
* there will be no newline character, and the remains
* of the line should be retrieved via further calls
* to this function.
*/
char *gl_get_line(GetLine *gl, const char *prompt,
const char *start_line, int start_pos)
{
char *retval; /* The return value of _gl_get_line() */
/*
* Check the arguments.
*/
if(!gl) {
errno = EINVAL;
return NULL;
};
/*
* Temporarily block all of the signals that we have been asked to trap.
*/
if(gl_mask_signals(gl, &gl->old_signal_set))
return NULL;
/*
* Perform the command-line editing task.
*/
retval = _gl_get_line(gl, prompt, start_line, start_pos);
/*
* Restore the process signal mask to how it was when this function was
* first called.
*/
gl_unmask_signals(gl, &gl->old_signal_set);
return retval;
}
/*.......................................................................
* This is the main body of the public function gl_get_line().
*/
static char *_gl_get_line(GetLine *gl, const char *prompt,
const char *start_line, int start_pos)
{
int waserr = 0; /* True if an error occurs */
/*
* Assume that this call will successfully complete the input
* line until proven otherwise.
*/
gl_clear_status(gl);
/*
* If this is the first call to this function since new_GetLine(),
* complete any postponed configuration.
*/
if(!gl->configured) {
(void) _gl_configure_getline(gl, NULL, NULL, TECLA_CONFIG_FILE);
gl->configured = 1;
};
/*
* Before installing our signal handler functions, record the fact
* that there are no pending signals.
*/
gl_pending_signal = -1;
/*
* Temporarily override the signal handlers of the calling program,
* so that we can intercept signals that would leave the terminal
* in a bad state.
*/
waserr = gl_override_signal_handlers(gl);
/*
* After recording the current terminal settings, switch the terminal
* into raw input mode.
*/
waserr = waserr || _gl_raw_io(gl, 1);
/*
* Attempt to read the line. This will require more than one attempt if
* either a current temporary input file is opened by gl_get_input_line()
* or the end of a temporary input file is reached by gl_read_stream_line().
*/
while(!waserr) {
/*
* Read a line from a non-interactive stream?
*/
if(gl->file_fp || !gl->is_term) {
if(gl_read_stream_line(gl)==0) {
break;
} else if(gl->file_fp) {
gl_revert_input(gl);
gl_record_status(gl, GLR_NEWLINE, 0);
} else {
waserr = 1;
break;
};
};
/*
* Read from the terminal? Note that the above if() block may have
* changed gl->file_fp, so it is necessary to retest it here, rather
* than using an else statement.
*/
if(!gl->file_fp && gl->is_term) {
if(gl_get_input_line(gl, prompt, start_line, start_pos))
waserr = 1;
else
break;
};
};
/*
* If an error occurred, but gl->rtn_status is still set to
* GLR_NEWLINE, change the status to GLR_ERROR. Otherwise
* leave it at whatever specific value was assigned by the function
* that aborted input. This means that only functions that trap
* non-generic errors have to remember to update gl->rtn_status
* themselves.
*/
if(waserr && gl->rtn_status == GLR_NEWLINE)
gl_record_status(gl, GLR_ERROR, errno);
/*
* Restore terminal settings.
*/
if(gl->io_mode != GL_SERVER_MODE)
_gl_normal_io(gl);
/*
* Restore the signal handlers.
*/
gl_restore_signal_handlers(gl);
/*
* If gl_get_line() gets aborted early, the errno value associated
* with the event that caused this to happen is recorded in
* gl->rtn_errno. Since errno may have been overwritten by cleanup
* functions after this, restore its value to the value that it had
* when the error condition occured, so that the caller can examine it
* to find out what happened.
*/
errno = gl->rtn_errno;
/*
* Check the completion status to see how to return.
*/
switch(gl->rtn_status) {
case GLR_NEWLINE: /* Success */
return gl->line;
case GLR_BLOCKED: /* These events abort the current input line, */
case GLR_SIGNAL: /* when in normal blocking I/O mode, but only */
case GLR_TIMEOUT: /* temporarily pause line editing when in */
case GLR_FDABORT: /* non-blocking server I/O mode. */
if(gl->io_mode != GL_SERVER_MODE)
_gl_abandon_line(gl);
return NULL;
case GLR_ERROR: /* Unrecoverable errors abort the input line, */
case GLR_EOF: /* regardless of the I/O mode. */
default:
_gl_abandon_line(gl);
return NULL;
};
}
/*.......................................................................
* Read a single character from the user.
*
* Input:
* gl GetLine * A resource object returned by new_GetLine().
* prompt char * The prompt to prefix the line with, or NULL if
* no prompt is required.
* defchar char The character to substitute if the
* user simply hits return, or '\n' if you don't
* need to substitute anything.
* Output:
* return int The character that was read, or EOF if the read
* had to be aborted (in which case you can call
* gl_return_status() to find out why).
*/
int gl_query_char(GetLine *gl, const char *prompt, char defchar)
{
int retval; /* The return value of _gl_query_char() */
/*
* Check the arguments.
*/
if(!gl) {
errno = EINVAL;
return EOF;
};
/*
* Temporarily block all of the signals that we have been asked to trap.
*/
if(gl_mask_signals(gl, &gl->old_signal_set))
return EOF;
/*
* Perform the character reading task.
*/
retval = _gl_query_char(gl, prompt, defchar);
/*
* Restore the process signal mask to how it was when this function was
* first called.
*/
gl_unmask_signals(gl, &gl->old_signal_set);
return retval;
}
/*.......................................................................
* This is the main body of the public function gl_query_char().
*/
static int _gl_query_char(GetLine *gl, const char *prompt, char defchar)
{
int c = EOF; /* The character to be returned */
int waserr = 0; /* True if an error occurs */
/*
* Assume that this call will successfully complete the input operation
* until proven otherwise.
*/
gl_clear_status(gl);
/*
* If this is the first call to this function or gl_get_line(),
* since new_GetLine(), complete any postponed configuration.
*/
if(!gl->configured) {
(void) _gl_configure_getline(gl, NULL, NULL, TECLA_CONFIG_FILE);
gl->configured = 1;
};
/*
* Before installing our signal handler functions, record the fact
* that there are no pending signals.
*/
gl_pending_signal = -1;
/*
* Temporarily override the signal handlers of the calling program,
* so that we can intercept signals that would leave the terminal
* in a bad state.
*/
waserr = gl_override_signal_handlers(gl);
/*
* After recording the current terminal settings, switch the terminal
* into raw input mode without redisplaying any partially entered
* input line.
*/
waserr = waserr || _gl_raw_io(gl, 0);
/*
* Attempt to read the line. This will require more than one attempt if
* either a current temporary input file is opened by gl_get_input_line()
* or the end of a temporary input file is reached by gl_read_stream_line().
*/
while(!waserr) {
/*
* Read a line from a non-interactive stream?
*/
if(gl->file_fp || !gl->is_term) {
c = gl_read_stream_char(gl);
if(c != EOF) { /* Success? */
if(c=='\n') c = defchar;
break;
} else if(gl->file_fp) { /* End of temporary input file? */
gl_revert_input(gl);
gl_record_status(gl, GLR_NEWLINE, 0);
} else { /* An error? */
waserr = 1;
break;
};
};
/*
* Read from the terminal? Note that the above if() block may have
* changed gl->file_fp, so it is necessary to retest it here, rather
* than using an else statement.
*/
if(!gl->file_fp && gl->is_term) {
c = gl_get_query_char(gl, prompt, defchar);
if(c==EOF)
waserr = 1;
else
break;
};
};
/*
* If an error occurred, but gl->rtn_status is still set to
* GLR_NEWLINE, change the status to GLR_ERROR. Otherwise
* leave it at whatever specific value was assigned by the function
* that aborted input. This means that only functions that trap
* non-generic errors have to remember to update gl->rtn_status
* themselves.
*/
if(waserr && gl->rtn_status == GLR_NEWLINE)
gl_record_status(gl, GLR_ERROR, errno);
/*
* Restore terminal settings.
*/
if(gl->io_mode != GL_SERVER_MODE)
_gl_normal_io(gl);
/*
* Restore the signal handlers.
*/
gl_restore_signal_handlers(gl);
/*
* If this function gets aborted early, the errno value associated
* with the event that caused this to happen is recorded in
* gl->rtn_errno. Since errno may have been overwritten by cleanup
* functions after this, restore its value to the value that it had
* when the error condition occured, so that the caller can examine it
* to find out what happened.
*/
errno = gl->rtn_errno;
/*
* Error conditions are signalled to the caller, by setting the returned
* character to EOF.
*/
if(gl->rtn_status != GLR_NEWLINE)
c = EOF;
/*
* In this mode, every character that is read is a completed
* transaction, just like reading a completed input line, so prepare
* for the next input line or character.
*/
_gl_abandon_line(gl);
/*
* Return the acquired character.
*/
return c;
}
/*.......................................................................
* Record of the signal handlers of the calling program, so that they
* can be restored later.
*
* Input:
* gl GetLine * The resource object of this library.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int gl_override_signal_handlers(GetLine *gl)
{
GlSignalNode *sig; /* A node in the list of signals to be caught */
/*
* Set up our signal handler.
*/
SigAction act;
act.sa_handler = gl_signal_handler;
memcpy(&act.sa_mask, &gl->all_signal_set, sizeof(sigset_t));
act.sa_flags = 0;
/*
* Get the subset of the signals that we are supposed to trap that
* should actually be trapped.
*/
sigemptyset(&gl->use_signal_set);
for(sig=gl->sigs; sig; sig=sig->next) {
/*
* Trap this signal? If it is blocked by the calling program and we
* haven't been told to unblock it, don't arrange to trap this signal.
*/
if(sig->flags & GLS_UNBLOCK_SIG ||
!sigismember(&gl->old_signal_set, sig->signo)) {
if(sigaddset(&gl->use_signal_set, sig->signo) == -1) {
_err_record_msg(gl->err, "sigaddset error", END_ERR_MSG);
return 1;
};
};
};
/*
* Override the actions of the signals that we are trapping.
*/
for(sig=gl->sigs; sig; sig=sig->next) {
if(sigismember(&gl->use_signal_set, sig->signo)) {
sigdelset(&act.sa_mask, sig->signo);
if(sigaction(sig->signo, &act, &sig->original)) {
_err_record_msg(gl->err, "sigaction error", END_ERR_MSG);
return 1;
};
sigaddset(&act.sa_mask, sig->signo);
};
};
/*
* Record the fact that the application's signal handlers have now
* been overriden.
*/
gl->signals_overriden = 1;
/*
* Just in case a SIGWINCH signal was sent to the process while our
* SIGWINCH signal handler wasn't in place, check to see if the terminal
* size needs updating.
*/
if(_gl_update_size(gl))
return 1;
return 0;
}
/*.......................................................................
* Restore the signal handlers of the calling program.
*
* Input:
* gl GetLine * The resource object of this library.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int gl_restore_signal_handlers(GetLine *gl)
{
GlSignalNode *sig; /* A node in the list of signals to be caught */
/*
* Restore application signal handlers that were overriden
* by gl_override_signal_handlers().
*/
for(sig=gl->sigs; sig; sig=sig->next) {
if(sigismember(&gl->use_signal_set, sig->signo) &&
sigaction(sig->signo, &sig->original, NULL)) {
_err_record_msg(gl->err, "sigaction error", END_ERR_MSG);
return 1;
};
};
/*
* Record the fact that the application's signal handlers have now
* been restored.
*/
gl->signals_overriden = 0;
return 0;
}
/*.......................................................................
* This signal handler simply records the fact that a given signal was
* caught in the file-scope gl_pending_signal variable.
*/
static void gl_signal_handler(int signo)
{
gl_pending_signal = signo;
siglongjmp(gl_setjmp_buffer, 1);
}
/*.......................................................................
* Switch the terminal into raw mode after storing the previous terminal
* settings in gl->attributes.
*
* Input:
* gl GetLine * The resource object of this program.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int gl_raw_terminal_mode(GetLine *gl)
{
Termios newattr; /* The new terminal attributes */
/*
* If the terminal is already in raw mode, do nothing.
*/
if(gl->raw_mode)
return 0;
/*
* Record the current terminal attributes.
*/
if(tcgetattr(gl->input_fd, &gl->oldattr)) {
_err_record_msg(gl->err, "tcgetattr error", END_ERR_MSG);
return 1;
};
/*
* This function shouldn't do anything but record the current terminal
* attritubes if editing has been disabled.
*/
if(gl->editor == GL_NO_EDITOR)
return 0;
/*
* Modify the existing attributes.
*/
newattr = gl->oldattr;
/*
* Turn off local echo, canonical input mode and extended input processing.
*/
newattr.c_lflag &= ~(ECHO | ICANON | IEXTEN);
/*
* Don't translate carriage return to newline, turn off input parity
* checking, don't strip off 8th bit, turn off output flow control.
*/
newattr.c_iflag &= ~(ICRNL | INPCK | ISTRIP);
/*
* Clear size bits, turn off parity checking, and allow 8-bit characters.
*/
newattr.c_cflag &= ~(CSIZE | PARENB);
newattr.c_cflag |= CS8;
/*
* Turn off output processing.
*/
newattr.c_oflag &= ~(OPOST);
/*
* Request one byte at a time, without waiting.
*/
newattr.c_cc[VMIN] = gl->io_mode==GL_SERVER_MODE ? 0:1;
newattr.c_cc[VTIME] = 0;
/*
* Install the new terminal modes.
*/
while(tcsetattr(gl->input_fd, TCSADRAIN, &newattr)) {
if(errno != EINTR) {
_err_record_msg(gl->err, "tcsetattr error", END_ERR_MSG);
return 1;
};
};
/*
* Record the new terminal mode.
*/
gl->raw_mode = 1;
return 0;
}
/*.......................................................................
* Restore the terminal attributes recorded in gl->oldattr.
*
* Input:
* gl GetLine * The resource object of this library.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int gl_restore_terminal_attributes(GetLine *gl)
{
int waserr = 0;
/*
* If not in raw mode, do nothing.
*/
if(!gl->raw_mode)
return 0;
/*
* Before changing the terminal attributes, make sure that all output
* has been passed to the terminal.
*/
if(gl_flush_output(gl))
waserr = 1;
/*
* Reset the terminal attributes to the values that they had on
* entry to gl_get_line().
*/
while(tcsetattr(gl->input_fd, TCSADRAIN, &gl->oldattr)) {
if(errno != EINTR) {
_err_record_msg(gl->err, "tcsetattr error", END_ERR_MSG);
waserr = 1;
break;
};
};
/*
* Record the new terminal mode.
*/
gl->raw_mode = 0;
return waserr;
}
/*.......................................................................
* Switch the terminal file descriptor to use non-blocking I/O.
*
* Input:
* gl GetLine * The resource object of gl_get_line().
* fd int The file descriptor to make non-blocking.
*/
static int gl_nonblocking_io(GetLine *gl, int fd)
{
int fcntl_flags; /* The new file-descriptor control flags */
/*
* Is non-blocking I/O supported on this system? Note that even
* without non-blocking I/O, the terminal will probably still act as
* though it was non-blocking, because we also set the terminal
* attributes to return immediately if no input is available and we
* use select() to wait to be able to write. If select() also isn't
* available, then input will probably remain fine, but output could
* block, depending on the behaviour of the terminal driver.
*/
#if defined(NON_BLOCKING_FLAG)
/*
* Query the current file-control flags, and add the
* non-blocking I/O flag.
*/
fcntl_flags = fcntl(fd, F_GETFL) | NON_BLOCKING_FLAG;
/*
* Install the new control flags.
*/
if(fcntl(fd, F_SETFL, fcntl_flags) == -1) {
_err_record_msg(gl->err, "fcntl error", END_ERR_MSG);
return 1;
};
#endif
return 0;
}
/*.......................................................................
* Switch to blocking terminal I/O.
*
* Input:
* gl GetLine * The resource object of gl_get_line().
* fd int The file descriptor to make blocking.
*/
static int gl_blocking_io(GetLine *gl, int fd)
{
int fcntl_flags; /* The new file-descriptor control flags */
/*
* Is non-blocking I/O implemented on this system?
*/
#if defined(NON_BLOCKING_FLAG)
/*
* Query the current file control flags and remove the non-blocking
* I/O flag.
*/
fcntl_flags = fcntl(fd, F_GETFL) & ~NON_BLOCKING_FLAG;
/*
* Install the modified control flags.
*/
if(fcntl(fd, F_SETFL, fcntl_flags) == -1) {
_err_record_msg(gl->err, "fcntl error", END_ERR_MSG);
return 1;
};
#endif
return 0;
}
/*.......................................................................
* Read a new input line from the user.
*
* Input:
* gl GetLine * The resource object of this library.
* prompt char * The prompt to prefix the line with, or NULL to
* use the same prompt that was used by the previous
* line.
* start_line char * The initial contents of the input line, or NULL
* if it should start out empty.
* start_pos int If start_line isn't NULL, this specifies the
* index of the character over which the cursor
* should initially be positioned within the line.
* If you just want it to follow the last character
* of the line, send -1.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int gl_get_input_line(GetLine *gl, const char *prompt,
const char *start_line, int start_pos)
{
char c; /* The character being read */
/*
* Flush any pending output to the terminal.
*/
if(_glq_char_count(gl->cq) > 0 && gl_flush_output(gl))
return 1;
/*
* Are we starting a new line?
*/
if(gl->endline) {
/*
* Delete any incompletely enterred line.
*/
if(gl_erase_line(gl))
return 1;
/*
* Display the new line to be edited.
*/
if(gl_present_line(gl, prompt, start_line, start_pos))
return 1;
};
/*
* Read one character at a time.
*/
while(gl_read_terminal(gl, 1, &c) == 0) {
/*
* Increment the count of the number of key sequences entered.
*/
gl->keyseq_count++;
/*
* Interpret the character either as the start of a new key-sequence,
* as a continuation of a repeat count, or as a printable character
* to be added to the line.
*/
if(gl_interpret_char(gl, c))
break;
/*
* If we just ran an action function which temporarily asked for
* input to be taken from a file, abort this call.
*/
if(gl->file_fp)
return 0;
/*
* Has the line been completed?
*/
if(gl->endline)
return gl_line_ended(gl, c);
};
/*
* To get here, gl_read_terminal() must have returned non-zero. See
* whether a signal was caught that requested that the current line
* be returned.
*/
if(gl->endline)
return gl_line_ended(gl, '\n');
/*
* If I/O blocked while attempting to get the latest character
* of the key sequence, rewind the key buffer to allow interpretation of
* the current key sequence to be restarted on the next call to this
* function.
*/
if(gl->rtn_status == GLR_BLOCKED && gl->pending_io == GLP_READ)
gl->nread = 0;
return 1;
}
/*.......................................................................
* This is the private function of gl_query_char() that handles
* prompting the user, reading a character from the terminal, and
* displaying what the user entered.
*
* Input:
* gl GetLine * The resource object of this library.
* prompt char * The prompt to prefix the line with.
* defchar char The character to substitute if the
* user simply hits return, or '\n' if you don't
* need to substitute anything.
* Output:
* return int The character that was read, or EOF if something
* prevented a character from being read.
*/
static int gl_get_query_char(GetLine *gl, const char *prompt, int defchar)
{
char c; /* The character being read */
int retval; /* The return value of this function */
/*
* Flush any pending output to the terminal.
*/
if(_glq_char_count(gl->cq) > 0 && gl_flush_output(gl))
return EOF;
/*
* Delete any incompletely entered line.
*/
if(gl_erase_line(gl))
return EOF;
/*
* Reset the line input parameters and display the prompt, if any.
*/
if(gl_present_line(gl, prompt, NULL, 0))
return EOF;
/*
* Read one character.
*/
if(gl_read_terminal(gl, 1, &c) == 0) {
/*
* In this mode, count each character as being a new key-sequence.
*/
gl->keyseq_count++;
/*
* Delete the character that was read, from the key-press buffer.
*/
gl_discard_chars(gl, gl->nread);
/*
* Convert carriage returns to newlines.
*/
if(c == '\r')
c = '\n';
/*
* If the user just hit return, subsitute the default character.
*/
if(c == '\n')
c = defchar;
/*
* Display the entered character to the right of the prompt.
*/
if(c!='\n') {
if(gl_end_of_line(gl, 1, NULL)==0)
gl_print_char(gl, c, ' ');
};
/*
* Record the return character, and mark the call as successful.
*/
retval = c;
gl_record_status(gl, GLR_NEWLINE, 0);
/*
* Was a signal caught whose disposition is to cause the current input
* line to be returned? If so return a newline character.
*/
} else if(gl->endline) {
retval = '\n';
gl_record_status(gl, GLR_NEWLINE, 0);
} else {
retval = EOF;
};
/*
* Start a new line.
*/
if(gl_start_newline(gl, 1))
return EOF;
/*
* Attempt to flush any pending output.
*/
(void) gl_flush_output(gl);
/*
* Return either the character that was read, or EOF if an error occurred.
*/
return retval;
}
/*.......................................................................
* Add a character to the line buffer at the current cursor position,
* inserting or overwriting according the current mode.
*
* Input:
* gl GetLine * The resource object of this library.
* c char The character to be added.
* Output:
* return int 0 - OK.
* 1 - Insufficient room.
*/
static int gl_add_char_to_line(GetLine *gl, char c)
{
/*
* Keep a record of the current cursor position.
*/
int buff_curpos = gl->buff_curpos;
int term_curpos = gl->term_curpos;
/*
* Work out the displayed width of the new character.
*/
int width = gl_displayed_char_width(gl, c, term_curpos);
/*
* If we are in insert mode, or at the end of the line,
* check that we can accomodate a new character in the buffer.
* If not, simply return, leaving it up to the calling program
* to check for the absence of a newline character.
*/
if((gl->insert || buff_curpos >= gl->ntotal) && gl->ntotal >= gl->linelen)
return 0;
/*
* Are we adding characters to the line (ie. inserting or appending)?
*/
if(gl->insert || buff_curpos >= gl->ntotal) {
/*
* If inserting, make room for the new character.
*/
if(buff_curpos < gl->ntotal)
gl_make_gap_in_buffer(gl, buff_curpos, 1);
/*
* Copy the character into the buffer.
*/
gl_buffer_char(gl, c, buff_curpos);
gl->buff_curpos++;
/*
* Redraw the line from the cursor position to the end of the line,
* and move the cursor to just after the added character.
*/
if(gl_print_string(gl, gl->line + buff_curpos, '\0') ||
gl_set_term_curpos(gl, term_curpos + width))
return 1;
/*
* Are we overwriting an existing character?
*/
} else {
/*
* Get the width of the character being overwritten.
*/
int old_width = gl_displayed_char_width(gl, gl->line[buff_curpos],
term_curpos);
/*
* Overwrite the character in the buffer.
*/
gl_buffer_char(gl, c, buff_curpos);
/*
* If we are replacing with a narrower character, we need to
* redraw the terminal string to the end of the line, then
* overwrite the trailing old_width - width characters
* with spaces.
*/
if(old_width > width) {
if(gl_print_string(gl, gl->line + buff_curpos, '\0'))
return 1;
/*
* Clear to the end of the terminal.
*/
if(gl_truncate_display(gl))
return 1;
/*
* Move the cursor to the end of the new character.
*/
if(gl_set_term_curpos(gl, term_curpos + width))
return 1;
gl->buff_curpos++;
/*
* If we are replacing with a wider character, then we will be
* inserting new characters, and thus extending the line.
*/
} else if(width > old_width) {
/*
* Redraw the line from the cursor position to the end of the line,
* and move the cursor to just after the added character.
*/
if(gl_print_string(gl, gl->line + buff_curpos, '\0') ||
gl_set_term_curpos(gl, term_curpos + width))
return 1;
gl->buff_curpos++;
/*
* The original and replacement characters have the same width,
* so simply overwrite.
*/
} else {
/*
* Copy the character into the buffer.
*/
gl_buffer_char(gl, c, buff_curpos);
gl->buff_curpos++;
/*
* Overwrite the original character.
*/
if(gl_print_char(gl, c, gl->line[gl->buff_curpos]))
return 1;
};
};
return 0;
}
/*.......................................................................
* Insert/append a string to the line buffer and terminal at the current
* cursor position.
*
* Input:
* gl GetLine * The resource object of this library.
* s char * The string to be added.
* Output:
* return int 0 - OK.
* 1 - Insufficient room.
*/
static int gl_add_string_to_line(GetLine *gl, const char *s)
{
int buff_slen; /* The length of the string being added to line[] */
int term_slen; /* The length of the string being written to the terminal */
int buff_curpos; /* The original value of gl->buff_curpos */
int term_curpos; /* The original value of gl->term_curpos */
/*
* Keep a record of the current cursor position.
*/
buff_curpos = gl->buff_curpos;
term_curpos = gl->term_curpos;
/*
* How long is the string to be added?
*/
buff_slen = strlen(s);
term_slen = gl_displayed_string_width(gl, s, buff_slen, term_curpos);
/*
* Check that we can accomodate the string in the buffer.
* If not, simply return, leaving it up to the calling program
* to check for the absence of a newline character.
*/
if(gl->ntotal + buff_slen > gl->linelen)
return 0;
/*
* Move the characters that follow the cursor in the buffer by
* buff_slen characters to the right.
*/
if(gl->ntotal > gl->buff_curpos)
gl_make_gap_in_buffer(gl, gl->buff_curpos, buff_slen);
/*
* Copy the string into the buffer.
*/
gl_buffer_string(gl, s, buff_slen, gl->buff_curpos);
gl->buff_curpos += buff_slen;
/*
* Write the modified part of the line to the terminal, then move
* the terminal cursor to the end of the displayed input string.
*/
if(gl_print_string(gl, gl->line + buff_curpos, '\0') ||
gl_set_term_curpos(gl, term_curpos + term_slen))
return 1;
return 0;
}
/*.......................................................................
* Read a single character from the terminal.
*
* Input:
* gl GetLine * The resource object of this library.
* keep int If true, the returned character will be kept in
* the input buffer, for potential replays. It should
* subsequently be removed from the buffer when the
* key sequence that it belongs to has been fully
* processed, by calling gl_discard_chars().
* Input/Output:
* c char * The character that is read, is assigned to *c.
* Output:
* return int 0 - OK.
* 1 - Either an I/O error occurred, or a signal was
* caught who's disposition is to abort gl_get_line()
* or to have gl_get_line() return the current line
* as though the user had pressed return. In the
* latter case gl->endline will be non-zero.
*/
static int gl_read_terminal(GetLine *gl, int keep, char *c)
{
/*
* Before waiting for a new character to be input, flush unwritten
* characters to the terminal.
*/
if(gl_flush_output(gl))
return 1;
/*
* Record the fact that we are about to read from the terminal.
*/
gl->pending_io = GLP_READ;
/*
* If there is already an unread character in the buffer,
* return it.
*/
if(gl->nread < gl->nbuf) {
*c = gl->keybuf[gl->nread];
/*
* Retain the character in the key buffer, but mark it as having been read?
*/
if(keep) {
gl->nread++;
/*
* Completely remove the character from the key buffer?
*/
} else {
memmove(gl->keybuf + gl->nread, gl->keybuf + gl->nread + 1,
gl->nbuf - gl->nread - 1);
};
return 0;
};
/*
* Make sure that there is space in the key buffer for one more character.
* This should always be true if gl_interpret_char() is called for each
* new character added, since it will clear the buffer once it has recognized
* or rejected a key sequence.
*/
if(gl->nbuf + 1 > GL_KEY_MAX) {
gl_print_info(gl, "gl_read_terminal: Buffer overflow avoided.",
GL_END_INFO);
errno = EIO;
return 1;
};
/*
* Read one character from the terminal.
*/
switch(gl_read_input(gl, c)) {
case GL_READ_OK:
break;
case GL_READ_BLOCKED:
gl_record_status(gl, GLR_BLOCKED, BLOCKED_ERRNO);
return 1;
break;
default:
return 1;
break;
};
/*
* Append the character to the key buffer?
*/
if(keep) {
gl->keybuf[gl->nbuf] = *c;
gl->nread = ++gl->nbuf;
};
return 0;
}
/*.......................................................................
* Read one or more keypresses from the terminal of an input stream.
*
* Input:
* gl GetLine * The resource object of this module.
* c char * The character that was read is assigned to *c.
* Output:
* return GlReadStatus The completion status of the read operation.
*/
static GlReadStatus gl_read_input(GetLine *gl, char *c)
{
/*
* We may have to repeat the read if window change signals are received.
*/
for(;;) {
/*
* Which file descriptor should we read from? Mark this volatile, so
* that siglongjmp() can't clobber it.
*/
volatile int fd = gl->file_fp ? fileno(gl->file_fp) : gl->input_fd;
/*
* If the endline flag becomes set, don't wait for another character.
*/
if(gl->endline)
return GL_READ_ERROR;
/*
* Since the code in this function can block, trap signals.
*/
if(sigsetjmp(gl_setjmp_buffer, 1)==0) {
/*
* Handle the different I/O modes.
*/
switch(gl->io_mode) {
/*
* In normal I/O mode, we call the event handler before attempting
* to read, since read() blocks.
*/
case GL_NORMAL_MODE:
if(gl_event_handler(gl, fd))
return GL_READ_ERROR;
return gl_read_unmasked(gl, fd, c); /* Read one character */
break;
/*
* In non-blocking server I/O mode, we attempt to read a character,
* and only if this fails, call the event handler to wait for a any
* user-configured timeout and any other user-configured events. In
* addition, we turn off the fcntl() non-blocking flag when reading
* from the terminal, to work around a bug in Solaris. We can do this
* without causing the read() to block, because when in non-blocking
* server-I/O mode, gl_raw_io() sets the VMIN terminal attribute to 0,
* which tells the terminal driver to return immediately if no
* characters are available to be read.
*/
case GL_SERVER_MODE:
{
GlReadStatus status; /* The return status */
if(isatty(fd)) /* If we reading from a terminal, */
gl_blocking_io(gl, fd); /* switch to blocking I/O */
status = gl_read_unmasked(gl, fd, c); /* Try reading */
if(status == GL_READ_BLOCKED) { /* Nothing readable yet */
if(gl_event_handler(gl, fd)) /* Wait for input */
status = GL_READ_ERROR;
else
status = gl_read_unmasked(gl, fd, c); /* Try reading again */
};
gl_nonblocking_io(gl, fd); /* Restore non-blocking I/O */
return status;
};
break;
};
};
/*
* To get here, one of the signals that we are trapping must have
* been received. Note that by using sigsetjmp() instead of setjmp()
* the signal mask that was blocking these signals will have been
* reinstated, so we can be sure that no more of these signals will
* be received until we explicitly unblock them again.
*
* First, if non-blocking I/O was temporarily disabled, reinstate it.
*/
if(gl->io_mode == GL_SERVER_MODE)
gl_nonblocking_io(gl, fd);
/*
* Now respond to the signal that was caught.
*/
if(gl_check_caught_signal(gl))
return GL_READ_ERROR;
};
}
/*.......................................................................
* This is a private function of gl_read_input(), which unblocks signals
* temporarily while it reads a single character from the specified file
* descriptor.
*
* Input:
* gl GetLine * The resource object of this module.
* fd int The file descriptor to read from.
* c char * The character that was read is assigned to *c.
* Output:
* return GlReadStatus The completion status of the read.
*/
static GlReadStatus gl_read_unmasked(GetLine *gl, int fd, char *c)
{
int nread; /* The return value of read() */
/*
* Unblock the signals that we are trapping, while waiting for I/O.
*/
gl_catch_signals(gl);
/*
* Attempt to read one character from the terminal, restarting the read
* if any signals that we aren't trapping, are received.
*/
do {
errno = 0;
nread = read(fd, c, 1);
} while(nread < 0 && errno==EINTR);
/*
* Block all of the signals that we are trapping.
*/
gl_mask_signals(gl, NULL);
/*
* Check the completion status of the read.
*/
switch(nread) {
case 1:
return GL_READ_OK;
case 0:
return (isatty(fd) || errno != 0) ? GL_READ_BLOCKED : GL_READ_EOF;
default:
return GL_READ_ERROR;
};
}
/*.......................................................................
* Remove a specified number of characters from the start of the
* key-press lookahead buffer, gl->keybuf[], and arrange for the next
* read to start from the character at the start of the shifted buffer.
*
* Input:
* gl GetLine * The resource object of this module.
* nused int The number of characters to discard from the start
* of the buffer.
*/
static void gl_discard_chars(GetLine *gl, int nused)
{
int nkeep = gl->nbuf - nused;
if(nkeep > 0) {
memmove(gl->keybuf, gl->keybuf + nused, nkeep);
gl->nbuf = nkeep;
gl->nread = 0;
} else {
gl->nbuf = gl->nread = 0;
};
}
/*.......................................................................
* This function is called to handle signals caught between calls to
* sigsetjmp() and siglongjmp().
*
* Input:
* gl GetLine * The resource object of this library.
* Output:
* return int 0 - Signal handled internally.
* 1 - Signal requires gl_get_line() to abort.
*/
static int gl_check_caught_signal(GetLine *gl)
{
GlSignalNode *sig; /* The signal disposition */
SigAction keep_action; /* The signal disposition of tecla signal handlers */
unsigned flags; /* The signal processing flags to use */
int signo; /* The signal to be handled */
/*
* Was no signal caught?
*/
if(gl_pending_signal == -1)
return 0;
/*
* Get the signal to be handled.
*/
signo = gl_pending_signal;
/*
* Mark the signal as handled. Note that at this point, all of
* the signals that we are trapping are blocked from delivery.
*/
gl_pending_signal = -1;
/*
* Record the signal that was caught, so that the user can query it later.
*/
gl->last_signal = signo;
/*
* In non-blocking server mode, the application is responsible for
* responding to terminal signals, and we don't want gl_get_line()s
* normal signal handling to clash with this, so whenever a signal
* is caught, we arrange for gl_get_line() to abort and requeue the
* signal while signals are still blocked. If the application
* had the signal unblocked when gl_get_line() was called, the signal
* will be delivered again as soon as gl_get_line() restores the
* process signal mask, just before returning to the application.
* Note that the caller of this function should set gl->pending_io
* to the appropriate choice of GLP_READ and GLP_WRITE, before returning.
*/
if(gl->io_mode==GL_SERVER_MODE) {
gl_record_status(gl, GLR_SIGNAL, EINTR);
raise(signo);
return 1;
};
/*
* Lookup the requested disposition of this signal.
*/
for(sig=gl->sigs; sig && sig->signo != signo; sig=sig->next)
;
if(!sig)
return 0;
/*
* Get the signal response flags for this signal.
*/
flags = sig->flags;
/*
* Only perform terminal-specific actions if the session is interactive.
*/
if(gl->is_term) {
/*
* Did we receive a terminal size signal?
*/
#ifdef SIGWINCH
if(signo == SIGWINCH && _gl_update_size(gl))
return 1;
#endif
/*
* Start a fresh line?
*/
if(flags & GLS_RESTORE_LINE) {
if(gl_start_newline(gl, 0))
return 1;
};
/*
* Restore terminal settings to how they were before gl_get_line() was
* called?
*/
if(flags & GLS_RESTORE_TTY)
gl_restore_terminal_attributes(gl);
};
/*
* Restore signal handlers to how they were before gl_get_line() was
* called? If this hasn't been requested, only reinstate the signal
* handler of the signal that we are handling.
*/
if(flags & GLS_RESTORE_SIG) {
gl_restore_signal_handlers(gl);
gl_unmask_signals(gl, &gl->old_signal_set);
} else {
(void) sigaction(sig->signo, &sig->original, &keep_action);
(void) sigprocmask(SIG_UNBLOCK, &sig->proc_mask, NULL);
};
/*
* Forward the signal to the application's signal handler.
*/
if(!(flags & GLS_DONT_FORWARD))
raise(signo);
/*
* Reinstate our signal handlers.
*/
if(flags & GLS_RESTORE_SIG) {
gl_mask_signals(gl, NULL);
gl_override_signal_handlers(gl);
} else {
(void) sigaction(sig->signo, &keep_action, NULL);
(void) sigprocmask(SIG_BLOCK, &sig->proc_mask, NULL);
};
/*
* Prepare the terminal for continued editing, if this is an interactive
* session.
*/
if(gl->is_term) {
/*
* Do we need to reinstate our terminal settings?
*/
if(flags & GLS_RESTORE_TTY)
gl_raw_terminal_mode(gl);
/*
* Redraw the line?
*/
if(flags & GLS_REDRAW_LINE)
gl_queue_redisplay(gl);
};
/*
* What next?
*/
switch(sig->after) {
case GLS_RETURN:
gl_newline(gl, 1, NULL);
return gl->is_term && gl_flush_output(gl);
break;
case GLS_ABORT:
gl_record_status(gl, GLR_SIGNAL, sig->errno_value);
return 1;
break;
case GLS_CONTINUE:
return gl->is_term && gl_flush_output(gl);
break;
};
return 0;
}
/*.......................................................................
* Get pertinent terminal control strings and the initial terminal size.
*
* Input:
* gl GetLine * The resource object of this library.
* term char * The type of the terminal.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int gl_control_strings(GetLine *gl, const char *term)
{
int bad_term = 0; /* True if term is unusable */
/*
* Discard any existing control strings from a previous terminal.
*/
gl->left = NULL;
gl->right = NULL;
gl->up = NULL;
gl->down = NULL;
gl->home = NULL;
gl->bol = 0;
gl->clear_eol = NULL;
gl->clear_eod = NULL;
gl->u_arrow = NULL;
gl->d_arrow = NULL;
gl->l_arrow = NULL;
gl->r_arrow = NULL;
gl->sound_bell = NULL;
gl->bold = NULL;
gl->underline = NULL;
gl->standout = NULL;
gl->dim = NULL;
gl->reverse = NULL;
gl->blink = NULL;
gl->text_attr_off = NULL;
gl->nline = 0;
gl->ncolumn = 0;
#ifdef USE_TERMINFO
gl->left_n = NULL;
gl->right_n = NULL;
#endif
/*
* If possible lookup the information in a terminal information
* database.
*/
#ifdef USE_TERMINFO
{
int errret;
if(!term || setupterm((char *)term, gl->input_fd, &errret) == ERR) {
bad_term = 1;
} else {
_clr_StringGroup(gl->capmem);
gl->left = gl_tigetstr(gl, "cub1");
gl->right = gl_tigetstr(gl, "cuf1");
gl->up = gl_tigetstr(gl, "cuu1");
gl->down = gl_tigetstr(gl, "cud1");
gl->home = gl_tigetstr(gl, "home");
gl->clear_eol = gl_tigetstr(gl, "el");
gl->clear_eod = gl_tigetstr(gl, "ed");
gl->u_arrow = gl_tigetstr(gl, "kcuu1");
gl->d_arrow = gl_tigetstr(gl, "kcud1");
gl->l_arrow = gl_tigetstr(gl, "kcub1");
gl->r_arrow = gl_tigetstr(gl, "kcuf1");
gl->left_n = gl_tigetstr(gl, "cub");
gl->right_n = gl_tigetstr(gl, "cuf");
gl->sound_bell = gl_tigetstr(gl, "bel");
gl->bold = gl_tigetstr(gl, "bold");
gl->underline = gl_tigetstr(gl, "smul");
gl->standout = gl_tigetstr(gl, "smso");
gl->dim = gl_tigetstr(gl, "dim");
gl->reverse = gl_tigetstr(gl, "rev");
gl->blink = gl_tigetstr(gl, "blink");
gl->text_attr_off = gl_tigetstr(gl, "sgr0");
};
};
#elif defined(USE_TERMCAP)
if(!term || tgetent(gl->tgetent_buf, (char *)term) < 0) {
bad_term = 1;
} else {
char *tgetstr_buf_ptr = gl->tgetstr_buf;
_clr_StringGroup(gl->capmem);
gl->left = gl_tgetstr(gl, "le", &tgetstr_buf_ptr);
gl->right = gl_tgetstr(gl, "nd", &tgetstr_buf_ptr);
gl->up = gl_tgetstr(gl, "up", &tgetstr_buf_ptr);
gl->down = gl_tgetstr(gl, "do", &tgetstr_buf_ptr);
gl->home = gl_tgetstr(gl, "ho", &tgetstr_buf_ptr);
gl->clear_eol = gl_tgetstr(gl, "ce", &tgetstr_buf_ptr);
gl->clear_eod = gl_tgetstr(gl, "cd", &tgetstr_buf_ptr);
gl->u_arrow = gl_tgetstr(gl, "ku", &tgetstr_buf_ptr);
gl->d_arrow = gl_tgetstr(gl, "kd", &tgetstr_buf_ptr);
gl->l_arrow = gl_tgetstr(gl, "kl", &tgetstr_buf_ptr);
gl->r_arrow = gl_tgetstr(gl, "kr", &tgetstr_buf_ptr);
gl->sound_bell = gl_tgetstr(gl, "bl", &tgetstr_buf_ptr);
gl->bold = gl_tgetstr(gl, "md", &tgetstr_buf_ptr);
gl->underline = gl_tgetstr(gl, "us", &tgetstr_buf_ptr);
gl->standout = gl_tgetstr(gl, "so", &tgetstr_buf_ptr);
gl->dim = gl_tgetstr(gl, "mh", &tgetstr_buf_ptr);
gl->reverse = gl_tgetstr(gl, "mr", &tgetstr_buf_ptr);
gl->blink = gl_tgetstr(gl, "mb", &tgetstr_buf_ptr);
gl->text_attr_off = gl_tgetstr(gl, "me", &tgetstr_buf_ptr);
};
#endif
/*
* Report term being unusable.
*/
if(bad_term) {
gl_print_info(gl, "Bad terminal type: \"", term ? term : "(null)",
"\". Will assume vt100.", GL_END_INFO);
};
/*
* Fill in missing information with ANSI VT100 strings.
*/
if(!gl->left)
gl->left = "\b"; /* ^H */
if(!gl->right)
gl->right = GL_ESC_STR "[C";
if(!gl->up)
gl->up = GL_ESC_STR "[A";
if(!gl->down)
gl->down = "\n";
if(!gl->home)
gl->home = GL_ESC_STR "[H";
if(!gl->bol)
gl->bol = "\r";
if(!gl->clear_eol)
gl->clear_eol = GL_ESC_STR "[K";
if(!gl->clear_eod)
gl->clear_eod = GL_ESC_STR "[J";
if(!gl->u_arrow)
gl->u_arrow = GL_ESC_STR "[A";
if(!gl->d_arrow)
gl->d_arrow = GL_ESC_STR "[B";
if(!gl->l_arrow)
gl->l_arrow = GL_ESC_STR "[D";
if(!gl->r_arrow)
gl->r_arrow = GL_ESC_STR "[C";
if(!gl->sound_bell)
gl->sound_bell = "\a";
if(!gl->bold)
gl->bold = GL_ESC_STR "[1m";
if(!gl->underline)
gl->underline = GL_ESC_STR "[4m";
if(!gl->standout)
gl->standout = GL_ESC_STR "[1;7m";
if(!gl->dim)
gl->dim = ""; /* Not available */
if(!gl->reverse)
gl->reverse = GL_ESC_STR "[7m";
if(!gl->blink)
gl->blink = GL_ESC_STR "[5m";
if(!gl->text_attr_off)
gl->text_attr_off = GL_ESC_STR "[m";
/*
* Find out the current terminal size.
*/
(void) _gl_terminal_size(gl, GL_DEF_NCOLUMN, GL_DEF_NLINE, NULL);
return 0;
}
#ifdef USE_TERMINFO
/*.......................................................................
* This is a private function of gl_control_strings() used to look up
* a termninal capability string from the terminfo database and make
* a private copy of it.
*
* Input:
* gl GetLine * The resource object of gl_get_line().
* name const char * The name of the terminfo string to look up.
* Output:
* return const char * The local copy of the capability, or NULL
* if not available.
*/
static const char *gl_tigetstr(GetLine *gl, const char *name)
{
const char *value = tigetstr((char *)name);
if(!value || value == (char *) -1)
return NULL;
return _sg_store_string(gl->capmem, value, 0);
}
#elif defined(USE_TERMCAP)
/*.......................................................................
* This is a private function of gl_control_strings() used to look up
* a termninal capability string from the termcap database and make
* a private copy of it. Note that some emulations of tgetstr(), such
* as that used by Solaris, ignores the buffer pointer that is past to
* it, so we can't assume that a private copy has been made that won't
* be trashed by another call to gl_control_strings() by another
* GetLine object. So we make what may be a redundant private copy
* of the string in gl->capmem.
*
* Input:
* gl GetLine * The resource object of gl_get_line().
* name const char * The name of the terminfo string to look up.
* Input/Output:
* bufptr char ** On input *bufptr points to the location in
* gl->tgetstr_buf at which to record the
* capability string. On output *bufptr is
* incremented over the stored string.
* Output:
* return const char * The local copy of the capability, or NULL
* on error.
*/
static const char *gl_tgetstr(GetLine *gl, const char *name, char **bufptr)
{
const char *value = tgetstr((char *)name, bufptr);
if(!value || value == (char *) -1)
return NULL;
return _sg_store_string(gl->capmem, value, 0);
}
#endif
/*.......................................................................
* This is an action function that implements a user interrupt (eg. ^C).
*/
static KT_KEY_FN(gl_user_interrupt)
{
raise(SIGINT);
return 1;
}
/*.......................................................................
* This is an action function that implements the abort signal.
*/
static KT_KEY_FN(gl_abort)
{
raise(SIGABRT);
return 1;
}
/*.......................................................................
* This is an action function that sends a suspend signal (eg. ^Z) to the
* the parent process.
*/
static KT_KEY_FN(gl_suspend)
{
raise(SIGTSTP);
return 0;
}
/*.......................................................................
* This is an action function that halts output to the terminal.
*/
static KT_KEY_FN(gl_stop_output)
{
tcflow(gl->output_fd, TCOOFF);
return 0;
}
/*.......................................................................
* This is an action function that resumes halted terminal output.
*/
static KT_KEY_FN(gl_start_output)
{
tcflow(gl->output_fd, TCOON);
return 0;
}
/*.......................................................................
* This is an action function that allows the next character to be accepted
* without any interpretation as a special character.
*/
static KT_KEY_FN(gl_literal_next)
{
char c; /* The character to be added to the line */
int i;
/*
* Get the character to be inserted literally.
*/
if(gl_read_terminal(gl, 1, &c))
return 1;
/*
* Add the character to the line 'count' times.
*/
for(i=0; incolumn) % TAB_WIDTH);
}
/*.......................................................................
* Return the number of characters needed to display a given character
* on the screen. Tab characters require eight spaces, and control
* characters are represented by a caret followed by the modified
* character.
*
* Input:
* gl GetLine * The resource object of this library.
* c char The character to be displayed.
* term_curpos int The destination terminal location of the character.
* This is needed because the width of tab characters
* depends on where they are, relative to the
* preceding tab stops.
* Output:
* return int The number of terminal charaters needed.
*/
static int gl_displayed_char_width(GetLine *gl, char c, int term_curpos)
{
if(c=='\t')
return gl_displayed_tab_width(gl, term_curpos);
if(IS_CTRL_CHAR(c))
return 2;
if(!isprint((int)(unsigned char) c))
return gl_octal_width((int)(unsigned char)c) + 1;
return 1;
}
/*.......................................................................
* Work out the length of given string of characters on the terminal.
*
* Input:
* gl GetLine * The resource object of this library.
* string char * The string to be measured.
* nc int The number of characters to be measured, or -1
* to measure the whole string.
* term_curpos int The destination terminal location of the character.
* This is needed because the width of tab characters
* depends on where they are, relative to the
* preceding tab stops.
* Output:
* return int The number of displayed characters.
*/
static int gl_displayed_string_width(GetLine *gl, const char *string, int nc,
int term_curpos)
{
int slen = 0; /* The displayed number of characters */
int i;
/*
* How many characters are to be measured?
*/
if(nc < 0)
nc = strlen(string);
/*
* Add up the length of the displayed string.
*/
for(i=0; iflush_fn;
/*
* Only display output when echoing is turned on.
*/
if(gl->echo) {
int ndone = 0; /* The number of characters written so far */
/*
* When using un-buffered I/O, flush pending output first.
*/
if(!buffered) {
if(gl_flush_output(gl))
return 1;
};
/*
* If no length has been provided, measure the length of the string.
*/
if(n < 0)
n = strlen(string);
/*
* Write the string.
*/
if(write_fn(gl, string + ndone, n-ndone) != n)
return 1;
};
return 0;
}
/*.......................................................................
* Output a terminal control sequence. When using terminfo,
* this must be a sequence returned by tgetstr() or tigetstr()
* respectively.
*
* Input:
* gl GetLine * The resource object of this library.
* nline int The number of lines affected by the operation,
* or 1 if not relevant.
* string char * The control sequence to be sent.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int gl_print_control_sequence(GetLine *gl, int nline, const char *string)
{
int waserr = 0; /* True if an error occurs */
/*
* Only write characters to the terminal when echoing is enabled.
*/
if(gl->echo) {
#if defined(USE_TERMINFO) || defined(USE_TERMCAP)
tputs_gl = gl;
errno = 0;
tputs((char *)string, nline, gl_tputs_putchar);
waserr = errno != 0;
#else
waserr = gl_print_raw_string(gl, 1, string, -1);
#endif
};
return waserr;
}
#if defined(USE_TERMINFO) || defined(USE_TERMCAP)
/*.......................................................................
* The following callback function is called by tputs() to output a raw
* control character to the terminal.
*/
static TputsRetType gl_tputs_putchar(TputsArgType c)
{
char ch = c;
#if TPUTS_RETURNS_VALUE
return gl_print_raw_string(tputs_gl, 1, &ch, 1);
#else
(void) gl_print_raw_string(tputs_gl, 1, &ch, 1);
#endif
}
#endif
/*.......................................................................
* Move the terminal cursor n characters to the left or right.
*
* Input:
* gl GetLine * The resource object of this program.
* n int number of positions to the right (> 0) or left (< 0).
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int gl_terminal_move_cursor(GetLine *gl, int n)
{
int cur_row, cur_col; /* The current terminal row and column index of */
/* the cursor wrt the start of the input line. */
int new_row, new_col; /* The target terminal row and column index of */
/* the cursor wrt the start of the input line. */
/*
* Do nothing if the input line isn't currently displayed. In this
* case, the cursor will be moved to the right place when the line
* is next redisplayed.
*/
if(!gl->displayed)
return 0;
/*
* How far can we move left?
*/
if(gl->term_curpos + n < 0)
n = gl->term_curpos;
/*
* Break down the current and target cursor locations into rows and columns.
*/
/**** BEGIN ABB: 2009-06-15 div-by-zero exception ***/
if (gl->ncolumn == 0) {
gl->ncolumn = 1;
}
/**** END ABB: 2009-06-15 div-by-zero exception ***/
cur_row = gl->term_curpos / gl->ncolumn;
cur_col = gl->term_curpos % gl->ncolumn;
new_row = (gl->term_curpos + n) / gl->ncolumn;
new_col = (gl->term_curpos + n) % gl->ncolumn;
/*
* Move down to the next line.
*/
for(; cur_row < new_row; cur_row++) {
if(gl_print_control_sequence(gl, 1, gl->down))
return 1;
};
/*
* Move up to the previous line.
*/
for(; cur_row > new_row; cur_row--) {
if(gl_print_control_sequence(gl, 1, gl->up))
return 1;
};
/*
* Move to the right within the target line?
*/
if(cur_col < new_col) {
#ifdef USE_TERMINFO
/*
* Use a parameterized control sequence if it generates less control
* characters (guess based on ANSI terminal termcap entry).
*/
if(gl->right_n != NULL && new_col - cur_col > 1) {
if(gl_print_control_sequence(gl, 1, tparm((char *)gl->right_n,
(long)(new_col - cur_col), 0l, 0l, 0l, 0l, 0l, 0l, 0l, 0l)))
return 1;
} else
#endif
{
for(; cur_col < new_col; cur_col++) {
if(gl_print_control_sequence(gl, 1, gl->right))
return 1;
};
};
/*
* Move to the left within the target line?
*/
} else if(cur_col > new_col) {
#ifdef USE_TERMINFO
/*
* Use a parameterized control sequence if it generates less control
* characters (guess based on ANSI terminal termcap entry).
*/
if(gl->left_n != NULL && cur_col - new_col > 3) {
if(gl_print_control_sequence(gl, 1, tparm((char *)gl->left_n,
(long)(cur_col - new_col), 0l, 0l, 0l, 0l, 0l, 0l, 0l, 0l)))
return 1;
} else
#endif
{
for(; cur_col > new_col; cur_col--) {
if(gl_print_control_sequence(gl, 1, gl->left))
return 1;
};
};
}
/*
* Update the recorded position of the terminal cursor.
*/
gl->term_curpos += n;
return 0;
}
/*.......................................................................
* Write a character to the terminal after expanding tabs and control
* characters to their multi-character representations.
*
* Input:
* gl GetLine * The resource object of this program.
* c char The character to be output.
* pad char Many terminals have the irritating feature that
* when one writes a character in the last column of
* of the terminal, the cursor isn't wrapped to the
* start of the next line until one more character
* is written. Some terminals don't do this, so
* after such a write, we don't know where the
* terminal is unless we output an extra character.
* This argument specifies the character to write.
* If at the end of the input line send '\0' or a
* space, and a space will be written. Otherwise,
* pass the next character in the input line
* following the one being written.
* Output:
* return int 0 - OK.
*/
static int gl_print_char(GetLine *gl, char c, char pad)
{
char string[TAB_WIDTH + 4]; /* A work area for composing compound strings */
int nchar; /* The number of terminal characters */
int i;
/*
* Check for special characters.
*/
if(c == '\t') {
/*
* How many spaces do we need to represent a tab at the current terminal
* column?
*/
nchar = gl_displayed_tab_width(gl, gl->term_curpos);
/*
* Compose the tab string.
*/
for(i=0; iterm_curpos += nchar;
/*
* Keep a record of the number of characters in the terminal version
* of the input line.
*/
if(gl->term_curpos > gl->term_len)
gl->term_len = gl->term_curpos;
/*
* If the new character ended exactly at the end of a line,
* most terminals won't move the cursor onto the next line until we
* have written a character on the next line, so append an extra
* space then move the cursor back.
*/
if(gl->term_curpos % gl->ncolumn == 0) {
int term_curpos = gl->term_curpos;
if(gl_print_char(gl, pad ? pad : ' ', ' ') ||
gl_set_term_curpos(gl, term_curpos))
return 1;
};
return 0;
}
/*.......................................................................
* Write a string to the terminal after expanding tabs and control
* characters to their multi-character representations.
*
* Input:
* gl GetLine * The resource object of this program.
* string char * The string to be output.
* pad char Many terminals have the irritating feature that
* when one writes a character in the last column of
* of the terminal, the cursor isn't wrapped to the
* start of the next line until one more character
* is written. Some terminals don't do this, so
* after such a write, we don't know where the
* terminal is unless we output an extra character.
* This argument specifies the character to write.
* If at the end of the input line send '\0' or a
* space, and a space will be written. Otherwise,
* pass the next character in the input line
* following the one being written.
* Output:
* return int 0 - OK.
*/
static int gl_print_string(GetLine *gl, const char *string, char pad)
{
const char *cptr; /* A pointer into string[] */
for(cptr=string; *cptr; cptr++) {
char nextc = cptr[1];
if(gl_print_char(gl, *cptr, nextc ? nextc : pad))
return 1;
};
return 0;
}
/*.......................................................................
* Move the terminal cursor position.
*
* Input:
* gl GetLine * The resource object of this library.
* term_curpos int The destination terminal cursor position.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int gl_set_term_curpos(GetLine *gl, int term_curpos)
{
return gl_terminal_move_cursor(gl, term_curpos - gl->term_curpos);
}
/*.......................................................................
* This is an action function that moves the buffer cursor one character
* left, and updates the terminal cursor to match.
*/
static KT_KEY_FN(gl_cursor_left)
{
return gl_place_cursor(gl, gl->buff_curpos - count);
}
/*.......................................................................
* This is an action function that moves the buffer cursor one character
* right, and updates the terminal cursor to match.
*/
static KT_KEY_FN(gl_cursor_right)
{
return gl_place_cursor(gl, gl->buff_curpos + count);
}
/*.......................................................................
* This is an action function that toggles between overwrite and insert
* mode.
*/
static KT_KEY_FN(gl_insert_mode)
{
gl->insert = !gl->insert;
return 0;
}
/*.......................................................................
* This is an action function which moves the cursor to the beginning of
* the line.
*/
static KT_KEY_FN(gl_beginning_of_line)
{
return gl_place_cursor(gl, 0);
}
/*.......................................................................
* This is an action function which moves the cursor to the end of
* the line.
*/
static KT_KEY_FN(gl_end_of_line)
{
return gl_place_cursor(gl, gl->ntotal);
}
/*.......................................................................
* This is an action function which deletes the entire contents of the
* current line.
*/
static KT_KEY_FN(gl_delete_line)
{
/*
* If in vi command mode, preserve the current line for potential
* use by vi-undo.
*/
gl_save_for_undo(gl);
/*
* Copy the contents of the line to the cut buffer.
*/
strcpy(gl->cutbuf, gl->line);
/*
* Clear the buffer.
*/
gl_truncate_buffer(gl, 0);
/*
* Move the terminal cursor to just after the prompt.
*/
if(gl_place_cursor(gl, 0))
return 1;
/*
* Clear from the end of the prompt to the end of the terminal.
*/
if(gl_truncate_display(gl))
return 1;
return 0;
}
/*.......................................................................
* This is an action function which deletes all characters between the
* current cursor position and the end of the line.
*/
static KT_KEY_FN(gl_kill_line)
{
/*
* If in vi command mode, preserve the current line for potential
* use by vi-undo.
*/
gl_save_for_undo(gl);
/*
* Copy the part of the line that is about to be deleted to the cut buffer.
*/
strcpy(gl->cutbuf, gl->line + gl->buff_curpos);
/*
* Terminate the buffered line at the current cursor position.
*/
gl_truncate_buffer(gl, gl->buff_curpos);
/*
* Clear the part of the line that follows the cursor.
*/
if(gl_truncate_display(gl))
return 1;
/*
* Explicitly reset the cursor position to allow vi command mode
* constraints on its position to be set.
*/
return gl_place_cursor(gl, gl->buff_curpos);
}
/*.......................................................................
* This is an action function which deletes all characters between the
* start of the line and the current cursor position.
*/
static KT_KEY_FN(gl_backward_kill_line)
{
/*
* How many characters are to be deleted from before the cursor?
*/
int nc = gl->buff_curpos - gl->insert_curpos;
if (!nc)
return 0;
/*
* Move the cursor to the start of the line, or in vi input mode,
* the start of the sub-line at which insertion started, and delete
* up to the old cursor position.
*/
return gl_place_cursor(gl, gl->insert_curpos) ||
gl_delete_chars(gl, nc, gl->editor == GL_EMACS_MODE || gl->vi.command);
}
/*.......................................................................
* This is an action function which moves the cursor forward by a word.
*/
static KT_KEY_FN(gl_forward_word)
{
return gl_place_cursor(gl, gl_nth_word_end_forward(gl, count) +
(gl->editor==GL_EMACS_MODE));
}
/*.......................................................................
* This is an action function which moves the cursor forward to the start
* of the next word.
*/
static KT_KEY_FN(gl_forward_to_word)
{
return gl_place_cursor(gl, gl_nth_word_start_forward(gl, count));
}
/*.......................................................................
* This is an action function which moves the cursor backward by a word.
*/
static KT_KEY_FN(gl_backward_word)
{
return gl_place_cursor(gl, gl_nth_word_start_backward(gl, count));
}
/*.......................................................................
* Delete one or more characters, starting with the one under the cursor.
*
* Input:
* gl GetLine * The resource object of this library.
* nc int The number of characters to delete.
* cut int If true, copy the characters to the cut buffer.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int gl_delete_chars(GetLine *gl, int nc, int cut)
{
/*
* If in vi command mode, preserve the current line for potential
* use by vi-undo.
*/
gl_save_for_undo(gl);
/*
* If there are fewer than nc characters following the cursor, limit
* nc to the number available.
*/
if(gl->buff_curpos + nc > gl->ntotal)
nc = gl->ntotal - gl->buff_curpos;
/*
* Copy the about to be deleted region to the cut buffer.
*/
if(cut) {
memcpy(gl->cutbuf, gl->line + gl->buff_curpos, nc);
gl->cutbuf[nc] = '\0';
}
/*
* Nothing to delete?
*/
if(nc <= 0)
return 0;
/*
* In vi overwrite mode, restore any previously overwritten characters
* from the undo buffer.
*/
if(gl->editor == GL_VI_MODE && !gl->vi.command && !gl->insert) {
/*
* How many of the characters being deleted can be restored from the
* undo buffer?
*/
int nrestore = gl->buff_curpos + nc <= gl->vi.undo.ntotal ?
nc : gl->vi.undo.ntotal - gl->buff_curpos;
/*
* Restore any available characters.
*/
if(nrestore > 0) {
gl_buffer_string(gl, gl->vi.undo.line + gl->buff_curpos, nrestore,
gl->buff_curpos);
};
/*
* If their were insufficient characters in the undo buffer, then this
* implies that we are deleting from the end of the line, so we need
* to terminate the line either where the undo buffer ran out, or if
* we are deleting from beyond the end of the undo buffer, at the current
* cursor position.
*/
if(nc != nrestore) {
gl_truncate_buffer(gl, (gl->vi.undo.ntotal > gl->buff_curpos) ?
gl->vi.undo.ntotal : gl->buff_curpos);
};
} else {
/*
* Copy the remaining part of the line back over the deleted characters.
*/
gl_remove_from_buffer(gl, gl->buff_curpos, nc);
};
/*
* Redraw the remaining characters following the cursor.
*/
if(gl_print_string(gl, gl->line + gl->buff_curpos, '\0'))
return 1;
/*
* Clear to the end of the terminal.
*/
if(gl_truncate_display(gl))
return 1;
/*
* Place the cursor at the start of where the deletion was performed.
*/
return gl_place_cursor(gl, gl->buff_curpos);
}
/*.......................................................................
* This is an action function which deletes character(s) under the
* cursor without moving the cursor.
*/
static KT_KEY_FN(gl_forward_delete_char)
{
/*
* Delete 'count' characters.
*/
return gl_delete_chars(gl, count, gl->vi.command);
}
/*.......................................................................
* This is an action function which deletes character(s) under the
* cursor and moves the cursor back one character.
*/
static KT_KEY_FN(gl_backward_delete_char)
{
/*
* Restrict the deletion count to the number of characters that
* precede the insertion point.
*/
if(count > gl->buff_curpos - gl->insert_curpos)
count = gl->buff_curpos - gl->insert_curpos;
/*
* If in vi command mode, preserve the current line for potential
* use by vi-undo.
*/
gl_save_for_undo(gl);
return gl_cursor_left(gl, count, NULL) ||
gl_delete_chars(gl, count, gl->vi.command);
}
/*.......................................................................
* Starting from the cursor position delete to the specified column.
*/
static KT_KEY_FN(gl_delete_to_column)
{
if (--count >= gl->buff_curpos)
return gl_forward_delete_char(gl, count - gl->buff_curpos, NULL);
else
return gl_backward_delete_char(gl, gl->buff_curpos - count, NULL);
}
/*.......................................................................
* Starting from the cursor position delete characters to a matching
* parenthesis.
*/
static KT_KEY_FN(gl_delete_to_parenthesis)
{
int curpos = gl_index_of_matching_paren(gl);
if(curpos >= 0) {
gl_save_for_undo(gl);
if(curpos >= gl->buff_curpos)
return gl_forward_delete_char(gl, curpos - gl->buff_curpos + 1, NULL);
else
return gl_backward_delete_char(gl, ++gl->buff_curpos - curpos + 1, NULL);
};
return 0;
}
/*.......................................................................
* This is an action function which deletes from the cursor to the end
* of the word that the cursor is either in or precedes.
*/
static KT_KEY_FN(gl_forward_delete_word)
{
/*
* If in vi command mode, preserve the current line for potential
* use by vi-undo.
*/
gl_save_for_undo(gl);
/*
* In emacs mode delete to the end of the word. In vi mode delete to the
* start of the net word.
*/
if(gl->editor == GL_EMACS_MODE) {
return gl_delete_chars(gl,
gl_nth_word_end_forward(gl,count) - gl->buff_curpos + 1, 1);
} else {
return gl_delete_chars(gl,
gl_nth_word_start_forward(gl,count) - gl->buff_curpos,
gl->vi.command);
};
}
/*.......................................................................
* This is an action function which deletes the word that precedes the
* cursor.
*/
static KT_KEY_FN(gl_backward_delete_word)
{
/*
* Keep a record of the current cursor position.
*/
int buff_curpos = gl->buff_curpos;
/*
* If in vi command mode, preserve the current line for potential
* use by vi-undo.
*/
gl_save_for_undo(gl);
/*
* Move back 'count' words.
*/
if(gl_backward_word(gl, count, NULL))
return 1;
/*
* Delete from the new cursor position to the original one.
*/
return gl_delete_chars(gl, buff_curpos - gl->buff_curpos,
gl->editor == GL_EMACS_MODE || gl->vi.command);
}
/*.......................................................................
* Searching in a given direction, delete to the count'th
* instance of a specified or queried character, in the input line.
*
* Input:
* gl GetLine * The getline resource object.
* count int The number of times to search.
* c char The character to be searched for, or '\0' if
* the character should be read from the user.
* forward int True if searching forward.
* onto int True if the search should end on top of the
* character, false if the search should stop
* one character before the character in the
* specified search direction.
* change int If true, this function is being called upon
* to do a vi change command, in which case the
* user will be left in insert mode after the
* deletion.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int gl_delete_find(GetLine *gl, int count, char c, int forward,
int onto, int change)
{
/*
* Search for the character, and abort the deletion if not found.
*/
int pos = gl_find_char(gl, count, forward, onto, c);
if(pos < 0)
return 0;
/*
* If in vi command mode, preserve the current line for potential
* use by vi-undo.
*/
gl_save_for_undo(gl);
/*
* Allow the cursor to be at the end of the line if this is a change
* command.
*/
if(change)
gl->vi.command = 0;
/*
* Delete the appropriate span of characters.
*/
if(forward) {
if(gl_delete_chars(gl, pos - gl->buff_curpos + 1, 1))
return 1;
} else {
int buff_curpos = gl->buff_curpos;
if(gl_place_cursor(gl, pos) ||
gl_delete_chars(gl, buff_curpos - gl->buff_curpos, 1))
return 1;
};
/*
* If this is a change operation, switch the insert mode.
*/
if(change && gl_vi_insert(gl, 0, NULL))
return 1;
return 0;
}
/*.......................................................................
* This is an action function which deletes forward from the cursor up to and
* including a specified character.
*/
static KT_KEY_FN(gl_forward_delete_find)
{
return gl_delete_find(gl, count, '\0', 1, 1, 0);
}
/*.......................................................................
* This is an action function which deletes backward from the cursor back to
* and including a specified character.
*/
static KT_KEY_FN(gl_backward_delete_find)
{
return gl_delete_find(gl, count, '\0', 0, 1, 0);
}
/*.......................................................................
* This is an action function which deletes forward from the cursor up to but
* not including a specified character.
*/
static KT_KEY_FN(gl_forward_delete_to)
{
return gl_delete_find(gl, count, '\0', 1, 0, 0);
}
/*.......................................................................
* This is an action function which deletes backward from the cursor back to
* but not including a specified character.
*/
static KT_KEY_FN(gl_backward_delete_to)
{
return gl_delete_find(gl, count, '\0', 0, 0, 0);
}
/*.......................................................................
* This is an action function which deletes to a character specified by a
* previous search.
*/
static KT_KEY_FN(gl_delete_refind)
{
return gl_delete_find(gl, count, gl->vi.find_char, gl->vi.find_forward,
gl->vi.find_onto, 0);
}
/*.......................................................................
* This is an action function which deletes to a character specified by a
* previous search, but in the opposite direction.
*/
static KT_KEY_FN(gl_delete_invert_refind)
{
return gl_delete_find(gl, count, gl->vi.find_char,
!gl->vi.find_forward, gl->vi.find_onto, 0);
}
/*.......................................................................
* This is an action function which converts the characters in the word
* following the cursor to upper case.
*/
static KT_KEY_FN(gl_upcase_word)
{
/*
* Locate the count'th word ending after the cursor.
*/
int last = gl_nth_word_end_forward(gl, count);
/*
* If in vi command mode, preserve the current line for potential
* use by vi-undo.
*/
gl_save_for_undo(gl);
/*
* Upcase characters from the current cursor position to 'last'.
*/
while(gl->buff_curpos <= last) {
char *cptr = gl->line + gl->buff_curpos;
/*
* Convert the character to upper case?
*/
if(islower((int)(unsigned char) *cptr))
gl_buffer_char(gl, toupper((int) *cptr), gl->buff_curpos);
gl->buff_curpos++;
/*
* Write the possibly modified character back. Note that for non-modified
* characters we want to do this as well, so as to advance the cursor.
*/
if(gl_print_char(gl, *cptr, cptr[1]))
return 1;
};
return gl_place_cursor(gl, gl->buff_curpos); /* bounds check */
}
/*.......................................................................
* This is an action function which converts the characters in the word
* following the cursor to lower case.
*/
static KT_KEY_FN(gl_downcase_word)
{
/*
* Locate the count'th word ending after the cursor.
*/
int last = gl_nth_word_end_forward(gl, count);
/*
* If in vi command mode, preserve the current line for potential
* use by vi-undo.
*/
gl_save_for_undo(gl);
/*
* Upcase characters from the current cursor position to 'last'.
*/
while(gl->buff_curpos <= last) {
char *cptr = gl->line + gl->buff_curpos;
/*
* Convert the character to upper case?
*/
if(isupper((int)(unsigned char) *cptr))
gl_buffer_char(gl, tolower((int) *cptr), gl->buff_curpos);
gl->buff_curpos++;
/*
* Write the possibly modified character back. Note that for non-modified
* characters we want to do this as well, so as to advance the cursor.
*/
if(gl_print_char(gl, *cptr, cptr[1]))
return 1;
};
return gl_place_cursor(gl, gl->buff_curpos); /* bounds check */
}
/*.......................................................................
* This is an action function which converts the first character of the
* following word to upper case, in order to capitalize the word, and
* leaves the cursor at the end of the word.
*/
static KT_KEY_FN(gl_capitalize_word)
{
char *cptr; /* &gl->line[gl->buff_curpos] */
int first; /* True for the first letter of the word */
int i;
/*
* Keep a record of the current insert mode and the cursor position.
*/
int insert = gl->insert;
/*
* If in vi command mode, preserve the current line for potential
* use by vi-undo.
*/
gl_save_for_undo(gl);
/*
* We want to overwrite the modified word.
*/
gl->insert = 0;
/*
* Capitalize 'count' words.
*/
for(i=0; ibuff_curpos < gl->ntotal; i++) {
int pos = gl->buff_curpos;
/*
* If we are not already within a word, skip to the start of the word.
*/
for(cptr = gl->line + pos ; posntotal && !gl_is_word_char((int) *cptr);
pos++, cptr++)
;
/*
* Move the cursor to the new position.
*/
if(gl_place_cursor(gl, pos))
return 1;
/*
* While searching for the end of the word, change lower case letters
* to upper case.
*/
for(first=1; gl->buff_curposntotal && gl_is_word_char((int) *cptr);
gl->buff_curpos++, cptr++) {
/*
* Convert the character to upper case?
*/
if(first) {
if(islower((int)(unsigned char) *cptr))
gl_buffer_char(gl, toupper((int) *cptr), cptr - gl->line);
} else {
if(isupper((int)(unsigned char) *cptr))
gl_buffer_char(gl, tolower((int) *cptr), cptr - gl->line);
};
first = 0;
/*
* Write the possibly modified character back. Note that for non-modified
* characters we want to do this as well, so as to advance the cursor.
*/
if(gl_print_char(gl, *cptr, cptr[1]))
return 1;
};
};
/*
* Restore the insertion mode.
*/
gl->insert = insert;
return gl_place_cursor(gl, gl->buff_curpos); /* bounds check */
}
/*.......................................................................
* This is an action function which redraws the current line.
*/
static KT_KEY_FN(gl_redisplay)
{
/*
* Keep a record of the current cursor position.
*/
int buff_curpos = gl->buff_curpos;
/*
* Do nothing if there is no line to be redisplayed.
*/
if(gl->endline)
return 0;
/*
* Erase the current input line.
*/
if(gl_erase_line(gl))
return 1;
/*
* Display the current prompt.
*/
if(gl_display_prompt(gl))
return 1;
/*
* Render the part of the line that the user has typed in so far.
*/
if(gl_print_string(gl, gl->line, '\0'))
return 1;
/*
* Restore the cursor position.
*/
if(gl_place_cursor(gl, buff_curpos))
return 1;
/*
* Mark the redisplay operation as having been completed.
*/
gl->redisplay = 0;
/*
* Flush the redisplayed line to the terminal.
*/
return gl_flush_output(gl);
}
/*.......................................................................
* This is an action function which clears the display and redraws the
* input line from the home position.
*/
static KT_KEY_FN(gl_clear_screen)
{
/*
* Home the cursor and clear from there to the end of the display.
*/
if(gl_print_control_sequence(gl, gl->nline, gl->home) ||
gl_print_control_sequence(gl, gl->nline, gl->clear_eod))
return 1;
/*
* The input line is no longer displayed.
*/
gl_line_erased(gl);
/*
* Arrange for the input line to be redisplayed.
*/
gl_queue_redisplay(gl);
return 0;
}
/*.......................................................................
* This is an action function which swaps the character under the cursor
* with the character to the left of the cursor.
*/
static KT_KEY_FN(gl_transpose_chars)
{
char from[3]; /* The original string of 2 characters */
char swap[3]; /* The swapped string of two characters */
/*
* If we are at the beginning or end of the line, there aren't two
* characters to swap.
*/
if(gl->buff_curpos < 1 || gl->buff_curpos >= gl->ntotal)
return 0;
/*
* If in vi command mode, preserve the current line for potential
* use by vi-undo.
*/
gl_save_for_undo(gl);
/*
* Get the original and swapped strings of the two characters.
*/
from[0] = gl->line[gl->buff_curpos - 1];
from[1] = gl->line[gl->buff_curpos];
from[2] = '\0';
swap[0] = gl->line[gl->buff_curpos];
swap[1] = gl->line[gl->buff_curpos - 1];
swap[2] = '\0';
/*
* Move the cursor to the start of the two characters.
*/
if(gl_place_cursor(gl, gl->buff_curpos-1))
return 1;
/*
* Swap the two characters in the buffer.
*/
gl_buffer_char(gl, swap[0], gl->buff_curpos);
gl_buffer_char(gl, swap[1], gl->buff_curpos+1);
/*
* If the sum of the displayed width of the two characters
* in their current and final positions is the same, swapping can
* be done by just overwriting with the two swapped characters.
*/
if(gl_displayed_string_width(gl, from, -1, gl->term_curpos) ==
gl_displayed_string_width(gl, swap, -1, gl->term_curpos)) {
int insert = gl->insert;
gl->insert = 0;
if(gl_print_char(gl, swap[0], swap[1]) ||
gl_print_char(gl, swap[1], gl->line[gl->buff_curpos+2]))
return 1;
gl->insert = insert;
/*
* If the swapped substring has a different displayed size, we need to
* redraw everything after the first of the characters.
*/
} else {
if(gl_print_string(gl, gl->line + gl->buff_curpos, '\0') ||
gl_truncate_display(gl))
return 1;
};
/*
* Advance the cursor to the character after the swapped pair.
*/
return gl_place_cursor(gl, gl->buff_curpos + 2);
}
/*.......................................................................
* This is an action function which sets a mark at the current cursor
* location.
*/
static KT_KEY_FN(gl_set_mark)
{
gl->buff_mark = gl->buff_curpos;
return 0;
}
/*.......................................................................
* This is an action function which swaps the mark location for the
* cursor location.
*/
static KT_KEY_FN(gl_exchange_point_and_mark)
{
/*
* Get the old mark position, and limit to the extent of the input
* line.
*/
int old_mark = gl->buff_mark <= gl->ntotal ? gl->buff_mark : gl->ntotal;
/*
* Make the current cursor position the new mark.
*/
gl->buff_mark = gl->buff_curpos;
/*
* Move the cursor to the old mark position.
*/
return gl_place_cursor(gl, old_mark);
}
/*.......................................................................
* This is an action function which deletes the characters between the
* mark and the cursor, recording them in gl->cutbuf for later pasting.
*/
static KT_KEY_FN(gl_kill_region)
{
/*
* If in vi command mode, preserve the current line for potential
* use by vi-undo.
*/
gl_save_for_undo(gl);
/*
* Limit the mark to be within the line.
*/
if(gl->buff_mark > gl->ntotal)
gl->buff_mark = gl->ntotal;
/*
* If there are no characters between the cursor and the mark, simply clear
* the cut buffer.
*/
if(gl->buff_mark == gl->buff_curpos) {
gl->cutbuf[0] = '\0';
return 0;
};
/*
* If the mark is before the cursor, swap the cursor and the mark.
*/
if(gl->buff_mark < gl->buff_curpos && gl_exchange_point_and_mark(gl,1,NULL))
return 1;
/*
* Delete the characters.
*/
if(gl_delete_chars(gl, gl->buff_mark - gl->buff_curpos, 1))
return 1;
/*
* Make the mark the same as the cursor position.
*/
gl->buff_mark = gl->buff_curpos;
return 0;
}
/*.......................................................................
* This is an action function which records the characters between the
* mark and the cursor, in gl->cutbuf for later pasting.
*/
static KT_KEY_FN(gl_copy_region_as_kill)
{
int ca, cb; /* The indexes of the first and last characters in the region */
int mark; /* The position of the mark */
/*
* Get the position of the mark, limiting it to lie within the line.
*/
mark = gl->buff_mark > gl->ntotal ? gl->ntotal : gl->buff_mark;
/*
* If there are no characters between the cursor and the mark, clear
* the cut buffer.
*/
if(mark == gl->buff_curpos) {
gl->cutbuf[0] = '\0';
return 0;
};
/*
* Get the line indexes of the first and last characters in the region.
*/
if(mark < gl->buff_curpos) {
ca = mark;
cb = gl->buff_curpos - 1;
} else {
ca = gl->buff_curpos;
cb = mark - 1;
};
/*
* Copy the region to the cut buffer.
*/
memcpy(gl->cutbuf, gl->line + ca, cb + 1 - ca);
gl->cutbuf[cb + 1 - ca] = '\0';
return 0;
}
/*.......................................................................
* This is an action function which inserts the contents of the cut
* buffer at the current cursor location.
*/
static KT_KEY_FN(gl_yank)
{
int i;
/*
* Set the mark at the current location.
*/
gl->buff_mark = gl->buff_curpos;
/*
* Do nothing else if the cut buffer is empty.
*/
if(gl->cutbuf[0] == '\0')
return gl_ring_bell(gl, 1, NULL);
/*
* If in vi command mode, preserve the current line for potential
* use by vi-undo.
*/
gl_save_for_undo(gl);
/*
* Insert the string count times.
*/
for(i=0; icutbuf))
return 1;
};
/*
* gl_add_string_to_line() leaves the cursor after the last character that
* was pasted, whereas vi leaves the cursor over the last character pasted.
*/
if(gl->editor == GL_VI_MODE && gl_cursor_left(gl, 1, NULL))
return 1;
return 0;
}
/*.......................................................................
* This is an action function which inserts the contents of the cut
* buffer one character beyond the current cursor location.
*/
static KT_KEY_FN(gl_append_yank)
{
int was_command = gl->vi.command;
int i;
/*
* If the cut buffer is empty, ring the terminal bell.
*/
if(gl->cutbuf[0] == '\0')
return gl_ring_bell(gl, 1, NULL);
/*
* Set the mark at the current location + 1.
*/
gl->buff_mark = gl->buff_curpos + 1;
/*
* If in vi command mode, preserve the current line for potential
* use by vi-undo.
*/
gl_save_for_undo(gl);
/*
* Arrange to paste the text in insert mode after the current character.
*/
if(gl_vi_append(gl, 0, NULL))
return 1;
/*
* Insert the string count times.
*/
for(i=0; icutbuf))
return 1;
};
/*
* Switch back to command mode if necessary.
*/
if(was_command)
gl_vi_command_mode(gl);
return 0;
}
/*.......................................................................
* Attempt to ask the terminal for its current size. On systems that
* don't support the TIOCWINSZ ioctl() for querying the terminal size,
* the current values of gl->ncolumn and gl->nrow are returned.
*
* Input:
* gl GetLine * The resource object of gl_get_line().
* Input/Output:
* ncolumn int * The number of columns will be assigned to *ncolumn.
* nline int * The number of lines will be assigned to *nline.
*/
static void gl_query_size(GetLine *gl, int *ncolumn, int *nline)
{
#ifdef TIOCGWINSZ
/*
* Query the new terminal window size. Ignore invalid responses.
*/
struct winsize size;
if(ioctl(gl->output_fd, TIOCGWINSZ, &size) == 0 &&
size.ws_row > 0 && size.ws_col > 0) {
*ncolumn = size.ws_col;
*nline = size.ws_row;
return;
};
#endif
/*
* Return the existing values.
*/
*ncolumn = gl->ncolumn;
*nline = gl->nline;
return;
}
/*.......................................................................
* Query the size of the terminal, and if it has changed, redraw the
* current input line accordingly.
*
* Input:
* gl GetLine * The resource object of gl_get_line().
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int _gl_update_size(GetLine *gl)
{
int ncolumn, nline; /* The new size of the terminal */
/*
* Query the new terminal window size.
*/
gl_query_size(gl, &ncolumn, &nline);
/*
* Update gl and the displayed line to fit the new dimensions.
*/
return gl_handle_tty_resize(gl, ncolumn, nline);
}
/*.......................................................................
* Redraw the current input line to account for a change in the terminal
* size. Also install the new size in gl.
*
* Input:
* gl GetLine * The resource object of gl_get_line().
* ncolumn int The new number of columns.
* nline int The new number of lines.
* Output:
* return int 0 - OK.
* 1 - Error.
*/
static int gl_handle_tty_resize(GetLine *gl, int ncolumn, int nline)
{
/*
* If the input device isn't a terminal, just record the new size.
*/
if(!gl->is_term) {
gl->nline = nline;
gl->ncolumn = ncolumn;
/*
* Has the size actually changed?
*/
} else if(ncolumn != gl->ncolumn || nline != gl->nline) {
/*
* If we are currently editing a line, erase it.
*/
if(gl_erase_line(gl))
return 1;
/*
* Update the recorded window size.
*/
gl->nline = nline;
gl->ncolumn = ncolumn;
/*
* Arrange for the input line to be redrawn before the next character
* is read from the terminal.
*/
gl_queue_redisplay(gl);
};
return 0;
}
/*.......................................................................
* This is the action function that recalls the previous line in the
* history buffer.
*/
static KT_KEY_FN(gl_up_history)
{
/*
* In vi mode, switch to command mode, since the user is very
* likely to want to move around newly recalled lines.
*/
gl_vi_command_mode(gl);
/*
* Forget any previous recall session.
*/
gl->preload_id = 0;
/*
* Record the key sequence number of this search action.
*/
gl->last_search = gl->keyseq_count;
/*
* We don't want a search prefix for this function.
*/
if(_glh_search_prefix(gl->glh, gl->line, 0)) {
_err_record_msg(gl->err, _glh_last_error(gl->glh), END_ERR_MSG);
return 1;
};
/*
* Recall the count'th next older line in the history list. If the first one
* fails we can return since nothing has changed, otherwise we must continue
* and update the line state.
*/
if(_glh_find_backwards(gl->glh, gl->line, gl->linelen+1) == NULL)
return 0;
while(--count && _glh_find_backwards(gl->glh, gl->line, gl->linelen+1))
;
/*
* Accomodate the new contents of gl->line[].
*/
gl_update_buffer(gl);
/*
* Arrange to have the cursor placed at the end of the new line.
*/
gl->buff_curpos = gl->ntotal;
/*
* Erase and display the new line.
*/
gl_queue_redisplay(gl);
return 0;
}
/*.......................................................................
* This is the action function that recalls the next line in the
* history buffer.
*/
static KT_KEY_FN(gl_down_history)
{
/*
* In vi mode, switch to command mode, since the user is very
* likely to want to move around newly recalled lines.
*/
gl_vi_command_mode(gl);
/*
* Record the key sequence number of this search action.
*/
gl->last_search = gl->keyseq_count;
/*
* If no search is currently in progress continue a previous recall
* session from a previous entered line if possible.
*/
if(_glh_line_id(gl->glh, 0) == 0 && gl->preload_id) {
_glh_recall_line(gl->glh, gl->preload_id, gl->line, gl->linelen+1);
gl->preload_id = 0;
} else {
/*
* We don't want a search prefix for this function.
*/
if(_glh_search_prefix(gl->glh, gl->line, 0)) {
_err_record_msg(gl->err, _glh_last_error(gl->glh), END_ERR_MSG);
return 1;
};
/*
* Recall the count'th next newer line in the history list. If the first one
* fails we can return since nothing has changed otherwise we must continue
* and update the line state.
*/
if(_glh_find_forwards(gl->glh, gl->line, gl->linelen+1) == NULL)
return 0;
while(--count && _glh_find_forwards(gl->glh, gl->line, gl->linelen+1))
;
};
/*
* Accomodate the new contents of gl->line[].
*/
gl_update_buffer(gl);
/*
* Arrange to have the cursor placed at the end of the new line.
*/
gl->buff_curpos = gl->ntotal;
/*
* Erase and display the new line.
*/
gl_queue_redisplay(gl);
return 0;
}
/*.......................................................................
* This is the action function that recalls the previous line in the
* history buffer whos prefix matches the characters that currently
* precede the cursor. By setting count=-1, this can be used internally
* to force searching for the prefix used in the last search.
*/
static KT_KEY_FN(gl_history_search_backward)
{
/*
* In vi mode, switch to command mode, since the user is very
* likely to want to move around newly recalled lines.
*/
gl_vi_command_mode(gl);
/*
* Forget any previous recall session.
*/
gl->preload_id = 0;
/*
* Record the key sequence number of this search action.
*/
gl->last_search = gl->keyseq_count;
/*
* If a prefix search isn't already in progress, replace the search
* prefix to the string that precedes the cursor. In vi command mode
* include the character that is under the cursor in the string. If
* count<0 keep the previous search prefix regardless, so as to force
* a repeat search even if the last command wasn't a history command.
*/
if(count >= 0 && !_glh_search_active(gl->glh) &&
_glh_search_prefix(gl->glh, gl->line, gl->buff_curpos +
(gl->editor==GL_VI_MODE && gl->ntotal>0))) {
_err_record_msg(gl->err, _glh_last_error(gl->glh), END_ERR_MSG);
return 1;
};
/*
* Search backwards for a match to the part of the line which precedes the
* cursor.
*/
if(_glh_find_backwards(gl->glh, gl->line, gl->linelen+1) == NULL)
return 0;
/*
* Accomodate the new contents of gl->line[].
*/
gl_update_buffer(gl);
/*
* Arrange to have the cursor placed at the end of the new line.
*/
gl->buff_curpos = gl->ntotal;
/*
* Erase and display the new line.
*/
gl_queue_redisplay(gl);
return 0;
}
/*.......................................................................
* This is the action function that recalls the previous line in the
* history buffer who's prefix matches that specified in an earlier call
* to gl_history_search_backward() or gl_history_search_forward().
*/
static KT_KEY_FN(gl_history_re_search_backward)
{
return gl_history_search_backward(gl, -1, NULL);
}
/*.......................................................................
* This is the action function that recalls the next line in the
* history buffer who's prefix matches that specified in the earlier call
* to gl_history_search_backward) which started the history search.
* By setting count=-1, this can be used internally to force searching
* for the prefix used in the last search.
*/
static KT_KEY_FN(gl_history_search_forward)
{
/*
* In vi mode, switch to command mode, since the user is very
* likely to want to move around newly recalled lines.
*/
gl_vi_command_mode(gl);
/*
* Record the key sequence number of this search action.
*/
gl->last_search = gl->keyseq_count;
/*
* If a prefix search isn't already in progress, replace the search
* prefix to the string that precedes the cursor. In vi command mode
* include the character that is under the cursor in the string. If
* count<0 keep the previous search prefix regardless, so as to force
* a repeat search even if the last command wasn't a history command.
*/
if(count >= 0 && !_glh_search_active(gl->glh) &&
_glh_search_prefix(gl->glh, gl->line, gl->buff_curpos +
(gl->editor==GL_VI_MODE && gl->ntotal>0))) {
_err_record_msg(gl->err, _glh_last_error(gl->glh), END_ERR_MSG);
return 1;
};
/*
* Search forwards for the next matching line.
*/
if(_glh_find_forwards(gl->glh, gl->line, gl->linelen+1) == NULL)
return 0;
/*
* Accomodate the new contents of gl->line[].
*/
gl_update_buffer(gl);
/*
* Arrange for the cursor to be placed at the end of the new line.
*/
gl->buff_curpos = gl->ntotal;
/*
* Erase and display the new line.
*/
gl_queue_redisplay(gl);
return 0;
}
/*.......................................................................
* This is the action function that recalls the next line in the
* history buffer who's prefix matches that specified in an earlier call
* to gl_history_search_backward() or gl_history_search_forward().
*/
static KT_KEY_FN(gl_history_re_search_forward)
{
return gl_history_search_forward(gl, -1, NULL);
}
#ifdef HIDE_FILE_SYSTEM
/*.......................................................................
* The following function is used as the default completion handler when
* the filesystem is to be hidden. It simply reports no completions.
*/
static CPL_MATCH_FN(gl_no_completions)
{
return 0;
}
#endif
/*.......................................................................
* This is the tab completion function that completes the filename that
* precedes the cursor position. Its callback data argument must be a
* pointer to a GlCplCallback containing the completion callback function
* and its callback data, or NULL to use the builtin filename completer.
*/
static KT_KEY_FN(gl_complete_word)
{
CplMatches *matches; /* The possible completions */
int suffix_len; /* The length of the completion extension */
int cont_len; /* The length of any continuation suffix */
int nextra; /* The number of characters being added to the */
/* total length of the line. */
int buff_pos; /* The buffer index at which the completion is */
/* to be inserted. */
int waserr = 0; /* True after errors */
/*
* Get the container of the completion callback and its callback data.
*/
GlCplCallback *cb = data ? (GlCplCallback *) data : &gl->cplfn;
/*
* In vi command mode, switch to append mode so that the character under
* the cursor is included in the completion (otherwise people can't
* complete at the end of the line).
*/
if(gl->vi.command && gl_vi_append(gl, 0, NULL))
return 1;
/*
* Get the cursor position at which the completion is to be inserted.
*/
buff_pos = gl->buff_curpos;
/*
* Perform the completion.
*/
matches = cpl_complete_word(gl->cpl, gl->line, gl->buff_curpos, cb->data,
cb->fn);
/*
* No matching completions?
*/
if(!matches) {
waserr = gl_print_info(gl, cpl_last_error(gl->cpl), GL_END_INFO);
/*
* Are there any completions?
*/
} else if(matches->nmatch >= 1) {
/*
* If there any ambiguous matches, report them, starting on a new line.
*/
if(matches->nmatch > 1 && gl->echo) {
if(_gl_normal_io(gl) ||
_cpl_output_completions(matches, gl_write_fn, gl, gl->ncolumn))
waserr = 1;
};
/*
* Get the length of the suffix and any continuation suffix to add to it.
*/
suffix_len = strlen(matches->suffix);
cont_len = strlen(matches->cont_suffix);
/*
* If there is an unambiguous match, and the continuation suffix ends in
* a newline, strip that newline and arrange to have getline return
* after this action function returns.
*/
if(matches->nmatch==1 && cont_len > 0 &&
matches->cont_suffix[cont_len - 1] == '\n') {
cont_len--;
if(gl_newline(gl, 1, NULL))
waserr = 1;
};
/*
* Work out the number of characters that are to be added.
*/
nextra = suffix_len + cont_len;
/*
* Is there anything to be added?
*/
if(!waserr && nextra) {
/*
* Will there be space for the expansion in the line buffer?
*/
if(gl->ntotal + nextra < gl->linelen) {
/*
* Make room to insert the filename extension.
*/
gl_make_gap_in_buffer(gl, gl->buff_curpos, nextra);
/*
* Insert the filename extension.
*/
gl_buffer_string(gl, matches->suffix, suffix_len, gl->buff_curpos);
/*
* Add the terminating characters.
*/
gl_buffer_string(gl, matches->cont_suffix, cont_len,
gl->buff_curpos + suffix_len);
/*
* Place the cursor position at the end of the completion.
*/
gl->buff_curpos += nextra;
/*
* If we don't have to redisplay the whole line, redisplay the part
* of the line which follows the original cursor position, and place
* the cursor at the end of the completion.
*/
if(gl->displayed) {
if(gl_truncate_display(gl) ||
gl_print_string(gl, gl->line + buff_pos, '\0') ||
gl_place_cursor(gl, gl->buff_curpos))
waserr = 1;
};
} else {
(void) gl_print_info(gl,
"Insufficient room in line for file completion.",
GL_END_INFO);
waserr = 1;
};
};
};
/*
* If any output had to be written to the terminal, then editing will
* have been suspended, make sure that we are back in raw line editing
* mode before returning.
*/
if(_gl_raw_io(gl, 1))
waserr = 1;
return 0;
}
#ifndef HIDE_FILE_SYSTEM
/*.......................................................................
* This is the function that expands the filename that precedes the
* cursor position. It expands ~user/ expressions, $envvar expressions,
* and wildcards.
*/
static KT_KEY_FN(gl_expand_filename)
{
char *start_path; /* The pointer to the start of the pathname in */
/* gl->line[]. */
FileExpansion *result; /* The results of the filename expansion */
int pathlen; /* The length of the pathname being expanded */
int length; /* The number of characters needed to display the */
/* expanded files. */
int nextra; /* The number of characters to be added */
int i,j;
/*
* In vi command mode, switch to append mode so that the character under
* the cursor is included in the completion (otherwise people can't
* complete at the end of the line).
*/
if(gl->vi.command && gl_vi_append(gl, 0, NULL))
return 1;
/*
* Locate the start of the filename that precedes the cursor position.
*/
start_path = _pu_start_of_path(gl->line, gl->buff_curpos);
if(!start_path)
return 1;
/*
* Get the length of the string that is to be expanded.
*/
pathlen = gl->buff_curpos - (start_path - gl->line);
/*
* Attempt to expand it.
*/
result = ef_expand_file(gl->ef, start_path, pathlen);
/*
* If there was an error, report the error on a new line.
*/
if(!result)
return gl_print_info(gl, ef_last_error(gl->ef), GL_END_INFO);
/*
* If no files matched, report this as well.
*/
if(result->nfile == 0 || !result->exists)
return gl_print_info(gl, "No files match.", GL_END_INFO);
/*
* If in vi command mode, preserve the current line for potential use by
* vi-undo.
*/
gl_save_for_undo(gl);
/*
* Work out how much space we will need to display all of the matching
* filenames, taking account of the space that we need to place between
* them, and the number of additional '\' characters needed to escape
* spaces, tabs and backslash characters in the individual filenames.
*/
length = 0;
for(i=0; infile; i++) {
char *file = result->files[i];
while(*file) {
int c = *file++;
switch(c) {
case ' ': case '\t': case '\\': case '*': case '?': case '[':
length++; /* Count extra backslash characters */
};
length++; /* Count the character itself */
};
length++; /* Count the space that follows each filename */
};
/*
* Work out the number of characters that are to be added.
*/
nextra = length - pathlen;
/*
* Will there be space for the expansion in the line buffer?
*/
if(gl->ntotal + nextra >= gl->linelen) {
return gl_print_info(gl, "Insufficient room in line for file expansion.",
GL_END_INFO);
} else {
/*
* Do we need to move the part of the line that followed the unexpanded
* filename?
*/
if(nextra > 0) {
gl_make_gap_in_buffer(gl, gl->buff_curpos, nextra);
} else if(nextra < 0) {
gl->buff_curpos += nextra;
gl_remove_from_buffer(gl, gl->buff_curpos, -nextra);
};
/*
* Insert the filenames, separated by spaces, and with internal spaces,
* tabs and backslashes escaped with backslashes.
*/
for(i=0,j=start_path - gl->line; i