VariableContext Class Reference

Classes
class	Scope

Public Member Functions
	VariableContext ()
virtual	~VariableContext ()
void	pushScope ()
void	popScope ()
void	clear ()
void	clearExceptGlobal ()
void	addVariable (const QCString &type, const QCString &name)
ClassDef *	findVariable (const QCString &name)
int	count () const

Static Public Attributes
static const ClassDef *	dummyContext = (ClassDef*)0x8

Private Attributes
Scope	m_globalScope
QList< Scope >	m_scopes

Detailed Description

Represents a stack of variable to class mappings as found in the code. Each scope is enclosed in pushScope() and popScope() calls. Variables are added by calling addVariables() and one can search for variable using findVariable().

Definition at line 10707 of file code.cpp.

Constructor & Destructor Documentation

VariableContext::VariableContext ( )

inline

Definition at line 10718 of file code.cpp.

    {
      m_scopes.setAutoDelete(TRUE);
    }

virtual VariableContext::~VariableContext ( )

inlinevirtual

Definition at line 10722 of file code.cpp.

    {
    }

Member Function Documentation

void VariableContext::addVariable	(	const QCString &	type,
		const QCString &	name
	)

Definition at line 10767 of file code.cpp.

{
  //printf("VariableContext::addVariable(%s,%s)\n",type.data(),name.data());
  QCString ltype = type.simplifyWhiteSpace();
  QCString lname = name.simplifyWhiteSpace();
  if (ltype.left(7)=="struct ") 
  {
    ltype = ltype.right(ltype.length()-7);
  }
  else if (ltype.left(6)=="union ")
  {
    ltype = ltype.right(ltype.length()-6);
  }
  if (ltype.isEmpty() || lname.isEmpty()) return;
  DBG_CTX((stderr,"** addVariable trying: type='%s' name='%s' g_currentDefinition=%s\n",
        ltype.data(),lname.data(),g_currentDefinition?g_currentDefinition->name().data():"<none>"));
  Scope *scope = m_scopes.count()==0 ? &m_globalScope : m_scopes.getLast();
  ClassDef *varType;
  int i=0;
  if (
      (varType=g_codeClassSDict->find(ltype)) ||  // look for class definitions inside the code block
      (varType=getResolvedClass(g_currentDefinition,g_sourceFileDef,ltype)) // look for global class definitions
     ) 
  {
    DBG_CTX((stderr,"** addVariable type='%s' name='%s'\n",ltype.data(),lname.data()));
    scope->append(lname,varType); // add it to a list
  }
  else if ((i=ltype.find('<'))!=-1)
  {
    // probably a template class
    QCString typeName(ltype.left(i));
    ClassDef* newDef = 0;
    QCString templateArgs(ltype.right(ltype.length() - i));
    if (  
         ( // look for class definitions inside the code block
           (varType=g_codeClassSDict->find(typeName)) ||
           // otherwise look for global class definitions
           (varType=getResolvedClass(g_currentDefinition,g_sourceFileDef,typeName,0,0,TRUE,TRUE))
         ) && // and it must be a template
         varType->templateArguments())
    {
      newDef = varType->getVariableInstance( templateArgs );
    }
    if (newDef)
    {
      DBG_CTX((stderr,"** addVariable type='%s' templ='%s' name='%s'\n",typeName.data(),templateArgs.data(),lname.data()));
      scope->append(lname, newDef);
    }
    else
    {
      // Doesn't seem to be a template. Try just the base name.
      addVariable(typeName,name);
    }
  }
  else 
  {
    if (m_scopes.count()>0) // for local variables add a dummy entry so the name 
                            // is hidden to avoid false links to global variables with the same name
                            // TODO: make this work for namespaces as well!
    {
      DBG_CTX((stderr,"** addVariable: dummy context for '%s'\n",lname.data()));
      scope->append(lname,dummyContext);
    }
    else
    {
      DBG_CTX((stderr,"** addVariable: not adding variable!\n"));
    }
  }
}

void VariableContext::clear ( )

inline

Definition at line 10745 of file code.cpp.

    {
      m_scopes.clear();
      m_globalScope.clear();
    }

void VariableContext::clearExceptGlobal ( )

inline

Definition at line 10751 of file code.cpp.

    {
      DBG_CTX((stderr,"** Clear var context\n"));
      m_scopes.clear();
    }

int VariableContext::count ( ) const

inline

Definition at line 10760 of file code.cpp.

{ return m_scopes.count(); }

ClassDef * VariableContext::findVariable

(

const QCString &

name

)

Definition at line 10837 of file code.cpp.

{
  if (name.isEmpty()) return 0;
  ClassDef *result = 0;
  QListIterator<Scope> sli(m_scopes);
  Scope *scope;
  QCString key = name;
  // search from inner to outer scope
  for (sli.toLast();(scope=sli.current());--sli)
  {
    result = scope->find(key);
    if (result)
    {
      DBG_CTX((stderr,"** findVariable(%s)=%p\n",name.data(),result));
      return result;
    }
  }
  // nothing found -> also try the global scope
  result=m_globalScope.find(name);
  DBG_CTX((stderr,"** findVariable(%s)=%p\n",name.data(),result));
  return result;
}

void VariableContext::popScope ( )

inline

Definition at line 10732 of file code.cpp.

    {
      if (m_scopes.count()>0)
      {
        DBG_CTX((stderr,"** Pop var context %d\n",m_scopes.count()));
        m_scopes.remove(m_scopes.count()-1);
      }
      else
      {
        DBG_CTX((stderr,"** ILLEGAL: Pop var context\n"));
      }
    }

void VariableContext::pushScope ( )

inline

Definition at line 10726 of file code.cpp.

    {
      m_scopes.append(new Scope);
      DBG_CTX((stderr,"** Push var context %d\n",m_scopes.count()));
    }

Member Data Documentation

const ClassDef * VariableContext::dummyContext = (ClassDef*)0x8

static

Definition at line 10710 of file code.cpp.

Scope VariableContext::m_globalScope

private

Definition at line 10763 of file code.cpp.

QList<Scope> VariableContext::m_scopes

private

Definition at line 10764 of file code.cpp.

---

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

• doxygen-1.8.11/build/generated_src/code.cpp