anon/csope
1
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

'clang-format'-ing

Browse Source
This commit is contained in:
anon 2023-08-13 11:21:52 +02:00
parent dc399a1b86
commit 987c69f75c
38 changed files with 8022 additions and 8311 deletions

1108
src/build.c
View File

File diff suppressed because it is too large Load Diff

40
src/build.h
View File

@ -33,38 +33,38 @@
#ifndef CSCOPE_BUILD_H
#define CSCOPE_BUILD_H
#include "global.h" /* FIXME: temp. only */
#include "global.h" /* FIXME: temp. only */
#include "invlib.h"
/* types and macros of build.c to be used by other modules */
/* database output macros that update its offset */
#define dbputc(c) (++dboffset, (void) putc(c, newrefs))
#define dbfputs(s) (dboffset += strlen(s), fputs(s, newrefs))
#define dbputc(c) (++dboffset, (void)putc(c, newrefs))
#define dbfputs(s) (dboffset += strlen(s), fputs(s, newrefs))
/* declarations for globals defined in build.c */
extern bool buildonly; /* only build the database */
extern bool unconditional; /* unconditionally build database */
extern bool fileschanged; /* assume some files changed */
extern bool buildonly; /* only build the database */
extern bool unconditional; /* unconditionally build database */
extern bool fileschanged; /* assume some files changed */
extern char *reffile; /* cross-reference file path name */
extern char *invname; /* inverted index to the database */
extern char *invpost; /* inverted index postings */
extern char *newreffile; /* new cross-reference file name */
extern FILE *newrefs; /* new cross-reference */
extern FILE *postings; /* new inverted index postings */
extern int symrefs; /* cross-reference file */
extern char *reffile; /* cross-reference file path name */
extern char *invname; /* inverted index to the database */
extern char *invpost; /* inverted index postings */
extern char *newreffile; /* new cross-reference file name */
extern FILE *newrefs; /* new cross-reference */
extern FILE *postings; /* new inverted index postings */
extern int symrefs; /* cross-reference file */
extern INVCONTROL invcontrol; /* inverted file control structure */
extern INVCONTROL invcontrol; /* inverted file control structure */
/* Prototypes of external functions defined by build.c */
void build(void);
void free_newbuildfiles(void);
void opendatabase(void);
void rebuild(void);
void setup_build_filenames(char *reffile);
void seek_to_trailer(FILE *f);
void build(void);
void free_newbuildfiles(void);
void opendatabase(void);
void rebuild(void);
void setup_build_filenames(char *reffile);
void seek_to_trailer(FILE *f);
#endif /* CSCOPE_BUILD_H */

255
src/command.c
View File

