ParseStore Class Reference

#include <cccc_utl.h>

Collaboration diagram for ParseStore:

Public Member Functions
	ParseStore (const string &filename)
	~ParseStore ()
void	IncrementCount (LexicalCount lc)
void	endOfLine (int line)
void	record_module_extent (int startLine, int endLine, const string &moduleName, const string &moduleType, const string &description, UseType ut)
void	record_function_extent (int startLine, int endLine, const string &returnType, const string &moduleName, const string &memberName, const string &paramList, const string &description, Visibility visibility, UseType ut)
void	record_userel_extent (int startLine, int endLine, const string &clientName, const string &memberName, const string &serverName, const string &description, Visibility visibility, UseType ut)
void	record_other_extent (int startLine, int endLine, const string &description)
void	record_file_balance_extent (string)
void	insert_extent (CCCC_Item &, int, int, const string &, const string &, UseType, bool allocate_lexcounts)
int	get_flag (PSFlag) const
void	set_flag (PSFlag, int)
void	set_flag (Visibility)
Visibility	get_visibility ()
string	filename ()
char *	flags ()

Static Public Member Functions
static ParseStore *	currentInstance ()

Private Types
typedef std::vector< int >	LexicalCountArray
typedef std::map< int, LexicalCountArray >	LineLexicalCountMatrix
typedef std::vector< char >	CharArray

Private Member Functions
	ParseStore (const ParseStore &)
const ParseStore &	operator= (const ParseStore &)

Private Attributes
string	theFilename
LexicalCountArray	pendingLexicalCounts
LineLexicalCountMatrix	lineLexicalCounts
CharArray	flag

Static Private Attributes
static ParseStore *	theCurrentInstance =NULL

Detailed Description

Definition at line 209 of file cccc_utl.h.

Member Typedef Documentation

typedef std::vector<char> ParseStore::CharArray

private

Definition at line 281 of file cccc_utl.h.

typedef std::vector<int> ParseStore::LexicalCountArray

private

Definition at line 275 of file cccc_utl.h.

typedef std::map<int,LexicalCountArray> ParseStore::LineLexicalCountMatrix

private

Definition at line 278 of file cccc_utl.h.

Constructor & Destructor Documentation

ParseStore::ParseStore

(

const string &

filename

)

Definition at line 234 of file cccc_utl.cc.

: theFilename(filename)
, pendingLexicalCounts(static_cast<int>(tcLAST),0)
, flag(static_cast<int>(psfLAST)+1,'?')
{
  // This is designed as a serial-singleton class (e.g. many 
  // instances may exist over time but no more than one at a
  // time).
  // For the lifetime of an instance, the static member theCurrentInstance
  // points to it. When no instance exists, this pointer is null.
  assert(theCurrentInstance==NULL);
  theCurrentInstance=this;
  flag[psfLAST]='\0';
}

ParseStore::~ParseStore

(

)

Definition at line 249 of file cccc_utl.cc.

{
  // If the current object came from the default constructor
  // it is the primary singleton instance and we wish to 
  // set the static pointer to itself back to null.  Otherwise,
  // it was a cached copy, and we don't really care.
  if(theCurrentInstance==this)
    {
      theCurrentInstance=NULL;
    }
}

ParseStore::ParseStore ( const ParseStore &  )

private

Member Function Documentation

static ParseStore* ParseStore::currentInstance ( )

inlinestatic

Definition at line 269 of file cccc_utl.h.

{ return theCurrentInstance; }

Here is the caller graph for this function:

void ParseStore::endOfLine

(

int

line

)

Definition at line 587 of file cccc_utl.cc.

{
  // We only do the processing below if the line which has just
  // ended contained at least one non-skippable token
  // The flag which tells us whether this is true is set in the 
  // token constructor
  if(ANTLRToken::bCodeLine)
  {
    pendingLexicalCounts[tcCODELINES]++;
    LineLexicalCountMatrix::value_type 
      vt(line,LexicalCountArray(static_cast<int>(tcLAST),0));

    for(int i=0; i<tcLAST; i++)
      {
    vt.second[i]=pendingLexicalCounts[i];
    pendingLexicalCounts[i]=0;
      }
    lineLexicalCounts.insert(vt);

    // reset the flat for next time
    ANTLRToken::bCodeLine=false;
  }
}

