Program 3A: Class/Method 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 a block begin
  bool last_line_is_block_begin (void) const;
  //whether last line was a block end
  bool last_line_is_block_end (void) const;
  //whether last line was part of a begin/end pair
  bool last_line_is_block_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);
  //updates the block nesting level
  void update_block_nesting_level (void);
  //are we in a block?
  bool is_in_block (void) const;
  //block nesting level
  int block_nesting_level (void) const;
  //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
  virtual 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 "block" nesting level
  int m_block_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
#ifndef CONTRACT_H
#include "contract.h"
#endif

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

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_block_begin (void) const
{
  bool
    Result = false;
  if (last_line_starts_with (block_begin))
    {
      Result = true;
    }
  return Result;
}

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

bool
simple_loc_counter::last_line_is_block_begin_or_end (void) const
{
  return (last_line_is_block_begin () | last_line_is_block_end ());
}

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_block_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;
	}
    }
}

void
simple_loc_counter::update_block_nesting_level (void)
{
  if (last_line_is_block_begin ())
    {
      ++m_block_nesting_level;
    }
  else if (last_line_is_block_end ())
    {
      --m_block_nesting_level;
    }
  ENSURE (m_block_nesting_level >= 0);
}

bool simple_loc_counter::is_in_block (void) const
{
  return (m_block_nesting_level > 0);
}

int
simple_loc_counter::block_nesting_level (void) const
{
  return m_block_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 = input_string.length ();
    }
  if (end < input_string.length ())
    {
      ++end;
    }
  std::string Result = input_string.substr (start, end);
  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;
  m_block_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 = std::string( "/" ) + std::string ("*");

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

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 CLASS_METRIC_H
#define CLASS_METRIC_H

class class_metric
{
  public:
    //LOC in the class
  int loc;
  //number of features
  int feature_count;
    class_metric (void);
};

#endif


/*
*/

/*
*/

#include "class_metric.h"

class_metric::class_metric (void):
loc (0), feature_count (0)
{
}


/*
*/

/*
*/

#ifndef CLASS_BASED_LOC_COUNTER_H
#define CLASS_BASED_LOC_COUNTER_H

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

#include <map>

class class_based_loc_counter:public simple_loc_counter
{
  protected:
    //mapping of class names to metrics
  std::map < std::string, class_metric > m_class_map;
  //are we in a class declaration?
  bool m_in_class_declaration;
  //are we in a class feature implementation?
  bool m_in_class_feature;
  //name of the class we're in
    std::string m_current_class_name;
  static const std::string class_begin;
  static const std::string scope_operator;
    std::string m_previous_line;

    public:
    //adds the last line to method/class counts as appropriate
    virtual void parse_last_line (void);
    std::string class_name_from_class_begin (const std::string & str) const;
    std::string class_name_from_external_feature (const std::string & str) const;
  bool last_line_is_class_begin (void) const;
  bool last_line_is_class_end (void) const;
  bool last_line_is_feature_begin (void) const;
  bool last_line_is_feature_end (void) const;
  bool last_line_is_data_feature (void) const;
  bool last_line_declares_feature (void) const;
  bool last_line_contains_scope_operator (void) const;
  bool last_line_contains_known_class_before_scope_operator (void) const;
  void adjust_class_feature_count (const std::string & class_name,
				   int adjustment);
  void adjust_class_loc_count (const std::string & class_name,
			       int adjustment);
  bool has_entry_for_class_name (const std::string & class_name) const;
  const std::map < std::string, class_metric > &class_map (void) const;

    class_based_loc_counter (void);
  virtual void reset (void);

};

#endif


/*
*/

/*
*/

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

const
std::string class_based_loc_counter::class_begin ("class ");

const
std::string class_based_loc_counter::scope_operator ("::");

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

void
class_based_loc_counter::reset (void)
{
  simple_loc_counter::reset();
  m_class_map.clear ();
  m_in_class_declaration = false;
  m_in_class_feature = false;
  m_current_class_name = "UNSET";
  m_previous_line = "";
}