@ -36,14 +36,14 @@
*/
#include "global.h"
#include "build.h" /* for rebuild() */
#include "build.h" /* for rebuild() */
#include <stdlib.h>
#if defined(USE_NCURSES) && !defined(RENAMED_NCURSES)
#include <ncurses.h>
# include <ncurses.h>
#else
#include <curses.h>
# include <curses.h>
#endif
#include <ctype.h>
@ -54,164 +54,135 @@
* In the original version this was handled by
* "int selecting // whether the (upper) symbol list is being browsed".
*/
extern const void *const winput;
extern const void *const wmode;
extern const void *const wresult;
extern const void *const winput;
extern const void *const wmode;
extern const void *const wresult;
extern const void *const *const current_window;
bool caseless; /* ignore letter case when searching */
bool *change; /* change this line */
char newpat[PATLEN + 1]; /* new pattern */
bool caseless; /* ignore letter case when searching */
bool *change; /* change this line */
char newpat[PATLEN + 1]; /* new pattern */
/* Internal prototypes: */
static void scrollbar(MOUSE *p);
static void scrollbar(MOUSE *p);
/* read references from a file */
bool
readrefs(char *filename)
{
FILE *file;
int c;
bool readrefs(char *filename) {
FILE *file;
int c;
if ((file = myfopen(filename, "rb")) == NULL) {
cannotopen(filename);
return(false);
}
if ((c = getc(file)) == EOF) { /* if file is empty */
fclose(file);
return(false);
}
totallines = 0;
disprefs = 0;
nextline = 1;
if (writerefsfound() == true) {
putc(c, refsfound);
while ((c = getc(file)) != EOF) {
putc(c, refsfound);
}
fclose(file);
fclose(refsfound);
if ( (refsfound = myfopen(temp1, "rb")) == NULL) {
cannotopen(temp1);
return(false);
}
countrefs();
} else
fclose(file);
return(true);
if((file = myfopen(filename, "rb")) == NULL) {
cannotopen(filename);
return (false);
}
if((c = getc(file)) == EOF) { /* if file is empty */
fclose(file);
return (false);
}
totallines = 0;
disprefs = 0;
nextline = 1;
if(writerefsfound() == true) {
putc(c, refsfound);
while((c = getc(file)) != EOF) {
putc(c, refsfound);
}
fclose(file);
fclose(refsfound);
if((refsfound = myfopen(temp1, "rb")) == NULL) {
cannotopen(temp1);
return (false);
}
countrefs();
} else
fclose(file);
return (true);
}
/* scrollbar actions */
static void
scrollbar(MOUSE *p)
{
///* reposition list if it makes sense */
//if (totallines == 0) {
//return;
//}
//switch (p->percent) {
static void scrollbar(MOUSE *p) {
///* reposition list if it makes sense */
// if (totallines == 0) {
// return;
// }
// switch (p->percent) {
//case 101: /* scroll down one page */
//if (nextline + mdisprefs > totallines) {
// nextline = totallines - mdisprefs + 1;
//}
//break;
// case 101: /* scroll down one page */
// if (nextline + mdisprefs > totallines) {
// nextline = totallines - mdisprefs + 1;
// }
// break;
//case 102: /* scroll up one page */
//nextline = topline - mdisprefs;
//if (nextline < 1) {
// nextline = 1;
//}
//break;
// case 102: /* scroll up one page */
// nextline = topline - mdisprefs;
// if (nextline < 1) {
// nextline = 1;
// }
// break;
//case 103: /* scroll down one line */
//nextline = topline + 1;
//break;
// case 103: /* scroll down one line */
// nextline = topline + 1;
// break;
//case 104: /* scroll up one line */
//if (topline > 1) {
// nextline = topline - 1;
//}
//break;
//default:
//nextline = p->percent * totallines / 100;
//}
////seekline(nextline);
// case 104: /* scroll up one line */
// if (topline > 1) {
// nextline = topline - 1;
// }
// break;
// default:
// nextline = p->percent * totallines / 100;
// }
////seekline(nextline);
}
/* count the references found */
void
countrefs(void)
{
char *subsystem; /* OGS subsystem name */
char *book; /* OGS book name */
char file[PATHLEN + 1]; /* file name */
char function[PATLEN + 1]; /* function name */
char linenum[NUMLEN + 1]; /* line number */
int i;
void countrefs(void) {
char *subsystem; /* OGS subsystem name */
char *book; /* OGS book name */
char file[PATHLEN + 1]; /* file name */
char function[PATLEN + 1]; /* function name */
char linenum[NUMLEN + 1]; /* line number */
int i;
/* count the references found and find the length of the file,
function, and line number display fields */
/* count the references found and find the length of the file,
function, and line number display fields */
/* HBB falseTE 2012-04-07: it may look like we shouldn't assing tempstring here,
* since it's not used. But it has to be assigned just so the return value
* of fscanf will actually reach 4. */
while (EOF != (i = fscanf(refsfound,
"%" PATHLEN_STR "s%" PATLEN_STR "s%" NUMLEN_STR "s %" TEMPSTRING_LEN_STR "[^\n]",
file, function, linenum, tempstring
)
)
) {
if ( (i != 4)
|| !isgraph((unsigned char) *file)
|| !isgraph((unsigned char) *function)
|| !isdigit((unsigned char) *linenum)
) {
postmsg("File does not have expected format");
totallines = 0;
disprefs = 0;
return;
}
if ((i = strlen(pathcomponents(file, dispcomponents))) > filelen) {
filelen = i;
}
if (ogs == true) {
ogsnames(file, &subsystem, &book);
if ((i = strlen(subsystem)) > subsystemlen) {
subsystemlen = i;
}
if ((i = strlen(book)) > booklen) {
booklen = i;
}
}
if ((i = strlen(function)) > fcnlen) {
fcnlen = i;
}
if ((i = strlen(linenum)) > numlen) {
numlen = i;
}
++totallines;
}
rewind(refsfound);
/* HBB falseTE 2012-04-07: it may look like we shouldn't assing tempstring here,
* since it's not used. But it has to be assigned just so the return value
* of fscanf will actually reach 4. */
while(EOF != (i = fscanf(refsfound,
"%" PATHLEN_STR "s%" PATLEN_STR "s%" NUMLEN_STR
"s %" TEMPSTRING_LEN_STR "[^\n]",
file,
function,
linenum,
tempstring))) {
if((i != 4) || !isgraph((unsigned char)*file) ||
!isgraph((unsigned char)*function) || !isdigit((unsigned char)*linenum)) {
postmsg("File does not have expected format");
totallines = 0;
disprefs = 0;
return;
}
if((i = strlen(pathcomponents(file, dispcomponents))) > filelen) { filelen = i; }
if(ogs == true) {
ogsnames(file, &subsystem, &book);
if((i = strlen(subsystem)) > subsystemlen) { subsystemlen = i; }
if((i = strlen(book)) > booklen) { booklen = i; }
}
if((i = strlen(function)) > fcnlen) { fcnlen = i; }
if((i = strlen(linenum)) > numlen) { numlen = i; }
++totallines;
}
rewind(refsfound);
/* restrict the width of displayed columns */
/* HBB FIXME 20060419: magic number alert! */
i = (COLS - 5) / 3;
if (ogs == true) {
i = (COLS - 7) / 5;
}
if (filelen > i && i > 4) {
filelen = i;
}
if (subsystemlen > i && i > 9) {
subsystemlen = i;
}
if (booklen > i && i > 4) {
booklen = i;
}
if (fcnlen > i && i > 8) {
fcnlen = i;
}
/* restrict the width of displayed columns */
/* HBB FIXME 20060419: magic number alert! */
i = (COLS - 5) / 3;
if(ogs == true) { i = (COLS - 7) / 5; }
if(filelen > i && i > 4) { filelen = i; }
if(subsystemlen > i && i > 9) { subsystemlen = i; }
if(booklen > i && i > 4) { booklen = i; }
if(fcnlen > i && i > 8) { fcnlen = i; }
}

82
src/constants.h
View File

@ -38,77 +38,79 @@
#ifndef CSCOPE_CONSTANTS_H
#define CSCOPE_CONSTANTS_H
#define ctrl(x) (x & 037) /* control character macro */
#define ctrl(x) (x & 037) /* control character macro */
/* fast string equality tests (avoids most strcmp() calls) */
#define strequal(s1, s2) (*(s1) == *(s2) && strcmp(s1, s2) == 0)
#define strnotequal(s1, s2) (*(s1) != *(s2) || strcmp(s1, s2) != 0)
#define strequal(s1, s2) (*(s1) == *(s2) && strcmp(s1, s2) == 0)
#define strnotequal(s1, s2) (*(s1) != *(s2) || strcmp(s1, s2) != 0)
/* set the mark character for searching the cross-reference file */
#define setmark(c) (blockmark = c, block[blocklen] = blockmark)
#define setmark(c) (blockmark = c, block[blocklen] = blockmark)
/* get the next character in the cross-reference */
/* note that blockp is assumed not to be null */
#define getrefchar() (*(++blockp + 1) != '\0' ? *blockp : \
(read_block() != NULL ? *blockp : '\0'))
#define getrefchar() \
(*(++blockp + 1) != '\0' ? *blockp : (read_block() != NULL ? *blockp : '\0'))
/* skip the next character in the cross-reference */
/* note that blockp is assumed not to be null and that
this macro will always be in a statement by itself */
#define skiprefchar() if (*(++blockp + 1) == '\0') (void) read_block()
#define skiprefchar() \
if(*(++blockp + 1) == '\0') (void)read_block()
#define DUMMYCHAR ' ' /* use space as a dummy character */
#define MSGLEN ((PATLEN) + 80) /* displayed message length */
#define NUMLEN 10 /* line number length */
#define PATHLEN 250 /* file pathname length */
#define PATLEN 250 /* symbol pattern length */
#define TEMPSTRING_LEN 8191 /* max strlen() of the global temp string */
#define REFFILE "cscope.out" /* cross-reference output file */
#define NAMEFILE "cscope.files" /* default list-of-files file */
#define INVNAME "cscope.in.out" /* inverted index to the database */
#define INVPOST "cscope.po.out" /* inverted index postings */
#define INVNAME2 "cscope.out.in"/* follows correct naming convention */
#define INVPOST2 "cscope.out.po"/* follows correct naming convention */
#define DUMMYCHAR ' ' /* use space as a dummy character */
#define MSGLEN ((PATLEN) + 80) /* displayed message length */
#define NUMLEN 10 /* line number length */
#define PATHLEN 250 /* file pathname length */
#define PATLEN 250 /* symbol pattern length */
#define TEMPSTRING_LEN 8191 /* max strlen() of the global temp string */
#define REFFILE "cscope.out" /* cross-reference output file */
#define NAMEFILE "cscope.files" /* default list-of-files file */
#define INVNAME "cscope.in.out" /* inverted index to the database */
#define INVPOST "cscope.po.out" /* inverted index postings */
#define INVNAME2 "cscope.out.in" /* follows correct naming convention */
#define INVPOST2 "cscope.out.po" /* follows correct naming convention */
#define STMTMAX 10000 /* maximum source statement length */
#define STMTMAX 10000 /* maximum source statement length */
#define STR2(x) #x
#define STRINGIZE(x) STR2(x)
#define PATLEN_STR STRINGIZE(PATLEN)
#define PATHLEN_STR STRINGIZE(PATHLEN)
#define NUMLEN_STR STRINGIZE(NUMLEN)
#define STR2(x) #x
#define STRINGIZE(x) STR2(x)
#define PATLEN_STR STRINGIZE(PATLEN)
#define PATHLEN_STR STRINGIZE(PATHLEN)
#define NUMLEN_STR STRINGIZE(NUMLEN)
#define TEMPSTRING_LEN_STR STRINGIZE(TEMPSTRING_LEN)
/* input fields (value matches field order on screen) */
enum {
SYMBOL = 0,
DEFINITION = 1,
CALLEDBY = 2,
CALLING = 3,
STRING = 4,
CHANGE = 5,
REGEXP = 6,
FILENAME = 7,
INCLUDES = 8
SYMBOL = 0,
DEFINITION = 1,
CALLEDBY = 2,
CALLING = 3,
STRING = 4,
CHANGE = 5,
REGEXP = 6,
FILENAME = 7,
INCLUDES = 8
};
#define FIELDS 10
#define FIELDS 10
// XXX
#define bazdki 1
/* file open modes */
#ifndef R_OK
# define READ R_OK
# define READ R_OK
#else
# define READ 4
# define READ 4
#endif
#ifdef W_OK
# define WRITE W_OK
# define WRITE W_OK
#else
# define WRITE 2
# define WRITE 2
#endif
#define O_TEXT 0x00
#define O_TEXT 0x00
#define O_BINARY 0x00

713
src/crossref.c
View File

@ -46,447 +46,408 @@
#include <sys/stat.h>
/* convert long to a string in base BASE notation */
#define ltobase(value) \
do { \
n = (value); \
s = buf + (sizeof(buf) - 1); \
*s = '\0'; \
digits = 1; \
while (n >= BASE) { \
++digits; \
i = n; \
n /= BASE; \
*--s = i - n * BASE + '!'; \
} \
*--s = n + '!'; \
} while (0)
#define ltobase(value) \
do { \
n = (value); \
s = buf + (sizeof(buf) - 1); \
*s = '\0'; \
digits = 1; \
while(n >= BASE) { \
++digits; \
i = n; \
n /= BASE; \
*--s = i - n * BASE + '!'; \
} \
*--s = n + '!'; \
} while(0)
#define SYMBOLINC 20 /* symbol list size increment */
#define SYMBOLINC 20 /* symbol list size increment */
long dboffset; /* new database offset */
bool errorsfound; /* prompt before clearing messages */
long lineoffset; /* source line database offset */
long npostings; /* number of postings */
int nsrcoffset; /* number of file name database offsets */
long *srcoffset; /* source file name database offsets */
unsigned long symbols; /* number of symbols */
long dboffset; /* new database offset */
bool errorsfound; /* prompt before clearing messages */
long lineoffset; /* source line database offset */
long npostings; /* number of postings */
int nsrcoffset; /* number of file name database offsets */
long *srcoffset; /* source file name database offsets */
unsigned long symbols; /* number of symbols */
static char *filename; /* file name for warning messages */
static long fcnoffset; /* function name database offset */
static long macrooffset; /* macro name database offset */
static unsigned long msymbols = SYMBOLINC; /* maximum number of symbols */
static char *filename; /* file name for warning messages */
static long fcnoffset; /* function name database offset */
static long macrooffset; /* macro name database offset */
static unsigned long msymbols = SYMBOLINC; /* maximum number of symbols */
struct symbol { /* symbol data */
int type; /* type */
unsigned int first; /* index of first character in text */
unsigned int last; /* index of last+1 character in text */
unsigned int length; /* symbol length */
unsigned int fcn_level; /* function level of the symbol */
struct symbol { /* symbol data */
int type; /* type */
unsigned int first; /* index of first character in text */
unsigned int last; /* index of last+1 character in text */
unsigned int length; /* symbol length */
unsigned int fcn_level; /* function level of the symbol */
};
static struct symbol *symbol;
static void putcrossref(void);
static void savesymbol(int token, int num);
static void putcrossref(void);
static void savesymbol(int token, int num);
void
crossref(char *srcfile)
{
unsigned int i;
unsigned int length; /* symbol length */
unsigned int entry_no; /* function level of the symbol */
int token; /* current token */
struct stat st;
void crossref(char *srcfile) {
unsigned int i;
unsigned int length; /* symbol length */
unsigned int entry_no; /* function level of the symbol */
int token; /* current token */
struct stat st;
if (! ((stat(srcfile, &st) == 0)
&& S_ISREG(st.st_mode))) {
cannotopen(srcfile);
errorsfound = true;
return;
}
if(!((stat(srcfile, &st) == 0) && S_ISREG(st.st_mode))) {
cannotopen(srcfile);
errorsfound = true;
return;
}
entry_no = 0;
/* open the source file */
if ((yyin = myfopen(srcfile, "r")) == NULL) {
cannotopen(srcfile);
errorsfound = true;
return;
}
filename = srcfile; /* save the file name for warning messages */
putfilename(srcfile); /* output the file name */
dbputc('\n');
dbputc('\n');
entry_no = 0;
/* open the source file */
if((yyin = myfopen(srcfile, "r")) == NULL) {
cannotopen(srcfile);
errorsfound = true;
return;
}
filename = srcfile; /* save the file name for warning messages */
putfilename(srcfile); /* output the file name */
dbputc('\n');
dbputc('\n');
/* read the source file */
initscanner(srcfile);
fcnoffset = macrooffset = 0;
symbols = 0;
if (symbol == NULL) {
symbol = malloc(msymbols * sizeof(*symbol));
}
for (;;) {
/* read the source file */
initscanner(srcfile);
fcnoffset = macrooffset = 0;
symbols = 0;
if(symbol == NULL) { symbol = malloc(msymbols * sizeof(*symbol)); }
for(;;) {
/* get the next token */
switch (token = yylex()) {
default:
/* if requested, truncate C symbols */
length = last - first;
if (trun_syms == true && length > 8 &&
token != INCLUDE && token != NEWFILE) {
length = 8;
last = first + 8;
}
/* see if the token has a symbol */
if (length == 0) {
savesymbol(token, entry_no);
break;
}
/* update entry_no if see function entry */
if (token == FCNDEF) {
entry_no++;
}
/* see if the symbol is already in the list */
for (i = 0; i < symbols; ++i) {
if (length == symbol[i].length
&& strncmp(my_yytext + first,
my_yytext + symbol[i].first,
length) == 0
&& entry_no == symbol[i].fcn_level
&& token == symbol[i].type
) { /* could be a::a() */
break;
}
}
if (i == symbols) { /* if not already in list */
savesymbol(token, entry_no);
}
break;
/* get the next token */
switch(token = yylex()) {
default:
/* if requested, truncate C symbols */
length = last - first;
if(trun_syms == true && length > 8 && token != INCLUDE &&
token != NEWFILE) {
length = 8;
last = first + 8;
}
/* see if the token has a symbol */
if(length == 0) {
savesymbol(token, entry_no);
break;
}
/* update entry_no if see function entry */
if(token == FCNDEF) { entry_no++; }
/* see if the symbol is already in the list */
for(i = 0; i < symbols; ++i) {
if(length == symbol[i].length &&
strncmp(my_yytext + first, my_yytext + symbol[i].first, length) ==
0 &&
entry_no == symbol[i].fcn_level &&
token == symbol[i].type) { /* could be a::a() */
break;
}
}
if(i == symbols) { /* if not already in list */
savesymbol(token, entry_no);
}
break;
case NEWLINE: /* end of line containing symbols */
entry_no = 0; /* reset entry_no for each line */
case NEWLINE: /* end of line containing symbols */
entry_no = 0; /* reset entry_no for each line */
#ifdef USING_LEX
--yyleng; /* remove the newline */
--yyleng; /* remove the newline */
#endif
putcrossref(); /* output the symbols and source line */
lineno = myylineno; /* save the symbol line number */
putcrossref(); /* output the symbols and source line */
lineno = myylineno; /* save the symbol line number */
#ifndef USING_LEX
/* HBB 20010425: replaced yyleng-- by this chunk: */
if (my_yytext)
*my_yytext = '\0';
my_yyleng = 0;
/* HBB 20010425: replaced yyleng-- by this chunk: */
if(my_yytext) *my_yytext = '\0';
my_yyleng = 0;
#endif
break;
break;
case LEXERR: /* Lexer error, abort further parsing of this file */
case LEXEOF: /* end of file; last line may not have \n */
case LEXERR: /* Lexer error, abort further parsing of this file */
case LEXEOF: /* end of file; last line may not have \n */
/* if there were symbols, output them and the source line */
if (symbols > 0) {
putcrossref();
}
(void) fclose(yyin); /* close the source file */
/* if there were symbols, output them and the source line */
if(symbols > 0) { putcrossref(); }
(void)fclose(yyin); /* close the source file */
/* output the leading tab expected by the next call */
dbputc('\t');
return;
}
}
/* output the leading tab expected by the next call */
dbputc('\t');
return;
}
}
}
/* save the symbol in the list */
static void
savesymbol(int token, int num)
{
/* make sure there is room for the symbol */
if (symbols == msymbols) {
msymbols += SYMBOLINC;
symbol = realloc(symbol, msymbols * sizeof(*symbol));
}
/* save the symbol */
symbol[symbols].type = token;
symbol[symbols].first = first;
symbol[symbols].last = last;
symbol[symbols].length = last - first;
symbol[symbols].fcn_level = num;
++symbols;
static void savesymbol(int token, int num) {
/* make sure there is room for the symbol */
if(symbols == msymbols) {
msymbols += SYMBOLINC;
symbol = realloc(symbol, msymbols * sizeof(*symbol));
}
/* save the symbol */
symbol[symbols].type = token;
symbol[symbols].first = first;
symbol[symbols].last = last;
symbol[symbols].length = last - first;
symbol[symbols].fcn_level = num;
++symbols;
}
/* output the file name */
void
putfilename(char *srcfile)
{
/* check for file system out of space */
/* note: dbputc is not used to avoid lint complaint */
if (putc(NEWFILE, newrefs) == EOF) {
cannotwrite(newreffile);
/* NOTREACHED */
}
++dboffset;
if (invertedindex == true) {
srcoffset[nsrcoffset++] = dboffset;
}
dbfputs(srcfile);
fcnoffset = macrooffset = 0;
void putfilename(char *srcfile) {
/* check for file system out of space */
/* note: dbputc is not used to avoid lint complaint */
if(putc(NEWFILE, newrefs) == EOF) {
cannotwrite(newreffile);
/* NOTREACHED */
}
++dboffset;
if(invertedindex == true) { srcoffset[nsrcoffset++] = dboffset; }
dbfputs(srcfile);
fcnoffset = macrooffset = 0;
}
/* output the symbols and source line */
static void
putcrossref(void)
{
unsigned int i, j;
unsigned char c;
bool blank; /* blank indicator */
unsigned int symput = 0; /* symbols output */
int type;
static void putcrossref(void) {
unsigned int i, j;
unsigned char c;
bool blank; /* blank indicator */
unsigned int symput = 0; /* symbols output */
int type;
/* output the source line */
lineoffset = dboffset;
dboffset += fprintf(newrefs, "%d ", lineno);
/* output the source line */
lineoffset = dboffset;
dboffset += fprintf(newrefs, "%d ", lineno);
#ifdef PRINTF_RETVAL_BROKEN
dboffset = ftell(newrefs); /* fprintf doesn't return chars written */
dboffset = ftell(newrefs); /* fprintf doesn't return chars written */
#endif
/* HBB 20010425: added this line: */
my_yytext[my_yyleng] = '\0';
/* HBB 20010425: added this line: */
my_yytext[my_yyleng] = '\0';
blank = false;
for (i = 0; i < my_yyleng; ++i) {
blank = false;
for(i = 0; i < my_yyleng; ++i) {
/* change a tab to a blank and compress blanks */
if ((c = my_yytext[i]) == ' ' || c == '\t') {
blank = true;
} else if (symput < symbols && i == symbol[symput].first) {
/* look for the start of a symbol */
/* change a tab to a blank and compress blanks */
if((c = my_yytext[i]) == ' ' || c == '\t') {
blank = true;
} else if(symput < symbols && i == symbol[symput].first) {
/* look for the start of a symbol */
/* check for compressed blanks */
if (blank == true) {
blank = false;
dbputc(' ');
}
dbputc('\n'); /* symbols start on a new line */
/* check for compressed blanks */
if(blank == true) {
blank = false;
dbputc(' ');
}
dbputc('\n'); /* symbols start on a new line */
/* output any symbol type */
if ((type = symbol[symput].type) != IDENT) {
dbputc('\t');
dbputc(type);
} else {
type = ' ';
}
/* output the symbol */
j = symbol[symput].last;
c = my_yytext[j];
my_yytext[j] = '\0';
if (invertedindex == true) {
putposting(my_yytext + i, type);
}
writestring(my_yytext + i);
dbputc('\n');
my_yytext[j] = c;
i = j - 1;
++symput;
} else {
/* HBB: try to save some time by early-out handling of
* non-compressed mode */
if (compress == false) {
if (blank == true) {
dbputc(' ');
blank = false;
}
j = i + strcspn(my_yytext+i, "\t ");
if (symput < symbols
&& j >= symbol[symput].first)
j = symbol[symput].first;
c = my_yytext[j];
my_yytext[j] = '\0';
writestring(my_yytext + i);
my_yytext[j] = c;
i = j - 1;
/* finished this 'i', continue with the blank */
continue;
}
/* output any symbol type */
if((type = symbol[symput].type) != IDENT) {
dbputc('\t');
dbputc(type);
} else {
type = ' ';
}
/* output the symbol */
j = symbol[symput].last;
c = my_yytext[j];
my_yytext[j] = '\0';
if(invertedindex == true) { putposting(my_yytext + i, type); }
writestring(my_yytext + i);
dbputc('\n');
my_yytext[j] = c;
i = j - 1;
++symput;
} else {
/* HBB: try to save some time by early-out handling of
* non-compressed mode */
if(compress == false) {
if(blank == true) {
dbputc(' ');
blank = false;
}
j = i + strcspn(my_yytext + i, "\t ");
if(symput < symbols && j >= symbol[symput].first)
j = symbol[symput].first;
c = my_yytext[j];
my_yytext[j] = '\0';
writestring(my_yytext + i);
my_yytext[j] = c;
i = j - 1;
/* finished this 'i', continue with the blank */
continue;
}
/* check for compressed blanks */
if (blank == true) {
if (dicode2[c]) {
c = DICODE_COMPRESS(' ', c);
} else {
dbputc(' ');
}
} else if (IS_A_DICODE(c, my_yytext[i + 1])
&& symput < symbols
&& i + 1 != symbol[symput].first) {
/* compress digraphs */
c = DICODE_COMPRESS(c, my_yytext[i + 1]);
++i;
}
dbputc((int) c);
blank = false;
/* check for compressed blanks */
if(blank == true) {
if(dicode2[c]) {
c = DICODE_COMPRESS(' ', c);
} else {
dbputc(' ');
}
} else if(IS_A_DICODE(c, my_yytext[i + 1]) && symput < symbols &&
i + 1 != symbol[symput].first) {
/* compress digraphs */
c = DICODE_COMPRESS(c, my_yytext[i + 1]);
++i;
}
dbputc((int)c);
blank = false;
/* skip compressed characters */
if (c < ' ') {
++i;
/* skip compressed characters */
if(c < ' ') {
++i;
/* skip blanks before a preprocesor keyword */
/* note: don't use isspace() because \f and \v
are used for keywords */
while ((j = my_yytext[i]) == ' ' || j == '\t') {
++i;
}
/* skip the rest of the keyword */
while (isalpha((unsigned char)my_yytext[i])) {
++i;
}
/* skip space after certain keywords */
if (keyword[c].delim != '\0') {
while ((j = my_yytext[i]) == ' ' || j == '\t') {
++i;
}
}
/* skip a '(' after certain keywords */
if (keyword[c].delim == '('
&& my_yytext[i] == '(') {
++i;
}
--i; /* compensate for ++i in for() */
} /* if compressed char */
} /* else: not a symbol */
} /* for(i) */
/* skip blanks before a preprocesor keyword */
/* note: don't use isspace() because \f and \v
are used for keywords */
while((j = my_yytext[i]) == ' ' || j == '\t') {
++i;
}
/* skip the rest of the keyword */
while(isalpha((unsigned char)my_yytext[i])) {
++i;
}
/* skip space after certain keywords */
if(keyword[c].delim != '\0') {
while((j = my_yytext[i]) == ' ' || j == '\t') {
++i;
}
}
/* skip a '(' after certain keywords */
if(keyword[c].delim == '(' && my_yytext[i] == '(') { ++i; }
--i; /* compensate for ++i in for() */
} /* if compressed char */
} /* else: not a symbol */
} /* for(i) */
/* ignore trailing blanks */
dbputc('\n');
dbputc('\n');
/* ignore trailing blanks */
dbputc('\n');
dbputc('\n');
/* output any #define end marker */
/* note: must not be part of #define so putsource() doesn't discard it
so findcalledbysub() can find it and return */
if (symput < symbols && symbol[symput].type == DEFINEEND) {
dbputc('\t');
dbputc(DEFINEEND);
dbputc('\n');
dbputc('\n'); /* mark beginning of next source line */
macrooffset = 0;
}
symbols = 0;
/* output any #define end marker */
/* note: must not be part of #define so putsource() doesn't discard it
so findcalledbysub() can find it and return */
if(symput < symbols && symbol[symput].type == DEFINEEND) {
dbputc('\t');
dbputc(DEFINEEND);
dbputc('\n');
dbputc('\n'); /* mark beginning of next source line */
macrooffset = 0;
}
symbols = 0;
}
/* HBB 20000421: new function, for avoiding memory leaks */
/* free the cross reference symbol table */
void
freecrossref()
{
if (symbol)
free(symbol);
symbol = NULL;
symbols = 0;
void freecrossref() {
if(symbol) free(symbol);
symbol = NULL;
symbols = 0;
}
/* output the inverted index posting */
void
putposting(char *term, int type)
{
long i, n;
char *s;
int digits; /* digits output */
long offset; /* function/macro database offset */
char buf[11]; /* number buffer */
void putposting(char *term, int type) {
long i, n;
char *s;
int digits; /* digits output */
long offset; /* function/macro database offset */
char buf[11]; /* number buffer */
/* get the function or macro name offset */
offset = fcnoffset;
if (macrooffset != 0) {
offset = macrooffset;
}
/* then update them to avoid negative relative name offset */
switch (type) {
case DEFINE:
macrooffset = dboffset;
break;
case DEFINEEND:
macrooffset = 0;
return; /* null term */
case FCNDEF:
fcnoffset = dboffset;
break;
case FCNEND:
fcnoffset = 0;
return; /* null term */
}
/* ignore a null term caused by a enum/struct/union without a tag */
if (*term == '\0') {
return;
}
/* skip any #include secondary type char (< or ") */
if (type == INCLUDE) {
++term;
}
/* output the posting, which should be as small as possible to reduce
the temp file size and sort time */
(void) fputs(term, postings);
(void) putc(' ', postings);
/* get the function or macro name offset */
offset = fcnoffset;
if(macrooffset != 0) { offset = macrooffset; }
/* then update them to avoid negative relative name offset */
switch(type) {
case DEFINE:
macrooffset = dboffset;
break;
case DEFINEEND:
macrooffset = 0;
return; /* null term */
case FCNDEF:
fcnoffset = dboffset;
break;
case FCNEND:
fcnoffset = 0;
return; /* null term */
}
/* ignore a null term caused by a enum/struct/union without a tag */
if(*term == '\0') { return; }
/* skip any #include secondary type char (< or ") */
if(type == INCLUDE) { ++term; }
/* output the posting, which should be as small as possible to reduce
the temp file size and sort time */
(void)fputs(term, postings);
(void)putc(' ', postings);
/* the line offset is padded so postings for the same term will sort
in ascending line offset order to order the references as they
appear withing a source file */
ltobase(lineoffset);
for (i = PRECISION - digits; i > 0; --i) {
(void) putc('!', postings);
}
do {
(void) putc(*s, postings);
} while (*++s != '\0');
/* the line offset is padded so postings for the same term will sort
in ascending line offset order to order the references as they
appear withing a source file */
ltobase(lineoffset);
for(i = PRECISION - digits; i > 0; --i) {
(void)putc('!', postings);
}
do {
(void)putc(*s, postings);
} while(*++s != '\0');
/* postings are also sorted by type */
(void) putc(type, postings);
/* postings are also sorted by type */
(void)putc(type, postings);
/* function or macro name offset */
if (offset > 0) {
(void) putc(' ', postings);
ltobase(offset);
do {
(void) putc(*s, postings);
} while (*++s != '\0');
}
if (putc('\n', postings) == EOF) {
cannotwrite(temp1);
/* NOTREACHED */
}
++npostings;
/* function or macro name offset */
if(offset > 0) {
(void)putc(' ', postings);
ltobase(offset);
do {
(void)putc(*s, postings);
} while(*++s != '\0');
}
if(putc('\n', postings) == EOF) {
cannotwrite(temp1);
/* NOTREACHED */
}
++npostings;
}
/* put the string into the new database */
void
writestring(char *s)
{
unsigned char c;
int i;
void writestring(char *s) {
unsigned char c;
int i;
if (compress == false) {
/* Save some I/O overhead by using puts() instead of putc(): */
dbfputs(s);
return;
}
/* compress digraphs */
for (i = 0; (c = s[i]) != '\0'; ++i) {
if (/* dicode1[c] && dicode2[(unsigned char) s[i + 1]] */
IS_A_DICODE(c, s[i + 1])) {
/* c = (0200 - 2) + dicode1[c] + dicode2[(unsigned char) s[i + 1]]; */
c = DICODE_COMPRESS(c, s[i + 1]);
++i;
}
dbputc(c);
}
if(compress == false) {
/* Save some I/O overhead by using puts() instead of putc(): */
dbfputs(s);
return;
}
/* compress digraphs */
for(i = 0; (c = s[i]) != '\0'; ++i) {
if(/* dicode1[c] && dicode2[(unsigned char) s[i + 1]] */
IS_A_DICODE(c, s[i + 1])) {
/* c = (0200 - 2) + dicode1[c] + dicode2[(unsigned char) s[i + 1]]; */
c = DICODE_COMPRESS(c, s[i + 1]);
++i;
}
dbputc(c);
}
}
/* print a warning message with the file name and line number */
void
warning(char *text)
{
void warning(char *text) {
(void) fprintf(stderr, PROGRAM_NAME ": \"%s\", line %d: warning: %s\n", filename,
myylineno, text);
errorsfound = true;
(void)fprintf(stderr,
PROGRAM_NAME ": \"%s\", line %d: warning: %s\n",
filename,
myylineno,
text);
errorsfound = true;
}

1104
src/dir.c
View File

File diff suppressed because it is too large Load Diff

1022
src/display.c
View File

File diff suppressed because it is too large Load Diff

130
src/edit.c
View File

@ -37,111 +37,95 @@
#include "global.h"
#if defined(USE_NCURSES) && !defined(RENAMED_NCURSES)
#include <ncurses.h>
# include <ncurses.h>
#else
#include <curses.h>
# include <curses.h>
#endif
/* edit this displayed reference */
void
editref(int i)
{
char file[PATHLEN + 1]; /* file name */
char linenum[NUMLEN + 1]; /* line number */
void editref(int i) {
char file[PATHLEN + 1]; /* file name */
char linenum[NUMLEN + 1]; /* line number */
/* verify that there is a references found file */
if (refsfound == NULL) {
return;
}
/* get the selected line */
seekrelline(i);
/* verify that there is a references found file */
if(refsfound == NULL) { return; }
/* get the selected line */
seekrelline(i);
/* get the file name and line number */
if (fscanf(refsfound, "%" PATHLEN_STR "s%*s%" NUMLEN_STR "s", file, linenum) == 2) {
edit(file, linenum);
}
/* get the file name and line number */
if(fscanf(refsfound, "%" PATHLEN_STR "s%*s%" NUMLEN_STR "s", file, linenum) == 2) {
edit(file, linenum);
}
}
/* edit all references */
void
editall(void)
{
char file[PATHLEN + 1]; /* file name */
char linenum[NUMLEN + 1]; /* line number */
int c;
void editall(void) {
char file[PATHLEN + 1]; /* file name */
char linenum[NUMLEN + 1]; /* line number */
int c;
/* verify that there is a references found file */
if (refsfound == NULL) {
return;
}
/* get the first line */
/* verify that there is a references found file */
if(refsfound == NULL) { return; }
/* get the first line */
fseek(refsfound, 0, SEEK_SET);
/* get each file name and line number */
while (fscanf(refsfound, "%" PATHLEN_STR "s%*s%" NUMLEN_STR "s%*[^\n]", file, linenum) == 2) {
edit(file, linenum); /* edit it */
if (editallprompt == true) {
addstr("Type ^D to stop editing all lines, or any other character to continue: ");
if ((c = getch()) == EOF || c == ctrl('D') || c == ctrl('Z')) {
break;
}
}
}
/* get each file name and line number */
while(
fscanf(refsfound, "%" PATHLEN_STR "s%*s%" NUMLEN_STR "s%*[^\n]", file, linenum) ==
2) {
edit(file, linenum); /* edit it */
if(editallprompt == true) {
addstr(
"Type ^D to stop editing all lines, or any other character to continue: ");
if((c = getch()) == EOF || c == ctrl('D') || c == ctrl('Z')) { break; }
}
}
}
/* call the editor */
void
edit(char *file, const char *const linenum)
{
const char *const editor_basename = basename(editor);
char msg[MSGLEN + 1]; /* message */
char plusnum[NUMLEN + 20]; /* line number option: allow space for wordy line# flag */
void edit(char *file, const char *const linenum) {
const char *const editor_basename = basename(editor);
char msg[MSGLEN + 1]; /* message */
char plusnum[NUMLEN + 20]; /* line number option: allow space for wordy line# flag */
file = filepath(file);
snprintf(msg, sizeof(msg), "%s +%s %s", basename(editor), linenum, file);
postmsg(msg);
snprintf(plusnum, sizeof(plusnum), lineflag, linenum);
file = filepath(file);
snprintf(msg, sizeof(msg), "%s +%s %s", basename(editor), linenum, file);
postmsg(msg);
snprintf(plusnum, sizeof(plusnum), lineflag, linenum);
/* Some pagers will not start paging, unless the input
* file has more lines thant the screen does.
* The way to get them to pause, is to pass in /dev/null too,
* imatating endless blank lines.
*/
const char* const shit_pagers[] = {
"page",
"more",
NULL
};
for(const char *const *sp = shit_pagers; *sp != NULL; sp++){
if(!strcmp(editor_basename, *sp)){
execute(editor, editor, plusnum, file, "/dev/null", NULL);
const char *const shit_pagers[] = {"page", "more", NULL};
for(const char *const *sp = shit_pagers; *sp != NULL; sp++) {
if(!strcmp(editor_basename, *sp)) {
execute(editor, editor, plusnum, file, "/dev/null", NULL);
goto end;
}
}
if (lineflagafterfile) {
execute(editor, editor, file, plusnum, NULL);
}
else {
execute(editor, editor, plusnum, file, NULL);
}
if(lineflagafterfile) {
execute(editor, editor, file, plusnum, NULL);
} else {
execute(editor, editor, plusnum, file, NULL);
}
end:
clear(); /* redisplay screen */
end:
clear(); /* redisplay screen */
}
/* if requested, prepend a path to a relative file name */
char *
filepath(char *file)
{
static char path[PATHLEN + 1];
char *filepath(char *file) {
static char path[PATHLEN + 1];
if (prependpath != NULL && *file != '/') {
(void) snprintf(path, sizeof(path), "%s/%s", prependpath, file);
file = path;
}
return(file);
if(prependpath != NULL && *file != '/') {
(void)snprintf(path, sizeof(path), "%s/%s", prependpath, file);
file = path;
}
return (file);
}

2881
src/egrep.c
View File

File diff suppressed because it is too large Load Diff

64
src/egrep.h
View File

@ -36,7 +36,7 @@
private implementation details that can be changed or removed. */
#ifndef YY_YY_EGREP_H_INCLUDED
# define YY_YY_EGREP_H_INCLUDED
#define YY_YY_EGREP_H_INCLUDED
/* Debug traces. */
#ifndef YYDEBUG
# define YYDEBUG 0
@ -48,43 +48,43 @@ extern int yydebug;
/* Token kinds. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
enum yytokentype
{
YYEMPTY = -2,
YYEOF = 0, /* "end of file" */
YYerror = 256, /* error */
YYUNDEF = 257, /* "invalid token" */
CHAR = 258, /* CHAR */
DOT = 259, /* DOT */
CCL = 260, /* CCL */
NCCL = 261, /* NCCL */
OR = 262, /* OR */
CAT = 263, /* CAT */
STAR = 264, /* STAR */
PLUS = 265, /* PLUS */
QUEST = 266 /* QUEST */
};
typedef enum yytokentype yytoken_kind_t;
enum yytokentype {
YYEMPTY = -2,
YYEOF = 0, /* "end of file" */
YYerror = 256, /* error */
YYUNDEF = 257, /* "invalid token" */
CHAR = 258, /* CHAR */
DOT = 259, /* DOT */
CCL = 260, /* CCL */
NCCL = 261, /* NCCL */
OR = 262, /* OR */
CAT = 263, /* CAT */
STAR = 264, /* STAR */
PLUS = 265, /* PLUS */
QUEST = 266 /* QUEST */
};
typedef enum yytokentype yytoken_kind_t;
#endif
/* Token kinds. */
#define YYEMPTY -2
#define YYEOF 0
#define YYEOF 0
#define YYerror 256
#define YYUNDEF 257
#define CHAR 258
#define DOT 259
#define CCL 260
#define NCCL 261
#define OR 262
#define CAT 263
#define STAR 264
#define PLUS 265
#define QUEST 266
#define CHAR 258
#define DOT 259
#define CCL 260
#define NCCL 261
#define OR 262
#define CAT 263
#define STAR 264
#define PLUS 265
#define QUEST 266
/* Value type. */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef int YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
#if !defined YYSTYPE && !defined YYSTYPE_IS_DECLARED
typedef int YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif
@ -92,7 +92,7 @@ typedef int YYSTYPE;
extern YYSTYPE yylval;
int yyparse (void);
int yyparse(void);
#endif /* !YY_YY_EGREP_H_INCLUDED */

170
src/exec.c
View File

@ -39,20 +39,20 @@
#include "global.h"
#include <stdarg.h>
#include <sys/wait.h>
#include <sys/types.h> /* pid_t */
#include <sys/types.h> /* pid_t */
#ifdef __DJGPP__
#include <process.h>
# include <process.h>
#endif
#include <ncurses.h>
static sighandler_t oldsigquit; /* old value of quit signal */
static sighandler_t oldsighup; /* old value of hangup signal */
static sighandler_t oldsigtstp; /* old value of SIGTSTP */
static sighandler_t oldsigquit; /* old value of quit signal */
static sighandler_t oldsighup; /* old value of hangup signal */
static sighandler_t oldsigtstp; /* old value of SIGTSTP */
#ifndef __MSDOS__ /* none of these is needed, there */
static int join(pid_t p);
static int myexecvp(char *a, char **args);
static pid_t myfork(void);
#ifndef __MSDOS__ /* none of these is needed, there */
static int join(pid_t p);
static int myexecvp(char *a, char **args);
static pid_t myfork(void);
#endif
/* execute forks and executes a program or shell script, waits for it to
@ -60,39 +60,37 @@ static pid_t myfork(void);
*/
/*VARARGS1*/
int
execute(char *a, ...) /* NOTE: "exec" is already defined on u370 */
int execute(char *a, ...) /* NOTE: "exec" is already defined on u370 */
{
va_list ap;
int exitcode = -1;
char *argv[BUFSIZ];
pid_t p;
va_list ap;
int exitcode = -1;
char *argv[BUFSIZ];
pid_t p;
/* fork and exec the program or shell script */
endwin(); /* restore the terminal modes */
mousecleanup();
fflush(stdout);
va_start(ap, a);
/* fork and exec the program or shell script */
endwin(); /* restore the terminal modes */
mousecleanup();
fflush(stdout);
va_start(ap, a);
for (p = 0; (argv[p] = va_arg(ap, char *)) != 0; p++){}
for(p = 0; (argv[p] = va_arg(ap, char *)) != 0; p++) { }
#ifdef __MSDOS__
/* HBB 20010313: in MSDOG, everything is completely different.
* No fork()/exec()/wait(), but rather a single libc call: */
exitcode = spawnvp(P_WAIT, a, argv);
/* HBB 20010313: in MSDOG, everything is completely different.
* No fork()/exec()/wait(), but rather a single libc call: */
exitcode = spawnvp(P_WAIT, a, argv);
#else
if ((p = myfork()) == 0) {
myexecvp(a, argv); /* child */
}
else {
exitcode = join(p); /* parent */
}
if((p = myfork()) == 0) {
myexecvp(a, argv); /* child */
} else {
exitcode = join(p); /* parent */
}
#endif /* MSDOS */
entercurses();
va_end(ap);
return(exitcode);
va_end(ap);
return (exitcode);
}
#ifndef __MSDOS__ /* None of the following functions is used there */
@ -100,79 +98,71 @@ execute(char *a, ...) /* NOTE: "exec" is already defined on u370 */
/* myexecvp is an interface to the execvp system call to
* modify argv[0] to reference the last component of its path-name.
*/
static int
myexecvp(char *a, char **args)
{
char msg[MSGLEN + 1];
static int myexecvp(char *a, char **args) {
char msg[MSGLEN + 1];
/* modify argv[0] to reference the last component of its path name */
args[0] = basename(args[0]);
/* modify argv[0] to reference the last component of its path name */
args[0] = basename(args[0]);
/* execute the program or shell script */
execvp(a, args); /* returns only on failure */
snprintf(msg, sizeof(msg), "\nCannot exec %s", a);
perror(msg); /* display the reason */
askforreturn(); /* wait until the user sees the message */
myexit(1); /* exit the child */
/* NOTREACHED */
return 0;
/* execute the program or shell script */
execvp(a, args); /* returns only on failure */
snprintf(msg, sizeof(msg), "\nCannot exec %s", a);
perror(msg); /* display the reason */
askforreturn(); /* wait until the user sees the message */
myexit(1); /* exit the child */
/* NOTREACHED */
return 0;
}
/* myfork acts like fork but also handles signals */
static pid_t
myfork(void)
{
pid_t p; /* process number */
static pid_t myfork(void) {
pid_t p; /* process number */
p = fork();
p = fork();
/* the parent ignores the interrupt, quit, and hangup signals */
if (p > 0) {
oldsigquit = signal(SIGQUIT, SIG_IGN);
oldsighup = signal(SIGHUP, SIG_IGN);
#ifdef SIGTSTP
oldsigtstp = signal(SIGTSTP, SIG_DFL);
#endif
}
/* so they can be used to stop the child */
else if (p == 0) {
signal(SIGINT, SIG_DFL);
signal(SIGQUIT, SIG_DFL);
signal(SIGHUP, SIG_DFL);
#ifdef SIGTSTP
signal(SIGTSTP, SIG_DFL);
#endif
}
/* check for fork failure */
if (p == -1) {
myperror("Cannot fork");
}
return p;
/* the parent ignores the interrupt, quit, and hangup signals */
if(p > 0) {
oldsigquit = signal(SIGQUIT, SIG_IGN);
oldsighup = signal(SIGHUP, SIG_IGN);
# ifdef SIGTSTP
oldsigtstp = signal(SIGTSTP, SIG_DFL);
# endif
}
/* so they can be used to stop the child */
else if(p == 0) {
signal(SIGINT, SIG_DFL);
signal(SIGQUIT, SIG_DFL);
signal(SIGHUP, SIG_DFL);
# ifdef SIGTSTP
signal(SIGTSTP, SIG_DFL);
# endif
}
/* check for fork failure */
if(p == -1) { myperror("Cannot fork"); }
return p;
}
/* join is the compliment of fork */
static int
join(pid_t p)
{
int status = -1;
pid_t w;
static int join(pid_t p) {
int status = -1;
pid_t w;
/* wait for the correct child to exit */
do {
w = wait(&status);
} while (p != -1 && w != p);
/* wait for the correct child to exit */
do {
w = wait(&status);
} while(p != -1 && w != p);
/* restore signal handling */
signal(SIGQUIT, oldsigquit);
signal(SIGHUP, oldsighup);
#ifdef SIGTSTP
signal(SIGTSTP, oldsigtstp);
#endif
/* restore signal handling */
signal(SIGQUIT, oldsigquit);
signal(SIGHUP, oldsighup);
# ifdef SIGTSTP
signal(SIGTSTP, oldsigtstp);
# endif
/* return the child's exit code */
return(status >> 8);
/* return the child's exit code */
return (status >> 8);
}
#endif /* !MSDOS */

2162
src/find.c
View File

File diff suppressed because it is too large Load Diff

414
src/global.h
View File

@ -43,46 +43,47 @@
#include <unistd.h>
#include <sys/types.h>
#include <assert.h>
#include <ctype.h> /* isalpha, isdigit, etc. */
#include <signal.h> /* SIGINT and SIGQUIT */
#include <stdio.h> /* standard I/O package */
#include <stdlib.h> /* standard library functions */
#include <ctype.h> /* isalpha, isdigit, etc. */
#include <signal.h> /* SIGINT and SIGQUIT */
#include <stdio.h> /* standard I/O package */
#include <stdlib.h> /* standard library functions */
#include <stdarg.h>
#include <fcntl.h>
#include <stdbool.h>
#include <string.h> /* string functions */
#include <string.h> /* string functions */
#include "constants.h" /* misc. constants */
#include "invlib.h" /* inverted index library */
#include "library.h" /* library function return values */
#include "stddef.h" /* size_t */
#include "constants.h" /* misc. constants */
#include "invlib.h" /* inverted index library */
#include "library.h" /* library function return values */
#include "stddef.h" /* size_t */
typedef void (*sighandler_t)(int);
typedef struct { /* mouse action */
int button;
int percent;
int x1;
int y1;
int x2;
int y2;
typedef struct { /* mouse action */
int button;
int percent;
int x1;
int y1;
int x2;
int y2;
} MOUSE;
struct cmd { /* command history struct */
struct cmd *prev, *next; /* list ptrs */
int field; /* input field number */
char *text; /* input field text */
struct cmd { /* command history struct */
struct cmd *prev, *next; /* list ptrs */
int field; /* input field number */
char *text; /* input field text */
};
enum {
CH_NONE = 0x0000,
CH_RESULT = 0x0001 << 0,
CH_INPUT = 0x0001 << 1,
CH_MODE = 0x0001 << 2,
CH_HELP = 0x0001 << 3, /* do NOT add to CH_ALL */
CH_ALL = CH_RESULT | CH_INPUT | CH_MODE
CH_NONE = 0x0000,
CH_RESULT = 0x0001 << 0,
CH_INPUT = 0x0001 << 1,
CH_MODE = 0x0001 << 2,
CH_HELP = 0x0001 << 3, /* do NOT add to CH_ALL */
CH_ALL = CH_RESULT | CH_INPUT | CH_MODE
};
enum {
INPUT_NORMAL,
INPUT_APPEND,
@ -97,224 +98,225 @@ enum {
#endif
/* digraph data for text compression */
extern char dichar1[]; /* 16 most frequent first chars */
extern char dichar2[]; /* 8 most frequent second chars
using the above as first chars */
extern char dicode1[]; /* digraph first character code */
extern char dicode2[]; /* digraph second character code */
extern char dichar1[]; /* 16 most frequent first chars */
extern char dichar2[]; /* 8 most frequent second chars
using the above as first chars */
extern char dicode1[]; /* digraph first character code */
extern char dicode2[]; /* digraph second character code */
/* and some macros to help using dicodes: */
/* Check if a given pair of chars is compressable as a dicode: */
#define IS_A_DICODE(inchar1, inchar2) \
(dicode1[(unsigned char)(inchar1)] && dicode2[(unsigned char)(inchar2)])
#define IS_A_DICODE(inchar1, inchar2) \
(dicode1[(unsigned char)(inchar1)] && dicode2[(unsigned char)(inchar2)])
/* Combine the pair into a dicode */
#define DICODE_COMPRESS(inchar1, inchar2) \
((0200 - 2) + dicode1[(unsigned char)(inchar1)] \
+ dicode2[(unsigned char)(inchar2)])
#define DICODE_COMPRESS(inchar1, inchar2) \
((0200 - 2) + dicode1[(unsigned char)(inchar1)] + dicode2[(unsigned char)(inchar2)])
#define PROGRAM_NAME "Csope"
/* main.c global data */
extern char *editor, *home, *shell, *lineflag; /* environment variables */
extern char *home; /* Home directory */
extern bool lineflagafterfile;
extern bool compress; /* compress the characters in the crossref */
extern bool dbtruncated; /* database symbols truncated to 8 chars */
extern int dispcomponents; /* file path components to display */
extern bool editallprompt; /* prompt between editing files */
extern unsigned int fileargc; /* file argument count */
extern char **fileargv; /* file argument values */
extern int fileversion; /* cross-reference file version */
extern bool incurses; /* in curses */
extern bool invertedindex; /* the database has an inverted index */
extern bool isuptodate; /* consider the crossref up-to-date */
extern bool kernelmode; /* don't use DFLT_INCDIR - bad for kernels */
extern bool linemode; /* use line oriented user interface */
extern bool verbosemode; /* print extra information on line mode */
extern bool recurse_dir; /* recurse dirs when searching for src files */
extern char *namefile; /* file of file names */
extern bool ogs; /* display OGS book and subsystem names */
extern char *prependpath; /* prepend path to file names */
extern FILE *refsfound; /* references found file */
extern long totalterms; /* total inverted index terms */
extern bool trun_syms; /* truncate symbols to 8 characters */
extern char tempstring[TEMPSTRING_LEN + 1]; /* global dummy string buffer */
extern char *editor, *home, *shell, *lineflag; /* environment variables */
extern char *home; /* Home directory */
extern bool lineflagafterfile;
extern bool compress; /* compress the characters in the crossref */
extern bool dbtruncated; /* database symbols truncated to 8 chars */
extern int dispcomponents; /* file path components to display */
extern bool editallprompt; /* prompt between editing files */
extern unsigned int fileargc; /* file argument count */
extern char **fileargv; /* file argument values */
extern int fileversion; /* cross-reference file version */
extern bool incurses; /* in curses */
extern bool invertedindex; /* the database has an inverted index */
extern bool isuptodate; /* consider the crossref up-to-date */
extern bool kernelmode; /* don't use DFLT_INCDIR - bad for kernels */
extern bool linemode; /* use line oriented user interface */
extern bool verbosemode; /* print extra information on line mode */
extern bool recurse_dir; /* recurse dirs when searching for src files */
extern char *namefile; /* file of file names */
extern bool ogs; /* display OGS book and subsystem names */
extern char *prependpath; /* prepend path to file names */
extern FILE *refsfound; /* references found file */
extern long totalterms; /* total inverted index terms */
extern bool trun_syms; /* truncate symbols to 8 characters */
extern char tempstring[TEMPSTRING_LEN + 1]; /* global dummy string buffer */
extern char *tmpdir; /* temporary directory */
extern char temp1[]; /* temporary file name */
extern char temp2[]; /* temporary file name */
extern char *tmpdir; /* temporary directory */
extern char temp1[]; /* temporary file name */
extern char temp2[]; /* temporary file name */
/* command.c global data */
extern bool caseless; /* ignore letter case when searching */
extern bool *change; /* change this line */
extern unsigned int curdispline;
extern char newpat[]; /* new pattern */
extern bool caseless; /* ignore letter case when searching */
extern bool *change; /* change this line */
extern unsigned int curdispline;
extern char newpat[]; /* new pattern */
/* crossref.c global data */
extern long dboffset; /* new database offset */
extern bool errorsfound; /* prompt before clearing error messages */
extern long lineoffset; /* source line database offset */
extern long npostings; /* number of postings */
extern unsigned long symbols; /* number of symbols */
extern long dboffset; /* new database offset */
extern bool errorsfound; /* prompt before clearing error messages */
extern long lineoffset; /* source line database offset */
extern long npostings; /* number of postings */
extern unsigned long symbols; /* number of symbols */
/* dir.c global data */
extern char currentdir[]; /* current directory */
extern char **incdirs; /* #include directories */
extern char **srcdirs; /* source directories */
extern char **srcfiles; /* source files */
extern size_t nincdirs; /* number of #include directories */
extern size_t nsrcdirs; /* number of source directories */
extern size_t nsrcfiles; /* number of source files */
extern size_t msrcfiles; /* maximum number of source files */
extern char currentdir[]; /* current directory */
extern char **incdirs; /* #include directories */
extern char **srcdirs; /* source directories */
extern char **srcfiles; /* source files */
extern size_t nincdirs; /* number of #include directories */
extern size_t nsrcdirs; /* number of source directories */
extern size_t nsrcfiles; /* number of source files */
extern size_t msrcfiles; /* maximum number of source files */
/* display.c global data */
extern int subsystemlen; /* OGS subsystem name display field length */
extern int booklen; /* OGS book name display field length */
extern int filelen; /* file name display field length */
extern int fcnlen; /* function name display field length */
extern int numlen; /* line number display field length */
extern int *displine; /* screen line of displayed reference */
extern unsigned int disprefs; /* displayed references */
extern int field; /* input field */
extern unsigned int mdisprefs; /* maximum displayed references */
extern unsigned int nextline; /* next line to be shown */
extern long searchcount; /* count of files searched */
extern unsigned int totallines; /* total reference lines */
extern int window_change; /* bitmask type to mark which windows have to be rerendered by display() */
extern int subsystemlen; /* OGS subsystem name display field length */
extern int booklen; /* OGS book name display field length */
extern int filelen; /* file name display field length */
extern int fcnlen; /* function name display field length */
extern int numlen; /* line number display field length */
extern int *displine; /* screen line of displayed reference */
extern unsigned int disprefs; /* displayed references */
extern int field; /* input field */
extern unsigned int mdisprefs; /* maximum displayed references */
extern unsigned int nextline; /* next line to be shown */
extern long searchcount; /* count of files searched */
extern unsigned int totallines; /* total reference lines */
extern int window_change; /* bitmask type to mark which windows have to be rerendered by
display() */
/* find.c global data */
extern char block[]; /* cross-reference file block */
extern char blockmark; /* mark character to be searched for */
extern long blocknumber; /* block number */
extern char *blockp; /* pointer to current character in block */
extern int blocklen; /* length of disk block read */
extern char block[]; /* cross-reference file block */
extern char blockmark; /* mark character to be searched for */
extern long blocknumber; /* block number */
extern char *blockp; /* pointer to current character in block */
extern int blocklen; /* length of disk block read */
/* lookup.c global data */
extern struct keystruct {
char *text;
char delim;
struct keystruct *next;
extern struct keystruct {
char *text;
char delim;
struct keystruct *next;
} keyword[];
/* mouse.c global data */
extern bool mouse; /* mouse interface */
extern bool mouse; /* mouse interface */
/* readline.c global data */
extern char* rl_line_buffer;
extern char input_line[PATLEN + 1];
extern int rl_point;
extern char *rl_line_buffer;
extern char input_line[PATLEN + 1];
extern int rl_point;
//extern bool unixpcmouse; /* UNIX PC mouse interface */
// extern bool unixpcmouse; /* UNIX PC mouse interface */
/* cscope functions called from more than one function or between files */
char *filepath(char *file);
char *findsymbol(const char *pattern);
char *finddef(const char *pattern);
char *findcalledby(const char *pattern);
char *findcalling(const char *pattern);
char *findstring(const char *pattern);
char *findregexp(const char *egreppat);
char *findfile(const char *dummy);
char *findinclude(const char *pattern);
char *findassign(const char *pattern);
char *findallfcns(const char *dummy);
char *inviewpath(char *file);
char *lookup(char *ident);
char *pathcomponents(char *path, int components);
char *read_block(void);
char *scanpast(char c);
char *filepath(char *file);
char *findsymbol(const char *pattern);
char *finddef(const char *pattern);
char *findcalledby(const char *pattern);
char *findcalling(const char *pattern);
char *findstring(const char *pattern);
char *findregexp(const char *egreppat);
char *findfile(const char *dummy);
char *findinclude(const char *pattern);
char *findassign(const char *pattern);
char *findallfcns(const char *dummy);
char *inviewpath(char *file);
char *lookup(char *ident);
char *pathcomponents(char *path, int components);
char *read_block(void);
char *scanpast(char c);
char ** parse_options(int *argc, char **argv);
void error_usage(void);
void longusage(void);
void usage(void);
extern bool remove_symfile_onexit;
extern bool onesearch; /* one search only in line mode */
extern char *reflines; /* symbol reference lines file */
extern bool do_press_any_key; /* wait for any key to continue */
extern int current_page;
#define topref current_page*mdisprefs
void verswp_field(void);
void horswp_field(void);
bool interpret(int c); // XXX: probably rename
int handle_input(const int c);
int dispchar2int(const char c);
int process_mouse();
char **parse_options(int *argc, char **argv);
void error_usage(void);
void longusage(void);
void usage(void);
extern bool remove_symfile_onexit;
extern bool onesearch; /* one search only in line mode */
extern char *reflines; /* symbol reference lines file */
extern bool do_press_any_key; /* wait for any key to continue */
extern int current_page;
#define topref current_page *mdisprefs
void verswp_field(void);
void horswp_field(void);
bool interpret(int c); // XXX: probably rename
int handle_input(const int c);
int dispchar2int(const char c);
int process_mouse();
extern int input_mode;
int changestring(const char* from, const char* to, const bool *const change, const int change_len);
int changestring(const char *from, const char *to, const bool *const change,
const int change_len);
long seekpage(const size_t i);
long seekrelline(unsigned i);
void PCS_reset(void);
long seekpage(const size_t i);
long seekrelline(unsigned i);
void PCS_reset(void);
void rlinit(void);
void rlinit(void);
void addcmd(int f, char *s);
void addsrcfile(char *path);
void askforchar(void);
void askforreturn(void);
void cannotwrite(const char *const file);
void cannotopen(const char *const file);
void clearmsg(void);
void clearmsg2(void);
void countrefs(void);
void crossref(char *srcfile);
void dispinit(void);
void display(void);
void drawscrollbar(int top, int bot);
void edit(char *file, const char *const linenum);
void editall(void);
void editref(int);
void entercurses(void);
void exitcurses(void);
void findcleanup(void);
void freesrclist(void);
void freeinclist(void);
void freecrossref(void);
void freefilelist(void);
const char* help(void);
void incfile(char *file, char *type);
void includedir(char *_dirname);
void initsymtab(void);
void makefilelist(void);
void mousecleanup(void);
void mousemenu(void);
void mouseinit(void);
void mousereinit(void);
void myexit(int sig);
void myperror(char *text);
void ogsnames(char *file, char **subsystem, char **book);
void progress(char *what, long current, long max);
void putfilename(char *srcfile);
void postmsg(char *msg);
void postmsg2(char *msg);
void posterr(char *msg,...);
void postfatal(const char *msg,...);
void putposting(char *term, int type);
void fetch_string_from_dbase(char *, size_t);
void resetcmd(void);
void shellpath(char *out, int limit, char *in);
void sourcedir(char *dirlist);
void myungetch(int c);
void warning(char *text);
void writestring(char *s);
void addcmd(int f, char *s);
void addsrcfile(char *path);
void askforchar(void);
void askforreturn(void);
void cannotwrite(const char *const file);
void cannotopen(const char *const file);
void clearmsg(void);
void clearmsg2(void);
void countrefs(void);
void crossref(char *srcfile);
void dispinit(void);
void display(void);
void drawscrollbar(int top, int bot);
void edit(char *file, const char *const linenum);
void editall(void);
void editref(int);
void entercurses(void);
void exitcurses(void);
void findcleanup(void);
void freesrclist(void);
void freeinclist(void);
void freecrossref(void);
void freefilelist(void);
const char *help(void);
void incfile(char *file, char *type);
void includedir(char *_dirname);
void initsymtab(void);
void makefilelist(void);
void mousecleanup(void);
void mousemenu(void);
void mouseinit(void);
void mousereinit(void);
void myexit(int sig);
void myperror(char *text);
void ogsnames(char *file, char **subsystem, char **book);
void progress(char *what, long current, long max);
void putfilename(char *srcfile);
void postmsg(char *msg);
void postmsg2(char *msg);
void posterr(char *msg, ...);
void postfatal(const char *msg, ...);
void putposting(char *term, int type);
void fetch_string_from_dbase(char *, size_t);
void resetcmd(void);
void shellpath(char *out, int limit, char *in);
void sourcedir(char *dirlist);
void myungetch(int c);
void warning(char *text);
void writestring(char *s);
bool infilelist(char *file);
bool readrefs(char *filename);
bool search(const char* query);
bool writerefsfound(void);
bool infilelist(char *file);
bool readrefs(char *filename);
bool search(const char *query);
bool writerefsfound(void);
int findinit(const char *pattern_);
MOUSE *getmouseaction(char leading_char);
struct cmd *currentcmd(void);
struct cmd *prevcmd(void);
struct cmd *nextcmd(void);
int findinit(const char *pattern_);
MOUSE *getmouseaction(char leading_char);
struct cmd *currentcmd(void);
struct cmd *prevcmd(void);
struct cmd *nextcmd(void);
int egrep(char *file, FILE *output, char *format);
int hash(char *ss);
int execute(char *a, ...);
long dbseek(long offset);
int egrep(char *file, FILE *output, char *format);
int hash(char *ss);
int execute(char *a, ...);
long dbseek(long offset);
#endif /* CSCOPE_GLOBAL_H */

162
src/help.c
View File

@ -39,101 +39,91 @@
#include "global.h"
#include <ncurses.h>
/*
max num of lines of help screen -
this number needs to be increased if more than n help items are needed
max num of lines of help screen -
this number needs to be increased if more than n help items are needed
*/
const char tooltip_winput[] = "Search [Enter] -Mode [^k] +Mode [^j] Right [Tab] Down [%]";
const char tooltip_wmode[] = "-Mode [Up] +Mode [Down] Right [Tab] Up [%]";
const char tooltip_wresult[] = "Edit [Enter] Up [Up] Down [Down] Left [Tab] Previous [-] Next [+]";
const char tooltip_wmode[] = "-Mode [Up] +Mode [Down] Right [Tab] Up [%]";
const char tooltip_wresult[] =
"Edit [Enter] Up [Up] Down [Down] Left [Tab] Previous [-] Next [+]";
static char help_msg[] =
"Press the RETURN key repeatedly to move to the desired input field, type the\n"
"pattern to search for, and then press the RETURN key. For the first 4 and\n"
"last 2 input fields, the pattern can be a regcomp(3) regular expression.\n"
"If the search is successful, you can use these single-character commands:\n\n"
"0-9a-zA-Z\tEdit the file containing the displayed line.\n"
"space bar\tDisplay next set of matching lines.\n"
"+\t\tDisplay next set of matching lines.\n"
"^V\t\tDisplay next set of matching lines.\n"
"-\t\tDisplay previous set of matching lines.\n"
"^E\t\tEdit all lines.\n"
">\t\tWrite the list of lines being displayed to a file.\n"
">>\t\tAppend the list of lines being displayed to a file.\n"
"<\t\tRead lines from a file.\n"
"^\t\tFilter all lines through a shell command.\n"
"|\t\tPipe all lines to a shell command.\n"
"\nAt any time you can use these single-character commands:\n\n"
"TAB\t\tSwap positions between input and output areas.\n"
"RETURN\t\tMove to the next input field.\n"
"^N\t\tMove to the next input field.\n"
"^P\t\tMove to the previous input field.\n"
"^Y / ^A\t\tSearch with the last pattern typed.\n"
"^B\t\tRecall previous input field and search pattern.\n"
"^F\t\tRecall next input field and search pattern.\n"
"^C\t\tToggle ignore/use letter case when searching.\n"
"^R\t\tRebuild the cross-reference.\n"
"!\t\tStart an interactive shell (type ^D to return).\n"
"^L\t\tRedraw the screen.\n"
"?\t\tDisplay this list of commands.\n"
"^D\t\tExit the program.\n"
"\nNote: If the first character of the pattern you want to search for matches\n"
"a command, type a \\ character first.\n"
"Note: Some ctrl keys may be occupied by your terminal configuration.\n"
;
static char help_msg[] =
"Press the RETURN key repeatedly to move to the desired input field, type the\n"
"pattern to search for, and then press the RETURN key. For the first 4 and\n"
"last 2 input fields, the pattern can be a regcomp(3) regular expression.\n"
"If the search is successful, you can use these single-character commands:\n\n"
"0-9a-zA-Z\tEdit the file containing the displayed line.\n"
"space bar\tDisplay next set of matching lines.\n"
"+\t\tDisplay next set of matching lines.\n"
"^V\t\tDisplay next set of matching lines.\n"
"-\t\tDisplay previous set of matching lines.\n"
"^E\t\tEdit all lines.\n"
">\t\tWrite the list of lines being displayed to a file.\n"
">>\t\tAppend the list of lines being displayed to a file.\n"
"<\t\tRead lines from a file.\n"
"^\t\tFilter all lines through a shell command.\n"
"|\t\tPipe all lines to a shell command.\n"
"\nAt any time you can use these single-character commands:\n\n"
"TAB\t\tSwap positions between input and output areas.\n"
"RETURN\t\tMove to the next input field.\n"
"^N\t\tMove to the next input field.\n"
"^P\t\tMove to the previous input field.\n"
"^Y / ^A\t\tSearch with the last pattern typed.\n"
"^B\t\tRecall previous input field and search pattern.\n"
"^F\t\tRecall next input field and search pattern.\n"
"^C\t\tToggle ignore/use letter case when searching.\n"
"^R\t\tRebuild the cross-reference.\n"
"!\t\tStart an interactive shell (type ^D to return).\n"
"^L\t\tRedraw the screen.\n"
"?\t\tDisplay this list of commands.\n"
"^D\t\tExit the program.\n"
"\nNote: If the first character of the pattern you want to search for matches\n"
"a command, type a \\ character first.\n"
"Note: Some ctrl keys may be occupied by your terminal configuration.\n";
static char changeing_help_msg[] =
"When changing text, you can use these single-character commands:\n\n"
"0-9a-zA-Z\tMark or unmark the line to be changed.\n"
"*\t\tMark or unmark all displayed lines to be changed.\n"
"space bar\tDisplay next set of lines.\n"
"+\t\tDisplay next set of lines.\n"
"-\t\tDisplay previous set of lines.\n"
"^A\t\tMark or unmark all lines to be changed.\n"
"^D\t\tChange the marked lines and exit.\n"
"ESC\t\tExit without changing the marked lines.\n"
"!\t\tStart an interactive shell (type ^D to return).\n"
"^L\t\tRedraw the screen.\n"
"?\t\tDisplay this list of commands.\n"
;
static char changeing_help_msg[] =
"When changing text, you can use these single-character commands:\n\n"
"0-9a-zA-Z\tMark or unmark the line to be changed.\n"
"*\t\tMark or unmark all displayed lines to be changed.\n"
"space bar\tDisplay next set of lines.\n"
"+\t\tDisplay next set of lines.\n"
"-\t\tDisplay previous set of lines.\n"
"^A\t\tMark or unmark all lines to be changed.\n"
"^D\t\tChange the marked lines and exit.\n"
"ESC\t\tExit without changing the marked lines.\n"
"!\t\tStart an interactive shell (type ^D to return).\n"
"^L\t\tRedraw the screen.\n"
"?\t\tDisplay this list of commands.\n";
const char*
help(void)
{
if (input_mode == INPUT_CHANGE) {
const char *help(void) {
if(input_mode == INPUT_CHANGE) {
return help_msg;
} else {
} else {
return changeing_help_msg;
}
}
}
/* error exit including short usage information */
void
error_usage(void)
{
usage();
fputs("Try the -h option for more information.\n", stderr);
myexit(1);
void error_usage(void) {
usage();
fputs("Try the -h option for more information.\n", stderr);
myexit(1);
}
/* normal usage message */
void
usage(void)
{
fputs(
"Usage: " PROGRAM_NAME " [-bcCdehklLqRTuUvV] [-f file] [-F file] [-i file] [-I dir] [-s dir]\n"
" [-p number] [-P path] [-[0-8] pattern] [source files]\n",
stderr
);
void usage(void) {
fputs("Usage: " PROGRAM_NAME
" [-bcCdehklLqRTuUvV] [-f file] [-F file] [-i file] [-I dir] [-s dir]\n"
" [-p number] [-P path] [-[0-8] pattern] [source files]\n",
stderr);
}
/* long usage message */
void
longusage(void)
{
usage();
fprintf(stderr, "\
void longusage(void) {
usage();
fprintf(stderr,
"\
\n\
-b Build the cross-reference only.\n\
-C Ignore letter case when searching.\n\
@ -142,16 +132,18 @@ longusage(void)
-e Suppress the <Ctrl>-e command prompt between files.\n\
-F symfile Read symbol reference lines from symfile.\n\
-f reffile Use reffile as cross-ref file name instead of %s.\n",
REFFILE);
fprintf(stderr, "\
REFFILE);
fprintf(stderr,
"\
-h This help screen.\n\
-I incdir Look in incdir for any #include files.\n\
-i namefile Browse through files listed in namefile, instead of %s\n",
NAMEFILE);
fprintf(stderr, "\
NAMEFILE);
fprintf(stderr,
"\
-k Kernel Mode - don't use %s for #include files.\n",
DFLT_INCDIR);
fputs("\
DFLT_INCDIR);
fputs("\
-L Do a single search with line-oriented output.\n\
-l Line-oriented interface.\n\
-num pattern Go to input field num (counting from 0) and find pattern.\n\
@ -167,5 +159,5 @@ longusage(void)
-V Print the version number.\n\
\n\
Please see the manpage for more information.\n",
stderr);
stderr);
}

85
src/history.c
View File

@ -39,66 +39,57 @@
static struct cmd *tail, *current;
static struct cmd *tail, *current;
/* add a cmd to the history list */
void
addcmd(int f, char *s) /* field number and command text */
void addcmd(int f, char *s) /* field number and command text */
{
struct cmd *h;
struct cmd *h;
h = malloc(sizeof(struct cmd));
if( tail) {
tail->next = h;
h->next = 0;
h->prev = tail;
tail = h;
} else {
tail = h;
h->next = h->prev = 0;
}
h->field = f;
h->text = strdup( s);
current = 0;
h = malloc(sizeof(struct cmd));
if(tail) {
tail->next = h;
h->next = 0;
h->prev = tail;
tail = h;
} else {
tail = h;
h->next = h->prev = 0;
}
h->field = f;
h->text = strdup(s);
current = 0;
}
/* return previous history item */
struct cmd *
prevcmd(void)
{
if( current) {
if( current->prev) /* stay on first item */
return current = current->prev;
else
return current;
} else if( tail)
return current = tail;
else
return NULL;
struct cmd *prevcmd(void) {
if(current) {
if(current->prev) /* stay on first item */
return current = current->prev;
else
return current;
} else if(tail)
return current = tail;
else
return NULL;
}
/* return next history item */
struct cmd *
nextcmd(void)
{
if( current) {
if( current->next) /* stay on first item */
return current = current->next;
else
return current;
} else
return NULL;
struct cmd *nextcmd(void) {
if(current) {
if(current->next) /* stay on first item */
return current = current->next;
else
return current;
} else
return NULL;
}
/* reset current to tail */
void
resetcmd(void)
{
current = 0;
void resetcmd(void) {
current = 0;
}
struct cmd *
currentcmd(void)
{
return current;
struct cmd *currentcmd(void) {
return current;
}

783
src/input.c
View File

@ -37,7 +37,7 @@
#include "global.h"
#include <ncurses.h>
#include <setjmp.h> /* jmp_buf */
#include <setjmp.h> /* jmp_buf */
#include <stdlib.h>
#include <errno.h>
#if HAVE_SYS_TERMIOS_H
@ -48,522 +48,489 @@
bool do_press_any_key = false;
static jmp_buf env; /* setjmp/longjmp buffer */
static int prevchar; /* previous, ungotten character */
static jmp_buf env; /* setjmp/longjmp buffer */
static int prevchar; /* previous, ungotten character */
/* Internal prototypes: */
static void catchint(int sig);
/* catch the interrupt signal */
static void
catchint(int sig){
static void catchint(int sig) {
UNUSED(sig);
signal(SIGINT, catchint);
longjmp(env, 1);
signal(SIGINT, catchint);
longjmp(env, 1);
}
/* unget a character */
void
myungetch(int c)
{
prevchar = c;
void myungetch(int c) {
prevchar = c;
}
/* ask user to enter a character after reading the message */
void
askforchar(void){
addstr("Type any character to continue: ");
getch();
void askforchar(void) {
addstr("Type any character to continue: ");
getch();
}
/* ask user to press the RETURN key after reading the message */
void
askforreturn(void){
fprintf(stderr, "Press the RETURN key to continue: ");
getchar();
/* HBB 20060419: message probably messed up the screen --- redraw */
if (incurses == true) {
redrawwin(curscr);
}
void askforreturn(void) {
fprintf(stderr, "Press the RETURN key to continue: ");
getchar();
/* HBB 20060419: message probably messed up the screen --- redraw */
if(incurses == true) { redrawwin(curscr); }
}
/* expand the ~ and $ shell meta characters in a path */
void
shellpath(char *out, int limit, char *in){
char *lastchar;
char *s, *v;
void shellpath(char *out, int limit, char *in) {
char *lastchar;
char *s, *v;
/* skip leading white space */
while (isspace((unsigned char)*in)) {
++in;
}
lastchar = out + limit - 1;
/* skip leading white space */
while(isspace((unsigned char)*in)) {
++in;
}
lastchar = out + limit - 1;
/* a tilde (~) by itself represents $HOME; followed by a name it
represents the $LOGDIR of that login name */
if (*in == '~') {
*out++ = *in++; /* copy the ~ because it may not be expanded */
/* a tilde (~) by itself represents $HOME; followed by a name it
represents the $LOGDIR of that login name */
if(*in == '~') {
*out++ = *in++; /* copy the ~ because it may not be expanded */
/* get the login name */
s = out;
while (s < lastchar && *in != '/' && *in != '\0' && !isspace((unsigned char)*in)) {
*s++ = *in++;
}
*s = '\0';
/* get the login name */
s = out;
while(s < lastchar && *in != '/' && *in != '\0' && !isspace((unsigned char)*in)) {
*s++ = *in++;
}
*s = '\0';
/* if the login name is null, then use $HOME */
if (*out == '\0') {
v = getenv("HOME");
} else { /* get the home directory of the login name */
v = logdir(out);
}
/* copy the directory name if it isn't too big */
if (v != NULL && strlen(v) < (lastchar - out)) {
strcpy(out - 1, v);
out += strlen(v) - 1;
} else {
/* login not found, so ~ must be part of the file name */
out += strlen(out);
}
}
/* get the rest of the path */
while (out < lastchar && *in != '\0' && !isspace((unsigned char)*in)) {
/* if the login name is null, then use $HOME */
if(*out == '\0') {
v = getenv("HOME");
} else { /* get the home directory of the login name */
v = logdir(out);
}
/* copy the directory name if it isn't too big */
if(v != NULL && strlen(v) < (lastchar - out)) {
strcpy(out - 1, v);
out += strlen(v) - 1;
} else {
/* login not found, so ~ must be part of the file name */
out += strlen(out);
}
}
/* get the rest of the path */
while(out < lastchar && *in != '\0' && !isspace((unsigned char)*in)) {
/* look for an environment variable */
if (*in == '$') {
*out++ = *in++; /* copy the $ because it may not be expanded */
/* look for an environment variable */
if(*in == '$') {
*out++ = *in++; /* copy the $ because it may not be expanded */
/* get the variable name */
s = out;
while (s < lastchar && *in != '/' && *in != '\0' &&
!isspace((unsigned char)*in)) {
*s++ = *in++;
}
*s = '\0';
/* get the variable name */
s = out;
while(s < lastchar && *in != '/' && *in != '\0' &&
!isspace((unsigned char)*in)) {
*s++ = *in++;
}
*s = '\0';
/* get its value, but only it isn't too big */
if ((v = getenv(out)) != NULL && strlen(v) < (lastchar - out)) {
strcpy(out - 1, v);
out += strlen(v) - 1;
} else {
/* var not found, or too big, so assume $ must be part of the
* file name */
out += strlen(out);
}
}
else { /* ordinary character */
*out++ = *in++;
}
}
*out = '\0';
/* get its value, but only it isn't too big */
if((v = getenv(out)) != NULL && strlen(v) < (lastchar - out)) {
strcpy(out - 1, v);
out += strlen(v) - 1;
} else {
/* var not found, or too big, so assume $ must be part of the
* file name */
out += strlen(out);
}
} else { /* ordinary character */
*out++ = *in++;
}
}
*out = '\0';
}
static int
wmode_input(const int c){
switch (c) {
case KEY_ENTER:
case '\r':
case '\n':
case ctrl('N'): /* go to next input field */
case KEY_DOWN:
case KEY_RIGHT:
field = (field + 1) % FIELDS;
resetcmd();
static int wmode_input(const int c) {
switch(c) {
case KEY_ENTER:
case '\r':
case '\n':
case ctrl('N'): /* go to next input field */
case KEY_DOWN:
case KEY_RIGHT:
field = (field + 1) % FIELDS;
resetcmd();
break;
case ctrl('P'): /* go to previous input field */
case KEY_UP:
case KEY_LEFT:
field = (field + (FIELDS - 1)) % FIELDS;
resetcmd();
case ctrl('P'): /* go to previous input field */
case KEY_UP:
case KEY_LEFT:
field = (field + (FIELDS - 1)) % FIELDS;
resetcmd();
break;
case KEY_HOME: /* go to first input field */
field = 0;
resetcmd();
case KEY_HOME: /* go to first input field */
field = 0;
resetcmd();
break;
case KEY_LL: /* go to last input field */
curdispline = disprefs;
case KEY_LL: /* go to last input field */
curdispline = disprefs;
break;
default:
return 0;
}
}
window_change |= CH_MODE;
return 1;
}
static int
wresult_input(const int c){
switch (c) {
case KEY_ENTER: /* open for editing */
case '\r':
case '\n':
editref(curdispline);
window_change = CH_ALL;
static int wresult_input(const int c) {
switch(c) {
case KEY_ENTER: /* open for editing */
case '\r':
case '\n':
editref(curdispline);
window_change = CH_ALL;
break;
case ctrl('N'):
case KEY_DOWN:
case KEY_RIGHT:
if ((curdispline + 1) < disprefs) {
++curdispline;
}
case ctrl('N'):
case KEY_DOWN:
case KEY_RIGHT:
if((curdispline + 1) < disprefs) { ++curdispline; }
break;
case ctrl('P'):
case KEY_UP:
case KEY_LEFT:
if (curdispline) {
--curdispline;
}
case ctrl('P'):
case KEY_UP:
case KEY_LEFT:
if(curdispline) { --curdispline; }
break;
case KEY_HOME:
curdispline = 0;
case KEY_HOME:
curdispline = 0;
break;
case KEY_LL:
field = FIELDS - 1;
resetcmd();
case KEY_LL:
field = FIELDS - 1;
resetcmd();
break;
default:
if(c > mdisprefs){ goto noredisp; }
const int pos = dispchar2int(c);
if(pos > -1){ editref(pos); }
default:
if(c > mdisprefs) { goto noredisp; }
const int pos = dispchar2int(c);
if(pos > -1) { editref(pos); }
goto noredisp;
}
}
window_change |= CH_RESULT;
noredisp:
noredisp:
return 1;
}
static int
global_input(const int c){
switch(c){
case '\t':
horswp_field();
break;
case '%':
verswp_field();
break;
static int global_input(const int c) {
switch(c) {
case '\t':
horswp_field();
break;
case '%':
verswp_field();
break;
case ctrl('K'):
field = (field + (FIELDS - 1)) % FIELDS;
resetcmd();
field = (field + (FIELDS - 1)) % FIELDS;
resetcmd();
window_change |= CH_MODE;
break;
break;
case ctrl('J'):
field = (field + 1) % FIELDS;
resetcmd();
field = (field + 1) % FIELDS;
resetcmd();
window_change |= CH_MODE;
break;
case ctrl('H'): /* display previous page */
case '-':
case KEY_PPAGE:
if (totallines == 0) { return 0; } /* don't redisplay if there are no lines */
curdispline = 0;
if(current_page > 0){
break;
case ctrl('H'): /* display previous page */
case '-':
case KEY_PPAGE:
if(totallines == 0) { return 0; } /* don't redisplay if there are no lines */
curdispline = 0;
if(current_page > 0) {
--current_page;
window_change |= CH_RESULT;
}
break;
case '+':
case ctrl('L'):
case KEY_NPAGE:
if (totallines == 0) { return 0; } /* don't redisplay if there are no lines */
curdispline = 0;
break;
case '+':
case ctrl('L'):
case KEY_NPAGE:
if(totallines == 0) { return 0; } /* don't redisplay if there are no lines */
curdispline = 0;
++current_page;
window_change |= CH_RESULT;
break;
case '>': /* write or append the lines to a file */
break; // XXX
//char filename[PATHLEN + 1];
//char* s;
//char ch;
//FILE* file;
//if (totallines == 0) {
// postmsg("There are no lines to write to a file");
// return(NO);
//}
//move(PRLINE, 0);
////addstr("Write to file: "); // XXX
//s = "w";
//if ((ch = getch()) == '>') {
//move(PRLINE, 0);
////addstr(appendprompt); // XXX fix
////ch = '\0';
////s = "a";
////}
////if (ch != '\r' && mygetline("", newpat, COLS - sizeof(appendprompt), c, NO) > 0) {
//// shellpath(filename, sizeof(filename), newpat);
//// if ((file = myfopen(filename, s)) == NULL) {
//// cannotopen(filename);
//// } else {
//// seekline(1);
//// while ((ch = getc(refsfound)) != EOF) {
//// putc(ch, file);
//// }
//// seekline(topline);
//// fclose(file);
//// }
////}
////clearprompt();
break;
case '<': /* read lines from a file */
break; // XXX
//move(PRLINE, 0);
//addstr(readprompt); // XXX fix
//if (mygetline("", newpat, COLS - sizeof(readprompt), '\0', NO) > 0) {
// clearprompt();
// shellpath(filename, sizeof(filename), newpat);
// if (readrefs(filename) == NO) {
// postmsg2("Ignoring an empty file");
// return(NO);
// }
// window_change |= CH_INPUT;
// return(YES);
//}
//clearprompt();
return 0;
case '|': /* pipe the lines to a shell command */
case '^':
break; // XXX fix
if (totallines == 0) {
postmsg("There are no lines to pipe to a shell command");
return 0;
}
/* get the shell command */
//move(PRLINE, 0);
//addstr(pipeprompt);
//if (mygetline("", newpat, COLS - sizeof(pipeprompt), '\0', NO) == 0) {
// clearprompt();
// return(NO);
//}
///* if the ^ command, redirect output to a temp file */
//if (commandc == '^') {
// strcat(strcat(newpat, " >"), temp2);
// /* HBB 20020708: somebody might have even
// * their non-interactive default shells
// * complain about clobbering
// * redirections... --> delete before
// * overwriting */
// remove(temp2);
//}
//exitcurses();
//if ((file = mypopen(newpat, "w")) == NULL) {
// fprintf(stderr, "cscope: cannot open pipe to shell command: %s\n", newpat);
//} else {
// seekline(1);
// while ((c = getc(refsfound)) != EOF) {
// putc(c, file);
// }
// seekline(topline);
// mypclose(file);
//}
//if (commandc == '^') {
// if (readrefs(temp2) == NO) {
// postmsg("Ignoring empty output of ^ command");
// }
//}
//askforreturn();
//entercurses();
break;
case '!': /* shell escape */
execute(shell, shell, NULL);
break;
case '>': /* write or append the lines to a file */
break; // XXX
// char filename[PATHLEN + 1];
// char* s;
// char ch;
// FILE* file;
// if (totallines == 0) {
// postmsg("There are no lines to write to a file");
// return(NO);
// }
// move(PRLINE, 0);
////addstr("Write to file: "); // XXX
// s = "w";
// if ((ch = getch()) == '>') {
// move(PRLINE, 0);
////addstr(appendprompt); // XXX fix
////ch = '\0';
////s = "a";
////}
////if (ch != '\r' && mygetline("", newpat, COLS - sizeof(appendprompt), c,
///NO) > 0) { / shellpath(filename, sizeof(filename), newpat); / if
///((file = myfopen(filename, s)) == NULL) { / cannotopen(filename); /
///} else { / seekline(1); / while ((ch = getc(refsfound)) !=
///EOF) { / putc(ch, file); / } / seekline(topline); /
///fclose(file); / }
////}
////clearprompt();
break;
case '<': /* read lines from a file */
break; // XXX
// move(PRLINE, 0);
// addstr(readprompt); // XXX fix
// if (mygetline("", newpat, COLS - sizeof(readprompt), '\0', NO) > 0) {
// clearprompt();
// shellpath(filename, sizeof(filename), newpat);
// if (readrefs(filename) == NO) {
// postmsg2("Ignoring an empty file");
// return(NO);
// }
// window_change |= CH_INPUT;
// return(YES);
// }
// clearprompt();
return 0;
case '|': /* pipe the lines to a shell command */
case '^':
break; // XXX fix
if(totallines == 0) {
postmsg("There are no lines to pipe to a shell command");
return 0;
}
/* get the shell command */
// move(PRLINE, 0);
// addstr(pipeprompt);
// if (mygetline("", newpat, COLS - sizeof(pipeprompt), '\0', NO) == 0) {
// clearprompt();
// return(NO);
// }
///* if the ^ command, redirect output to a temp file */
// if (commandc == '^') {
// strcat(strcat(newpat, " >"), temp2);
// /* HBB 20020708: somebody might have even
// * their non-interactive default shells
// * complain about clobbering
// * redirections... --> delete before
// * overwriting */
// remove(temp2);
// }
// exitcurses();
// if ((file = mypopen(newpat, "w")) == NULL) {
// fprintf(stderr, "cscope: cannot open pipe to shell command: %s\n",
// newpat);
// } else {
// seekline(1);
// while ((c = getc(refsfound)) != EOF) {
// putc(c, file);
// }
// seekline(topline);
// mypclose(file);
// }
// if (commandc == '^') {
// if (readrefs(temp2) == NO) {
// postmsg("Ignoring empty output of ^ command");
// }
// }
// askforreturn();
// entercurses();
break;
case '!': /* shell escape */
execute(shell, shell, NULL);
current_page = 0;
break;
case KEY_RESIZE:
/* XXX: fill in*/
break;
case ctrl('U'): /* redraw screen */
case KEY_CLEAR:
window_change = CH_ALL;
break;
case '?': /* help */
break;
case KEY_RESIZE:
/* XXX: fill in*/
break;
case ctrl('U'): /* redraw screen */
case KEY_CLEAR:
window_change = CH_ALL;
break;
case '?': /* help */
window_change = CH_HELP;
break;
case ctrl('E'): /* edit all lines */
editall();
break;
default:
return 0;
}
break;
case ctrl('E'): /* edit all lines */
editall();
break;
default:
return 0;
}
return 1;
return 1;
}
extern const void *const winput;
extern const void *const wmode;
extern const void *const wresult;
extern const void *const winput;
extern const void *const wmode;
extern const void *const wresult;
extern const void *const *const current_window;
int
change_input(const int c){
MOUSE *p; /* mouse data */
int change_input(const int c) {
MOUSE *p; /* mouse data */
switch(c){
case '*': /* invert page */
for(int i = 0; topref + i < nextline; i++){
change[topref + i] = !change[topref + i];
}
window_change |= CH_RESULT;
break;
case ctrl('A'): /* invert all lines */
for(unsigned i = 0; i < totallines; i++) {
change[i] = !change[i];
}
window_change |= CH_RESULT;
break;
case ctrl('X'): /* mouse selection */
if ((p = getmouseaction(DUMMYCHAR)) == NULL) {
break; /* unknown control sequence */
}
/* if the button number is a scrollbar tag */
if (p->button == '0') {
//scrollbar(p);
switch(c) {
case '*': /* invert page */
for(int i = 0; topref + i < nextline; i++) {
change[topref + i] = !change[topref + i];
}
window_change |= CH_RESULT;
break;
}
/* find the selected line */
/* NOTE: the selection is forced into range */
{
int i;
for(i = disprefs - 1; i > 0; --i) {
if (p->y1 >= displine[i]) {
break;
case ctrl('A'): /* invert all lines */
for(unsigned i = 0; i < totallines; i++) {
change[i] = !change[i];
}
window_change |= CH_RESULT;
break;
case ctrl('X'): /* mouse selection */
if((p = getmouseaction(DUMMYCHAR)) == NULL) {
break; /* unknown control sequence */
}
/* if the button number is a scrollbar tag */
if(p->button == '0') {
// scrollbar(p);
break;
}
/* find the selected line */
/* NOTE: the selection is forced into range */
{
int i;
for(i = disprefs - 1; i > 0; --i) {
if(p->y1 >= displine[i]) { break; }
}
change[i] = !change[i];
}
break;
case ctrl('D'):
changestring(input_line, newpat, change, totallines);
break;
default:
{
/* if a line was selected */
const int cc = dispchar2int(c);
if(cc != -1) {
change[cc] = !change[cc];
window_change |= CH_RESULT;
}
}
change[i] = !change[i];
}
break;
case ctrl('D'):
changestring(input_line, newpat, change, totallines);
break;
default:
{
/* if a line was selected */
const int cc = dispchar2int(c);
if(cc != -1){
change[cc] = !change[cc];
window_change |= CH_RESULT;
}
}
}
return 0;
}
int
changestring(const char* from,
const char* to,
const bool *const change,
const int change_len
){
char newfile[PATHLEN + 1]; /* new file name */
char oldfile[PATHLEN + 1]; /* old file name */
char linenum[NUMLEN + 1]; /* file line number */
char msg[MSGLEN + 1]; /* message */
FILE *script; /* shell script file */
int changestring(const char *from, const char *to, const bool *const change,
const int change_len) {
char newfile[PATHLEN + 1]; /* new file name */
char oldfile[PATHLEN + 1]; /* old file name */
char linenum[NUMLEN + 1]; /* file line number */
char msg[MSGLEN + 1]; /* message */
FILE *script; /* shell script file */
/* Return early */
bool anymarked = false; /* any line marked */
for(int i = 0; i < change_len; i++){
if(change[i]){
/* Return early */
bool anymarked = false; /* any line marked */
for(int i = 0; i < change_len; i++) {
if(change[i]) {
anymarked = true;
break;
}
}
if(!anymarked){ return false; }
if(!anymarked) { return false; }
/* open the temporary file */
if((script = myfopen(temp2, "w")) == NULL) {
/* open the temporary file */
if((script = myfopen(temp2, "w")) == NULL) {
cannotopen(temp2);
return(false);
}
return (false);
}
/* for each line containing the old text */
fprintf(script, "ed - <<\\!\n");
*oldfile = '\0';
/* for each line containing the old text */
fprintf(script, "ed - <<\\!\n");
*oldfile = '\0';
fseek(refsfound, 0, SEEK_SET);
for(int i = 0;
fscanf(refsfound, "%" PATHLEN_STR "s%*s%" NUMLEN_STR "s%*[^\n]", newfile, linenum) == 2;
++i)
{
for(int i = 0; fscanf(refsfound,
"%" PATHLEN_STR "s%*s%" NUMLEN_STR "s%*[^\n]",
newfile,
linenum) == 2;
++i) {
/* see if the line is to be changed */
if (!change[i]) { break; }
/* if this is a new file */
if (strcmp(newfile, oldfile) != 0) {
/* make sure it can be changed */
if (access(newfile, WRITE) != 0) {
snprintf(msg, sizeof(msg), "Cannot write to file %s", newfile);
postmsg(msg);
goto end;
}
/* if there was an old file */
if (*oldfile != '\0') {
fprintf(script, "w\n"); /* save it */
}
/* edit the new file */
strcpy(oldfile, newfile);
fprintf(script, "e %s\n", oldfile);
}
/* output substitute command */
fprintf(script, "%ss/", linenum); /* change */
for(const char *s = from; *s != '\0'; ++s) {
/* old text */
if (strchr("/\\[.^*", *s) != NULL) {
putc('\\', script);
if(!change[i]) { break; }
/* if this is a new file */
if(strcmp(newfile, oldfile) != 0) {
/* make sure it can be changed */
if(access(newfile, WRITE) != 0) {
snprintf(msg, sizeof(msg), "Cannot write to file %s", newfile);
postmsg(msg);
goto end;
}
if (caseless == true && isalpha((unsigned char)*s)) {
/* if there was an old file */
if(*oldfile != '\0') { fprintf(script, "w\n"); /* save it */ }
/* edit the new file */
strcpy(oldfile, newfile);
fprintf(script, "e %s\n", oldfile);
}
/* output substitute command */
fprintf(script, "%ss/", linenum); /* change */
for(const char *s = from; *s != '\0'; ++s) {
/* old text */
if(strchr("/\\[.^*", *s) != NULL) { putc('\\', script); }
if(caseless == true && isalpha((unsigned char)*s)) {
putc('[', script);
if(islower((unsigned char)*s)) {
putc(toupper((unsigned char)*s), script);
putc(*s, script);
putc(toupper((unsigned char)*s), script);
putc(*s, script);
} else {
putc(*s, script);
putc(tolower((unsigned char)*s), script);
putc(*s, script);
putc(tolower((unsigned char)*s), script);
}
putc(']', script);
} else {
putc(*s, script);
}
}
putc('/', script); /* to */
for(const char *s = to; *s != '\0'; ++s) { /* new text */
if (strchr("/\\&", *s) != NULL) {
putc('\\', script);
}
}
putc('/', script); /* to */
for(const char *s = to; *s != '\0'; ++s) { /* new text */
if(strchr("/\\&", *s) != NULL) { putc('\\', script); }
putc(*s, script);
}
fprintf(script, "/gp\n"); /* and print */
}
fprintf(script, "w\nq\n!\n"); /* write and quit */
fflush(script);
}
fprintf(script, "/gp\n"); /* and print */
}
fprintf(script, "w\nq\n!\n"); /* write and quit */
fflush(script);
/* edit the files */
fprintf(stderr, "Changed lines:\n\r");
execute("sh", "sh", temp2, NULL);
askforchar();
end:
fclose(script);
return true;
fclose(script);
return true;
}
int
handle_input(const int c){
int handle_input(const int c) {
/* - was wating for any input - */
if(do_press_any_key){
if(do_press_any_key) {
do_press_any_key = false;
return 0;
}
/* --- global --- */
const int r = global_input(c);
if(r){ return 0; }
/* --- mode specific --- */
switch(input_mode){
/* --- global --- */
const int r = global_input(c);
if(r) { return 0; }
/* --- mode specific --- */
switch(input_mode) {
case INPUT_NORMAL:
if(*current_window == winput){
if(*current_window == winput) {
return interpret(c);
}else if(*current_window == wmode){
} else if(*current_window == wmode) {
return wmode_input(c);
}else if(*current_window == wresult){
} else if(*current_window == wresult) {
return wresult_input(c);
}
assert("'current_window' dangling.");
@ -574,5 +541,5 @@ handle_input(const int c){
return change_input(c);
}
return 0;
return 0;
}

1708
src/invlib.c
View File

File diff suppressed because it is too large Load Diff

106
src/invlib.h
View File

@ -33,82 +33,82 @@
#ifndef CSCOPE_INVLIB_H
#define CSCOPE_INVLIB_H
#include <stdio.h> /* need definition of FILE* */
#include <limits.h> /* need definition of CHAR_MAX */
#include <stdio.h> /* need definition of FILE* */
#include <limits.h> /* need definition of CHAR_MAX */
/* inverted index definitions */
/* postings temporary file long number coding into characters */
#if CHAR_MAX==255
# define BASE 223 /* 255 - ' ' */
# define PRECISION 4 /* maximum digits after converting a long */
#if CHAR_MAX == 255
# define BASE 223 /* 255 - ' ' */
# define PRECISION 4 /* maximum digits after converting a long */
#else
# if CHAR_MAX==127 /* assume sign-extension of a char when converted to an int */
# define BASE 95 /* 127 - ' ' */
# define PRECISION 5 /* maximum digits after converting a long */
# if CHAR_MAX == 127 /* assume sign-extension of a char when converted to an int */
# define BASE 95 /* 127 - ' ' */
# define PRECISION 5 /* maximum digits after converting a long */
# else
#error Need a platform with 8 bits in a char value
# error Need a platform with 8 bits in a char value
# endif
#endif
/* inverted index access parameters */
#define INVAVAIL 0
#define INVBUSY 1
#define INVALONE 2
#define INVAVAIL 0
#define INVBUSY 1
#define INVALONE 2
/* boolean set operations */
#define bool_OR 3
#define AND 4
#define falseT 5
#define REVERSEfalseT 6
#define bool_OR 3
#define AND 4
#define falseT 5
#define REVERSEfalseT 6
/* note that the entire first block is for parameters */
typedef struct {
long version; /* inverted index format version */
long filestat; /* file status word */
long sizeblk; /* size of logical block in bytes */
long startbyte; /* first byte of superfinger */
long supsize; /* size of superfinger in bytes */
long cntlsize; /* size of max cntl space (should be a multiple of BUFSIZ) */
long share; /* flag whether to use shared memory */
typedef struct {
long version; /* inverted index format version */
long filestat; /* file status word */
long sizeblk; /* size of logical block in bytes */
long startbyte; /* first byte of superfinger */
long supsize; /* size of superfinger in bytes */
long cntlsize; /* size of max cntl space (should be a multiple of BUFSIZ) */
long share; /* flag whether to use shared memory */
} PARAM;
typedef struct {
FILE *invfile; /* the inverted file ptr */
FILE *postfile; /* posting file ptr */
PARAM param; /* control parameters for the file */
char *iindex; /* ptr to space for superindex */
union logicalblk *logblk; /* ptr to space for a logical block */
long numblk; /* number of block presently at *logblk */
long keypnt; /* number item in present block found */
typedef struct {
FILE *invfile; /* the inverted file ptr */
FILE *postfile; /* posting file ptr */
PARAM param; /* control parameters for the file */
char *iindex; /* ptr to space for superindex */
union logicalblk *logblk; /* ptr to space for a logical block */
long numblk; /* number of block presently at *logblk */
long keypnt; /* number item in present block found */
} INVCONTROL;
typedef struct {
short offset; /* offset in this logical block */
unsigned char size; /* size of term */
unsigned char space; /* number of longs of growth space */
long post; /* number of postings for this entry */
typedef struct {
short offset; /* offset in this logical block */
unsigned char size; /* size of term */
unsigned char space; /* number of longs of growth space */
long post; /* number of postings for this entry */
} ENTRY;
typedef struct {
long lineoffset; /* source line database offset */
long fcnoffset; /* function name database offset */
long fileindex : 24; /* source file name index */
long type : 8; /* reference type (mark character) */
typedef struct {
long lineoffset; /* source line database offset */
long fcnoffset; /* function name database offset */
long fileindex : 24; /* source file name index */
long type : 8; /* reference type (mark character) */
} POSTING;
extern long *srcoffset; /* source file name database offsets */
extern int nsrcoffset; /* number of file name database offsets */
extern long *srcoffset; /* source file name database offsets */
extern int nsrcoffset; /* number of file name database offsets */
void boolclear(void);
POSTING *boolfile(INVCONTROL *invcntl, long *num, int boolarg);
void invclose(INVCONTROL *invcntl);
void invdump(INVCONTROL *invcntl, char *term);
long invfind(INVCONTROL *invcntl, char *searchterm);
int invforward(INVCONTROL *invcntl);
int invopen(INVCONTROL *invcntl, char *invname, char *invpost, int status);
long invmake(char *invname, char *invpost, FILE *infile);
long invterm(INVCONTROL *invcntl, char *term);
void boolclear(void);
POSTING *boolfile(INVCONTROL *invcntl, long *num, int boolarg);
void invclose(INVCONTROL *invcntl);
void invdump(INVCONTROL *invcntl, char *term);
long invfind(INVCONTROL *invcntl, char *searchterm);
int invforward(INVCONTROL *invcntl);
int invopen(INVCONTROL *invcntl, char *invname, char *invpost, int status);
long invmake(char *invname, char *invpost, FILE *infile);
long invterm(INVCONTROL *invcntl, char *term);
#endif /* CSCOPE_INVLIB_H */

28
src/keys.h
View File

@ -12,48 +12,48 @@
#define KEY_UNDEF_BASE 0
#ifndef KEY_DOWN
# define KEY_DOWN KEY_UNDEF_BASE-1
# define KEY_DOWN KEY_UNDEF_BASE - 1
#endif
#ifndef KEY_UP
# define KEY_UP KEY_UNDEF_BASE-2
# define KEY_UP KEY_UNDEF_BASE - 2
#endif
#ifndef KEY_LEFT
# define KEY_LEFT KEY_UNDEF_BASE-3
# define KEY_LEFT KEY_UNDEF_BASE - 3
#endif
#ifndef KEY_RIGHT
# define KEY_RIGHT KEY_UNDEF_BASE-4
# define KEY_RIGHT KEY_UNDEF_BASE - 4
#endif
#ifndef KEY_HOME
# define KEY_HOME _KEY_UNDEF_BASE-5
# define KEY_HOME _KEY_UNDEF_BASE - 5
#endif
#ifndef KEY_LL
# define KEY_LL KEY_UNDEF_BASE-6
# define KEY_LL KEY_UNDEF_BASE - 6
#endif
#ifndef KEY_PPAGE
# define KEY_PPAGE KEY_UNDEF_BASE-7
# define KEY_PPAGE KEY_UNDEF_BASE - 7
#endif
#ifndef KEY_NPAGE
# define KEY_NPAGE KEY_UNDEF_BASE-8
# define KEY_NPAGE KEY_UNDEF_BASE - 8
#endif
#ifndef KEY_ENTER
# define KEY_ENTER KEY_UNDEF_BASE-9
# define KEY_ENTER KEY_UNDEF_BASE - 9
#endif
#ifndef KEY_CLEAR
# define KEY_CLEAR KEY_UNDEF_BASE-10
# define KEY_CLEAR KEY_UNDEF_BASE - 10
#endif
#ifndef KEY_RESIZE
# define KEY_RESIZE KEY_UNDEF_BASE-11
# define KEY_RESIZE KEY_UNDEF_BASE - 11
#endif
#ifndef KEY_END
# define KEY_END KEY_UNDEF_BASE-12
# define KEY_END KEY_UNDEF_BASE - 12
#endif
/* Always define these keys */
#ifndef ESC
# define ESC '\033' /* escape character */
# define ESC '\033' /* escape character */
#endif
#ifndef DEL
# define DEL '\177' /* delete character */
# define DEL '\177' /* delete character */
#endif

24
src/library.h
View File

@ -33,19 +33,19 @@
#ifndef CSCOPE_LIBRARY_H
#define CSCOPE_LIBRARY_H
#include <stdio.h> /* need FILE* type def. */
#include <stdio.h> /* need FILE* type def. */
/* private library */
char *compath(char *pathname);
char *egrepinit(const char *egreppat);
char *logdir(char *name);
const char *basename(const char *path);
FILE *myfopen(char *path, char *mode);
char *mygetenv(char *variable, char *deflt);
int myopen(char *path, int flag, int mode);
FILE *mypopen(char *cmd, char *mode);
int mypclose(FILE *ptr);
FILE *vpfopen(char *filename, char *type);
void egrepcaseless(int i);
char *compath(char *pathname);
char *egrepinit(const char *egreppat);
char *logdir(char *name);
const char *basename(const char *path);
FILE *myfopen(char *path, char *mode);
char *mygetenv(char *variable, char *deflt);
int myopen(char *path, int flag, int mode);
FILE *mypopen(char *cmd, char *mode);
int mypclose(FILE *ptr);
FILE *vpfopen(char *filename, char *type);
void egrepcaseless(int i);
#endif /* CSCOPE_LIBRARY_H */

80
src/logdir.c
View File

@ -43,58 +43,50 @@
#include <string.h>
#include "global.h"
#define OURBUFSIZ 160 /* renamed: avoid conflict with <stdio.h> */
#define OURBUFSIZ 160 /* renamed: avoid conflict with <stdio.h> */
static char line[OURBUFSIZ+1];
static char line[OURBUFSIZ + 1];
/* Internal prototypes: */
static char *nextfield(char *p);
static char *nextfield(char *p);
static char *
nextfield(char *p)
{
while (*p && *p != ':')
++p;
if (*p) *p++ = 0;
return(p);
static char *nextfield(char *p) {
while(*p && *p != ':')
++p;
if(*p) *p++ = 0;
return (p);
}
char *
logdir(char *name)
{
char *p;
int i, j;
int pwf;
char *logdir(char *name) {
char *p;
int i, j;
int pwf;
/* attempt to open the password file */
if ((pwf = myopen("/etc/passwd", 0, 0)) == -1)
return(0);
/* attempt to open the password file */
if((pwf = myopen("/etc/passwd", 0, 0)) == -1) return (0);
/* find the matching password entry */
do {
/* get the next line in the password file */
i = read(pwf, line, OURBUFSIZ);
for (j = 0; j < i; j++)
if (line[j] == '\n')
break;
/* return a null pointer if the whole file has been read */
if (j >= i)
return(0);
line[++j] = 0; /* terminate the line */
(void) lseek(pwf, (long) (j - i), 1); /* point at the next line */
p = nextfield(line); /* get the logname */
} while (*name != *line || /* fast pretest */
strcmp(name, line) != 0);
(void) close(pwf);
/* find the matching password entry */
do {
/* get the next line in the password file */
i = read(pwf, line, OURBUFSIZ);
for(j = 0; j < i; j++)
if(line[j] == '\n') break;
/* return a null pointer if the whole file has been read */
if(j >= i) return (0);
line[++j] = 0; /* terminate the line */
(void)lseek(pwf, (long)(j - i), 1); /* point at the next line */
p = nextfield(line); /* get the logname */
} while(*name != *line || /* fast pretest */
strcmp(name, line) != 0);
(void)close(pwf);
/* skip the intervening fields */
p = nextfield(p);
p = nextfield(p);
p = nextfield(p);
p = nextfield(p);
/* skip the intervening fields */
p = nextfield(p);
p = nextfield(p);
p = nextfield(p);
p = nextfield(p);
/* return the login directory */
(void) nextfield(p);
return(p);
/* return the login directory */
(void)nextfield(p);
return (p);
}

160
src/lookup.c
View File

@ -39,11 +39,11 @@
#include "lookup.h"
/* keyword text for fast testing of keywords in the scanner */
char enumtext[] = "enum";
char externtext[] = "extern";
char structtext[] = "struct";
char typedeftext[] = "typedef";
char uniontext[] = "union";
char enumtext[] = "enum";
char externtext[] = "extern";
char structtext[] = "struct";
char typedeftext[] = "typedef";
char uniontext[] = "union";
/* This keyword table is also used for keyword text compression. Keywords
* with an index less than the numeric value of a space are replaced with the
@ -51,99 +51,93 @@ char uniontext[] = "union";
* without changing the database file version and adding compatibility code
* for old databases.
*/
struct keystruct keyword[] = {
{"", '\0', NULL}, /* dummy entry */
{"#define", ' ', NULL}, /* must be table entry 1 */
{"#include", ' ', NULL}, /* must be table entry 2 */
{"break", '\0', NULL}, /* rarely in cross-reference */
{"case", ' ', NULL},
{"char", ' ', NULL},
{"continue", '\0', NULL}, /* rarely in cross-reference */
{"default", '\0', NULL}, /* rarely in cross-reference */
{"double", ' ', NULL},
{"\t", '\0', NULL}, /* must be the table entry 9 */
{"\n", '\0', NULL}, /* must be the table entry 10 */
{"else", ' ', NULL},
{enumtext, ' ', NULL},
{externtext, ' ', NULL},
{"float", ' ', NULL},
{"for", '(', NULL},
{"goto", ' ', NULL},
{"if", '(', NULL},
{"int", ' ', NULL},
{"long", ' ', NULL},
{"register", ' ', NULL},
{"return", '\0', NULL},
{"short", ' ', NULL},
{"sizeof", '\0', NULL},
{"static", ' ', NULL},
{structtext, ' ', NULL},
{"switch", '(', NULL},
{typedeftext, ' ', NULL},
{uniontext, ' ', NULL},
{"unsigned", ' ', NULL},
{"void", ' ', NULL},
{"while", '(', NULL},
struct keystruct keyword[] = {
{"", '\0', NULL}, /* dummy entry */
{"#define", ' ', NULL}, /* must be table entry 1 */
{"#include", ' ', NULL}, /* must be table entry 2 */
{"break", '\0', NULL}, /* rarely in cross-reference */
{"case", ' ', NULL},
{"char", ' ', NULL},
{"continue", '\0', NULL}, /* rarely in cross-reference */
{"default", '\0', NULL}, /* rarely in cross-reference */
{"double", ' ', NULL},
{"\t", '\0', NULL}, /* must be the table entry 9 */
{"\n", '\0', NULL}, /* must be the table entry 10 */
{"else", ' ', NULL},
{enumtext, ' ', NULL},
{externtext, ' ', NULL},
{"float", ' ', NULL},
{"for", '(', NULL},
{"goto", ' ', NULL},
{"if", '(', NULL},
{"int", ' ', NULL},
{"long", ' ', NULL},
{"register", ' ', NULL},
{"return", '\0', NULL},
{"short", ' ', NULL},
{"sizeof", '\0', NULL},
{"static", ' ', NULL},
{structtext, ' ', NULL},
{"switch", '(', NULL},
{typedeftext, ' ', NULL},
{uniontext, ' ', NULL},
{"unsigned", ' ', NULL},
{"void", ' ', NULL},
{"while", '(', NULL},
/* these keywords are not compressed */
{"do", '\0', NULL},
{"auto", ' ', NULL},
{"fortran", ' ', NULL},
{"const", ' ', NULL},
{"signed", ' ', NULL},
{"volatile", ' ', NULL},
/* these keywords are not compressed */
{"do", '\0', NULL},
{"auto", ' ', NULL},
{"fortran", ' ', NULL},
{"const", ' ', NULL},
{"signed", ' ', NULL},
{"volatile", ' ', NULL},
};
#define KEYWORDS (sizeof(keyword) / sizeof(keyword[0]))
#define KEYWORDS (sizeof(keyword) / sizeof(keyword[0]))
#define HASHMOD (KEYWORDS * 2 + 1)
#define HASHMOD (KEYWORDS * 2 + 1)
static struct keystruct *hashtab[HASHMOD]; /* pointer table */
static struct keystruct *hashtab[HASHMOD]; /* pointer table */
/* put the keywords into the symbol table */
void
initsymtab(void)
{
unsigned int i, j;
struct keystruct *p;
void initsymtab(void) {
unsigned int i, j;
struct keystruct *p;
for (i = 1; i < KEYWORDS; ++i) {
p = keyword + i;
j = hash(p->text) % HASHMOD;
p->next = hashtab[j];
hashtab[j] = p;
}
for(i = 1; i < KEYWORDS; ++i) {
p = keyword + i;
j = hash(p->text) % HASHMOD;
p->next = hashtab[j];
hashtab[j] = p;
}
}
/* see if this identifier is a keyword */
char *
lookup(char *ident)
{
struct keystruct *p;
int c;
char *lookup(char *ident) {
struct keystruct *p;
int c;
/* look up the identifier in the keyword table */
for (p = hashtab[hash(ident) % HASHMOD]; p != NULL; p = p->next) {
if (strequal(ident, p->text)) {
if (compress == true && (c = p - keyword) < ' ') {
ident[0] = c; /* compress the keyword */
}
return(p->text);
}
}
/* this is an identifier */
return(NULL);
/* look up the identifier in the keyword table */
for(p = hashtab[hash(ident) % HASHMOD]; p != NULL; p = p->next) {
if(strequal(ident, p->text)) {
if(compress == true && (c = p - keyword) < ' ') {
ident[0] = c; /* compress the keyword */
}
return (p->text);
}
}
/* this is an identifier */
return (NULL);
}
/* form hash value for string */
int
hash(char *ss)
{
int i;
unsigned char *s = (unsigned char *)ss;
int hash(char *ss) {
int i;
unsigned char *s = (unsigned char *)ss;
for (i = 0; *s != '\0'; )
i += *s++; /* += is faster than <<= for cscope */
return(i);
for(i = 0; *s != '\0';)
i += *s++; /* += is faster than <<= for cscope */
return (i);
}

10
src/lookup.h
View File

@ -36,10 +36,10 @@
/* declarations for objects defined in lookup.c */
/* keyword text for fast testing of keywords in the scanner */
extern char enumtext[];
extern char externtext[];
extern char structtext[];
extern char typedeftext[];
extern char uniontext[];
extern char enumtext[];
extern char externtext[];
extern char structtext[];
extern char typedeftext[];
extern char uniontext[];
#endif /* CSCOPE_LOOKUP_H */

1012
src/main.c
View File

File diff suppressed because it is too large Load Diff

647
src/mouse.c
View File

@ -37,439 +37,392 @@
extern int LINES;
#define FLDLINE (LINES - FIELDS - 1 - 1) /* first input field line */
#define FLDLINE (LINES - FIELDS - 1 - 1) /* first input field line */
#include "global.h"
bool mouse = false; /* mouse interface */
bool mouse = false; /* mouse interface */
#ifdef UNIXPC /* build command requires #ifdef instead of #if */
#include <sys/window.h>
bool unixpcmouse = false; /* running with a mouse on the Unix PC? */
static int uw_hs, uw_vs; /* character height and width */
#ifdef UNIXPC /* build command requires #ifdef instead of #if */
# include <sys/window.h>
bool unixpcmouse = false; /* running with a mouse on the Unix PC? */
static int uw_hs, uw_vs; /* character height and width */
#endif
typedef struct { /* menu */
char *text;
char *value;
typedef struct { /* menu */
char *text;
char *value;
} MENU;
static MENU mainmenu[] = { /* main menu */
{"Send", "##\033s##\r"},
{"Repeat", "\031"},
{"Edit All", "\05"},
{"Rebuild", "\022"},
{"Shell", "!"},
{"Redraw", "\f"},
{"Help", "?"},
{"Exit", "\04"},
{NULL, NULL}
static MENU mainmenu[] = {
/* main menu */
{"Send", "##\033s##\r"},
{"Repeat", "\031" },
{"Edit All", "\05" },
{"Rebuild", "\022" },
{"Shell", "!" },
{"Redraw", "\f" },
{"Help", "?" },
{"Exit", "\04" },
{NULL, NULL }
};
static MENU changemenu[] = { /* change mode menu */
{"Mark Screen", "*"},
{"Mark All", "a"},
{"Change", "\04"},
{"No Change", "\033"},
{"Shell", "!"},
{"Redraw", "\f"},
{"Help", "?"},
{NULL, NULL}
static MENU changemenu[] = {
/* change mode menu */
{"Mark Screen", "*" },
{"Mark All", "a" },
{"Change", "\04" },
{"No Change", "\033"},
{"Shell", "!" },
{"Redraw", "\f" },
{"Help", "?" },
{NULL, NULL }
};
static MENU *loaded; /* menu loaded */
static bool emacsviterm = false; /* terminal type */
static MENU *loaded; /* menu loaded */
static bool emacsviterm = false; /* terminal type */
static void loadmenu(MENU *menu);
static int getcoordinate(void);
static int getpercent(void);
static void loadmenu(MENU *menu);
static int getcoordinate(void);
static int getpercent(void);
/* see if there is a mouse interface */
void
mouseinit(void)
{
char *term;
void mouseinit(void) {
char *term;
/* see if this is emacsterm or viterm */
term = mygetenv("TERM", "");
if (strcmp(term, "emacsterm") == 0 ||
strcmp(term, "viterm") == 0) {
emacsviterm = true;
mouse = true;
}
/* the MOUSE enviroment variable is for 5620 terminal programs that have
mouse support but the TERM environment variable is the same as a
terminal without a mouse, such as myx */
else if (strcmp(mygetenv("MOUSE", ""), "myx") == 0) {
mouse = true;
}
/* see if this is emacsterm or viterm */
term = mygetenv("TERM", "");
if(strcmp(term, "emacsterm") == 0 || strcmp(term, "viterm") == 0) {
emacsviterm = true;
mouse = true;
}
/* the MOUSE enviroment variable is for 5620 terminal programs that have
mouse support but the TERM environment variable is the same as a
terminal without a mouse, such as myx */
else if(strcmp(mygetenv("MOUSE", ""), "myx") == 0) {
mouse = true;
}
#if UNIXPC
else if (strcmp(term,"s4") == 0 ||
strcmp(term,"s120") == 0 ||
strcmp(term,"s90") == 0) {
int retval;
struct uwdata uwd; /* Window data structure */
struct umdata umd; /* Mouse data structure */
else if(strcmp(term, "s4") == 0 || strcmp(term, "s120") == 0 ||
strcmp(term, "s90") == 0) {
int retval;
struct uwdata uwd; /* Window data structure */
struct umdata umd; /* Mouse data structure */
/* Ask for character size info */
/* Ask for character size info */
retval = ioctl(1,WIOCGETD,&uwd);
if(retval || uwd.uw_hs <= 0 || uwd.uw_vs <= 0) {
/**************************************************
* something wrong with the kernel, so fake it...
**************************************************/
if(!strcmp(term,"s4")) {
uw_hs = 9;
uw_vs = 12;
}
else {
uw_hs = 6;
uw_vs = 10;
}
}
else {
/* Kernel is working and knows about this font */
uw_hs = uwd.uw_hs;
uw_vs = uwd.uw_vs;
}
retval = ioctl(1, WIOCGETD, &uwd);
if(retval || uwd.uw_hs <= 0 || uwd.uw_vs <= 0) {
/**************************************************
* something wrong with the kernel, so fake it...
**************************************************/
if(!strcmp(term, "s4")) {
uw_hs = 9;
uw_vs = 12;
} else {
uw_hs = 6;
uw_vs = 10;
}
} else {
/* Kernel is working and knows about this font */
uw_hs = uwd.uw_hs;
uw_vs = uwd.uw_vs;
}
/**************************************************
* Now turn on mouse reporting so we can actually
* make use of all this stuff.
**************************************************/
if((retval = ioctl(1,WIOCGETMOUSE,&umd)) != -1) {
umd.um_flags= MSDOWN+MSUP;
ioctl(1,WIOCSETMOUSE,&umd);
}
unixpcmouse = true;
}
/**************************************************
* Now turn on mouse reporting so we can actually
* make use of all this stuff.
**************************************************/
if((retval = ioctl(1, WIOCGETMOUSE, &umd)) != -1) {
umd.um_flags = MSDOWN + MSUP;
ioctl(1, WIOCSETMOUSE, &umd);
}
unixpcmouse = true;
}
#endif
if (mouse == true) {
loadmenu(mainmenu);
}
if(mouse == true) { loadmenu(mainmenu); }
}
/* load the correct mouse menu */
void
mousemenu(void)
{
if (mouse == true) {
if (input_mode == INPUT_CHANGE) {
loadmenu(changemenu);
}
else {
loadmenu(mainmenu);
}
}
void mousemenu(void) {
if(mouse == true) {
if(input_mode == INPUT_CHANGE) {
loadmenu(changemenu);
} else {
loadmenu(mainmenu);
}
}
}
/* download a menu */
static void
loadmenu(MENU *menu)
{
int i;
static void loadmenu(MENU *menu) {
int i;
if (emacsviterm == true) {
mousereinit();
(void) printf("\033V1"); /* display the scrollbar */
(void) printf("\033M0@%s@%s@", menu[0].text, menu[0].value);
for (i = 1; menu[i].text != NULL; ++i) {
(void) printf("\033M@%s@%s@", menu[i].text, menu[i].value);
}
}
else { /* myx */
int len;
if(emacsviterm == true) {
mousereinit();
(void)printf("\033V1"); /* display the scrollbar */
(void)printf("\033M0@%s@%s@", menu[0].text, menu[0].value);
for(i = 1; menu[i].text != NULL; ++i) {
(void)printf("\033M@%s@%s@", menu[i].text, menu[i].value);
}
} else { /* myx */
int len;
mousecleanup();
(void) printf("\033[6;1X\033[9;1X");
for (i = 0; menu[i].text != NULL; ++i) {
len = strlen(menu[i].text);
(void) printf("\033[%d;%dx%s%s", len,
(int) (len + strlen(menu[i].value)),
menu[i].text, menu[i].value);
}
loaded = menu;
}
(void) fflush(stdout);
mousecleanup();
(void)printf("\033[6;1X\033[9;1X");
for(i = 0; menu[i].text != NULL; ++i) {
len = strlen(menu[i].text);
(void)printf("\033[%d;%dx%s%s",
len,
(int)(len + strlen(menu[i].value)),
menu[i].text,
menu[i].value);
}
loaded = menu;
}
(void)fflush(stdout);
}
/* reinitialize the mouse in case curses changed the attributes */
void
mousereinit(void)
{
if (emacsviterm == true) {
void mousereinit(void) {
if(emacsviterm == true) {
/* enable the mouse click and sweep coordinate control sequence */
/* and switch to menu 2 */
(void) printf("\033{2\033#2");
(void) fflush(stdout);
}
/* enable the mouse click and sweep coordinate control sequence */
/* and switch to menu 2 */
(void)printf("\033{2\033#2");
(void)fflush(stdout);
}
}
/* restore the mouse attributes */
void
mousecleanup(void)
{
int i;
void mousecleanup(void) {
int i;
if (loaded != NULL) { /* only true for myx */
if(loaded != NULL) { /* only true for myx */
/* remove the mouse menu */
(void) printf("\033[6;0X\033[9;0X");
for (i = 0; loaded[i].text != NULL; ++i) {
(void) printf("\033[0;0x");
}
loaded = NULL;
}
/* remove the mouse menu */
(void)printf("\033[6;0X\033[9;0X");
for(i = 0; loaded[i].text != NULL; ++i) {
(void)printf("\033[0;0x");
}
loaded = NULL;
}
}
/* draw the scrollbar */
void
drawscrollbar(int top, int bot)
{
int p1, p2;
void drawscrollbar(int top, int bot) {
int p1, p2;
if (emacsviterm == true) {
if (bot > top) {
p1 = 16 + (top - 1) * 100 / totallines;
p2 = 16 + (bot - 1) * 100 / totallines;
if (p2 > 116) {
p2 = 116;
}
if (p1 < 16) {
p1 = 16;
}
/* don't send ^S or ^Q because it will hang a layer using cu(1) */
if (p1 == ctrl('Q') || p1 == ctrl('S')) {
++p1;
}
if (p2 == ctrl('Q') || p2 == ctrl('S')) {
++p2;
}
}
else {
p1 = p2 = 16;
}
(void) printf("\033W%c%c", p1, p2);
}
if(emacsviterm == true) {
if(bot > top) {
p1 = 16 + (top - 1) * 100 / totallines;
p2 = 16 + (bot - 1) * 100 / totallines;
if(p2 > 116) { p2 = 116; }
if(p1 < 16) { p1 = 16; }
/* don't send ^S or ^Q because it will hang a layer using cu(1) */
if(p1 == ctrl('Q') || p1 == ctrl('S')) { ++p1; }
if(p2 == ctrl('Q') || p2 == ctrl('S')) { ++p2; }
} else {
p1 = p2 = 16;
}
(void)printf("\033W%c%c", p1, p2);
}
}
/* get the mouse information */
MOUSE *
getmouseaction(char leading_char)
{
static MOUSE m;
MOUSE *getmouseaction(char leading_char) {
static MOUSE m;
#if UNIXPC
if(unixpcmouse == true && leading_char == ESC) {
if(unixpcmouse == true && leading_char == ESC) {
/* Called if cscope received an ESC character. See if it is
* a mouse report and if so, decipher it. A mouse report
* looks like: "<ESC>[?xx;yy;b;rM"
*/
int x = 0, y = 0, button = 0, reason = 0;
int i;
/* Called if cscope received an ESC character. See if it is
* a mouse report and if so, decipher it. A mouse report
* looks like: "<ESC>[?xx;yy;b;rM"
*/
int x = 0, y = 0, button = 0, reason = 0;
int i;
/* Get a mouse report. The form is: XX;YY;B;RM where
* XX is 1,2, or 3 decimal digits with the X pixel position.
* Similarly for YY. B is a single decimal digit with the
* button number (4 for one, 2 for two, and 1 for three).
* R is the reason for the mouse report.
*
* In general, the input is read until the mouse report has
* been completely read in or we have discovered that this
* escape sequence is falseT a mouse report. In the latter case
* return the last character read to the input stream with
* myungetch().
*/
/* Get a mouse report. The form is: XX;YY;B;RM where
* XX is 1,2, or 3 decimal digits with the X pixel position.
* Similarly for YY. B is a single decimal digit with the
* button number (4 for one, 2 for two, and 1 for three).
* R is the reason for the mouse report.
*
* In general, the input is read until the mouse report has
* been completely read in or we have discovered that this
* escape sequence is falseT a mouse report. In the latter case
* return the last character read to the input stream with
* myungetch().
*/
/* Check for "[?" being next 2 chars */
if(((i = getch()) != '[') || ((i = getch()) != '?')) {
myungetch(i);
return(NULL);
}
/* Check for "[?" being next 2 chars */
if(((i = getch()) != '[') || ((i = getch()) != '?')) {
myungetch(i);
return (NULL);
}
/* Grab the X position (in pixels) */
while(isdigit(i = getch())) {
x = (x*10) + (i - '0');
}
if(i != ';') {
myungetch(i);
return(NULL); /* not a mouse report after all */
}
/* Grab the X position (in pixels) */
while(isdigit(i = getch())) {
x = (x * 10) + (i - '0');
}
if(i != ';') {
myungetch(i);
return (NULL); /* not a mouse report after all */
}
/* Grab the Y position (in pixels) */
while(isdigit(i = getch())) {
y = (y*10) + (i - '0');
}
if(i != ';') {
myungetch(i);
return(NULL);
}
/* Grab the Y position (in pixels) */
while(isdigit(i = getch())) {
y = (y * 10) + (i - '0');
}
if(i != ';') {
myungetch(i);
return (NULL);
}
/* Get which button */
if((button = getch()) > '4') {
myungetch(button);
return(NULL);
}
if((i = getch()) != ';') {
myungetch(i);
return(NULL);
}
/* Get which button */
if((button = getch()) > '4') {
myungetch(button);
return (NULL);
}
if((i = getch()) != ';') {
myungetch(i);
return (NULL);
}
/* Get the reason for this mouse report */
if((reason = getch()) > '8') {
myungetch(reason);
return(NULL);
}
/* Get the reason for this mouse report */
if((reason = getch()) > '8') {
myungetch(reason);
return (NULL);
}
/* sequence should terminate with an 'M' */
if((i = getch()) != 'M') {
myungetch(i);
return(NULL);
}
/* sequence should terminate with an 'M' */
if((i = getch()) != 'M') {
myungetch(i);
return (NULL);
}
/* OK. We get a mouse report whenever a button is depressed
* or released. Let's ignore the report whenever the button
* is depressed until when I am ready to implement sweeping.
*/
if(reason != '2') {
return(NULL); /* '2' means button is released */
}
/* OK. We get a mouse report whenever a button is depressed
* or released. Let's ignore the report whenever the button
* is depressed until when I am ready to implement sweeping.
*/
if(reason != '2') { return (NULL); /* '2' means button is released */ }
/************************************************************
* Always indicate button 1 irregardless of which button was
* really pushed.
************************************************************/
m.button = 1;
/************************************************************
* Always indicate button 1 irregardless of which button was
* really pushed.
************************************************************/
m.button = 1;
/************************************************************
* Convert pixel coordinates to line and column coords.
* The height and width are obtained using an ioctl() call
* in mouseinit(). This assumes that variable width chars
* are not being used ('though it would probably work anyway).
************************************************************/
/************************************************************
* Convert pixel coordinates to line and column coords.
* The height and width are obtained using an ioctl() call
* in mouseinit(). This assumes that variable width chars
* are not being used ('though it would probably work anyway).
************************************************************/
m.x1 = x/uw_hs; /* pixel/horizontal_spacing */
m.y1 = y/uw_vs; /* pixel/vertical_spacing */
m.x1 = x / uw_hs; /* pixel/horizontal_spacing */
m.y1 = y / uw_vs; /* pixel/vertical_spacing */
/* "null" out the other fields */
m.percent = m.x2 = m.y2 = -1;
}
else
#endif /* not UNIXPC */
/* "null" out the other fields */
m.percent = m.x2 = m.y2 = -1;
} else
#endif /* not UNIXPC */
if (mouse == true && leading_char == ctrl('X')) {
if(mouse == true && leading_char == ctrl('X')) {
switch (getch()) {
case ctrl('_'): /* click */
if ((m.button = getch()) == '0') { /* if scrollbar */
m.percent = getpercent();
}
else {
m.x1 = getcoordinate();
m.y1 = getcoordinate();
m.x2 = m.y2 = -1;
}
break;
switch(getch()) {
case ctrl('_'): /* click */
if((m.button = getch()) == '0') { /* if scrollbar */
m.percent = getpercent();
} else {
m.x1 = getcoordinate();
m.y1 = getcoordinate();
m.x2 = m.y2 = -1;
}
break;
case ctrl(']'): /* sweep */
m.button = getch();
m.x1 = getcoordinate();
m.y1 = getcoordinate();
m.x2 = getcoordinate();
m.y2 = getcoordinate();
break;
default:
return(NULL);
}
}
else return(NULL);
case ctrl(']'): /* sweep */
m.button = getch();
m.x1 = getcoordinate();
m.y1 = getcoordinate();
m.x2 = getcoordinate();
m.y2 = getcoordinate();
break;
default:
return (NULL);
}
} else
return (NULL);
return(&m);
return (&m);
}
/* get a row or column coordinate from a mouse button click or sweep */
static int
getcoordinate(void)
{
int c, next;
static int getcoordinate(void) {
int c, next;
c = getch();
next = 0;
if (c == ctrl('A')) {
next = 95;
c = getch();
}
if (c < ' ') {
return (0);
}
return (next + c - ' ');
c = getch();
next = 0;
if(c == ctrl('A')) {
next = 95;
c = getch();
}
if(c < ' ') { return (0); }
return (next + c - ' ');
}
/* get a percentage */
static int
getpercent(void)
{
int c;
static int getpercent(void) {
int c;
c = getch();
if (c < 16) {
return(0);
}
if (c > 120) {
return(100);
}
return(c - 16);
c = getch();
if(c < 16) { return (0); }
if(c > 120) { return (100); }
return (c - 16);
}
int process_mouse(){
int i;
MOUSE* p;
if ((p = getmouseaction(DUMMYCHAR)) == NULL) {
return(false); /* unknown control sequence */
}
/* if the button number is a scrollbar tag */
if (p->button == '0') {
//scrollbar(p); // XXX
return(false);
}
/* ignore a sweep */
if (p->x2 >= 0) {
return(false);
}
/* if this is a line selection */
if (p->y1 > FLDLINE) {
int process_mouse() {
int i;
MOUSE *p;
if((p = getmouseaction(DUMMYCHAR)) == NULL) {
return (false); /* unknown control sequence */
}
/* if the button number is a scrollbar tag */
if(p->button == '0') {
// scrollbar(p); // XXX
return (false);
}
/* ignore a sweep */
if(p->x2 >= 0) { return (false); }
/* if this is a line selection */
if(p->y1 > FLDLINE) {
/* find the selected line */
/* note: the selection is forced into range */
for (i = disprefs - 1; i > 0; --i) {
if (p->y1 >= displine[i]) {
return(false);
}
}
/* display it in the file with the editor */
editref(i);
} else { /* this is an input field selection */
field = p->y1 - FLDLINE;
/* force it into range */
if (field >= FIELDS) {
field = FIELDS - 1;
}
resetcmd();
return(false);
}
/* find the selected line */
/* note: the selection is forced into range */
for(i = disprefs - 1; i > 0; --i) {
if(p->y1 >= displine[i]) { return (false); }
}
/* display it in the file with the editor */
editref(i);
} else { /* this is an input field selection */
field = p->y1 - FLDLINE;
/* force it into range */
if(field >= FIELDS) { field = FIELDS - 1; }
resetcmd();
return (false);
}
return false;
}

14
src/mygetenv.c
View File

@ -36,14 +36,10 @@
/* return the non-null environment value or the default argument */
char *
mygetenv(char *variable, char *deflt)
{
char *value;
char *mygetenv(char *variable, char *deflt) {
char *value;
value = getenv(variable);
if (value == NULL || *value == '\0') {
return(deflt);
}
return(value);
value = getenv(variable);
if(value == NULL || *value == '\0') { return (deflt); }
return (value);
}

188
src/mypopen.c
View File

@ -35,11 +35,11 @@
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include "global.h" /* pid_t, shell, and basename() */
#include "global.h" /* pid_t, shell, and basename() */
#define tst(a,b) (*mode == 'r'? (b) : (a))
#define RDR 0
#define WTR 1
#define tst(a, b) (*mode == 'r' ? (b) : (a))
#define RDR 0
#define WTR 1
/* HBB 20010312: make this a bit safer --- don't blindly assume it's 1 */
#ifdef FD_CLOEXEC
@ -49,132 +49,112 @@
#endif
#ifdef HAVE_IO_H
# include <io.h> /* for setmode() */
# include <io.h> /* for setmode() */
#endif
static pid_t popen_pid[20];
static void (*tstat)(int);
int
myopen(char *path, int flag, int mode)
{
/* opens a file descriptor and then sets close-on-exec for the file */
int fd;
int myopen(char *path, int flag, int mode) {
/* opens a file descriptor and then sets close-on-exec for the file */
int fd;
/* If file is not explicitly in Binary mode, make
* sure we override silly Cygwin behaviour of automatic binary
* mode for files in "binary mounted" paths */
/* If file is not explicitly in Binary mode, make
* sure we override silly Cygwin behaviour of automatic binary
* mode for files in "binary mounted" paths */
#if O_BINARY != O_TEXT
if (! (flag | O_BINARY))
flag |= O_TEXT;
if(!(flag | O_BINARY)) flag |= O_TEXT;
#endif
if(mode)
fd = open(path, flag, mode);
else
fd = open(path, flag);
if(mode)
fd = open(path, flag, mode);
else
fd = open(path, flag);
if(fd != -1 && (fcntl(fd, F_SETFD, CLOSE_ON_EXEC) != -1))
return(fd);
if(fd != -1 && (fcntl(fd, F_SETFD, CLOSE_ON_EXEC) != -1))
return (fd);
else
{
/* Ensure that if the fcntl fails and fd is valid, then
the file is closed properly. In general this should
not happen. */
if (fd != -1)
{
close (fd);
}
else {
/* Ensure that if the fcntl fails and fd is valid, then
the file is closed properly. In general this should
not happen. */
if(fd != -1) { close(fd); }
return(-1);
}
return (-1);
}
}
FILE *
myfopen(char *path, char *mode)
{
/* opens a file pointer and then sets close-on-exec for the file */
FILE *fp;
FILE *myfopen(char *path, char *mode) {
/* opens a file pointer and then sets close-on-exec for the file */
FILE *fp;
fp = fopen(path, mode);
fp = fopen(path, mode);
#ifdef SETMODE
if (fp && ! strchr(mode, 'b')) {
SETMODE(fileno(fp), O_TEXT);
}
if(fp && !strchr(mode, 'b')) { SETMODE(fileno(fp), O_TEXT); }
#endif /* SETMODE */
if(fp && (fcntl(fileno(fp), F_SETFD, CLOSE_ON_EXEC) != -1))
return(fp);
if(fp && (fcntl(fileno(fp), F_SETFD, CLOSE_ON_EXEC) != -1))
return (fp);
else {
if (fp)
fclose(fp);
return(NULL);
}
else {
if(fp) fclose(fp);
return (NULL);
}
}
FILE *
mypopen(char *cmd, char *mode)
{
int p[2];
pid_t *poptr;
int myside, yourside;
pid_t pid;
FILE *mypopen(char *cmd, char *mode) {
int p[2];
pid_t *poptr;
int myside, yourside;
pid_t pid;
if(pipe(p) < 0)
return(NULL);
myside = tst(p[WTR], p[RDR]);
yourside = tst(p[RDR], p[WTR]);
if((pid = fork()) == 0) {
/* myside and yourside reverse roles in child */
int stdio;
if(pipe(p) < 0) return (NULL);
myside = tst(p[WTR], p[RDR]);
yourside = tst(p[RDR], p[WTR]);
if((pid = fork()) == 0) {
/* myside and yourside reverse roles in child */
int stdio;
/* close all pipes from other popen's */
for (poptr = popen_pid; poptr < popen_pid+20; poptr++) {
if(*poptr)
(void) close(poptr - popen_pid);
}
stdio = tst(0, 1);
close(myside);
close(stdio);
fcntl(yourside, F_DUPFD, stdio);
close(yourside);
execlp(shell, basename(shell), "-c", cmd, (void *)0);
_exit(1);
} else if (pid > 0)
tstat = signal(SIGTSTP, SIG_DFL);
if(pid == -1)
return(NULL);
popen_pid[myside] = pid;
(void) close(yourside);
return(fdopen(myside, mode));
/* close all pipes from other popen's */
for(poptr = popen_pid; poptr < popen_pid + 20; poptr++) {
if(*poptr) (void)close(poptr - popen_pid);
}
stdio = tst(0, 1);
close(myside);
close(stdio);
fcntl(yourside, F_DUPFD, stdio);
close(yourside);
execlp(shell, basename(shell), "-c", cmd, (void *)0);
_exit(1);
} else if(pid > 0)
tstat = signal(SIGTSTP, SIG_DFL);
if(pid == -1) return (NULL);
popen_pid[myside] = pid;
(void)close(yourside);
return (fdopen(myside, mode));
}
/* HBB 20010705: renamed from 'pclose', which would collide with
* system-supplied function of same name */
int
mypclose(FILE *ptr)
{
int f;
pid_t r;
int status = -1;
sighandler_t hstat, istat, qstat;
int mypclose(FILE *ptr) {
int f;
pid_t r;
int status = -1;
sighandler_t hstat, istat, qstat;
f = fileno(ptr);
(void) fclose(ptr);
istat = signal(SIGINT, SIG_IGN);
qstat = signal(SIGQUIT, SIG_IGN);
hstat = signal(SIGHUP, SIG_IGN);
while((r = wait(&status)) != popen_pid[f] && r != -1)
; /* nothing */
if(r == -1)
status = -1;
(void) signal(SIGINT, istat);
(void) signal(SIGQUIT, qstat);
(void) signal(SIGHUP, hstat);
(void) signal(SIGTSTP, tstat);
/* mark this pipe closed */
popen_pid[f] = 0;
return(status);
f = fileno(ptr);
(void)fclose(ptr);
istat = signal(SIGINT, SIG_IGN);
qstat = signal(SIGQUIT, SIG_IGN);
hstat = signal(SIGHUP, SIG_IGN);
while((r = wait(&status)) != popen_pid[f] && r != -1)
; /* nothing */
if(r == -1) status = -1;
(void)signal(SIGINT, istat);
(void)signal(SIGQUIT, qstat);
(void)signal(SIGHUP, hstat);
(void)signal(SIGTSTP, tstat);
/* mark this pipe closed */
popen_pid[f] = 0;
return (status);
}

286
src/opt.c
View File

@ -2,157 +2,159 @@
#include "build.h"
#include "vp.h"
#include "version.h" /* FILEVERSION and FIXVERSION */
#include "version.h" /* FILEVERSION and FIXVERSION */
#include <stdlib.h> /* atoi */
#include <stdlib.h> /* atoi */
#include <getopt.h>
bool remove_symfile_onexit = false;
bool onesearch; /* one search only in line mode */
char *reflines; /* symbol reference lines file */
bool remove_symfile_onexit = false;
bool onesearch; /* one search only in line mode */
char *reflines; /* symbol reference lines file */
char ** parse_options(int *argc, char **argv)
{
int opt;
int longind;
char path[PATHLEN + 1]; /* file path */
char *s;
int argcc = *argc;
char **parse_options(int *argc, char **argv) {
int opt;
int longind;
char path[PATHLEN + 1]; /* file path */
char *s;
int argcc = *argc;
struct option lopts[] = {
{"help", 0, NULL, 'h'},
{"version", 0, NULL, 'V'},
{0, 0, 0, 0}
};
struct option lopts[] = {
{"help", 0, NULL, 'h'},
{"version", 0, NULL, 'V'},
{0, 0, 0, 0 }
};
while ((opt = getopt_long(argcc, argv,
"hVbcCdeF:f:I:i:kLl0:1:2:3:4:5:6:7:8:9:P:p:qRs:TUuvX",
lopts, &longind)) != -1) {
switch(opt) {
while((opt = getopt_long(argcc,
argv,
"hVbcCdeF:f:I:i:kLl0:1:2:3:4:5:6:7:8:9:P:p:qRs:TUuvX",
lopts,
&longind)) != -1) {
switch(opt) {
case '?':
usage();
myexit(1);
break;
case 'X':
remove_symfile_onexit = true;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
/* The input fields numbers for line mode operation */
field = opt - '0';
if (strlen(optarg) > PATHLEN) {
postfatal("\
case '?':
usage();
myexit(1);
break;
case 'X':
remove_symfile_onexit = true;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
/* The input fields numbers for line mode operation */
field = opt - '0';
if(strlen(optarg) > PATHLEN) {
postfatal("\
cscope: pattern too long, cannot be > \
%d characters\n", PATLEN);
}
strcpy(input_line, optarg);
break;
case 'b': /* only build the cross-reference */
buildonly = true;
linemode = true;
break;
case 'c': /* ASCII characters only in crossref */
compress = false;
break;
case 'C': /* turn on caseless mode for symbol searches */
caseless = true;
egrepcaseless(caseless); /* simulate egrep -i flag */
break;
case 'd': /* consider crossref up-to-date */
isuptodate = true;
break;
case 'e': /* suppress ^E prompt between files */
editallprompt = false;
break;
case 'h':
longusage();
myexit(1);
break;
case 'k': /* ignore DFLT_INCDIR */
kernelmode = true;
break;
case 'L':
onesearch = true;
/* FALLTHROUGH */
case 'l':
linemode = true;
break;
case 'v':
verbosemode = true;
break;
case 'V':
fprintf(stderr, PROGRAM_NAME ": version %d%s\n",
FILEVERSION, FIXVERSION);
myexit(0);
break;
case 'q': /* quick search */
invertedindex = true;
break;
case 'T': /* truncate symbols to 8 characters */
trun_syms = true;
break;
case 'u': /* unconditionally build the cross-reference */
unconditional = true;
break;
case 'U': /* assume some files have changed */
fileschanged = true;
break;
case 'R':
recurse_dir = true;
break;
case 'f': /* alternate cross-reference file */
reffile = optarg;
if (strlen(reffile) > sizeof(path) - 3) {
postfatal("\
%d characters\n",
PATLEN);
}
strcpy(input_line, optarg);
break;
case 'b': /* only build the cross-reference */
buildonly = true;
linemode = true;
break;
case 'c': /* ASCII characters only in crossref */
compress = false;
break;
case 'C': /* turn on caseless mode for symbol searches */
caseless = true;
egrepcaseless(caseless); /* simulate egrep -i flag */
break;
case 'd': /* consider crossref up-to-date */
isuptodate = true;
break;
case 'e': /* suppress ^E prompt between files */
editallprompt = false;
break;
case 'h':
longusage();
myexit(1);
break;
case 'k': /* ignore DFLT_INCDIR */
kernelmode = true;
break;
case 'L':
onesearch = true;
/* FALLTHROUGH */
case 'l':
linemode = true;
break;
case 'v':
verbosemode = true;
break;
case 'V':
fprintf(stderr, PROGRAM_NAME ": version %d%s\n", FILEVERSION, FIXVERSION);
myexit(0);
break;
case 'q': /* quick search */
invertedindex = true;
break;
case 'T': /* truncate symbols to 8 characters */
trun_syms = true;
break;
case 'u': /* unconditionally build the cross-reference */
unconditional = true;
break;
case 'U': /* assume some files have changed */
fileschanged = true;
break;
case 'R':
recurse_dir = true;
break;
case 'f': /* alternate cross-reference file */
reffile = optarg;
if(strlen(reffile) > sizeof(path) - 3) {
postfatal("\
cscope: reffile too long, cannot \
be > %d characters\n", sizeof(path) - 3);
/* NOTREACHED */
}
strcpy(path, reffile);
be > %d characters\n",
sizeof(path) - 3);
/* NOTREACHED */
}
strcpy(path, reffile);
s = path + strlen(path);
strcpy(s, ".in");
/*coverity[overwrite_var]*/
invname = strdup(path);
strcpy(s, ".po");
/*coverity[overwrite_var]*/
invpost = strdup(path);
break;
s = path + strlen(path);
strcpy(s, ".in");
/*coverity[overwrite_var]*/
invname = strdup(path);
strcpy(s, ".po");
/*coverity[overwrite_var]*/
invpost = strdup(path);
break;
case 'F': /* symbol reference lines file */
reflines = optarg;
break;
case 'i': /* file containing file names */
namefile = optarg;
break;
case 'I': /* #include file directory */
includedir(optarg);
break;
case 'p': /* file path components to display */
dispcomponents = atoi(optarg);
break;
case 'P': /* prepend path to file names */
prependpath = optarg;
break;
case 's': /* additional source file directory */
sourcedir(optarg);
break;
}
}
/*
* This adjusts argv so that we only see the remaining
* args. Its ugly, but we need to do it so that the rest
* of the main routine doesn't get all confused
*/
*argc = *argc - optind;
return argv + optind;
case 'F': /* symbol reference lines file */
reflines = optarg;
break;
case 'i': /* file containing file names */
namefile = optarg;
break;
case 'I': /* #include file directory */
includedir(optarg);
break;
case 'p': /* file path components to display */
dispcomponents = atoi(optarg);
break;
case 'P': /* prepend path to file names */
prependpath = optarg;
break;
case 's': /* additional source file directory */
sourcedir(optarg);
break;
}
}
/*
* This adjusts argv so that we only see the remaining
* args. Its ugly, but we need to do it so that the rest
* of the main routine doesn't get all confused
*/
*argc = *argc - optind;
return argv + optind;
}

273
src/path.c
View File

@ -34,37 +34,28 @@
#include "global.h"
const char *
basename(const char *path)
{
const char *s;
const char *basename(const char *path) {
const char *s;
if ((s = strrchr(path, '/')) != 0) {
return(s + 1);
}
return(path);
if((s = strrchr(path, '/')) != 0) { return (s + 1); }
return (path);
}
/* get the requested path components */
char *
pathcomponents(char *path, int components)
{
int i;
char *s;
char *pathcomponents(char *path, int components) {
int i;
char *s;
s = path + strlen(path) - 1;
for (i = 0; i < components; ++i) {
while (s > path && *--s != '/') {
;
}
}
if (s > path && *s == '/') {
++s;
}
return(s);
s = path + strlen(path) - 1;
for(i = 0; i < components; ++i) {
while(s > path && *--s != '/') {
;
}
}
if(s > path && *s == '/') { ++s; }
return (s);
}
/*
* compath(pathname)
*
@ -79,162 +70,150 @@ pathcomponents(char *path, int components)
* and stored in global structures.
*/
char *
compath(char *pathname) /*FDEF*/
char *compath(char *pathname) /*FDEF*/
{
char *nextchar;
char *lastchar;
char *sofar;
char *pnend;
char *nextchar;
char *lastchar;
char *sofar;
char *pnend;
int pnlen;
int pnlen;
/*
* do not change the path if it has no "/"
*/
/*
* do not change the path if it has no "/"
*/
if (strchr(pathname, '/') == NULL)
return(pathname);
if(strchr(pathname, '/') == NULL) return (pathname);
/*
* find all strings consisting of more than one '/'
*/
/*
* find all strings consisting of more than one '/'
*/
for (lastchar = pathname + 1; *lastchar != '\0'; lastchar++)
if ((*lastchar == '/') && (*(lastchar - 1) == '/'))
{
for(lastchar = pathname + 1; *lastchar != '\0'; lastchar++)
if((*lastchar == '/') && (*(lastchar - 1) == '/')) {
/*
* find the character after the last slash
*/
/*
* find the character after the last slash
*/
nextchar = lastchar;
while (*++lastchar == '/')
{
}
nextchar = lastchar;
while(*++lastchar == '/') { }
/*
* eliminate the extra slashes by copying
* everything after the slashes over the slashes
*/
/*
* eliminate the extra slashes by copying
* everything after the slashes over the slashes
*/
sofar = nextchar;
while ((*nextchar++ = *lastchar++) != '\0')
;
lastchar = sofar;
}
sofar = nextchar;
while((*nextchar++ = *lastchar++) != '\0')
;
lastchar = sofar;
}
/*
* find all strings of "./"
*/
/*
* find all strings of "./"
*/
for (lastchar = pathname + 1; *lastchar != '\0'; lastchar++)
if ((*lastchar == '/') && (*(lastchar - 1) == '.') &&
((lastchar - 1 == pathname) || (*(lastchar - 2) == '/')))
{
for(lastchar = pathname + 1; *lastchar != '\0'; lastchar++)
if((*lastchar == '/') && (*(lastchar - 1) == '.') &&
((lastchar - 1 == pathname) || (*(lastchar - 2) == '/'))) {
/*
* copy everything after the "./" over the "./"
*/
/*
* copy everything after the "./" over the "./"
*/
nextchar = lastchar - 1;
sofar = nextchar;
while ((*nextchar++ = *++lastchar) != '\0')
;
lastchar = sofar;
}
nextchar = lastchar - 1;
sofar = nextchar;
while((*nextchar++ = *++lastchar) != '\0')
;
lastchar = sofar;
}
/*
* find each occurrence of "/.."
*/
/*
* find each occurrence of "/.."
*/
for (lastchar = pathname + 1; *lastchar != '\0'; lastchar++)
if ((lastchar != pathname) && (*lastchar == '/') &&
(*(lastchar + 1) == '.') && (*(lastchar + 2) == '.') &&
((*(lastchar + 3) == '/') || (*(lastchar + 3) == '\0')))
{
for(lastchar = pathname + 1; *lastchar != '\0'; lastchar++)
if((lastchar != pathname) && (*lastchar == '/') && (*(lastchar + 1) == '.') &&
(*(lastchar + 2) == '.') &&
((*(lastchar + 3) == '/') || (*(lastchar + 3) == '\0'))) {
/*
* find the directory name preceding the "/.."
*/
/*
* find the directory name preceding the "/.."
*/
nextchar = lastchar - 1;
while ((nextchar != pathname) &&
(*(nextchar - 1) != '/'))
--nextchar;
nextchar = lastchar - 1;
while((nextchar != pathname) && (*(nextchar - 1) != '/'))
--nextchar;
/*
* make sure the preceding directory's name
* is not "." or ".."
*/
/*
* make sure the preceding directory's name
* is not "." or ".."
*/
if ((*nextchar == '.') &&
((*(nextchar + 1) == '/') ||
((*(nextchar + 1) == '.') && (*(nextchar + 2) == '/'))))
/* EMPTY */;
else
{
if((*nextchar == '.') &&
((*(nextchar + 1) == '/') ||
((*(nextchar + 1) == '.') && (*(nextchar + 2) == '/'))))
/* EMPTY */;
else {
/*
* prepare to eliminate either
* "dir_name/../" or "dir_name/.."
*/
/*
* prepare to eliminate either
* "dir_name/../" or "dir_name/.."
*/
if (*(lastchar + 3) == '/')
lastchar += 4;
else
lastchar += 3;
if(*(lastchar + 3) == '/')
lastchar += 4;
else
lastchar += 3;
/*
* copy everything after the "/.." to
* before the preceding directory name
*/
/*
* copy everything after the "/.." to
* before the preceding directory name
*/
sofar = nextchar - 1;
while ((*nextchar++ = *lastchar++) != '\0');
sofar = nextchar - 1;
while((*nextchar++ = *lastchar++) != '\0')
;
lastchar = sofar;
lastchar = sofar;
/*
* if the character before what was taken
* out is '/', set up to check if the
* slash is part of "/.."
*/
/*
* if the character before what was taken
* out is '/', set up to check if the
* slash is part of "/.."
*/
if ((sofar + 1 != pathname) && (*sofar == '/'))
--lastchar;
}
}
if((sofar + 1 != pathname) && (*sofar == '/')) --lastchar;
}
}
/*
* if the string is more than a character long and ends
* in '/', eliminate the '/'.
*/
/*
* if the string is more than a character long and ends
* in '/', eliminate the '/'.
*/
pnlen = strlen(pathname);
pnend = strchr(pathname, '\0') - 1;
pnlen = strlen(pathname);
pnend = strchr(pathname, '\0') - 1;
if ((pnlen > 1) && (*pnend == '/'))
{
*pnend-- = '\0';
pnlen--;
}
if((pnlen > 1) && (*pnend == '/')) {
*pnend-- = '\0';
pnlen--;
}
/*
* if the string has more than two characters and ends in
* "/.", remove the "/.".
*/
/*
* if the string has more than two characters and ends in
* "/.", remove the "/.".
*/
if ((pnlen > 2) && (*(pnend - 1) == '/') && (*pnend == '.'))
*--pnend = '\0';
if((pnlen > 2) && (*(pnend - 1) == '/') && (*pnend == '.')) *--pnend = '\0';
/*
* if all characters were deleted, return ".";
* otherwise return pathname
*/
/*
* if all characters were deleted, return ".";
* otherwise return pathname
*/
if (*pathname == '\0')
(void) strcpy(pathname, ".");
if(*pathname == '\0') (void)strcpy(pathname, ".");
return(pathname);
return (pathname);
}

141
src/readline.c
View File

@ -4,121 +4,122 @@
#include "build.h"
#include <ncurses.h>
static int input_available = 0;
static int input_available = 0;
static char input_char;
char input_line[PATLEN + 1];
char input_line[PATLEN + 1];
bool interpret(int c){
input_char = c;
input_available = 1;
rl_callback_read_char();
bool interpret(int c) {
input_char = c;
input_available = 1;
rl_callback_read_char();
return 0;
return 0;
}
static int getc_function(FILE* ignore){
static int getc_function(FILE *ignore) {
UNUSED(ignore);
input_available = 0;
return (int)input_char;
input_available = 0;
return (int)input_char;
}
static int input_available_hook(){
return input_available;
static int input_available_hook() {
return input_available;
}
static void redisplay_function(){
window_change |= CH_INPUT;
static void redisplay_function() {
window_change |= CH_INPUT;
}
static void callback_handler(char* line){
if(!line){ return; }
static void callback_handler(char *line) {
if(!line) { return; }
switch(input_mode){
switch(input_mode) {
case INPUT_NORMAL:
strncpy(input_line, line, PATLEN);
strncpy(input_line, line, PATLEN);
search(input_line);
curdispline = 0;
PCS_reset();
current_page = 0;
break;
case INPUT_CHANGE_TO:
strncpy(newpat, line, PATLEN);
change = calloc(totallines, sizeof(*change));
strncpy(newpat, line, PATLEN);
change = calloc(totallines, sizeof(*change));
input_mode = INPUT_CHANGE;
horswp_field();
return;
}
switch(field){
switch(field) {
case CHANGE:
input_mode = INPUT_CHANGE_TO;
break;
case DEFINITION:
case FILENAME:
if(totallines == 1){ editref(0); }
if(totallines == 1) { editref(0); }
break;
}
}
static int ctrl_z(){
kill(0, SIGTSTP);
static int ctrl_z() {
kill(0, SIGTSTP);
return 0;
}
static int toggle_caseless(){
if (caseless == false) {
caseless = true;
postmsg2("Caseless mode is now ON");
} else {
caseless = false;
postmsg2("Caseless mode is now OFF");
}
egrepcaseless(caseless); /* turn on/off -i flag */
static int toggle_caseless() {
if(caseless == false) {
caseless = true;
postmsg2("Caseless mode is now ON");
} else {
caseless = false;
postmsg2("Caseless mode is now OFF");
}
egrepcaseless(caseless); /* turn on/off -i flag */
return 0;
}
static int rebuild_reference(){
if (isuptodate == true) {
postmsg("The -d option prevents rebuilding the symbol database");
return(false);
}
exitcurses();
freefilelist(); /* remake the source file list */
makefilelist();
rebuild();
if (errorsfound == true) {
errorsfound = false;
askforreturn();
}
entercurses();
postmsg(""); /* clear any previous message */
totallines = 0;
disprefs = 0;
return(true);
static int rebuild_reference() {
if(isuptodate == true) {
postmsg("The -d option prevents rebuilding the symbol database");
return (false);
}
exitcurses();
freefilelist(); /* remake the source file list */
makefilelist();
rebuild();
if(errorsfound == true) {
errorsfound = false;
askforreturn();
}
entercurses();
postmsg(""); /* clear any previous message */
totallines = 0;
disprefs = 0;
return (true);
}
void rlinit(){
rl_catch_signals = 0;
rl_catch_sigwinch = 0;
rl_prep_term_function = NULL;
rl_deprep_term_function = NULL;
rl_change_environment = 0;
void rlinit() {
rl_catch_signals = 0;
rl_catch_sigwinch = 0;
rl_prep_term_function = NULL;
rl_deprep_term_function = NULL;
rl_change_environment = 0;
rl_getc_function = getc_function;
rl_input_available_hook = input_available_hook;
rl_redisplay_function = redisplay_function;
rl_callback_handler_install("", callback_handler);
rl_getc_function = getc_function;
rl_input_available_hook = input_available_hook;
rl_redisplay_function = redisplay_function;
rl_callback_handler_install("", callback_handler);
rl_bind_key(7, rl_rubout); // XXX: 7 is backspace for some reason (on my system anyways?)
rl_bind_key(KEY_BACKSPACE, rl_rubout);
rl_bind_key(7,
rl_rubout); // XXX: 7 is backspace for some reason (on my system anyways?)
rl_bind_key(KEY_BACKSPACE, rl_rubout);
rl_bind_key(EOF, myexit);
rl_bind_key(ctrl('Z'), ctrl_z);
rl_bind_key(ctrl('Z'), toggle_caseless);
rl_bind_key(ctrl('R'), rebuild_reference);
rl_bind_key(ESC, process_mouse); /* possible unixpc mouse selection */
rl_bind_key(ctrl('X'), process_mouse); /* mouse selection */
rl_bind_key(EOF, myexit);
rl_bind_key(ctrl('Z'), ctrl_z);
rl_bind_key(ctrl('Z'), toggle_caseless);
rl_bind_key(ctrl('R'), rebuild_reference);
rl_bind_key(ESC, process_mouse); /* possible unixpc mouse selection */
rl_bind_key(ctrl('X'), process_mouse); /* mouse selection */
//rl_bind_key(ctrl('\\'), /**/); /* bypass bindings */
// rl_bind_key(ctrl('\\'), /**/); /* bypass bindings */
}

77
src/refsfound.c
View File

@ -4,15 +4,15 @@
struct FILE;
/* Page cursor stack */
static FILE** hto_page = &refsfound;
static FILE **hto_page = &refsfound;
#define PCS_MAXPAGE 16
static size_t PCS_pos[PCS_MAXPAGE] = {0};
static size_t PCS_top = 0;
static size_t PCS_top = 0;
long seekpage(const size_t i){
if(i > PCS_MAXPAGE-1){ return -1; }
long seekpage(const size_t i) {
if(i > PCS_MAXPAGE - 1) { return -1; }
if(i < PCS_top){
if(i < PCS_top) {
fseek(*hto_page, PCS_pos[i], SEEK_SET);
return PCS_pos[i];
}
@ -20,62 +20,59 @@ long seekpage(const size_t i){
fseek(*hto_page, PCS_pos[PCS_top], SEEK_SET);
size_t lc = 0;
while(PCS_top < i){
while(PCS_top < i) {
const char c = getc(*hto_page);
if(c == '\n'){ ++lc; }
if(c == EOF){ return -1; }
if(lc == mdisprefs){
PCS_pos[++PCS_top] = ftell(*hto_page);
}
if(c == '\n') { ++lc; }
if(c == EOF) { return -1; }
if(lc == mdisprefs) { PCS_pos[++PCS_top] = ftell(*hto_page); }
}
return PCS_pos[PCS_top];
}
long seekrelline(unsigned i){
long seekrelline(unsigned i) {
seekpage(current_page);
size_t lc = 0;
while(lc < i){
while(lc < i) {
const char c = getc(*hto_page);
assert("seekrelline() tried to read past the reference file" && !(c == EOF));
if(c == '\n'){ ++lc; }
if(c == '\n') { ++lc; }
}
return ftell(*hto_page);
}
void PCS_reset(void){
void PCS_reset(void) {
PCS_top = 0;
}
///* position references found file at specified line */
//void
//seekline(unsigned int line)
// void
// seekline(unsigned int line)
//{
// /* verify that there is a references found file */
// if (refsfound == NULL) {
// return;
// }
// /* go to the beginning of the file */
// rewind(refsfound);
// /* verify that there is a references found file */
// if (refsfound == NULL) {
// return;
// }
// /* go to the beginning of the file */
// rewind(refsfound);
// /**/
// seekrelline(line);
//}
// }
//
///* XXX: this is just dodging the problem */
//void
//seekrelline(unsigned int line){
// int c;
// void
// seekrelline(unsigned int line){
// int c;
//
// /* verify that there is a references found file */
// if (refsfound == NULL) {
// return;
// }
// /* verify that there is a references found file */
// if (refsfound == NULL) {
// return;
// }
//
// /* find the requested line */
// nextline = 1;
// while (nextline < line && (c = getc(refsfound)) != EOF) {
// if (c == '\n') {
// nextline++;
// }
// }
//}
// /* find the requested line */
// nextline = 1;
// while (nextline < line && (c = getc(refsfound)) != EOF) {
// if (c == '\n') {
// nextline++;
// }
// }
// }

72
src/scanner.h
View File

@ -35,60 +35,60 @@
#include <stdio.h>
#undef YYLMAX
#define YYLMAX STMTMAX + PATLEN + 1 /* scanner line buffer size */
#undef YYLMAX
#define YYLMAX STMTMAX + PATLEN + 1 /* scanner line buffer size */
/* cross-reference database mark characters (when new ones are added,
* update the cscope.out format description in cscope.1)
*/
#define CLASSDEF 'c'
#define DEFINE '#'
#define DEFINEEND ')'
#define ENUMDEF 'e'
#define FCNCALL '`'
#define FCNDEF '$'
#define FCNEND '}'
#define GLOBALDEF 'g'
#define INCLUDE '~'
#define MEMBERDEF 'm'
#define NEWFILE '@'
#define STRUCTDEF 's'
#define TYPEDEF 't'
#define UNIONDEF 'u'
#define CLASSDEF 'c'
#define DEFINE '#'
#define DEFINEEND ')'
#define ENUMDEF 'e'
#define FCNCALL '`'
#define FCNDEF '$'
#define FCNEND '}'
#define GLOBALDEF 'g'
#define INCLUDE '~'
#define MEMBERDEF 'm'
#define NEWFILE '@'
#define STRUCTDEF 's'
#define TYPEDEF 't'
#define UNIONDEF 'u'
/* other scanner token types */
#define LEXEOF 0
#define LEXERR 1
#define IDENT 2
#define NEWLINE 3
#define LEXEOF 0
#define LEXERR 1
#define IDENT 2
#define NEWLINE 3
/* scanner.l global data */
extern int first; /* buffer index for first char of symbol */
extern int last; /* buffer index for last char of symbol */
extern int lineno; /* symbol line number */
extern FILE *yyin; /* input file descriptor */
extern FILE *yyout; /* output file */
extern int myylineno; /* input line number */
extern int first; /* buffer index for first char of symbol */
extern int last; /* buffer index for last char of symbol */
extern int lineno; /* symbol line number */
extern FILE *yyin; /* input file descriptor */
extern FILE *yyout; /* output file */
extern int myylineno; /* input line number */
#ifdef USING_LEX
/* HBB 20010430: if lex is used instead of flex, have to simulate the
* private copies of yytext and yytext for the world outside scanner.l: */
/* FIXME: there should be a feature test for this! */
#if defined(__OSF1__) || defined(__sun) || defined(_AIX)
extern char yytext[];
#else
extern unsigned char yytext[];
#endif
extern int yyleng;
# if defined(__OSF1__) || defined(__sun) || defined(_AIX)
extern char yytext[];
# else
extern unsigned char yytext[];
# endif
extern int yyleng;
# define my_yytext yytext
# define my_yyleng yyleng
#else
extern char *my_yytext; /* private copy of input line */
extern size_t my_yyleng; /* ... and current length of it */
extern char *my_yytext; /* private copy of input line */
extern size_t my_yyleng; /* ... and current length of it */
#endif
/* The master function exported by scanner.l */
int yylex(void);
void initscanner(char *srcfile);
int yylex(void);
void initscanner(char *srcfile);
#endif /* CSCOPE_SCANNER_H ends */

6
src/version.h
View File

@ -39,7 +39,7 @@
#ifndef CSCOPE_VERSION_H
#define CSCOPE_VERSION_H
#define FILEVERSION 15 /* Initial Open Source and Linux Port */
#define FIXVERSION ".9" /* feature and bug fix version */
#define FILEVERSION 15 /* Initial Open Source and Linux Port */
#define FIXVERSION ".9" /* feature and bug fix version */
#endif /* CSCOPE_VERSION_H */
#endif /* CSCOPE_VERSION_H */

22
src/vp.h
View File

@ -40,31 +40,31 @@
#ifndef CSCOPE_VP_H
#define CSCOPE_VP_H
#define MAXPATH 200 /* max length for entire name */
#define MAXPATH 200 /* max length for entire name */
#ifdef HAVE_CONFIG_H
# include "config.h"
#else
# define HAVE_FCNTL_H 1 /* in case of doubt, assume it's there */
# define HAVE_FCNTL_H 1 /* in case of doubt, assume it's there */
#endif
#ifdef HAVE_FCNTL_H
# include <fcntl.h> /* needed for O_... open flags */
# include <fcntl.h> /* needed for O_... open flags */
#endif
#include <sys/types.h>
#include <sys/stat.h>
#if !falseMALLOC
extern char **vpdirs; /* directories (including current) in view path */
extern char **vpdirs; /* directories (including current) in view path */
#else
#define MAXDIR 25 /* same as libVP */
#define DIRLEN 80 /* same as libVP */
extern char vpdirs[MAXDIR][DIRLEN + 1];
# define MAXDIR 25 /* same as libVP */
# define DIRLEN 80 /* same as libVP */
extern char vpdirs[MAXDIR][DIRLEN + 1];
#endif
extern int vpndirs; /* number of directories in view path */
extern int vpndirs; /* number of directories in view path */
void vpinit(char *current_dir);
int vpopen(char *path, int oflag);
int vpaccess(char *path, mode_t amode);
void vpinit(char *current_dir);
int vpopen(char *path, int oflag);
int vpaccess(char *path, mode_t amode);
#endif /* CSCOPE_VP_H */

28
src/vpaccess.c
View File

@ -37,21 +37,17 @@
#include "vp.h"
#include <sys/types.h>
int
vpaccess(char *path, mode_t amode)
{
char buf[MAXPATH + 1];
int returncode;
int i;
int vpaccess(char *path, mode_t amode) {
char buf[MAXPATH + 1];
int returncode;
int i;
if ((returncode = access(path, amode)) == -1 && path[0] != '/') {
vpinit(NULL);
for (i = 1; i < vpndirs; i++) {
(void) snprintf(buf, sizeof(buf), "%s/%s", vpdirs[i], path);
if ((returncode = access(buf, amode)) != -1) {
break;
}
}
}
return(returncode);
if((returncode = access(path, amode)) == -1 && path[0] != '/') {
vpinit(NULL);
for(i = 1; i < vpndirs; i++) {
(void)snprintf(buf, sizeof(buf), "%s/%s", vpdirs[i], path);
if((returncode = access(buf, amode)) != -1) { break; }
}
}
return (returncode);
}

36
src/vpfopen.c
View File

@ -37,26 +37,20 @@
#include "vp.h"
#include "global.h"
FILE *
vpfopen(char *filename, char *type)
{
char buf[MAXPATH + 1];
FILE *returncode;
int i;
FILE *vpfopen(char *filename, char *type) {
char buf[MAXPATH + 1];
FILE *returncode;
int i;
if ((returncode = myfopen(filename, type)) == NULL
&& filename[0] != '/'
/* && strcmp(type, "r") == 0 */ /* HBB: this breaks if type=="rb" */
&& type[0] == 'r'
) {
vpinit(NULL);
for (i = 1; i < vpndirs; i++) {
(void) snprintf(buf, sizeof(buf), "%s/%s", vpdirs[i], filename);
if ((returncode = myfopen(buf, type)) != NULL) {
break;
}
}
}
return(returncode);
if((returncode = myfopen(filename, type)) == NULL &&
filename[0] != '/'
/* && strcmp(type, "r") == 0 */ /* HBB: this breaks if type=="rb" */
&& type[0] == 'r') {
vpinit(NULL);
for(i = 1; i < vpndirs; i++) {
(void)snprintf(buf, sizeof(buf), "%s/%s", vpdirs[i], filename);
if((returncode = myfopen(buf, type)) != NULL) { break; }
}
}
return (returncode);
}

208
src/vpinit.c
View File

@ -32,7 +32,7 @@
/* vpinit - initialize vpdirs or update vpdirs based on currentdir */
#include <stdio.h> /* stderr */
#include <stdio.h> /* stderr */
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
@ -43,127 +43,119 @@
#include "constants.h"
#if !falseMALLOC
char **vpdirs; /* directories (including current) in view path */
char **vpdirs; /* directories (including current) in view path */
#else
char vpdirs[MAXDIR][DIRLEN + 1];
#define MAXVPATH (MAXDIR * (DIRLEN + 1))
char vpdirs[MAXDIR][DIRLEN + 1];
# define MAXVPATH (MAXDIR * (DIRLEN + 1))
#endif
int vpndirs; /* number of directories in view path */
int vpndirs; /* number of directories in view path */
void
vpinit(char *current_dir)
{
char *suffix; /* path from view path node */
char *vpath; /* VPATH environment variable value */
char buf[MAXPATH + 1];
int i;
char *s;
void vpinit(char *current_dir) {
char *suffix; /* path from view path node */
char *vpath; /* VPATH environment variable value */
char buf[MAXPATH + 1];
int i;
char *s;
#if falseMALLOC
char *node; /* view path node */
char vpathbuf[MAXVPATH + 1];
char *node; /* view path node */
char vpathbuf[MAXVPATH + 1];
#endif
/* if an existing directory list is to be updated, free it */
if (current_dir != NULL && vpndirs > 0) {
/* if an existing directory list is to be updated, free it */
if(current_dir != NULL && vpndirs > 0) {
#if !falseMALLOC
for (i = 0; i < vpndirs; ++i) {
free(vpdirs[i]);
}
free(vpdirs);
for(i = 0; i < vpndirs; ++i) {
free(vpdirs[i]);
}
free(vpdirs);
#endif
vpndirs = 0;
}
/* return if the directory list has been computed */
/* or there isn't a view path environment variable */
if (vpndirs > 0 || (vpath = getenv("VPATH")) == NULL ||
*vpath == '\0') {
return;
}
/* if not given, get the current directory name */
if (current_dir == NULL && (current_dir = getcwd(buf, MAXPATH)) == NULL) {
fprintf(stderr, PROGRAM_NAME ": cannot get current directory name\n");
return;
}
/* see if this directory is in the first view path node */
for (i = 0; vpath[i] == current_dir[i] && vpath[i] != '\0'; ++i) {
;
}
if ((vpath[i] != ':' && vpath[i] != '\0') ||
(current_dir[i] != '/' && current_dir[i] != '\0')) {
return;
}
suffix = &current_dir[i];
vpndirs = 0;
}
/* return if the directory list has been computed */
/* or there isn't a view path environment variable */
if(vpndirs > 0 || (vpath = getenv("VPATH")) == NULL || *vpath == '\0') { return; }
/* if not given, get the current directory name */
if(current_dir == NULL && (current_dir = getcwd(buf, MAXPATH)) == NULL) {
fprintf(stderr, PROGRAM_NAME ": cannot get current directory name\n");
return;
}
/* see if this directory is in the first view path node */
for(i = 0; vpath[i] == current_dir[i] && vpath[i] != '\0'; ++i) {
;
}
if((vpath[i] != ':' && vpath[i] != '\0') ||
(current_dir[i] != '/' && current_dir[i] != '\0')) {
return;
}
suffix = &current_dir[i];
#if !falseMALLOC
/* count the nodes in the view path */
vpndirs = 1;
for (i = 0; vpath[i] != '\0'; ++i) {
if (vpath[i] == ':' && vpath[i + 1]) {
++vpndirs;
}
}
/* create the source directory list */
vpdirs = malloc(vpndirs * sizeof(*vpdirs));
/* count the nodes in the view path */
vpndirs = 1;
for(i = 0; vpath[i] != '\0'; ++i) {
if(vpath[i] == ':' && vpath[i + 1]) { ++vpndirs; }
}
/* create the source directory list */
vpdirs = malloc(vpndirs * sizeof(*vpdirs));
/* don't change VPATH in the environment */
vpath = strdup(vpath);
/* don't change VPATH in the environment */
vpath = strdup(vpath);
/* split the view path into nodes */
for (i = 0, s = vpath; *s != '\0'; ++i) {
vpdirs[i] = s;
while (*s != '\0' && *++s != ':') {
if (*s == '\n') {
*s = '\0';
}
}
if (*s != '\0') {
*s++ = '\0';
}
}
/* convert the view path nodes to directories */
for (i = 0; i < vpndirs; ++i) {
s = malloc(strlen(vpdirs[i]) + strlen(suffix) + 1);
(void) strcpy(s, vpdirs[i]);
(void) strcat(s, suffix);
vpdirs[i] = s;
}
free(vpath);
/* split the view path into nodes */
for(i = 0, s = vpath; *s != '\0'; ++i) {
vpdirs[i] = s;
while(*s != '\0' && *++s != ':') {
if(*s == '\n') { *s = '\0'; }
}
if(*s != '\0') { *s++ = '\0'; }
}
/* convert the view path nodes to directories */
for(i = 0; i < vpndirs; ++i) {
s = malloc(strlen(vpdirs[i]) + strlen(suffix) + 1);
(void)strcpy(s, vpdirs[i]);
(void)strcat(s, suffix);
vpdirs[i] = s;
}
free(vpath);
#else
/* don't change VPATH in the environment */
if (strlen(vpath) > MAXVPATH) {
(void) fprintf(stderr, "%s: VPATH is longer than %d characters: %s\n", argv0, MAXVPATH, vpath);
return;
}
(void) strcpy(vpathbuf, vpath);
s = vpathbuf;
/* don't change VPATH in the environment */
if(strlen(vpath) > MAXVPATH) {
(void)fprintf(stderr,
"%s: VPATH is longer than %d characters: %s\n",
argv0,
MAXVPATH,
vpath);
return;
}
(void)strcpy(vpathbuf, vpath);
s = vpathbuf;
/* convert the view path nodes to directories */
while (*s != '\0') {
/* convert the view path nodes to directories */
while(*s != '\0') {
/* get the next node */
node = s;
while (*s != '\0' && *++s != ':') {
if (*s == '\n') {
*s = '\0';
}
}
if (*s != '\0') {
*s++ = '\0';
}
/* ignore a directory that is too long */
if (strlen(node) + strlen(suffix) > DIRLEN) {
(void) fprintf(stderr, "%s: VPATH directory is longer than %d characters: %s%s\n", argv0, DIRLEN, node, suffix);
}
else if (vpndirs >= MAXDIR) {
(void) fprintf(stderr, "%s: VPATH has more than %d nodes\n", argv0, vpndirs);
return;
}
else {
/* create the view path directory */
(void) strcpy(vpdirs[vpndirs], node);
(void) strcat(vpdirs[vpndirs], suffix);
++vpndirs;
}
}
/* get the next node */
node = s;
while(*s != '\0' && *++s != ':') {
if(*s == '\n') { *s = '\0'; }
}
if(*s != '\0') { *s++ = '\0'; }
/* ignore a directory that is too long */
if(strlen(node) + strlen(suffix) > DIRLEN) {
(void)fprintf(stderr,
"%s: VPATH directory is longer than %d characters: %s%s\n",
argv0,
DIRLEN,
node,
suffix);
} else if(vpndirs >= MAXDIR) {
(void)fprintf(stderr, "%s: VPATH has more than %d nodes\n", argv0, vpndirs);
return;
} else {
/* create the view path directory */
(void)strcpy(vpdirs[vpndirs], node);
(void)strcat(vpdirs[vpndirs], suffix);
++vpndirs;
}
}
#endif
}

32
src/vpopen.c
View File

@ -37,24 +37,20 @@
#include "global.h"
#include "vp.h"
#define OPENFLAG_READ 0
#define OPENFLAG_READ 0
int
vpopen(char *path, int oflag)
{
char buf[MAXPATH + 1];
int returncode;
int i;
int vpopen(char *path, int oflag) {
char buf[MAXPATH + 1];
int returncode;
int i;
if ((returncode = myopen(path, oflag, 0666)) == -1 && path[0] != '/' &&
oflag == OPENFLAG_READ) {
vpinit(NULL);
for (i = 1; i < vpndirs; i++) {
(void) snprintf(buf, sizeof(buf), "%s/%s", vpdirs[i], path);
if ((returncode = myopen(buf, oflag, 0666)) != -1) {
break;
}
}
}
return(returncode);
if((returncode = myopen(path, oflag, 0666)) == -1 && path[0] != '/' &&
oflag == OPENFLAG_READ) {
vpinit(NULL);
for(i = 1; i < vpndirs; i++) {
(void)snprintf(buf, sizeof(buf), "%s/%s", vpdirs[i], path);
if((returncode = myopen(buf, oflag, 0666)) != -1) { break; }
}
}
return (returncode);
}