293 lines
8.0 KiB
C
293 lines
8.0 KiB
C
/*-
|
|
* Copyright (c) 1999 Timmy M. Vanderhoek
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
#ifndef lint
|
|
static const char rcsid[] =
|
|
"$FreeBSD$";
|
|
#endif /* not lint */
|
|
|
|
/*
|
|
* Expansion of macros.
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "less.h"
|
|
|
|
|
|
/*
|
|
* Used to construct tables of macros. Each macro string expands to command.
|
|
* A number N is associated with each execution of a macro. The command
|
|
* "set number <N>" will be done before the expansion. The end of the table is
|
|
* specified by mactabsize. A NULL entry for command denotes a macro that
|
|
* has been marked deleted for some reason. As of this writing, there is no
|
|
* code that actually deletes a macro...
|
|
*/
|
|
struct macro {
|
|
char *string; /* characters typed to activate macro */
|
|
char *command; /* command resulting after the macro is activated */
|
|
long defnumber; /* default value of the N number */
|
|
int flags; /* only holds STICKYNUMB for now... */
|
|
};
|
|
/* (struct macro) ->flags */
|
|
#define NOFLAGS 0
|
|
#define STICKYNUMB 1 /* Set defnumber to current number, if current number */
|
|
|
|
/*
|
|
* The macro table.
|
|
*/
|
|
struct macro *mactab = NULL;
|
|
int mactabsize = 0;
|
|
|
|
static enum runmacro runmacro_();
|
|
static struct macro *matchmac();
|
|
|
|
|
|
/*
|
|
* XXX Everything's really just a macro until resolved as a quantum wave
|
|
* probability distribution.
|
|
*/
|
|
|
|
|
|
/*
|
|
* Attempts to run the appropriate macro. Returns 0, or OK, if the macro
|
|
* was succesfully run. Returns BADMACRO and sets erreur if something is
|
|
* horribly wrong with the macro. Returns NOMACRO if the macro has no valid
|
|
* expansion. BADMACRO and NOMACRO are almost the same. Returns BADCOMMAND
|
|
* and leaves erreur set (hopefully it was set when runmacro() tried to execute
|
|
* the command associated with the macro) if the command associated with
|
|
* the macro was unsuccessful. Returns TOOMACRO if the macro appears to be
|
|
* incomplete (ie. the user has not finished typing it in yet). The erreur
|
|
* is not set in this case.
|
|
*
|
|
* XXX There's no good reason not to just disallow badmacros from within
|
|
* setmacro() ... It's not clear what the author was thinking at the time.
|
|
*/
|
|
enum runmacro
|
|
runmacro(macro, number, anyN)
|
|
const char *macro; /* the macro string to try and expand */
|
|
long number; /* the number N associated with this execution */
|
|
int anyN; /* FALSE is we should use the default N associated with
|
|
* the macro. TRUE if we should use the number argument. */
|
|
{
|
|
struct macro *cur, *matched;
|
|
int match, yetmatch;
|
|
int s;
|
|
|
|
if (!mactab) {
|
|
/* Should only happen with really sucky default rc files... */
|
|
SETERR (E_CANTXPND);
|
|
return NOMACRO;
|
|
}
|
|
|
|
match = yetmatch = 0;
|
|
for (cur = mactab, s = mactabsize; s; cur++, s--) {
|
|
if (!cur->command)
|
|
continue; /* deleted macro */
|
|
if (!strcmp(cur->string, macro))
|
|
matched = cur, match++;
|
|
else if (!strncmp(cur->string, macro, strlen(macro)))
|
|
yetmatch++;
|
|
}
|
|
|
|
if (match == 1) {
|
|
if (yetmatch) {
|
|
SETERR (E_AMBIG);
|
|
return BADMACRO;
|
|
}
|
|
|
|
/* XXX it's not clear how to handle error when setting
|
|
* the number N --- this is a deficiency in the style of error-
|
|
* reporting suggested in command.c and less.h. Could have
|
|
* setvar() guarantee success when setting "number". A failure
|
|
* must not become fatal or it becomes impossible to do
|
|
* any commands at all. */
|
|
if (anyN) {
|
|
if (matched->flags & STICKYNUMB)
|
|
matched->defnumber = number;
|
|
(void) setvari("number", number);
|
|
} else
|
|
(void) setvari("number", matched->defnumber);
|
|
clear_error();
|
|
|
|
if (command(matched->command))
|
|
return BADCOMMAND;
|
|
return OK;
|
|
}
|
|
if (match > 1) {
|
|
SETERR (E_AMBIG);
|
|
return BADMACRO;
|
|
}
|
|
if (!match && !yetmatch) {
|
|
SETERR (E_CANTXPND);
|
|
return NOMACRO;
|
|
}
|
|
assert(yetmatch);
|
|
return TOOMACRO;
|
|
}
|
|
|
|
/*
|
|
* Associates a macro with a given command. Returns -1 if it was unable to
|
|
* set the macro. Errors associated with setting a macro may be caught
|
|
* either in this function, setmacro(), or in runmacro(). Both macro and
|
|
* command are strcpy()'d into their own space.
|
|
*/
|
|
int
|
|
setmacro(macro, command)
|
|
const char *macro;
|
|
const char *command;
|
|
{
|
|
struct macro *cur, *new = NULL;
|
|
char *new_mac, *new_com;
|
|
int s;
|
|
|
|
assert (macro); assert (command);
|
|
|
|
/* First, check for any existing macro matches in the custom table */
|
|
s = mactabsize;
|
|
for (cur = mactab; s; cur++, s--) {
|
|
if (!cur->command) {
|
|
/* Hmm... A deleted macro in the table */
|
|
new = cur;
|
|
continue;
|
|
}
|
|
if (!strcmp(cur->string, macro)) {
|
|
/*
|
|
* An exact match to the new macro already exists.
|
|
* Calling realloc() on cur->string and cur->command
|
|
* without risking being left in bad state is tricky.
|
|
* Just do it the slow but sure way...
|
|
*/
|
|
new = cur;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Do the allocations here so that we can maintain consistent state
|
|
* even if realloc() fails when we try to expand the table (suppose
|
|
* the table gets expanded but the next malloc to get space for the
|
|
* macro fails).
|
|
*/
|
|
if (!FMALLOC(strlen(macro) + 1, new_mac))
|
|
return -1;
|
|
if (!FMALLOC(strlen(command) + 1, new_com))
|
|
return -1;
|
|
|
|
if (!new) {
|
|
/* Extend the command table by one record */
|
|
struct macro *t = realloc(mactab, (mactabsize + 1) *
|
|
sizeof(struct macro));
|
|
if (!t) {
|
|
/* The old mactab is still valid. Just back out. */
|
|
free(new_mac), free(new_com);
|
|
SETERR (E_MALLOC);
|
|
return -1;
|
|
} else
|
|
mactab = t;
|
|
new = &mactab[mactabsize];
|
|
mactabsize++;
|
|
new->string = new->command = NULL;
|
|
}
|
|
|
|
if (new->string) free(new->string);
|
|
if (new->command) free(new->command);
|
|
new->string = new_mac;
|
|
new->command = new_com;
|
|
strcpy(new->string, macro);
|
|
strcpy(new->command, command);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Set the sticky tag on a macro. Returns -1 on failure, 0 on success.
|
|
*/
|
|
int
|
|
stickymac(macro, state)
|
|
const char *macro;
|
|
int state; /* set it to TRUE or set it to FALSE */
|
|
{
|
|
struct macro *m = matchmac(macro);
|
|
if (!m)
|
|
return -1;
|
|
|
|
if (state)
|
|
m->flags |= STICKYNUMB;
|
|
else
|
|
m->flags &= ~STICKYNUMB;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Set the default number of a macro. Returns -1 on failure, 0 on success.
|
|
*/
|
|
int
|
|
setmacnumb(macro, N)
|
|
const char *macro;
|
|
long N; /* The default number */
|
|
{
|
|
struct macro *m = matchmac(macro);
|
|
if (!m)
|
|
return -1;
|
|
|
|
m->defnumber = N;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Tries to find a struct macro matching "macro". Returns NULL if an exact
|
|
* match could not be found (eg. ambiguous macro, no macro, etc).
|
|
*/
|
|
static struct macro *
|
|
matchmac(macro)
|
|
const char *macro;
|
|
{
|
|
struct macro *retr, *cur;
|
|
int s;
|
|
|
|
retr = NULL;
|
|
for (cur = mactab, s = mactabsize; s; cur++, s--) {
|
|
if (!cur->command)
|
|
continue;
|
|
if (!strcmp(cur->string, macro)) {
|
|
if (retr) {
|
|
SETERR (E_AMBIG);
|
|
return NULL; /* matched twice! */
|
|
} else
|
|
retr = cur;
|
|
} else if (!strncmp(cur->string, macro, strlen(macro))) {
|
|
SETERR (E_AMBIG);
|
|
return NULL; /* ambiguous macro! */
|
|
}
|
|
}
|
|
return retr;
|
|
}
|