void
class_based_loc_counter::parse_last_line (void)
{
  simple_loc_counter::parse_last_line ();
  //cout << m_class_map[ "class_based_loc_counter" ].loc << ":" << m_countable_lines.size() << ":" << last_line() << "\n";
  if (last_line_is_countable ())
    {
      if (last_line_is_class_begin ())
	{
	  CHECK (m_in_class_declaration == false);
	  m_in_class_declaration = true;
	  m_current_class_name = class_name_from_class_begin (last_line ());
	}
      if (m_in_class_declaration)
	{
	  adjust_class_loc_count (m_current_class_name, 1);
	  if (last_line_declares_feature ())
	    {
	      adjust_class_feature_count (m_current_class_name, 1);
	    }
	}
      if (last_line_is_feature_begin ())
	{
	  //cout << "<<begin feature; previous line = " << m_previous_line << ">>";
	  CHECK (m_in_class_feature == false);
	  m_in_class_feature = true;
	  m_current_class_name =
	    class_name_from_external_feature (last_line ());
	  //add one for the return type declaration, as indent usu puts it on the previous line
	  if ((m_previous_line.length () > 0))
	    {
	      //cout << "*" << m_previous_line;
	      adjust_class_loc_count (m_current_class_name, 1);
	    }
	}
      if (m_in_class_feature)
	{
	  adjust_class_loc_count (m_current_class_name, 1);
	}
      if (last_line_is_data_feature ())
	{
	  adjust_class_loc_count (class_name_from_external_feature
				  (last_line ()), 1);
	  if (m_previous_line.length () > 0)
	    {
	      //cout << "&" << m_previous_line;
	      adjust_class_loc_count (m_current_class_name, 1);
	    }
	}
    }
  if (last_line_is_class_end ())
    {
      CHECK (block_nesting_level () == 0);
      CHECK (m_in_class_declaration == true);
      CHECK (m_in_class_feature == false);
      m_in_class_declaration = false;
    }
  if (last_line_is_feature_end ())
    {
      //cout << "<<end feature, nesting:" << block_nesting_level() << ">>";
      CHECK (block_nesting_level () == 0);
      CHECK (m_in_class_declaration == false);
      CHECK (m_in_class_feature == true);
      m_in_class_feature = false;
    }
  m_previous_line = last_line ();
}


std::string
  class_based_loc_counter::
class_name_from_class_begin (const std::string & str) const
{
  REQUIRE (last_line_is_class_begin ());
  std::string::size_type class_begin_position =
    last_line ().find (class_begin);
  CHECK (class_begin_position != last_line ().npos);
  std::string::size_type next_white_space_position =
    last_line ().find_first_of (whitespace_characters, class_begin_position);
  CHECK (class_begin_position != last_line ().npos);
  std::string::size_type next_word_position =
    last_line ().find_first_not_of (whitespace_characters,
				    next_white_space_position);
  CHECK (next_word_position != last_line ().npos);

  std::string whitespace_characters_and_colon = whitespace_characters;
  whitespace_characters_and_colon.append (":");

  std::string::size_type end_of_class_name_position =
    last_line ().find_first_of (whitespace_characters_and_colon,
				next_word_position);
  if (end_of_class_name_position == last_line ().npos)
    {
      end_of_class_name_position = last_line ().length ();
    }
  std::string Result =
    last_line ().substr (next_word_position,
			 end_of_class_name_position - next_word_position);
  //cout << Result;
  return Result;
}

std::string
  class_based_loc_counter::
class_name_from_external_feature (const std::string & str) const
{
  //this is used by last_line_is_feature_begin, so we can't use it here as
  //a requirement...  be cautious!

  std::string::size_type scope_operator_position = last_line ().length ();
  while (scope_operator_position != last_line ().npos)
    {
      scope_operator_position =
	last_line ().rfind (scope_operator, scope_operator_position - 1);
      if (scope_operator_position != last_line ().npos);
      {
	std::string beginning_of_string =
	  last_line ().substr (0, scope_operator_position);
	//cout << "<<" << beginning_of_string << ">>";
	std::string::size_type begin =
	  beginning_of_string.find_last_of (whitespace_characters);
	if (begin == beginning_of_string.npos)
	  {
	    begin = 0;
	  }
	else
	  {
	    begin = begin + 1;
	  }
	std::string possible_result =
	  beginning_of_string.substr (begin, scope_operator_position);
	//cout << "POSS:" << possible_result;
	if (has_entry_for_class_name (possible_result))
	  {
	    return possible_result;
	  }
      }
    }
  return "";
}

bool
class_based_loc_counter::last_line_is_class_begin (void) const
{
  bool Result = false;
  if (last_line_starts_with (class_begin))
    {
      Result = true;
    }
  return Result;
}


