cstat.cpp

c c++代码行统计

#include <iostream>
#include <stdlib.h>
#include <stdio.h>

#include <windows.h>
#include "Cstat.h"

bool isDirectoryImpl(const string&_path) 
{

	DWORD attr = GetFileAttributes(_path.c_str());
	if (attr == 0xFFFFFFFF)
		cout<<"error"<<endl;
	return (attr & FILE_ATTRIBUTE_DIRECTORY) != 0;
}
bool needStat(const string&str);
bool needRRTStat(const string&str);

void getDirs2(vector<string>&v_dirs,map<string,vector<string> >&fileTree,const string &strdir=".",bool blIsRRT = false)
{
    string buf;
    int i=0;
    int j=0;
    string strTmp;
    string strdot("./");
    v_dirs.push_back(strdir);
    //string strcmd ("ls  ");
    //int size = v_dirs.size();
    cout<<"wait";
    //DIR* pDir = NULL;
    HANDLE          fh;
	WIN32_FIND_DATA fd;

    for(int k= 0;k<v_dirs.size(); ++k)    
    {
        cout<<".";
        string("").swap(buf);
        vector<string> vfs;
		string strdirt = v_dirs[k];
		strdirt.append("*");
        fileTree[v_dirs[k]] = vfs;
		fh = FindFirstFile(strdirt.c_str(), &fd);

        //pDir = opendir(v_dirs[k].c_str());
        if(fh == INVALID_HANDLE_VALUE)
        {
            cout<<"opendir error"<<endl;
            return;
        }

        do{
            strTmp = fd.cFileName;
            cout<<"("<<strTmp<<endl;
            if(strTmp == ".." || strTmp == "." )
            {
                //pEntry = readdir(pDir);
                continue;
            }
            buf = v_dirs[k]+strTmp;
            if(isDirectoryImpl(buf))
            {
                v_dirs.push_back(buf+"\\");
            }
            else
            {
                if(!blIsRRT)
                {
                    if(needStat(buf))
                    {
                        fileTree[v_dirs[k]].push_back(buf);
                    }
                }
                else
                {
                    if(needRRTStat(buf))
                    {
                        fileTree[v_dirs[k]].push_back(buf);
                    }
                }
            }
            //pEntry = readdir(pDir);

        }while(FindNextFile(fh, &fd) != 0);
        /*if (pDir) 
        {
            closedir(pDir);
        }
*/
        cout<<"v_dirs["<<k<<"]=("<<v_dirs[k]<<")"<<endl;
        
    }
    cout<<endl;


}


class Capsule;/*
			  */
class State
{

public:
    virtual DWORD transfer(Capsule&capsuleData)=0;
};
class Capsule
{
    friend class State;
protected:
    DWORD getData()
    {
        return 0;
    }
    DWORD registeState(DWORD dws,State*ps)
    {
        _stateContainer[dws] = ps;
		return dws;
    };
    
    DWORD unregisteState(DWORD dws)
    {
        if(_stateContainer.find(dws)==_stateContainer.end())
        {
            return 1;
        }
        bool blFlag = false;
        DWORD dwstmp = 0;
        if(_stateContainer.end() != _curState)
        {
            if(_curState->first == dws)
            {
                blFlag = true;
                
            }
            dwstmp = _curState->first;
        }
        delete _stateContainer[dws];
        _stateContainer.erase(dws);
        if(blFlag)
        {
            _curState = _stateContainer.end();
            return 0;
        }
        _curState = _stateContainer.find(dwstmp);
        
    }
    DWORD initial(DWORD dws)
    {
        if((_curState = _stateContainer.find(dws))==_stateContainer.end())
        {
            return 1;
        }
        return 0;
        
    }
    virtual void receive()
    {
        
    }
public:
    virtual DWORD Action()
    {
        while(1)
        {
            receive();
            schedule();
        }
    }
    DWORD schedule ()
    {
        if(_stateContainer.end() == _curState)
        {
            return 1;
        }
        
        DWORD dwStateCod = _curState->second->transfer(*this);
        if(dwStateCod == _curState->first)
        {
            return 0;
        }
        _curState = _stateContainer.find(dwStateCod);
        return 0;
    }
private:
    map<DWORD,State*>_stateContainer;
    map<DWORD,State*>::iterator _curState;
};
enum
{
    NBNC_INITIAL,
    NBNC_ANALYSE,
    NBNC_COMMENT,
    NBNC_BLANK,
    NBNC_CODE,
    NBNC_CPPCOMMENT,
    NBNC_END,
    NBNC_ENDED
};
struct CNBNCEndState:public State
{
    DWORD transfer(Capsule&capsuleData);
    
};
struct CNBNCPPCommentState:public State
{
    DWORD transfer(Capsule&capsuleData);
    
};
struct CNBNCAnalyseState:public State
{
    DWORD transfer(Capsule&capsuleData);
    
};
struct CNBNCommentState:public State
{
    DWORD transfer(Capsule&capsuleData)
    ;
};
struct CNBNCBlankState:public State
{
    DWORD transfer(Capsule&capsuleData);
    

};

