kf.c

This is code tutorial for image processing include:histogram,sketon....

/*

HERE"S HOW TO DO IT 20 Dec 99
DEFINITIONS:
Knowledge File - the whole thing
START TO END - a record
A PARAGRAPH - an entry

while(not end of file read){
  read a record
  write a record
} the end

read a record creates a list of lines.  that allows looking
ahead to the next line to see if the entry is done.
read a record will read from <START> to <END>
create a para code will format multiple line entries
correctly

   kf Program

   Dwayne Phillips
   December 1999

   Command Line:
      pageit in-file out-file -d -p -t title

   Purpose:
      This program reads my knowledge file (ASCII with
      format commands) and outputs the text to another
      ASCII file.

   Files:
      The program uses two files: (1) the input file,
      and (2) the output file.

      Input File
         The input file is unformatted ASCII text 
         created with vi or something simple like 
         that.  The lines can be as long or short 
         as you want (so long as they fit on the 
         screen of course).  

         The formatting commands are:
         <START> start of a record
         # any line starting with a pound sign is a comment
         #
         <T> title
         <A> authors
         <SBJ> subject, may have several subject lines
         <SRC> source
         <PAGES> pp. x-y
         <PY>  publication year
         <PM>  publication month
         <R> read date
         <E> emphasize this line
         .  level of indent 
         # a period at the start shows the level 
         # of the statement
         # one period is first level, two periods 
         # is second level etc.
         # 
         # If a line does not begin with a special character, 
         # it is a continuation
         # of the previous line.
         #
         <END> 

      Output File
         The output file is paginated ASCII text.  
         Instead of ragged text, the lines all fit 
         inside a formatted line.  Each page has a 
         header and footer.  The header may have a 
         heading title, date, and page number.  
         The user chooses to have or not have these 
         via the command line.

   Revision History:
      Version 1 - March 1996
      Version 2 - December 1999

*/
/**************************************************/
/**************************************************/
/*PAGE Includes and data structures */

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>

#define L              100
#define LPP             66
#define CPL             85
#define FOOTER           5
#define LEFT_MARGIN     10 
#define RIGHT_MARGIN     5 
#define END_OF_LIST   0x00
#define SPACE          ' '
#define VERSION    "kf Version 1 - December 1999"


struct word_list_struct{
   char   word[L];
   struct word_list_struct *next_word;
};

struct line_list_struct{
   char   line[L];
   struct line_list_struct *next_line;
};


   /* Here are the functions I needed to define. */

void   add_indents(char *, int);
struct word_list_struct * convert_lines_to_words(
                          struct line_list_struct *);
int    number_of_indent_levels(char *);
void   fill_page(FILE *, int *, int *);
void   fill_string(char *, int, char);
int    lpp(int, int);
void   output_line(char *, FILE *, int *, int *, 
                   char *, int, int, int);
void   print_report_header(FILE *, int *, int *, 
                   char *, int, int);
struct word_list_struct * read_a_paragraph(FILE *,
                                           int *);
struct line_list_struct * read_the_lines(FILE *, 
                                         int *);
struct line_list_struct * read_a_record(FILE *, 
                                        int *);
void   traverse_line_list(struct line_list_struct *);
void   traverse_word_list(struct word_list_struct *);
void   write_a_paragraph(struct word_list_struct *,
                         FILE *, int *, int *, 
                         char *, int, int, int);
void   write_a_record(struct line_list_struct *,
                      FILE *, int *, int *, 
                      char *, int, int, int);

void   strip_characters(char *, char *);

/**************************************************/
/**************************************************/

