Program 2A: Simple LOC counter

/*
*/

#ifndef SIMPLE_INPUT_PARSER_H
#define SIMPLE_INPUT_PARSER_H

#include <string>
#include <iostream>

//a standard "framework" for parsing a set of input lines
class simple_input_parser
{
  public:
    //sets input stream
  void set_input_stream (istream * new_input);
  //parse input until EOF
  void parse_until_eof (void);
  //reads single line from input, transforms it, stores it in last_line
  void read_line (void);
  //sets the last line read
  void set_last_line (const std::string & new_line);
  //last line read from input
  const std::string & last_line (void) const;
  //parses the last line read
  virtual void parse_last_line (void);
  //returns a "transformed" copy of the given line
  virtual std::string transformed_line (const std::string & line) const;
  //constructor
    simple_input_parser (void);
  //virtual destructor
    virtual ~ simple_input_parser (void);
  //resets the parser
  virtual void reset (void);

    private:
    //the input stream
    istream * m_input_stream;
  //the last line of input
    std::string m_last_line;
};

#endif

/*
*/

/*
*/

#include "simple_input_parser.h"
#ifndef CONTRACT_H
#include "contract.h"
#endif

void
simple_input_parser::set_input_stream (istream * new_input)
{
  m_input_stream = new_input;
}

void
simple_input_parser::parse_until_eof (void)
{
  REQUIRE (m_input_stream != NULL);
  while (!(m_input_stream->eof ()))
    {
      read_line ();
      parse_last_line ();
    }
}

void
simple_input_parser::read_line (void)
{
  REQUIRE (!(m_input_stream->eof ()));
  const int
    input_buffer_size = 255;
  char
    input_buffer[input_buffer_size];
  m_input_stream->getline (input_buffer, input_buffer_size);
  //for some reason, the G++ standard library needs me to do this or it
  //doesn't register the EOF condition properly.  This makes no sense
  //to me...
  char c = m_input_stream->get();
  m_input_stream->putback( c );
  std::string input_line (input_buffer);
  //no source code line should be longer than 255!
  CHECK (input_line.size () < 255);
  set_last_line (transformed_line (input_line));
}

void
simple_input_parser::set_last_line (const std::string & new_line)
{
  m_last_line = new_line;
}

const
std::string & simple_input_parser::last_line (void) const
{
  return m_last_line;
}

void
simple_input_parser::parse_last_line (void)
{
  //basic version does nothing
}

std::string simple_input_parser::transformed_line (const std::string & line) const
{
  return line;
}

simple_input_parser::simple_input_parser (void)
{
  reset ();
}

simple_input_parser::~simple_input_parser (void)
{
}

void
simple_input_parser::reset (void)
{
  m_input_stream = NULL;
  m_last_line = "";
}

/*
*/

/*
*/

#ifndef SIMPLE_LOC_COUNTER_H
#define SIMPLE_LOC_COUNTER_H

#ifndef SIMPLE_INPUT_PARSER_H
#include "simple_input_parser.h"
#endif

#include <string>
#include <vector>

//subclass of simple_input_parser that stores countable lines of code in a buffer
//and can return their count.
class simple_loc_counter:public simple_input_parser
{
  public:
    //adds last line to the buffered lines if it is countable
  void parse_last_line (void);
  //the count of LOC
  int loc_count (void) const;
  //whether last line was comment
  bool last_line_is_comment (void) const;
  //whether last line was compiler directive
  bool last_line_is_compiler_directive (void) const;
  //whether we are in a block comment
  bool is_in_block_comment (void) const;
  //whether last line was part of a begin/end pair
  bool last_line_is_begin_or_end (void) const;
  //whether the last line was countable
  bool last_line_is_countable (void) const;
  //whether the last line was empty
  bool last_line_is_empty (void) const;
  //updates the block comment count
  void update_block_comment_count (void);
  //whether the last line starts with the given string
  bool last_line_starts_with (const std::string & search_string) const;
  //whether a given string starts with a search string
  static bool string_starts_with (const std::string & given_string,
				  const std::string & search_string);

  //returns the input string stripped of leading/trailing whitespace

  
     std::string string_stripped_of_whitespace (const std::string & input_string) const;
  //returns the transformed line (here, the line stripped of whitespace)
  virtual std::string transformed_line (const std::
					string & input_string) const;

  //constructor
    simple_loc_counter (void);
  //destructor
    virtual ~ simple_loc_counter (void);
  //resets the object
  void reset (void);

  //writes the countable lines to the given output stream
  void write_countable_lines (ostream & ostr) const;

    protected:
    //the buffered countable lines
    std::vector < std::string > m_countable_lines;
  //the "block comment" nesting level
  int m_block_comment_nesting_level;
  //the beginning of a block comment
  static const std::string & block_comment_begin;
  //the end of a block comment
  static const std::string & block_comment_end;
  //the beginning of an inline comment
  static const std::string & inline_comment_begin;
  //the beginning of a compiler directive
  static const std::string & compiler_directive_begin;
  //the "begin block" string
  static const std::string & block_begin;
  //the "end block" string
  static const std::string & block_end;
  //whitespace characters
  static const std::string & whitespace_characters;
};