bool
class_based_loc_counter::last_line_is_class_end (void) const
{
  bool Result = false;
  if (last_line_is_block_end () && m_in_class_declaration)
    {
      Result = true;
    }
  return Result;
}

bool
class_based_loc_counter::last_line_contains_scope_operator (void) const
{
  return (last_line ().find (scope_operator) != last_line ().npos);
}

bool
  class_based_loc_counter::last_line_contains_known_class_before_scope_operator
  (void) const
{
  bool Result = false;
  if (last_line_contains_scope_operator ())
    {
      std::string class_name =
	class_name_from_external_feature (last_line ());
      if (has_entry_for_class_name (class_name))
	{
	  Result = true;
	}
    }
  return Result;
}

bool
class_based_loc_counter::last_line_is_feature_begin (void) const
{
  bool Result = false;
  if (last_line_contains_known_class_before_scope_operator ())
    {
      if (!last_line_is_data_feature ())
	{
	  Result = true;
	}
    }
  return Result;
}

bool
class_based_loc_counter::last_line_is_feature_end (void) const
{
  bool Result = false;
  if (last_line_is_block_end ()
      && m_in_class_feature && (block_nesting_level () == 0))
    {
      Result = true;
    }
  return Result;
}

bool
class_based_loc_counter::last_line_is_data_feature (void) const
{
  bool Result = false;
  if (last_line_contains_known_class_before_scope_operator ())
    {
      if (last_line ().find (";") != last_line ().npos)
	{
	  Result = true;
	}
    }
  return Result;
}

bool
class_based_loc_counter::last_line_declares_feature (void) const
{
  bool Result = false;
  if (m_in_class_declaration
      && (last_line ().find (";") != last_line ().npos))
    {
      Result = true;
    }
  return Result;
}

bool
  class_based_loc_counter::has_entry_for_class_name (const yak_string &
						     class_name) const
{
  bool Result = false;
  if (class_map ().find (class_name) != class_map ().end ())
    {
      Result = true;
    }
  return Result;
}

void
class_based_loc_counter::
adjust_class_feature_count (const std::string & class_name, int adjustment)
{
  if (!has_entry_for_class_name (class_name))
    {
      m_class_map[class_name] = class_metric ();
    }
  m_class_map[class_name].feature_count += adjustment;
}

void
class_based_loc_counter::
adjust_class_loc_count (const std::string & class_name, int adjustment)
{
  if (!has_entry_for_class_name (class_name))
    {
      m_class_map[class_name] = class_metric ();
    }
  m_class_map[class_name].loc += adjustment;
}

const
std::map < std::string,
  class_metric > & class_based_loc_counter::class_map (void) const
{
  return m_class_map;
}

/*
*/

/*
*/