main(int argc, char *argv[])
{

   char  in_file_name[L],
         out_file_name[L],
         title[L];

   FILE  *in_file, *out_file;

   int   double_space = 0,
         file_done    = 0,
         i,
         line_counter = 0,
         lines        = LPP,
         page_counter = 1,
         print_date   = 0,
         print_page   = 0,
         print_title  = 0;

   struct word_list_struct *word_list, *temp;
   struct line_list_struct *line_list;

   if(argc < 2){
   printf(
   "\n\nusage: kf in-file out-file -d -p -n # -l # -t ..."
   "\n         -d     = put the date in the header"
   "\n         -p     = put the page number in the header"
   "\n         -l #   = there are # lines per page (%d default)"
   "\n         -n #   = start numbering the pages with #"
   "\n         -ds    = double space print the output"
   "\n         -t ... = put the following title in the header",
   LPP);
   printf(
   "\n%s", VERSION);
      exit(1);
   }

   if(argc > 1){
      strcpy(in_file_name,  argv[1]);
      strcpy(out_file_name, argv[2]);
      fill_string(title, L, '\0');

      i=3;
      while(i < argc){
         if(strcmp(argv[i], "-ds") == 0)
            double_space = 1;
         if(strcmp(argv[i], "-d") == 0)
            print_date = 1;
         if(strcmp(argv[i], "-p") == 0)
            print_page = 1;
         if(strcmp(argv[i], "-l") == 0){
            i++;
            lines = atoi(argv[i]);
         }
         if(strcmp(argv[i], "-n") == 0){
            i++;
            page_counter = atoi(argv[i]);
         }
         if(strcmp(argv[i], "-t") == 0){
            i++;
            strcpy(title, " ");
            while(i < argc){
               strcat(title, argv[i]);
               strcat(title, " ");
               i++;
            }
         }
         i++;
      }  /* ends loop over i argc */
   }  /* ends if argc > 1 */

      /* Set the static variable in the lpp routine */
      /* All other calls to lpp will read this by   */
      /* Calling with lpp(0,0);                     */
   lpp(lines, 1);


   if((in_file = fopen(in_file_name, "rt")) == NULL){
      printf("\nERROR Could not open file %s",
             in_file_name);
      exit(2);
   }

   if((out_file = fopen(out_file_name, "wt")) == NULL){
      printf("\nERROR Could not open file %s",
             out_file_name);
      exit(2);
   }

   print_report_header(out_file, &line_counter, 
                       &page_counter, title, 
                       print_date, print_page);
   while(file_done == 0){
      line_list = read_a_record(in_file, &file_done);
      write_a_record(line_list, out_file,
                        &line_counter,
                        &page_counter,
                        title,
                        print_date,
                        print_page,
                        double_space);
   }  /* ends while file_done is 0 */

   /***fill_page(out_file, &line_counter, &page_counter);***/

   fclose(in_file);
   fclose(out_file);
}  /* ends main */



/**************************************************/
/**************************************************/

/* 
   struct word_list_struct * convert_lines_to_words(...

*/

       
struct word_list_struct * convert_lines_to_words(
       struct line_list_struct *line_list)
{
   char   aword[L];

   int    copying    = 1,
          first_time = 1,
          i,
          j,
          last_line  = 0,
          line_index = 0,
          reading_lines = 1;

   struct line_list_struct *this_line;

   struct word_list_struct *new_word,
                           *result,
                           *temp;

   this_line = line_list;
   line_index = 0;

   while(reading_lines){


      if(this_line->next_line == END_OF_LIST){
         last_line = 1;
/*printf("\nTHIS LINE -%s-",this_line->line);*/
      }


         /* still need to do this line of text */
      copying    = 1;
      i          = 0;
      fill_string(aword, L, '\0');

      while(copying){
         aword[i] = this_line->line[line_index];

        if(aword[i] == SPACE){
            copying  = 0;
            if(this_line->line[line_index+1] == SPACE){
               i++;
               line_index++;
               aword[i] = this_line->line[line_index];
            }  /* ends if line is SPACE */
         }  /* ends if aword is SPACE */

         else{  /* else aword not a SPACE */
            if(aword[i] == '\n'){
               aword[i] = SPACE;
               copying  = 0;
               this_line = this_line->next_line;
               line_index = -1;
               if(last_line)
                  reading_lines = 0;
            }  /* ends if aword is new line */
         }  /* ends else aword not a SPACE */

         i++;
         line_index++;

      }  /* ends while copying */
/*printf("\nA WORD is -%s-",aword);*/

      if(first_time){
         first_time = 0;
         new_word = (struct word_list_struct *) 
            calloc(1, sizeof(struct word_list_struct));
         strcpy(new_word->word, aword);
         new_word->next_word = END_OF_LIST;
         result = new_word;
         temp   = new_word;
      }  /* ends if first_time */

      else{  /* else not first_time */
         new_word = (struct word_list_struct *) 
            calloc(1, sizeof(struct word_list_struct));
         strcpy(new_word->word, aword);
         new_word->next_word = END_OF_LIST;
         temp->next_word = new_word;
         temp = new_word;
      }  /* ends else not first_time */


   }  /* ends while reading_lines */

   return(result);

}  /* ends convert_lines_to_words */



/**************************************************/
/**************************************************/

/* 
   int lpp(...

   This routine returns the number of lines per page.
   This is my first use of a static variable.  
   The first call to this routine sets the static
   result to the value given.  All other calls to 
   the routine have the set parameter equal to zero.  
   In those cases the result does not change, it 
   remains what it was in the first call, and is 
   returned as such.
*/

int lpp(int lines_per_page, int set)
{
   static int result;
   if(set)
      result = lines_per_page;
   return(result);
}  /* ends lpp */
       



/**************************************************/
/**************************************************/

/* 
   void fill_string(...
*/

void fill_string(char *string, int size, 
                 char fill_char)
{
   int i;
   for(i=0; i<size; i++)
      string[i] = fill_char;
}  /* ends fill_string */