#endif

/*
*/

/*
*/

#include "simple_loc_counter.h"

#ifndef YAK_MIN_MAX_H
#include "yak_min_max.h"
#endif

void
simple_loc_counter::parse_last_line (void)
{
  if (last_line_is_countable ())
    {
      m_countable_lines.push_back (last_line ());
    }
}

int
simple_loc_counter::loc_count (void) const
{
  return m_countable_lines.size ();
}

bool
simple_loc_counter::last_line_is_comment (void) const
{
  bool Result = false;
  if (last_line_starts_with (block_comment_begin)
      || last_line_starts_with (inline_comment_begin)
      || is_in_block_comment ())
    {
      Result = true;
    }
  return Result;
}


bool
simple_loc_counter::last_line_is_compiler_directive (void) const
{
  bool Result = false;
  if (last_line_starts_with (compiler_directive_begin))
    {
      Result = true;
    }
  return Result;
}

bool
simple_loc_counter::is_in_block_comment (void) const
{
  bool Result = false;
  if (m_block_comment_nesting_level > 0)
    {
      Result = true;
    }
  return Result;
}

bool
simple_loc_counter::last_line_is_begin_or_end (void) const
{
  bool Result = false;
  if (last_line_starts_with (block_begin)
      || last_line_starts_with (block_end))
    {
      Result = true;
    }
  return Result;
}

bool
simple_loc_counter::last_line_is_empty (void) const
{
  return (last_line ().length () == 0);
}

bool
simple_loc_counter::last_line_is_countable (void) const
{
  bool Result = true;
  if ((last_line_is_comment ())
      || (last_line_is_begin_or_end ())
      || (last_line_is_compiler_directive ()) || (last_line_is_empty ()))
    {
      Result = false;
    }
  return Result;
}


void
simple_loc_counter::update_block_comment_count (void)
{
  //count through the string; add 1 to the block comment count if the begin
  //string is encountered, subtract one if the end string is encountered.
  for (unsigned int i = 0; i < last_line ().length (); ++i)
    {
      std::string line_remaining =
	last_line ().substr (i, last_line ().length ());
      if (string_starts_with (line_remaining, block_comment_begin))
	{
	  ++m_block_comment_nesting_level;
	}
      else if (string_starts_with (line_remaining, block_comment_end))
	{
	  --m_block_comment_nesting_level;
	}
    }
}

bool
  simple_loc_counter::
last_line_starts_with (const std::string & search_string) const
{
  return string_starts_with (last_line (), search_string);
}

bool
  simple_loc_counter::string_starts_with (const std::string & given_string,
					  const std::string & search_string)
{
  int
    substring_size =
    yak_min (given_string.length (), search_string.length ());
  std::string substring = given_string.substr (0, substring_size);
  bool Result = (substring == search_string);
  return Result;
}

std::string
  simple_loc_counter::
string_stripped_of_whitespace (const std::string & input_string) const
{
  std::string::size_type start =
    input_string.find_first_not_of (whitespace_characters);
  if (start == input_string.npos)
    {
      start = 0;
    }
  std::string::size_type end =
    input_string.find_last_not_of (whitespace_characters);
  if (end == input_string.npos)
    {
      end = 0;
    }
  std::string Result = input_string.substr (start, (end == 0) ? 0 : end + 1);
  return Result;
}

std::string
  simple_loc_counter::transformed_line (const std::string & input_string) const
{
  return string_stripped_of_whitespace (input_string);
}

simple_loc_counter::simple_loc_counter (void)
{
  reset ();
}

simple_loc_counter::~simple_loc_counter (void)
{
}

void
simple_loc_counter::reset (void)
{
  m_countable_lines.clear ();
  m_block_comment_nesting_level = 0;
}

void
simple_loc_counter::write_countable_lines (ostream & ostr) const
{
  for (std::vector < std::string >::const_iterator iter =
       m_countable_lines.begin (); iter != m_countable_lines.end (); ++iter)
    {
      ostr << *iter << "\n";
    }
}

const
  std::string & simple_loc_counter::block_comment_begin = "/*";

const
  std::string & simple_loc_counter::block_comment_end = "*/";

const
  std::string & simple_loc_counter::inline_comment_begin = "//";

const
  std::string & simple_loc_counter::compiler_directive_begin = "#";

const
  std::string & simple_loc_counter::block_begin = "{";

const
  std::string & simple_loc_counter::block_end = "}";

const
  std::string & simple_loc_counter::whitespace_characters = " \t\n\0x32";

/*
*/

/*
*/

#ifndef SIMPLE_LOC_COUNTER_H
#include "simple_loc_counter.h"
#endif