struct CNBNCCodeState:public State
{
    DWORD transfer(Capsule&capsuleData);
    

};


struct CNBNCInitState:public State
{
    CNBNCInitState()
    {    }
    ~CNBNCInitState()
    {}
    DWORD transfer(Capsule&capsuleData);
    

};


class CNBNCCapsule:public Capsule
{
    public:
    CNBNCCapsule()
    {
        m_dwCounts = 0;
        m_dwBlankCounts = 0;
        m_dwCommentCounts = 0;
        m_dwcodeCounts = 0;
        registeState(NBNC_INITIAL,&m_objInitState);
        registeState(NBNC_ANALYSE,&m_objAnalyseState);
        registeState(NBNC_COMMENT,&m_objCommentState);
        registeState(NBNC_BLANK,&m_objBlankState);
        registeState(NBNC_CODE,&m_objCodeState);
        registeState(NBNC_END,&m_objEndState);
        registeState(NBNC_CPPCOMMENT,&m_objCPPCommentState);

    }
    ~CNBNCCapsule(){}
    void GetCount(DWORD &dwCounts,DWORD &dwcodeCounts,  DWORD &dwBlankCounts,    DWORD &dwCommentCounts)
    {
        dwCounts += m_dwCounts ;
        dwcodeCounts += m_dwcodeCounts;
        dwBlankCounts += m_dwBlankCounts ;
        dwCommentCounts += m_dwCommentCounts ;

    }
    static CNBNCCapsule*Instance()
    {
        static CNBNCCapsule staobj;
        return &staobj;
    }
    DWORD Action()
    {
        m_ipos = 0;
        while(0 == schedule ())
        {}
        m_dwCounts = m_dwcodeCounts+m_dwBlankCounts+m_dwCommentCounts;
        if(0 == m_dwCounts)
        {
            return 0;
        }
		/*
        cout<<m_strFName<<endl;
        double db1 = m_dwCommentCounts;
        double db2 = m_dwCounts;

        double dbper = db1/db2;
        int size = 5;
        cout<<"     sum =";
        cout.width(size);
        cout<<m_dwCounts;
        cout<<" ";
        cout<<"code =";
        cout.width(size);
        cout<<m_dwcodeCounts<<" ";
        cout<<"Comment =";
        cout.width(size);
        cout<<m_dwCommentCounts<<" ";
        cout<<"Blank =";
        cout.width(size);
        cout<<m_dwBlankCounts<<" ";
        cout<<"Comment/sum =";
        cout.width(size+5);
        cout<<dbper*100<<"%";
        if(dbper<0.2)
               cout<<"  comment is not enough!"<<endl;
        else
            cout<<endl;
		*/
        //cout<<m_strbuf<<endl;
		return 0;
    }
	//
    DWORD Init(const string&strPara)
    {
        m_strFName = strPara;
        m_dwCounts = 0;
        m_dwBlankCounts = 0;
        m_dwcodeCounts = 0;
        m_dwCommentCounts = 0;
        m_ipos = 0;
        readFile(m_strbuf);
        m_strbuf += "\n  ";
        initial(NBNC_INITIAL);
        return 0;
    }
    	//

    DWORD readFile(string&strBuf)
    {
        FILE* pf = NULL;
        pf = fopen(m_strFName.c_str(),"r");
        if(!pf)
        {
            cout<<m_strFName<<" can not open"<<endl;
    	    return 1;
            
        }
        fseek(pf,0,SEEK_END);  
        long isize = ftell(pf);
        //cout<<"size = "<<isize<<endl;
        fseek(pf,0,SEEK_SET);   
        char *buffer = new char[isize+1];
        long itmp = fread(buffer,isize,sizeof(char),pf);
        //cout<<"fread = "<<itmp<<endl;
	    buffer[isize-1] = 0;