First cut at fixing fc_sort.
This commit is contained in:
Karl MacMillan
parent
2224ed3aa5
commit
6847e8295c
@ -1,5 +1,9 @@
|
||||
/* Copyright 2005, Tresys Technology */
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
typedef unsigned char bool_t;
|
||||
|
||||
/* file_context_node
|
||||
* A node used in a linked list of file contexts.
|
||||
* Each node contains the regular expression, the type and
|
||||
@ -9,18 +13,22 @@
|
||||
* function after the regular expression has been loaded.
|
||||
* next points to the next node in the linked list.
|
||||
*/
|
||||
struct file_context_node {
|
||||
typedef struct file_context_node {
|
||||
char *regex;
|
||||
char* type;
|
||||
char *file_type;
|
||||
char *context;
|
||||
int meta;
|
||||
bool_t meta;
|
||||
int stem_len;
|
||||
int str_len;
|
||||
|
||||
struct file_context_node *next;
|
||||
};
|
||||
|
||||
} file_context_node_t;
|
||||
|
||||
void file_context_node_destroy(file_context_node_t *x)
|
||||
{
|
||||
free(x->regex);
|
||||
free(x->file_type);
|
||||
free(x->context);
|
||||
}
|
||||
|
||||
/* file_context_bucket
|
||||
* A node used in a linked list of buckets that contain
|
||||
@ -30,11 +38,10 @@ struct file_context_node {
|
||||
* content of this bucket.
|
||||
* next points to the next bucket in the linked list.
|
||||
*/
|
||||
struct file_context_bucket {
|
||||
struct file_context_node* data;
|
||||
|
||||
typedef struct file_context_bucket {
|
||||
file_context_node_t *data;
|
||||
struct file_context_bucket *next;
|
||||
};
|
||||
} file_context_bucket_t;
|
||||
|
||||
|
||||
|
||||
@ -44,20 +51,21 @@ struct file_context_bucket {
|
||||
* Pass two lists a and b, and after the completion of fc_merge,
|
||||
* the final list is contained in a, and b is empty.
|
||||
*/
|
||||
struct file_context_node* fc_merge( struct file_context_node* a, struct file_context_node* b )
|
||||
file_context_node_t *fc_merge(file_context_node_t *a,
|
||||
file_context_node_t *b)
|
||||
{
|
||||
struct file_context_node* a_current;
|
||||
struct file_context_node* b_current;
|
||||
struct file_context_node* temp;
|
||||
struct file_context_node* jumpto;
|
||||
file_context_node_t *a_current;
|
||||
file_context_node_t *b_current;
|
||||
file_context_node_t *temp;
|
||||
file_context_node_t *jumpto;
|
||||
|
||||
/* If a is a empty list, and b is not,
|
||||
* set a as b and proceed to the end. */
|
||||
if (!a && b)
|
||||
a = b;
|
||||
/* If b is an empty list, leave a as it is. */
|
||||
else if( !b ) { }
|
||||
else {
|
||||
else if (!b) {
|
||||
} else {
|
||||
/* Make it so the list a has the lesser
|
||||
* first element always. */
|
||||
if (fc_compare(a, b) == 1) {
|
||||
@ -75,7 +83,9 @@ struct file_context_node* fc_merge( struct file_context_node* a, struct file_con
|
||||
/* Insert b's nodes inbetween the current a node
|
||||
* and the next a node.*/
|
||||
while (b_current && a_current->next &&
|
||||
fc_compare( a_current->next, b_current) != -1 ) { temp = a_current->next;
|
||||
fc_compare(a_current->next,
|
||||
b_current) != -1) {
|
||||
temp = a_current->next;
|
||||
a_current->next = b_current;
|
||||
b_current = b_current->next;
|
||||
a_current->next->next = temp;
|
||||
@ -119,15 +129,15 @@ struct file_context_node* fc_merge( struct file_context_node* a, struct file_con
|
||||
* until there is only one bucket left, containing the list of
|
||||
* file contexts, sorted.
|
||||
*/
|
||||
void fc_merge_sort( struct file_context_bucket* master )
|
||||
void fc_merge_sort(file_context_bucket_t *master)
|
||||
{
|
||||
int i;
|
||||
|
||||
struct file_context_bucket* current;
|
||||
struct file_context_bucket* temp;
|
||||
file_context_bucket_t *current;
|
||||
file_context_bucket_t *temp;
|
||||
|
||||
struct file_context_node* ncurrent;
|
||||
struct file_context_node* ntemp;
|
||||
file_context_node_t *ncurrent;
|
||||
file_context_node_t *ntemp;
|
||||
|
||||
/* Loop until master is the only bucket left
|
||||
* so that this will stop when master contains
|
||||
@ -139,7 +149,9 @@ void fc_merge_sort( struct file_context_bucket* master )
|
||||
while (current) {
|
||||
if (current->next) {
|
||||
/* Merge the next one into the current one. */
|
||||
current->data = fc_merge( current->data, current->next->data );
|
||||
current->data =
|
||||
fc_merge(current->data,
|
||||
current->next->data);
|
||||
/* remove the next bucket that is now empty. */
|
||||
temp = current->next;
|
||||
current->next = current->next->next;
|
||||
@ -166,7 +178,7 @@ void fc_merge_sort( struct file_context_bucket* master )
|
||||
* If a does not have a specified type and b does not,
|
||||
* -> a is less specific than b.
|
||||
*/
|
||||
int fc_compare( struct file_context_node* a, struct file_context_node* b )
|
||||
int fc_compare(file_context_node_t *a, file_context_node_t *b)
|
||||
{
|
||||
/* Check to see if either a or b have meta characters
|
||||
* and the other doesn't. */
|
||||
@ -216,7 +228,7 @@ int fc_compare( struct file_context_node* a, struct file_context_node* b )
|
||||
* fc_node->stem_len = The number of characters up until
|
||||
* the first meta character.
|
||||
*/
|
||||
void fc_fill_data( struct file_context_node* fc_node )
|
||||
void fc_fill_data(file_context_node_t *fc_node)
|
||||
{
|
||||
int c = 0;
|
||||
|
||||
@ -252,7 +264,8 @@ void fc_fill_data( struct file_context_node* fc_node )
|
||||
default:
|
||||
/* If no meta character has been found yet,
|
||||
* add one to the stem length. */
|
||||
if( !fc_node->meta ) fc_node->stem_len++;
|
||||
if (!fc_node->meta)
|
||||
fc_node->stem_len++;
|
||||
break;
|
||||
}
|
||||
|
||||
@ -269,92 +282,105 @@ void fc_fill_data( struct file_context_node* fc_node )
|
||||
*/
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int i, j, lines;
|
||||
int start, finish;
|
||||
char* str;
|
||||
struct file_context_node* temp;
|
||||
struct file_context_node* head;
|
||||
struct file_context_node* current;
|
||||
struct file_context_node* array;
|
||||
struct file_context_bucket* master;
|
||||
struct file_context_bucket* bcurrent;
|
||||
int lines;
|
||||
size_t start, finish, regex_len;
|
||||
size_t line_len, i, j;
|
||||
char *str, *input_name, *output_name, *line_buf;
|
||||
|
||||
FILE *path;
|
||||
char line_buf[ 127 ];
|
||||
file_context_node_t *temp;
|
||||
file_context_node_t *head;
|
||||
file_context_node_t *current;
|
||||
file_context_node_t *array;
|
||||
file_context_bucket_t *master;
|
||||
file_context_bucket_t *bcurrent;
|
||||
|
||||
FILE *in_file, *out_file;
|
||||
|
||||
/* Check for the correct number of command line arguments. */
|
||||
if (argc != 3) {
|
||||
printf( "Error: invalid number of command line arguments.\n" );
|
||||
return -1;
|
||||
fprintf(stderr, "Error: invalid number of command line arguments.\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
input_name = argv[1];
|
||||
output_name = argv[2];
|
||||
|
||||
i = j = lines = 0;
|
||||
|
||||
/* Allocate the head of the file_context linked list. */
|
||||
if( !( current = head = (struct file_context_node*)malloc( sizeof( struct file_context_node ) ) ) ) {
|
||||
printf( "Error: failure allocating memory.\n" );
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Make sure to have a terminating character, always. */
|
||||
line_buf[127] = 0;
|
||||
line_buf[BUF_SIZE - 1] = '\0';
|
||||
|
||||
/* Open the input file. */
|
||||
if( !( path = fopen( argv[1], "r" ) ) ) {
|
||||
printf( "Error: failure opening input file for read.\n" );
|
||||
return -1;
|
||||
if (!(in_file = fopen(input_name), "r")) {
|
||||
fprintf(stderr, "Error: failure opening input file for read.\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Parse the file into a file_context linked list. */
|
||||
while( fgets( line_buf, 126, path ) != NULL ) {
|
||||
|
||||
buf = NULL;
|
||||
while (getline(&line_buf, &line_len, in_file) {
|
||||
/* Get rid of whitespace from the front of the line. */
|
||||
i = 0;
|
||||
while( line_buf[i] && line_buf[i] <= ' ' ) i++;
|
||||
|
||||
/* Check if the line isn't empty and isn't a comment */
|
||||
if( line_buf[i] && line_buf[i] != '#' ) {
|
||||
/* Allocate a new node. */
|
||||
temp = (struct file_context_node*)malloc( sizeof( struct file_context_node ) );
|
||||
if( !temp ) {
|
||||
printf( "Error: failure allocating memory.\n" );
|
||||
return -1;
|
||||
for (i = 0; i < line_len; i++) {
|
||||
if (line_buf[i] != ' ' || line_buf[i] != '\t')
|
||||
break;
|
||||
}
|
||||
temp->next = NULL;
|
||||
|
||||
if (i >= line_len)
|
||||
continue;
|
||||
/* Check if the line isn't empty and isn't a comment */
|
||||
if (line_buf[i] == '#')
|
||||
continue;
|
||||
|
||||
/* We have a valid line - allocate a new node. */
|
||||
temp = (file_context_node_t *)malloc(sizeof(file_context_node_t));
|
||||
if (!temp) {
|
||||
fprintf(stderr, "Error: failure allocating memory.\n");
|
||||
return 1;
|
||||
}
|
||||
memset(temp, 0, sizeof(file_context_node_t));
|
||||
|
||||
/* Parse out the regular expression from the line. */
|
||||
start = i;
|
||||
while( line_buf[i] > ' ' )i++;
|
||||
while (i < line_len && (line_buf[i] != ' ' || line_buf[i] != '\t'))
|
||||
i++;
|
||||
finish = i;
|
||||
|
||||
/* Allocate a character array to hold the regular
|
||||
* expression. */
|
||||
temp->regex = (char*)malloc( sizeof( char ) * ( finish - start + 1) );
|
||||
if( !( temp->regex ) ) {
|
||||
printf( "Error: failure allocating memory.\n" );
|
||||
return -1;
|
||||
}
|
||||
temp->regex[0] = 0;
|
||||
regex_len = start - finish;
|
||||
|
||||
/* Fill the regular expression array. */
|
||||
temp->regex[ ( finish - start ) ] = 0;
|
||||
for( j = 0; j < finish - start; j++ ) {
|
||||
temp->regex[j] = line_buf[j + start];
|
||||
if (regex_len == 0) {
|
||||
file_context_node_destroy(temp);
|
||||
free(temp);
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Get rid of whitespace after the regular
|
||||
* expression. */
|
||||
while( line_buf[i] <= ' ' ) i++;
|
||||
temp->path = strndup(&line_buf[start], regex_len);
|
||||
if (!temp->path) {
|
||||
file_context_node_destroy(temp);
|
||||
free(temp);
|
||||
fprintf(stderr, "Memory error\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Get rid of whitespace after the regular expression. */
|
||||
for (; i < line_len; i++) {
|
||||
if (line_buf[i] != ' ' || line_buf[i] != '\t')
|
||||
break;
|
||||
}
|
||||
|
||||
if (i == line_len) {
|
||||
file_context_node_destroy(temp);
|
||||
free(temp);
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Parse out the type from the line (if it
|
||||
* is there). */
|
||||
if (line_buf[i] == '-') {
|
||||
/* Allocate a character array to
|
||||
* hold the type. */
|
||||
|
||||
temp->type = (char *)malloc(sizeof(char) * 3);
|
||||
if (!(temp->type)) {
|
||||
printf( "Error: failure allocating memory.\n" );
|
||||
return -1;
|
||||
fprintf(stderr, "Error: failure allocating memory.\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Fill the type into the array. */
|
||||
@ -364,18 +390,23 @@ int main( int argc, char *argv[])
|
||||
temp->type[2] = 0;
|
||||
|
||||
/* Get rid of whitespace after the type. */
|
||||
while( line_buf[i] <= ' ' ) i++;
|
||||
while (line_buf[i] <= ' ')
|
||||
i++;
|
||||
}
|
||||
|
||||
/* Parse out the context from the line. */
|
||||
start = i;
|
||||
while( line_buf[i] > ' ' ) i++;
|
||||
while (line_buf[i] > ' ')
|
||||
i++;
|
||||
finish = i;
|
||||
|
||||
/* Allocate a character array to hold the context. */
|
||||
temp->context = (char*)malloc( sizeof( char ) * ( finish - start + 1 ) );
|
||||
temp->context =
|
||||
(char *) malloc(sizeof(char) *
|
||||
(finish - start + 1));
|
||||
if (!(temp->context)) {
|
||||
printf( "Error: failure allocating memory.\n" );
|
||||
printf
|
||||
("Error: failure allocating memory.\n");
|
||||
return -1;
|
||||
}
|
||||
temp->context[0] = 0;
|
||||
@ -396,12 +427,14 @@ int main( int argc, char *argv[])
|
||||
current = current->next;
|
||||
lines++;
|
||||
}
|
||||
}
|
||||
free(buf);
|
||||
fclose(path);
|
||||
|
||||
/* Create the bucket linked list from the earlier linked list. */
|
||||
current = head->next;
|
||||
bcurrent = master = (struct file_context_bucket*)malloc( sizeof( struct file_context_bucket ) );
|
||||
bcurrent = master =
|
||||
(file_context_bucket_t *)
|
||||
malloc(sizeof(file_context_bucket_t));
|
||||
/* Go until all the nodes have been put in individual buckets. */
|
||||
while (current) {
|
||||
/* Copy over the file context line into the bucket. */
|
||||
@ -413,9 +446,12 @@ int main( int argc, char *argv[])
|
||||
|
||||
/* If there should be another bucket, put one at the end. */
|
||||
if (current) {
|
||||
bcurrent->next = (struct file_context_bucket*) malloc( sizeof( struct file_context_bucket ) );
|
||||
bcurrent->next =
|
||||
(file_context_bucket_t *)
|
||||
malloc(sizeof(file_context_bucket_t));
|
||||
if (!(bcurrent->next)) {
|
||||
printf( "Error: failure allocating memory.\n" );
|
||||
printf
|
||||
("Error: failure allocating memory.\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -481,4 +517,3 @@ int main( int argc, char *argv[])
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user