istream *
input_stream_from_args (int arg_count, const char **arg_vector)
{
  istream *Result = NULL;
  if (arg_count == 1)
    {
      Result = &cin;
    }
  else
    {
      const char *help_text = "PSP exercise 2A: Count the physical LOC from standard input\n according to the style and counting guidelines in reports \n 1A and 2A. \n \n Usage:\n \tpsp_2a \n \n"; 
      cout << help_text;
    }
  return Result;
}

int
main (int arg_count, const char **arg_vector)
{
  //get the input stream, or print the help text as appropriate
  istream *input_stream = input_stream_from_args (arg_count, arg_vector);
  if (input_stream != NULL)
    {
      simple_loc_counter counter;
      counter.set_input_stream (input_stream);
      counter.parse_until_eof ();
      //output the loc
      cout << "LOC: " << counter.loc_count () << "\n";
    }
}


/*
*/

deferred class SIMPLE_INPUT_PARSER

feature {ANY} 
   
   parse_until_eof is 
      --parses all input until an EOF is reached
      require 
         input_stream /= Void; 
      do  
         from 
         until 
            input_stream.end_of_input
         loop 
            read_line;
            if not input_stream.end_of_input then 
               parse_last_line;
            end; 
         end; 
      end -- parse_until_eof
   
   set_input(new_input_stream: INPUT_STREAM) is 
      --sets the input stream
      do  
         input_stream := new_input_stream;
      end -- set_input
   
   read_line is 
      --reads a line from standard input
      do  
         input_stream.read_line;
         last_line := transformed_line(input_stream.last_string);
      end -- read_line
   
   last_line: STRING;
   
   input_stream: INPUT_STREAM;
   
   parse_last_line is 
      
deferred
      end -- parse_last_line
   
   transformed_line(to_transform: STRING): STRING is 
      --transforms the line according to rules defined in subclasses
      do  
         Result := to_transform;
      end -- transformed_line

end -- class SIMPLE_INPUT_PARSER

class SIMPLE_LOC_COUNTER
-- counts one form of LOC in eiffel files

inherit 
   SIMPLE_INPUT_PARSER
      redefine parse_last_line, transformed_line
      end; 
   
creation {ANY} 
   make

feature {ANY} 
   
   make is 
      do  
         !!counted_lines.make(1,0);
      end -- make
   
   parse_last_line is 
      -- store countable lines in an array
      do  
         if last_line_is_countable then 
            counted_lines.add_last(last_line);
         end; 
      end -- parse_last_line
   
   counted_lines: ARRAY[STRING];
      --array containing countable lines 
   
   loc_count: INTEGER is 
      -- number of lines counted as LOC
      do  
         Result := counted_lines.count;
      end -- loc_count
   
   last_line_is_comment: BOOLEAN is 
      do  
         if last_line_starts_with(comment_begin) then 
            Result := true;
         else 
            Result := false;
         end; 
      end -- last_line_is_comment
   
   comment_begin: STRING is "--";
   
   last_line_is_compiler_directive: BOOLEAN is false;
   
   in_block_comment: BOOLEAN is false;
   
   last_line_starts_with(test_string: STRING): BOOLEAN is 
      do  
         if last_line.has_prefix(test_string) then 
            Result := true;
         else 
            Result := false;
         end; 
      end -- last_line_starts_with
   
   last_line_is_countable: BOOLEAN is 
      do  
         if last_line_is_comment or last_line_is_begin_or_end or last_line_is_empty then 
            Result := false;
         else 
            Result := true;
         end; 
      end -- last_line_is_countable
   
   last_line_is_begin_or_end: BOOLEAN is 
      do  
         if last_line_starts_with("do") or last_line_starts_with("end") then 
            Result := true;
         else 
            Result := false;
         end; 
      end -- last_line_is_begin_or_end
   
   last_line_is_empty: BOOLEAN is 
      do  
         if last_line.empty then 
            Result := true;
         else 
            Result := false;
         end; 
      end -- last_line_is_empty
   
   transformed_line(string: STRING): STRING is 
      do  
         Result := string_stripped_of_whitespace(string);
      end -- transformed_line
   
   string_stripped_of_whitespace(string: STRING): STRING is 
      do  
         Result := string.twin;
         Result.replace_all('%T',' ');
         Result.left_adjust;
         Result.right_adjust;
      end -- string_stripped_of_whitespace
   
   print_counted_lines(output: OUTPUT_STREAM) is 
      local 
         index: INTEGER;
      do  
         from 
            index := counted_lines.lower;
         until 
            not counted_lines.valid_index(index)
         loop 
            output.put_string(counted_lines.item(index));
            output.put_string("%N");
            index := index + 1;
         end; 
      end -- print_counted_lines

end -- class SIMPLE_LOC_COUNTER

class MAIN

creation {ANY} 
   make

feature {ANY} 
   
   make is 
      local 
         simple_loc_counter: SIMPLE_LOC_COUNTER;
      do  
         !!simple_loc_counter.make;
         simple_loc_counter.set_input(io);
         simple_loc_counter.parse_until_eof;
         std_output.put_string("LOC: ");
         std_output.put_integer(simple_loc_counter.loc_count);
      end -- make

end -- class MAIN