\begin{minipage}[t]{8in}
\begin{tabular}{ll}
(macro)  & CLASSDATA\index{STkUtils!CLASSDATA}(x)
\end{tabular}\\
 
	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in} Returns the C++ pointer stored in SCM x by the wrapper which 
	  created that object.  For example, if the stored data is of 
	  type int, the extraction command is *(int*)CLASSDATA(x), while
	  if data of type Vertex* has been stored, the extraction 
	  command would be *(Vertex**)CLASSDATA(x).\end{minipage}
\end{minipage}
\vspace{0.2in}

\begin{minipage}[t]{8in}
\begin{tabular}{ll}
(macro)  & INSTANCEP\index{STkUtils!INSTANCEP}(x)
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in} Returns 1 if x is an STk class instance, 0 otherwise.\end{minipage}
\end{minipage}
\vspace{0.2in}

\begin{minipage}[t]{8in}
\begin{tabular}{ll}
(macro)  & STRING\index{STkUtils!STRING}(x)
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in} Returns the character pointer stored in x.  Should only be
	  called if it is known that x is a string (by calling STk's
	  STRINGP(x).\end{minipage}
\end{minipage}
\vspace{0.2in}

\begin{minipage}[t]{8in}
\begin{tabular}{ll}
(macro)  & SYMBOL\index{STkUtils!SYMBOL}(x)
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in} Returns the character pointer stored in x (representing the symbol's
	  name).  Should only be
	  called if it is known that x is a symbol (by calling STk's 
	  SYMBOLP(x).\end{minipage}
\end{minipage}
\vspace{0.2in}

\begin{minipage}[t]{8in}
\begin{tabular}{ll}
(macro)  & VAL\index{STkUtils!VAL}(x)
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in} Returns the val slot associated with each STk class 
	  defined by LINK.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
(macro)  & CXX\_TYPEP\index{STkUtils!CXX\_TYPEP}(x, t)
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in} Returns 1 if object x is a C++ class object of type t, otherwise
	  returns 0.  This is
	  usually used in conjunction with the Wrapper class.  For example:
	  if (CXX\_TYPEP(vs, Wrapper$<$Set$<$Vertex*$>$ $>$::type))
		Set$<$Vertex*$>$ s = *(Set$<$Vertex*$>$*)CLASSDATA(vs);\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Collection$<$T$>$ *  & CollectionWrapper$<$T$>$::getCollection\index{STkUtils!CollectionWrapper$<$T$>$::getCollection}(SCM)
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in} This templated routine (generated automatically - see
	  CollectionWrapper.h, CollectionWrapper.cc in the stkWrapper
	  include directory) extracts the appropriate Collection pointer
	  from SCM if its data is a member of the Collection$<$T$>$* hierarchy.
	  Otherwise the routine returns NULL.\end{minipage}
\end{minipage}
\vspace{0.2in}

	  
\begin{minipage}[t]{8in}
\begin{tabular}{ll}
char *  & getName\index{STkUtils!getName}(SCM)
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in} Returns a dynamically-allocated copy of the character string 
          stored in SCM if there is one, otherwise returns NULL.\end{minipage}
\end{minipage}
\vspace{0.2in}

 \begin{minipage}[t]{8in}
\begin{tabular}{ll}
char *  & getGraphObject\index{STkUtils!getGraphObject}(SCM)
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in} Returns the GraphObject* stored in SCM if there is one, 
	  otherwise returns NULL.\end{minipage}
\end{minipage}
\vspace{0.2in}

 \begin{minipage}[t]{8in}
\begin{tabular}{ll}
char *  & getGraph()\index{STkUtils!getGraph()}CM)
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in} Returns the Graph* stored in SCM if there is one, 
	  otherwise returns NULL.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
SCM  & STk\_add\_new\_cpp\_primitive\index{STkUtils!STk\_add\_new\_cpp\_primitive}(char *fct\_name, int fct\_type,SCM (*)(...))
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in} Almost an exact copy of STk's STk\_add\_new\_primitive, this routine
	  escapes C++'s tighter type checking.  This function adds a command
	  to the STk interpreter.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
SCM & STk\_make\_CXXwrapper\index{STkUtils!STk\_make\_CXXwrapper}(int id, char *type\_name, void*data, int static\_flag);
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Create a new class instance of the extended type associated with
	 id (and described with type\_name). The result is a pointer to
	 a new STk cons element containing a pointer to data.  The
	 static\_flag determines whether or not data will be deleted 
	 when this cons element is destroyed (LINK\_STATIC, LINK\_DYNAMIC.  
	 To the STk-knowledgeable
	 reader:  actually, two cons elements are created: one tc\_CXXwrapper
	 and one tc\_instance.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
SCM  & STk\_new\_CXXwrapper\_id\index{STkUtils!STk\_new\_CXXwrapper\_id}(char *, char *,void (*)(SCM,SCM,int), 
				void (*)(SCM), 
				void (*)(SCM))
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Registers a new class type with STk.  For examples, see the
	 files in the autogenSTkMethods directories of the LINK file
	 hierarchy.  The first argument is the name of the name (for
	 display purposes), the second is the name of any parent class,
	 the third is a display function to be called when a user calls
	 the ``describe'' function with an instance of the new class,
	 and the fourth and fifth arguments are marking and sweeping
	 functions (respectively) to be called by the STk garbage 
	 collector.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
SCM  & wrapGraph\index{STkUtils!wrapGraph}(Graph *g)
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Useful for wrapping routines returning Graph*. The appropriate
	 graph type is determined, then return value
	 is obtained by calling STk\_make\_CXXwrapper().\end{minipage}
\end{minipage}
\vspace{0.2in}