统计代码行和注释行

 1   //  parse_code_comment.hpp
  2  
  3   #pragma once
  4  
  5   #include  < map >
  6   #include  < fstream >
  7   #include  < utility >
  8  
  9  
 10   namespace  Comment
 11   {
 12  
 13   //  source file Line types
 14   enum  LineType { Blank  =   0 , Code  =   1 , CComment  =   2 , CppComment  =   3 ,
 15                            CCodeComment  =   4 , CppCodeComment  =   5  };
 16  
 17   //  source file line type in string literal style
 18   static  std:: string  LineArray[CppCodeComment  +   1U ]  =
 19   {  " Blank line " ,  " Code only " ,  " C Comment " ,  " C++ Comment " ,
 20      " Code and C Comment " ,  " Code and C++ Comment "  };
 21  
 22   //  read all characters of a txt style file into buffer and figure out the number of
 23   //  code lines and the number of comment lines
 24   class  file_code_comment
 25   {
 26   public :
 27     typedef std::map < int , LineType > ::size_type size_type;
 28  
 29   public :
 30  
 31     file_code_comment( const  std:: string & );
 32  
 33      virtual   ~ file_code_comment();
 34  
 35     size_type size()  const ;
 36  
 37     std::pair < int ,  int >  code_comment()  const ;
 38  
 39      //  list line number and type
 40      const  std::map < int , LineType >&  line_types()  const ;
 41  
 42   private :
 43  
 44      //  in case of comment marks in string literals
 45     size_type skip_double_quotes( const  std:: string & ,  const  std:: string & , size_type)  const ;
 46  
 47     std::pair < LineType,  bool >  cppcode_comment( const  std:: string & , size_type, size_type)  const ;
 48  
 49     std::pair < LineType,  bool >  multicomment( const  std:: string & , size_type, size_type, size_type)  const ;
 50  
 51   //   [Blank]
 52   //   if(a == b) [Code]
 53   //    //   [CppComment]
 54   //   /*  */ [CComment]
 55   //   /*  [CComment]
 56   //   */ [CComment]
 57   //    */ [CComment]
 58   //   if(a == b) /*  */ [CCodeComment]
 59   //   if(a == b) /*  [CCodeComment]
 60   //   */ [CCodeComment]
 61   //    [CCodeComment]
 62   //  /*  */ if(a == b) [CCodeComment]
 63   //  if(a == b)  //   [CppCodeComment]
 64  
 65      //  deduce what line type is for a string literal
 66     std::pair < LineType,  bool >  line_type( const  std:: string & , size_type & )  const ;
 67  
 68      void  read_ccomment( const  std:: string & , std::ifstream & ,  int & );
 69  
 70      //  Read source and figure out code lines, blank lines, comment lines
 71      void  read_file( const  std:: string & );
 72  
 73     size_type skip_leading_space( const  std:: string & , size_type  =   0 )  const ;
 74  
 75  
 76   private :
 77  
 78      void  initialize( const  std:: string & );
 79  
 80      static   const  std:: string  cppcmt;      //  C++ comment  //
 81      static   const  std:: string  ccmt_start;  //  C comment start /*
 82      static   const  std:: string  ccmt_end;    //  C comment end */
 83  
 84     std::map < int , LineType >  m_code_comment;  //  <line number, LineType>
 85   };
 86  
 87   file_code_comment::file_code_comment( const  std:: string &  file) :
 88     m_code_comment()
 89   {
 90     initialize(file);
 91   }
 92  
 93   file_code_comment:: ~ file_code_comment() { m_code_comment.clear(); }
 94  
 95   file_code_comment::size_type file_code_comment::
 96     skip_leading_space( const  std:: string &  str, size_type idx)  const
 97   {
 98      for (; idx  <  str.size()  &&  ( '   '   ==  str[idx]  ||   ' \t '   ==  str[idx]);  ++ idx);
 99      return  idx;
100   }
101  
102   file_code_comment::size_type file_code_comment::size()  const
103   {
104      return  m_code_comment.size();
105   }
106  
107   std::pair < int ,  int >  file_code_comment::code_comment()  const
108   {
109      int  code  =   0 ;  //  the number of code lines
110      int  cmt  =   0 ;   //  the number of comment lines
111      for (std::map < int , LineType > ::const_iterator cit(m_code_comment.begin());
112         cit  !=  m_code_comment.end();  ++ cit)
113        switch (cit -> second)
114       {
115          case  Code:  ++ code;  break ;
116          case  CComment:
117          case  CppComment:  ++ cmt;  break ;
118          case  CCodeComment:
119          case  CppCodeComment:  ++ code;  ++ cmt;  break ;
120          case  Blank:
121          default :  break ;
122       }
123      return  std::make_pair(code, cmt);
124   }
125  
126   //  list line number and type
127   const  std::map < int , LineType >&  file_code_comment::line_types()  const
128   {
129      return  m_code_comment;
130   }
131  
132   //  ignore comment marks in double quotes
133   //  "/*" "*/"
134   //  "  //  "
135   file_code_comment::size_type file_code_comment::skip_double_quotes
136     ( const  std:: string &  str,  const  std:: string &  cmt, size_type idx)  const
137   {
138      for (; idx  <  str.size();  ++ idx)
139     {
140       idx  =  str.find(cmt, idx);
141        if (str.size()  <  idx)
142       {
143         idx  =  str.size();
144          break ;
145       }
146       size_type ridx  =  str.find( ' " ' , idx);
147        if (str.size()  <  ridx)
148          break ;
149       size_type lidx  =  str.rfind( ' " ' , idx);
150        if (str.size()  <  lidx)
151          break ;
152        if (lidx  <  idx  &&  idx  <  ridx)
153         idx  =  ridx;
154        else
155          break ;
156     }
157      return  idx;
158   }
159  
160   //  many C style comment blocks in one single line match?
161   std::pair < LineType,  bool >  file_code_comment::cppcode_comment( const  std:: string &  str,
162                                                                size_type lidx,
163                                                                size_type idx)  const
164   {
165      if (lidx  ==  idx)
166        return  std::make_pair(CppComment,  false );
167      else
168     {
169       idx  =  str.size();
170        if (lidx  <  str.size())
171          return  std::make_pair(CppCodeComment,  false );
172        else
173          return  std::make_pair(Code,  false );
174     }
175   }
176  
177   //  /* */ while /* */  //  /*
178   //  /* ************** */ while {} /* ** */   //   
179   //  /* ******* */
180  
181   std::pair < LineType,  bool >  file_code_comment::multicomment( const  std:: string &  str,
182                                                                                              size_type eidx,
183                                                                                              size_type ridx,
184                                                                                              size_type idx)  const
185   {
186     size_type cnts  =   0 ;
187     size_type cnte  =   0 ;
188     LineType type  =  CComment;
189      if (idx  <  ridx)
190       type  =  CCodeComment;
191      bool  code_found  =   false ;
192      while (ridx  <  eidx)
193     {
194        ++ cnts;
195       ridx  =  skip_double_quotes(str, ccmt_end, ridx  +   2U );  //  +2 skip /*
196        if (ridx  <  eidx)
197       {
198         ridx  +=   2U ;  //  +2 skip */
199         idx  =  ridx;
200          ++ cnte;
201         ridx  =  skip_double_quotes(str, ccmt_start, ridx);
202          if ( skip_leading_space(str, idx)  <  ridx)
203           code_found  =   true ;
204       }
205     }
206      if (code_found)
207       type  =  CCodeComment;
208      return  std::make_pair(type, cnte  <  cnts);
209   }
210  
211   //  deduce what line type is for a string literal
212   std::pair < LineType,  bool >  file_code_comment::line_type( const  std:: string &  str,
213                                                          size_type &  idx)  const
214   {
215     idx  =  skip_leading_space(str);
216      if (str.size()  ==  idx)
217        return  std::make_pair(Blank,  false );
218      else
219     {
220       size_type lidx  =  skip_double_quotes(str, cppcmt, idx);
221       size_type ridx  =  skip_double_quotes(str, ccmt_start, idx);
222        /*  Somettimes C comments and C++ comments (or Code) are mixed in a single line  */
223        if (lidx  <  ridx)       //  C++ comment first then CppComment or CppCodeComment
224          return  cppcode_comment(str, lidx, idx);
225        else   if (ridx  <  lidx)  //  C comment first then CComment or CCodeComment
226          return  multicomment(str, lidx, ridx, idx);
227        else   //  no comment
228          return  std::make_pair(Code,  false );
229     }
230   }
231  
232  
233   void  file_code_comment::read_ccomment( const  std:: string &  str, std::ifstream &  fin,
234                                          int &  line)
235   {
236     std:: string  tstr;
237      while (std::getline(fin, tstr))
238     {
239        ++ line;
240       size_type idx  =  skip_leading_space(tstr);
241        if (tstr.size()  ==  idx)
242       {
243         m_code_comment.insert(std::make_pair(line, Blank));
244       }
245        else
246       {
247         m_code_comment.insert(std::make_pair(line, CComment));
248          if (skip_double_quotes(tstr, ccmt_end,  0 )  <  tstr.size())  //  found */
249            break ;
250       }
251     }
252   }
253  
254   //  Read source and figure out code lines, blank lines, comment lines
255   void  file_code_comment::read_file( const  std:: string &  file)
256   {
257     std::ifstream fin(file.c_str());
258      if ( ! fin.is_open())
259     {
260       std::cerr  <<   " Failed to open file ' "   <<  file
261                  <<   " ' @ Comment::file_code_comment\n " ;
262        return ;
263     }
264     std:: string  str;
265     size_type idx  =   0 ;
266      int  line  =   0 ;
267      while (std::getline(fin, str))
268     {
269        ++ line;
270       std::pair < LineType,  bool >  tp  =  line_type(str, idx);
271       m_code_comment.insert(std::make_pair(line, tp.first));
272        switch (tp.first)
273       {
274          case  Blank:
275          case  Code:
276          case  CppComment:
277          case  CppCodeComment:  break ;
278          case  CComment:
279          case  CCodeComment:  if (tp.second)
280                                            read_ccomment(str, fin, line);
281                                           break ;
282          default :  break ;
283       }
284     }
285   }
286  
287   void  file_code_comment::initialize( const  std:: string &  file)
288   {
289     read_file(file);
290   }
291  
292   const  std:: string  file_code_comment::cppcmt( " // " );      //  C++ comment  //
293   const  std:: string  file_code_comment::ccmt_start( " /* " );  //  C comment start /*
294   const  std:: string  file_code_comment::ccmt_end( " */ " );    //  C Comment end */
295  
296   }  //  namespace Comment
297