string ParseStore::filename

(

)

Definition at line 281 of file cccc_utl.cc.

{ 
  return theFilename; 
}

Here is the caller graph for this function:

char* ParseStore::flags ( )

inline

Definition at line 261 of file cccc_utl.h.

{ return &(*flag.begin()); }

Here is the caller graph for this function:

int ParseStore::get_flag

(

PSFlag

psf

)

const

Definition at line 261 of file cccc_utl.cc.

                                         {
  return int(flag[psf]); 
}

Visibility ParseStore::get_visibility

(

)

Definition at line 276 of file cccc_utl.cc.

{
  return static_cast<Visibility>(flag[psfVISIBILITY]);
}

void ParseStore::IncrementCount ( LexicalCount  lc )

inline

Definition at line 215 of file cccc_utl.h.

{ pendingLexicalCounts[lc]++; }

void ParseStore::insert_extent	(	CCCC_Item &	os,
		int	startLine,
		int	endLine,
		const string &	description,
		const string &	flags,
		UseType	ut,
		bool	allocate_lexcounts
	)

Definition at line 288 of file cccc_utl.cc.

{
  os.Insert(theFilename);
  os.Insert(startLine);
  os.Insert(description);
  os.Insert(flags);
  int i;
  int lexical_counts_for_this_extent[tcLAST];
  for(i=0; i<tcLAST; i++)
    {
      lexical_counts_for_this_extent[i]=0;
    }

  if(allocate_lexcounts==true)
    {
      LineLexicalCountMatrix::iterator extentStartIter =
    lineLexicalCounts.lower_bound(startLine); 
      LineLexicalCountMatrix::iterator extentEndIter =
    lineLexicalCounts.upper_bound(endLine-1); 
      LineLexicalCountMatrix::iterator llcmIter;
      for(llcmIter=extentStartIter;
      llcmIter!=extentEndIter; 
      ++llcmIter)
    {
      // This record relates to a line within the current
      // extent.
      for(i=0; i<tcLAST; i++)
        {   
          lexical_counts_for_this_extent[i]+=(*llcmIter).second[i];
        }
    }
      // The lexical occurrences mentioned in the records processed 
      // above are now been accounted for in the database, so we
      // purge these records.  This has the effect of allowing
      // accurate accounting on nested extents (i.e. the outer
      // extent will only be reported as containing lines which 
      // are not already listed in the inner extent).
      lineLexicalCounts.erase(extentStartIter,extentEndIter);

      ostringstream lexcount_str;

      lexcount_str << "LOC:" << lexical_counts_for_this_extent[tcCODELINES]
           << " COM:" << lexical_counts_for_this_extent[tcCOMLINES]
           << " MVG:" << lexical_counts_for_this_extent[tcMCCABES_VG]
           << ends;

      os.Insert(lexcount_str.str().c_str());

    }
  else
    {
      os.Insert("*");
    }
  os.Insert((char)flag[psfVISIBILITY]);
  os.Insert((char)ut);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const ParseStore& ParseStore::operator= ( const ParseStore &  )

private

void ParseStore::record_file_balance_extent

(

string

)

void ParseStore::record_function_extent	(	int	startLine,
		int	endLine,
		const string &	returnType,
		const string &	moduleName,
		const string &	memberName,
		const string &	paramList,
		const string &	description,
		Visibility	visibility,
		UseType	ut
	)

Definition at line 368 of file cccc_utl.cc.

{
  // We require every call to this function to specify a member
  // function name and a parameter list.
  if(memberName.size()>0)
  {
    // If the moduleName is an empty string, we remap this to the
    // string "anonymous".  This implies that we treat all
    // C-style functions as belonging to a single module.
    string mappedModuleName = moduleName;
    if(mappedModuleName.size()==0)
    {
       mappedModuleName = "anonymous";
    }

    CCCC_Item function_line;
    function_line.Insert(mappedModuleName);
    function_line.Insert(memberName);
    function_line.Insert(returnType);
    function_line.Insert(paramList);

    string baseFlags=flags();
    baseFlags[psfVISIBILITY]=visibility;

    insert_extent(function_line,startLine,endLine,
     description,baseFlags,ut,true);
    prj->add_member(function_line);
  }
}

Here is the call graph for this function:

void ParseStore::record_module_extent	(	int	startLine,
		int	endLine,
		const string &	moduleName,
		const string &	moduleType,
		const string &	description,
		UseType	ut
	)

Definition at line 349 of file cccc_utl.cc.

{
  // See the lengthy comment in record_userel_extent about
  // why we are filtering for empty module names.
  if(moduleName.size()>0)
  {
    CCCC_Item module_line;
    module_line.Insert(moduleName);
    module_line.Insert(moduleType);
    insert_extent(module_line,startLine,endLine,
     description,flags(),ut,true);
    prj->add_module(module_line);
  }
}

Here is the call graph for this function:

void ParseStore::record_other_extent	(	int	startLine,
		int	endLine,
		const string &	description
	)

Definition at line 452 of file cccc_utl.cc.

{
  CCCC_Item rejext_line;
  insert_extent(rejext_line,startLine,endLine,description,flags(),utREJECTED,true);
  prj->add_rejected_extent(rejext_line);
}

Here is the call graph for this function:

void ParseStore::record_userel_extent	(	int	startLine,
		int	endLine,
		const string &	clientName,
		const string &	memberName,
		const string &	serverName,
		const string &	description,
		Visibility	visibility,
		UseType	ut
	)

Definition at line 405 of file cccc_utl.cc.

{
  CCCC_Item userel_line;
  
  // This function should not be invoked unless the clientName
  // and serverName are non-empty strings, however it appears
  // that in test case prn16.java the parser does execute the 
  // actions of the 'implementsClause' rule, even though there
  // is no 'implements' keyword outside comments in the program
  // text.
  // I don't understand this, but as a workaround, I filter at 
  // this point and ensure that if either clientName or serverName
  // is empty, no action is taken.
  if(clientName.size()>0 && serverName.size()>0)
  {
      userel_line.Insert(clientName);
      userel_line.Insert(memberName);
      userel_line.Insert(serverName);

      // for data member definitions, we record lexical data for the
      // extent,
      // for inheritance and parameter relationships we do not
      bool record_lexcounts=false;
      switch(ut)
        {
        case utHASBYVAL:
        case utHASBYREF:
          record_lexcounts=true;
          break;
        default:
          record_lexcounts=false;
        }

      string baseFlags=flags();
      baseFlags[psfVISIBILITY]=visibility;
      insert_extent(userel_line,startLine,endLine,
            description,baseFlags,ut,record_lexcounts);
      prj->add_userel(userel_line);
   }
}

Here is the call graph for this function:

void ParseStore::set_flag	(	PSFlag	psf,
		int	value
	)

Definition at line 265 of file cccc_utl.cc.

                                               { 
  flag[psf]=value;
}

void ParseStore::set_flag

(

Visibility

value

)

Definition at line 269 of file cccc_utl.cc.

                                          { 
  MAKE_STRSTREAM(ofstr);
  ofstr << value;
  flag[psfVISIBILITY]=(ofstr.str())[0];
  RELEASE_STRSTREAM(ofstr);
}

Member Data Documentation

CharArray ParseStore::flag

private

Definition at line 282 of file cccc_utl.h.

LineLexicalCountMatrix ParseStore::lineLexicalCounts

private

Definition at line 279 of file cccc_utl.h.

LexicalCountArray ParseStore::pendingLexicalCounts

private

Definition at line 276 of file cccc_utl.h.

ParseStore * ParseStore::theCurrentInstance =NULL

staticprivate

Definition at line 271 of file cccc_utl.h.

string ParseStore::theFilename

private

Definition at line 273 of file cccc_utl.h.

---

The documentation for this class was generated from the following files:

• cccc_utl.h
• cccc_utl.cc