#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#define TRUE 1
#define FALSE 0
#define BUFF_FILE 256
#define BUFF_LINE 2048
struct NODE {
char filename[BUFF_FILE];
char lineNumber[10];
char line[BUFF_LINE];
struct NODE *next;
};
int buildList(struct NODE **listHead) {
/*
* buildList() reads input from stdin (the resulting output of a grep call)
* and generates a linked list of nodes. Each node contains the filename,
* line number, and line of text of the match that grep specified. The
* function returns a hitCount to main() so that the program knows
* whether or not the input (grep's output) was valid. The line number is
* not inserted into each node, but is available for testing purposes
* should this be necessary.
*/
char filename[BUFF_FILE];
char lineNumber[4];
char line[BUFF_LINE];
int hitCount = 0;
struct NODE *newNode = NULL;
while (fscanf(stdin, "%256[^:]:%4[^:]:%2048[^\n]\n", filename,
lineNumber, line) == 3) {
newNode = (struct NODE *) malloc(sizeof(struct NODE));
strncpy(newNode->filename, filename, BUFF_FILE);
strncpy(newNode->line, line, BUFF_LINE);
newNode->next = *listHead;
*listHead = newNode;
hitCount++;
}
return hitCount;
}
int lineHunter (struct NODE **listHead, int hitCount,
int lineNumberSwitch, int bannerSwitch) {
/*
* lineHunter() iterates through the nodes built in buildList()
* and looks for lines in the given files that match the lines presented
* in the nodes themselves. If it finds a match, it prints an '*' next
* to the line that it finds. It only opens new files (files that haven't
* been opened before) and then runs through the nodes a second time to
* find matches to the lines being printed.
*/
char filename[BUFF_FILE];
char line[BUFF_LINE];
int tagBool;
int lineCount;
struct NODE *currentNode = *listHead;
struct NODE *matchNode = NULL;
FILE *grepFile = NULL;
// If args specify banner then print it.
if (bannerSwitch) {
printf("\nTHERE ARE %d MATCHING LINES\n", hitCount);
}
// Iterate through filenames
while (currentNode->next != NULL) {
if (!(grepFile = fopen(currentNode->filename, "r"))) {
fprintf(stderr, "rgpp: error: grep filename couldn't "
"be opened -- check input.\n");
exit(1);
}
strcpy(filename, currentNode->filename);
printf("\n====================%s\n", currentNode->filename);
lineCount = 1;
// While in the same file print file contents.
while (fgets(line, BUFF_LINE, grepFile)) {
// Strip the newline off of lines pulled from file.
line[strlen(line) - 1] = '\0';
tagBool = FALSE;
matchNode = *listHead;
// Search through nodes to find match to line.
while (matchNode != NULL) {
if (strcmp(currentNode->filename, matchNode->filename) == 0
&& strcmp(currentNode->lineNumber,
matchNode->lineNumber) == 0
&& strcmp(line, matchNode->line) == 0) {
tagBool = TRUE;
}
matchNode = matchNode->next;
}
// Print tag if match was found in line.
if (tagBool) {
printf("* ");
}
else {
printf(" ");
}
// If args specify line numbering, print them.
if (lineNumberSwitch) {
printf("%4d: ", lineCount);
}
// Print the line of text.
printf("%s\n", line);
lineCount++;
}
fclose(grepFile);
// Search for next new file to open.
while (strcmp(filename, currentNode->filename) == 0
&& currentNode->next != NULL) {
currentNode = currentNode->next;
}
}
return 0;
}
int wordHunter (struct NODE **listHead, int lineNumberSwitch,
int bannerSwitch, char *word) {
/*
* wordHunter() iterates through the nodes created in buildList()
* and looks for lines in the given files that match the lines
* specified by the nodes themselves. If a match is found (aka a line
* is determined to contain matches according to grep) then the function
* goes through the line in the node looking for matching words, printing
* them in inverse video.
*/
char *matchWord[BUFF_FILE];
char filename[BUFF_FILE];
char line[BUFF_LINE];
int i;
int j;
int k;
int hitCount = 0;
int matchBool;
int lineCount;
struct NODE *currentNode = *listHead;
struct NODE *matchNode = NULL;
FILE *grepFile = NULL;
// Print out the banner based on args.
if (bannerSwitch) {
// Iterate through files to find matches for hitCount
while (currentNode != NULL) {
i = 0;
j = 0;
// This while loop checks the string character by character for
// matches to the given word.
while (currentNode->line[i] != '\0') {
if (word[j] == '\0') {
j = 0;
hitCount++;
}
else if (tolower(currentNode->line[i]) == tolower(word[j])) {
j++;
}
else {
j = 0;
}
i++;
}
currentNode = currentNode->next;
}
printf("\nTHERE ARE %d MATCHING WORDS\n", hitCount);
}
currentNode = *listHead;
// Iterate through filenames
while (currentNode->next != NULL) {
if (!(grepFile = fopen(currentNode->filename, "r"))) {
fprintf(stderr, "rgpp: error: grep filename couldn't be "
"opened -- check input\n");
exit(1);
}
strcpy(filename, currentNode->filename);
// Print out filename header.
printf("\n=====================%s\n", currentNode->filename);
lineCount = 1;
// While in the same file, print file contents
while (fgets(line, BUFF_LINE, grepFile)) {
// Strip the newline off of lines pulled from file.
line[strlen(line) - 1] = '\0';
// If the args specify line numbering, print them.
if (lineNumberSwitch) {
printf("%4d: ", lineCount);
}
// Find if line is a match in nodes.
matchNode = *listHead;
matchBool = FALSE;
while (matchNode != NULL) {
if (strcmp(line, matchNode->line) == 0) {
matchBool = TRUE;
}
matchNode = matchNode->next;
}
// If the line isn't a match then print the line
if (!matchBool) {
printf("%s", line);
}
else {
// Find and highlight the matching words in the node line.
i = 0;
j = 0;
*matchWord = "";
// This while loop checks the string character by character for
// matches to the given word. If a match is not found, the
// characters are printed to output. If a match is found, it
// is highlighted with inverse video and then printed.
while (line[i] != '\0') {
if (word[j] == '\0') {
printf("\e[7m");
for (k = i - j; k < i; k++) {
printf("%c", line[k]);
}
printf("\e[0m");
j = 0;
}
if (tolower(line[i]) == tolower(word[j])) {
j++;
}
else {
if (j != 0) {
for (k = i - j; k <= i; k++) {
printf("%c", line[k]);
}
j = 0;
}
else {
printf("%c", line[i]);
}
}
i++;
}
}
lineCount++;
printf("\n");
}
fclose(grepFile);
// Search for next file to open.
while (strcmp(filename, currentNode->filename) == 0
&& currentNode->next != NULL) {
currentNode = currentNode->next;
}
}
return 0;
}
int main(int argc, char *argv[]) {
/*
* main()'s soul purpose is to receive the command line arguments for rgpp
* and then process them and make the necessary function calls to fulfill
* the user's request. It also checks to make sure that return values are
* valid from those functions.
*/
char word[BUFF_LINE];
int i = 1;
int modeSwitch = -1;
int lineNumberSwitch = 0;
int bannerSwitch = 0;
int hitCount = 0;
struct NODE *list = NULL;
// Check for minimum number of required args.
if (strcmp(argv[1], "-l") != 0 && strcmp(argv[1], "-w") != 0) {
fprintf(stderr, "rgpp: usage: rgpp [-l | -w word] {-n} {-b}\n");
exit(1);
}
// Read args, set variables based on switches and optional word.
while(argv[i] != NULL) {
if (!strcmp(argv[i], "-l")) {
modeSwitch = 0;
}
else if (!strcmp(argv[i], "-w")) {
modeSwitch = 1;
strncpy(word, argv[i+1], BUFF_LINE);
i++;
}
else if (!strcmp(argv[i], "-b")) {
bannerSwitch = 1;
}
else if (!strcmp(argv[i], "-n")) {
lineNumberSwitch = 1;
}
else {
fprintf(stderr, "rgpp: usage: rgpp [-l | -w word] {-n} {-b}\n");
exit(1);
}
i++;
}
// Call buildList to read input and build linked list.
hitCount = buildList(&list);
if (hitCount == 0) {
fprintf(stderr, "rgpp: error: no grep results found -- "
"check grep input\n");
exit(1);
}
if (modeSwitch) {
if (wordHunter(&list, lineNumberSwitch, bannerSwitch, word) != 0) {
fprintf(stderr, "rgpp: error: no word matches --"
" check grep input and word arg\n");
exit(1);
}
}
else {
if (lineHunter(&list, hitCount, lineNumberSwitch, bannerSwitch) != 0) {
fprintf(stderr, "rgpp: error: no line matches --"
" check grep input\n");
exit(1);
}
}
// Free allocated memory.
struct NODE *tmp;
while (list != NULL) {
tmp = list;
list = list->next;
free(tmp);
}
exit(0);
}