#ifndef CLASS_BASED_LOC_COUNTER_H
#include "class_based_loc_counter.h"
#endif
#ifndef YAK_EXCEPTION_H
#include "yak_exception.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 3A: Count class and total LOC.\n Usage:\n\tpsp_3a\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)
    {
      class_based_loc_counter counter;
      try
      {
	counter.set_input_stream (input_stream);
	counter.parse_until_eof ();
	//output the counted lines
	//counter.write_countable_lines( cout );
	//output the loc
	cout << "Total LOC: " << counter.loc_count () << "\n";
	cout << "classname:feature count:LOC by class:\n";
	for (std::map < std::string, class_metric >::const_iterator iter =
	     counter.class_map ().begin ();
	     iter != counter.class_map ().end (); ++iter)
	  {
	    cout << iter->first << ":"
	      << iter->second.feature_count << ":"
	      << iter->second.loc << "\n";
	  }
      }
      catch (exception & e)
      {
	cout << "Aborted with exception: " << e.what () << "\n";
	cout << "last line parsed: \n" << counter.last_line () << "\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);
         block_nesting_level := 0;
      end -- make
   
   parse_last_line is 
      --store countable lines in an array
      do  
         update_block_nesting_level;
            --	 std_output.put_integer( block_nesting_level )
            --	 std_output.put_string( ":" + last_line + "%N" )
         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
   
   block_nesting_level: INTEGER;
      --nesting level of syntactic blocks
   
   update_block_nesting_level is 
      -- update the nesting level of syntactic blocks according to 
      -- the current line
      do  
         if last_line_is_block_begin then 
            block_nesting_level := block_nesting_level + 1;
         end; 
         if last_line_is_block_end then 
            block_nesting_level := block_nesting_level - 1;
         end; 
      ensure 
         block_nesting_level >= 0; 
      end -- update_block_nesting_level
   
   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_ends_with(test_string: STRING): BOOLEAN is 
      do  
         if last_line.has_suffix(test_string) then 
            Result := true;
         else 
            Result := false;
         end; 
      end -- last_line_ends_with
   
   last_line_is_countable: BOOLEAN is 
      do  
         if last_line_is_comment or last_line_is_block_begin_or_end or last_line_is_empty then 
            Result := false;
         else 
            Result := true;
         end; 
      end -- last_line_is_countable
   
   last_line_starts_with_any_of(strings: ARRAY[STRING]): BOOLEAN is 
      local 
         index: INTEGER;
      do  
         Result := false;
         from 
            index := strings.lower;
         until 
            index > strings.upper
         loop 
            if last_line_starts_with(strings.item(index)) then 
               Result := true;
            end; 
            index := index + 1;
         end; 
      end -- last_line_starts_with_any_of
   
   block_beginners: ARRAY[STRING] is 
      once 
         Result := <<"do","if","from","class ","redefine","check","deferred","once">>;
      end -- block_beginners
   
   last_line_is_block_begin: BOOLEAN is 
      do  
         if last_line_starts_with_any_of(block_beginners) then 
            Result := true;
         else 
            Result := false;
         end; 
      end -- last_line_is_block_begin
   
   last_line_is_block_end: BOOLEAN is 
      do  
         if last_line_starts_with("end") then 
            Result := true;
         else 
            Result := false;
         end; 
      end -- last_line_is_block_end
   
   last_line_is_block_begin_or_end: BOOLEAN is 
      do  
         if last_line_is_block_begin or last_line_is_block_end then 
            Result := true;
         else 
            Result := false;
         end; 
      end -- last_line_is_block_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 CLASS_METRIC

creation {ANY} 
   make

feature {ANY} 
   
   loc: INTEGER;
      --lines of code for this class
   
   feature_count: INTEGER;
      --number of features in this class
   
   adjust_loc(adjustment: INTEGER) is 
      --adjusts loc by given amount
      do  
         loc := loc + adjustment;
      end -- adjust_loc
   
   adjust_feature_count(adjustment: INTEGER) is 
      --adjusts feature count by given amount
      do  
         feature_count := feature_count + adjustment;
      end -- adjust_feature_count
   
   make is 
      do  
         loc := 0;
         feature_count := 0;
      end -- make

end -- CLASS_METRIC

class CLASS_BASED_LOC_COUNTER
--counts one form of LOC in eiffel files, giving a count of 
--LOC/class and number of features/class

inherit 
   SIMPLE_LOC_COUNTER
      redefine parse_last_line, make
      end; 
   
creation {ANY} 
   make

feature {ANY} 
   
   class_map: DICTIONARY[CLASS_METRIC,STRING];
   
   in_class: BOOLEAN;
   
   current_class_name: STRING;
   
   class_beginners: ARRAY[STRING] is 
      once 
         Result := <<"class ","deferred class ">>;
      end -- class_beginners
   
   last_line_is_class_begin: BOOLEAN is 
      --whether last line starts a class declaration
      do  
         if last_line_starts_with_any_of(class_beginners) then 
            Result := true;
         else 
            Result := false;
         end; 
      end -- last_line_is_class_begin
   
   last_line_is_class_end: BOOLEAN is 
      --whether last line ends class declaration
      do  
         if last_line_is_block_end and block_nesting_level = 0 then 
            Result := true;
         else 
            Result := false;
         end; 
      end -- last_line_is_class_end
   
   last_line_declares_feature: BOOLEAN is 
      --does last line begin new feature?
      do  
         Result := false;
            --	 if last_line_ends_with( "is" ) and ( block_nesting_level = 1 ) then
            --	    Result := true
            --	 else
            --	    Result :=false
            --	 end
         if in_class and block_nesting_level = 1 and not last_line_declares_feature_clause and not in_local_clause then 
            if last_line_is_countable and (last_line.has_string(" is") or last_line.has_string(":")) then 
               Result := true;
            end; 
         end; 
      end -- last_line_declares_feature
   
   last_line_declares_feature_clause: BOOLEAN is 
      do  
         if last_line_starts_with("feature ") then 
            Result := true;
         else 
            Result := false;
         end; 
      end -- last_line_declares_feature_clause
   
   feature_clause_encountered: BOOLEAN;
   
   blank_metric_entry: CLASS_METRIC is 
      once 
         !!Result.make;
      end -- blank_metric_entry
   
   ensure_class_entry(name: STRING) is 
      --ensure that class_map has an entry for name
      do  
         if not class_map.has(name) then 
            class_map.put(blank_metric_entry.twin,name);
         end; 
      end -- ensure_class_entry
   
   adjust_class_feature_count(name: STRING; adjustment: INTEGER) is 
      --adjust method count of class metric entry
      do  
         ensure_class_entry(name);
         class_map.at(name).adjust_feature_count(adjustment);
      end -- adjust_class_feature_count
   
   adjust_class_loc(name: STRING; adjustment: INTEGER) is 
      --adjust loc of class metric entry
      do  
         ensure_class_entry(name);
         class_map.at(name).adjust_loc(adjustment);
      end -- adjust_class_loc
   
   make is 
      do  
         Precursor;
         !!class_map.make;
         in_class := false;
         feature_clause_encountered := false;
         in_local_clause := false;
      end -- make
   
   adjust_in_class is 
      --adjust whether or not we're in a class
      do  
         if last_line_is_class_begin then 
            check 
               in_class = false; 
               block_nesting_level = 1; 
            end;
            in_class := true;
            current_class_name := class_name_from_last_line;
         end; 
         if last_line_is_class_end then 
            check 
               in_class = true; 
               block_nesting_level = 0; 
            end;
            in_class := false;
         end; 
      ensure 
         in_class implies block_nesting_level > 0; 
      end -- adjust_in_class
   
   class_name_from_last_line: STRING is 
      --get the class declaration from last input line
      require 
         last_line_is_class_begin; 
      local 
         split_line: ARRAY[STRING];
      do  
         split_line := last_line.split;
         Result := split_line.item(split_line.upper);
      ensure 
         Result /= Void; 
      end -- class_name_from_last_line
   
   adjust_feature_clause_encountered is 
      do  
         if in_class and last_line_declares_feature_clause then 
            feature_clause_encountered := true;
         end; 
         if not in_class then 
            feature_clause_encountered := false;
         end; 
      end -- adjust_feature_clause_encountered
   
   in_local_clause: BOOLEAN;
   
   adjust_in_local_clause is 
      do  
         if last_line_starts_with("local") then 
            in_local_clause := true;
         end; 
         if last_line_is_block_begin then 
            in_local_clause := false;
         end; 
      end -- adjust_in_local_clause
   
   parse_last_line is 
      --adjust class count after precursor
      do  
         Precursor;
         adjust_in_class;
         adjust_feature_clause_encountered;
         adjust_in_local_clause;
         if in_class and last_line_is_countable then 
            adjust_class_loc(current_class_name,1);
         end; 
         if in_class and last_line_declares_feature and feature_clause_encountered then 
            adjust_class_feature_count(current_class_name,1);
               --	    std_output.put_string( last_line + "%N" )
            
         end; 
      end -- parse_last_line

end -- class CLASS_BASED_LOC_COUNTER

class MAIN

creation {ANY} 
   make

feature {ANY} 
   
   make is 
      local 
         counter: CLASS_BASED_LOC_COUNTER;
         i: INTEGER;
      do  
         !!counter.make;
         counter.set_input(io);
         counter.parse_until_eof;
         std_output.put_string("LOC: ");
         std_output.put_integer(counter.loc_count);
         std_output.put_string("%Nname:features:loc by class%N");
         from 
            i := counter.class_map.lower
         until 
            i > counter.class_map.upper
         loop 
            std_output.put_string(counter.class_map.key(i));
            std_output.put_string(":");
            std_output.put_integer(counter.class_map.item(i).feature_count);
            std_output.put_string(":");
            std_output.put_integer(counter.class_map.item(i).loc);
            std_output.put_string("%N");
            i := i + 1
         end; 
            --	 std_output.put_string( "Block nesting level: " )
            --	 std_output.put_integer( counter.block_nesting_level )
         
      end -- make

end -- class MAIN